From c1b3fbfddd603f24ba45ffb701963ccb2b991a7c Mon Sep 17 00:00:00 2001 From: Raphael Fakhri <153192858+RaphaelFakhri@users.noreply.github.com> Date: Wed, 21 Oct 2026 06:53:18 +0000 Subject: [PATCH 1/2] fix(backup): report an unset completed_at as None Weaviate serializes the completedAt of a backup or export that is still running as Go's zero time, 0001-01-01T00:00:00.000Z. list_backups() and export.get_status() returned it as datetime(1, 1, 1) instead of None. --- test/test_backup.py | 17 +++++++++++++++++ test/test_export.py | 36 ++++++++++++++++++++++++++++++++++++ weaviate/backup/backup.py | 16 +++++++++++++++- weaviate/export/export.py | 9 +++++++-- 4 files changed, 75 insertions(+), 3 deletions(-) create mode 100644 test/test_export.py diff --git a/test/test_backup.py b/test/test_backup.py index 225588581..956672519 100644 --- a/test/test_backup.py +++ b/test/test_backup.py @@ -1,3 +1,4 @@ +from datetime import datetime, timezone from typing import Any, Dict import pytest @@ -39,3 +40,19 @@ def test_list_return_defaults_incremental_base_backup_id_to_none(entry: Dict[str # The server omits the field for non-incremental backups, and only populates # it for callers it has confirmed as root, so absent must not be an error. assert BackupListReturn(**entry).incremental_base_backup_id is None + + +def test_list_return_maps_unset_completed_at_to_none() -> None: + # A running backup is listed with Go's zero time as its completedAt. + backup = BackupListReturn( + **_list_entry(status="STARTED", completedAt="0001-01-01T00:00:00.000Z") + ) + + assert backup.completed_at is None + assert backup.started_at == datetime(2026, 8, 1, 10, 0, tzinfo=timezone.utc) + + +def test_list_return_keeps_set_completed_at() -> None: + backup = BackupListReturn(**_list_entry()) + + assert backup.completed_at == datetime(2026, 8, 1, 10, 5, tzinfo=timezone.utc) diff --git a/test/test_export.py b/test/test_export.py new file mode 100644 index 000000000..5950c0b76 --- /dev/null +++ b/test/test_export.py @@ -0,0 +1,36 @@ +from datetime import datetime, timezone +from typing import Any, Dict + +from weaviate.export.export import ExportStatus, ExportStatusReturn + + +def _status(**overrides: Any) -> Dict[str, Any]: + """An export status as Weaviate's ``GET /export/{backend}/{id}`` returns it.""" + status: Dict[str, Any] = { + "id": "my-export", + "backend": "filesystem", + "path": "/tmp/exports/my-export", + "classes": ["Article"], + "status": "SUCCESS", + "startedAt": "2026-08-01T10:00:00.000Z", + "completedAt": "2026-08-01T10:05:00.000Z", + "tookInMs": 300000, + } + status.update(overrides) + return status + + +def test_status_return_maps_unset_completed_at_to_none() -> None: + # A running export reports Go's zero time as its completedAt. + status = ExportStatusReturn( + **_status(status="TRANSFERRING", completedAt="0001-01-01T00:00:00.000Z", tookInMs=None) + ) + + assert status.status == ExportStatus.TRANSFERRING + assert status.completed_at is None + + +def test_status_return_keeps_set_completed_at() -> None: + status = ExportStatusReturn(**_status()) + + assert status.completed_at == datetime(2026, 8, 1, 10, 5, tzinfo=timezone.utc) diff --git a/weaviate/backup/backup.py b/weaviate/backup/backup.py index f00a4aed8..1391fc335 100644 --- a/weaviate/backup/backup.py +++ b/weaviate/backup/backup.py @@ -2,10 +2,19 @@ from enum import Enum from typing import Any, Dict, List, Optional, cast -from pydantic import BaseModel, Field +from pydantic import BaseModel, Field, field_validator from weaviate.backup.backup_location import _BackupLocationConfig + +def _zero_time_to_none(value: Optional[datetime]) -> Optional[datetime]: + # Weaviate sends Go's zero time (0001-01-01T00:00:00Z) for timestamps it has not set yet, + # for example `completedAt` while a backup or export is still running. + if value is not None and value.replace(tzinfo=None) == datetime.min: + return None + return value + + STORAGE_NAMES = { "filesystem", "s3", @@ -107,3 +116,8 @@ class BackupListReturn(BaseModel): # None when the backup is not incremental, and also when the server omits the # field: it is only returned to callers Weaviate has confirmed as root. incremental_base_backup_id: Optional[str] = Field(default=None) + + @field_validator("completed_at") + @classmethod + def _completed_at_unset_to_none(cls, v: Optional[datetime]) -> Optional[datetime]: + return _zero_time_to_none(v) diff --git a/weaviate/export/export.py b/weaviate/export/export.py index fe94afa5c..1e5525c90 100644 --- a/weaviate/export/export.py +++ b/weaviate/export/export.py @@ -4,9 +4,9 @@ from enum import Enum from typing import Dict, List, Optional -from pydantic import BaseModel, Field +from pydantic import BaseModel, Field, field_validator -from weaviate.backup.backup import BackupStorage +from weaviate.backup.backup import BackupStorage, _zero_time_to_none ExportStorage = BackupStorage @@ -69,3 +69,8 @@ class ExportStatusReturn(ExportCreateReturn): ) error: Optional[str] = None took_in_ms: Optional[int] = Field(alias="tookInMs", default=None) + + @field_validator("completed_at") + @classmethod + def _completed_at_unset_to_none(cls, v: Optional[datetime]) -> Optional[datetime]: + return _zero_time_to_none(v) From d7e618d86be85fb3a621adf59fb1d1c4b4ca4d5d Mon Sep 17 00:00:00 2001 From: Raphael Fakhri <153192858+RaphaelFakhri@users.noreply.github.com> Date: Sun, 15 Nov 2026 22:12:07 +0000 Subject: [PATCH 2/2] refactor: share the zero-time check in weaviate.util --- integration/test_backup_v4.py | 3 +++ integration/test_export.py | 2 ++ weaviate/backup/backup.py | 10 +--------- weaviate/export/export.py | 3 ++- weaviate/users/base.py | 10 +++------- weaviate/util.py | 8 ++++++++ 6 files changed, 19 insertions(+), 17 deletions(-) diff --git a/integration/test_backup_v4.py b/integration/test_backup_v4.py index 6da10bc7c..41f8dd293 100644 --- a/integration/test_backup_v4.py +++ b/integration/test_backup_v4.py @@ -662,6 +662,9 @@ def test_list_backup(client: weaviate.WeaviateClient, request: SubRequest) -> No backups = client.backup.list_backups(backend=BACKEND) assert backup_id.lower() in [b.backup_id.lower() for b in backups] + backup = next(b for b in backups if b.backup_id.lower() == backup_id.lower()) + if backup.status in (BackupStatus.STARTED, BackupStatus.TRANSFERRING): + assert backup.completed_at is None # wait until created while True: diff --git a/integration/test_export.py b/integration/test_export.py index 71e3a146f..5b9504ac9 100644 --- a/integration/test_export.py +++ b/integration/test_export.py @@ -101,7 +101,9 @@ def test_create_export_without_waiting( ExportStatus.SUCCESS, ] if status.status == ExportStatus.SUCCESS: + assert status.completed_at is not None break + assert status.completed_at is None time.sleep(0.1) assert status.export_id.lower() == export_id.lower() diff --git a/weaviate/backup/backup.py b/weaviate/backup/backup.py index 1391fc335..05495e299 100644 --- a/weaviate/backup/backup.py +++ b/weaviate/backup/backup.py @@ -5,15 +5,7 @@ from pydantic import BaseModel, Field, field_validator from weaviate.backup.backup_location import _BackupLocationConfig - - -def _zero_time_to_none(value: Optional[datetime]) -> Optional[datetime]: - # Weaviate sends Go's zero time (0001-01-01T00:00:00Z) for timestamps it has not set yet, - # for example `completedAt` while a backup or export is still running. - if value is not None and value.replace(tzinfo=None) == datetime.min: - return None - return value - +from weaviate.util import _zero_time_to_none STORAGE_NAMES = { "filesystem", diff --git a/weaviate/export/export.py b/weaviate/export/export.py index 1e5525c90..4966c5178 100644 --- a/weaviate/export/export.py +++ b/weaviate/export/export.py @@ -6,7 +6,8 @@ from pydantic import BaseModel, Field, field_validator -from weaviate.backup.backup import BackupStorage, _zero_time_to_none +from weaviate.backup.backup import BackupStorage +from weaviate.util import _zero_time_to_none ExportStorage = BackupStorage diff --git a/weaviate/users/base.py b/weaviate/users/base.py index 2a175a8b7..30a6303c0 100644 --- a/weaviate/users/base.py +++ b/weaviate/users/base.py @@ -1,4 +1,4 @@ -from datetime import datetime, timezone +from datetime import datetime from typing import Any, Dict, Generic, List, Literal, Optional, Union, cast, overload from httpx import Response @@ -19,17 +19,13 @@ OwnUser, UserDB, ) -from weaviate.util import _decode_json_response_dict, escape_string - -# Go's zero time value, returned by the server when a timestamp is not set -_GO_ZERO_TIME = datetime(1, 1, 1, 0, 0, tzinfo=timezone.utc) +from weaviate.util import _decode_json_response_dict, _zero_time_to_none, escape_string def _parse_optional_timestamp(value: Optional[str]) -> Optional[datetime]: if value is None: return None - dt = datetime.fromisoformat(value.replace("Z", "+00:00")) - return None if dt == _GO_ZERO_TIME else dt + return _zero_time_to_none(datetime.fromisoformat(value.replace("Z", "+00:00"))) class _BaseExecutor(Generic[ConnectionType]): diff --git a/weaviate/util.py b/weaviate/util.py index 81f51afea..4e7d61e50 100644 --- a/weaviate/util.py +++ b/weaviate/util.py @@ -789,6 +789,14 @@ def _datetime_from_weaviate_str(string: str) -> Optional[datetime.datetime]: raise e +def _zero_time_to_none(value: Optional[datetime.datetime]) -> Optional[datetime.datetime]: + # Weaviate sends Go's zero time (0001-01-01T00:00:00Z) for timestamps it has not set yet, + # for example `completedAt` while a backup or export is still running. + if value is not None and value.replace(tzinfo=None) == datetime.datetime.min: + return None + return value + + class _WeaviateUUIDInt(uuid_lib.UUID): def __init__(self, hex_: int) -> None: object.__setattr__(self, "int", hex_)