refactor: revert back

cognite/client/data_classes/data_modeling/typed_instances.py

@@ -3,7 +3,7 @@
 import inspect
 from abc import ABC
 from collections.abc import Iterable
-from datetime import date, datetime
+from datetime import date
 from typing import TYPE_CHECKING, Any, cast
 
 from typing_extensions import Self
@@ -20,6 +20,7 @@
     _serialize_property_value,
 )
 from cognite.client.utils._text import to_camel_case
+from cognite.client.utils._time import convert_data_modelling_timestamp
 
 if TYPE_CHECKING:
     from cognite.client import CogniteClient
@@ -304,7 +305,7 @@ def _deserialize_value(value: Any, parameter: inspect.Parameter) -> Any:
         return value
     annotation = str(parameter.annotation)
     if "datetime" in annotation and isinstance(value, str):
-        return datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%f%z")
+        return convert_data_modelling_timestamp(value)
     elif "date" in annotation and isinstance(value, str):
         return date.fromisoformat(value)
     elif DirectRelationReference.__name__ in annotation and isinstance(value, dict):

cognite/client/utils/_time.py

@@ -178,6 +178,23 @@ def datetime_to_ms_iso_timestamp(dt: datetime) -> str:
     raise TypeError(f"Expected datetime object, got {type(dt)}")
 
 
+def convert_data_modelling_timestamp(timestamp: str) -> datetime:
+    """Converts a timestamp string to a datetime object.
+
+    Args:
+        timestamp (str): A timestamp string.
+
+    Returns:
+        datetime: A datetime object.
+    """
+    try:
+        return datetime.fromisoformat(timestamp)
+    except ValueError:
+        # Typically hits if the timestamp has truncated milliseconds,
+        # For example, "2021-01-01T00:00:00.17+00:00".
+        return datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%f%z")
+
+
 def split_granularity_into_quantity_and_normalized_unit(granularity: str) -> tuple[int, str]:
     """A normalized unit is any unit accepted by the API"""
     if match := re.match(r"(\d+)(.*)", granularity):

tests/tests_unit/test_utils/test_time.py

@@ -19,6 +19,7 @@
     align_large_granularity,
     align_start_and_end_for_granularity,
     convert_and_isoformat_time_attrs,
+    convert_data_modelling_timestamp,
     datetime_to_ms,
     datetime_to_ms_iso_timestamp,
     granularity_to_ms,
@@ -230,6 +231,27 @@ def test_negative(self, t):
             timestamp_to_ms(t)
 
 
+class TestConvertDataModelingTimestamp:
+    @pytest.mark.parametrize(
+        "timestamp_str, expected",
+        [
+            ("2021-01-01T00:00:00.000+00:00", datetime(2021, 1, 1, 0, 0, 0, 0, tzinfo=timezone.utc)),
+            ("2021-01-01T00:00:00.000+01:00", datetime(2021, 1, 1, 0, 0, 0, 0, tzinfo=timezone(timedelta(hours=1)))),
+            (
+                "2021-01-01T00:00:00.000+01:15",
+                datetime(2021, 1, 1, 0, 0, 0, 0, tzinfo=timezone(timedelta(hours=1, minutes=15))),
+            ),
+            (
+                "2021-01-01T00:00:00.000-01:15",
+                datetime(2021, 1, 1, 0, 0, 0, 0, tzinfo=timezone(timedelta(hours=-1, minutes=-15))),
+            ),
+            ("2024-09-03T09:36:01.17+00:00", datetime(2024, 9, 3, 9, 36, 1, 170000, tzinfo=timezone.utc)),
+        ],
+    )
+    def test_valid_timestamp_str(self, timestamp_str: str, expected: datetime) -> None:
+        assert expected == convert_data_modelling_timestamp(timestamp_str)
+
+
 class TestGranularityToMs:
     @pytest.mark.parametrize(
         "granularity, expected_ms",