Change obj method to be private and raise warning when used

Author: dgarros

infrahub_sdk/timestamp.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+import warnings
 from datetime import UTC, datetime
 
 from whenever import Date, Instant, Time, ZonedDateTime
@@ -16,17 +17,26 @@ class TimestampFormatError(ValueError): ...
 
 
 class Timestamp:
-    obj: ZonedDateTime
+    _obj: ZonedDateTime
 
     def __init__(self, value: str | ZonedDateTime | Timestamp | None = None):
         if value and isinstance(value, ZonedDateTime):
-            self.obj = value
+            self._obj = value
         elif value and isinstance(value, self.__class__):
-            self.obj = value.obj
+            self._obj = value._obj
         elif isinstance(value, str):
-            self.obj = self._parse_string(value)
+            self._obj = self._parse_string(value)
         else:
-            self.obj = ZonedDateTime.now("UTC")
+            self._obj = ZonedDateTime.now("UTC")
+
+    @property
+    def obj(self) -> ZonedDateTime:
+        warnings.warn(
+            "Direct access to obj property is deprecated. Use to_string(), to_timestamp(), or to_datetime() instead.",
+            UserWarning,
+            stacklevel=2,
+        )
+        return self._obj
 
     @classmethod
     def _parse_string(cls, value: str) -> ZonedDateTime:
@@ -37,8 +47,8 @@ def _parse_string(cls, value: str) -> ZonedDateTime:
             pass
 
         try:
-            instant_date_ = Instant.parse_common_iso(value)
-            return instant_date_.to_tz("UTC")
+            instant_date = Instant.parse_common_iso(value)
+            return instant_date.to_tz("UTC")
         except ValueError:
             pass
 
@@ -65,14 +75,16 @@ def __repr__(self) -> str:
 
     def to_string(self, with_z: bool = True) -> str:
         if with_z:
-            return self.obj.instant().format_common_iso()
-        iso8601_string = self.obj.format_common_iso()
-        if iso8601_string[-1] == "Z":
-            iso8601_string = iso8601_string[:-1] + "+00:00"
-        return iso8601_string
+            return self._obj.instant().format_common_iso()
+        # iso8601_string = self._obj.format_common_iso()
+
+        # self.to_datetime().isoformat()
+        # if iso8601_string[-1] == "Z":
+        #     iso8601_string = iso8601_string[:-1] + "+00:00"
+        return self.to_datetime().isoformat()
 
     def to_timestamp(self) -> int:
-        return self.obj.timestamp()
+        return self._obj.timestamp()
 
     def to_datetime(self) -> datetime:
         time_str = self.to_string()
@@ -81,31 +93,31 @@ def to_datetime(self) -> datetime:
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj == other.obj
+        return self._obj == other._obj
 
     def __lt__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj < other.obj
+        return self._obj < other._obj
 
     def __gt__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj > other.obj
+        return self._obj > other._obj
 
     def __le__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj <= other.obj
+        return self._obj <= other._obj
 
     def __ge__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj >= other.obj
+        return self._obj >= other._obj
 
     def __hash__(self) -> int:
         return hash(self.to_string())
 
     def add_delta(self, hours: int = 0, minutes: int = 0, seconds: int = 0, microseconds: int = 0) -> Timestamp:
-        time = self.obj.add(hours=hours, minutes=minutes, seconds=seconds, microseconds=microseconds)
+        time = self._obj.add(hours=hours, minutes=minutes, seconds=seconds, microseconds=microseconds)
         return Timestamp(time)

tests/unit/sdk/test_timestamp.py

@@ -9,19 +9,19 @@
 def test_init_empty():
     t1 = Timestamp()
     assert isinstance(t1, Timestamp)
-    assert t1.to_string() == t1.obj.instant().format_common_iso()
+    assert t1.to_string() == t1._obj.instant().format_common_iso()
 
     t2 = Timestamp(None)
     assert isinstance(t2, Timestamp)
-    assert t2.to_string() == t2.obj.instant().format_common_iso()
+    assert t2.to_string() == t2._obj.instant().format_common_iso()
 
 
 def test_init_timestamp():
     t1 = Timestamp()
     t2 = Timestamp(t1)
     assert t1.to_string() == t2.to_string()
     assert isinstance(t2, Timestamp)
-    assert t2.to_string() == t2.obj.instant().format_common_iso()
+    assert t2.to_string() == t2._obj.instant().format_common_iso()
 
 
 def test_parse_string():
@@ -38,11 +38,43 @@ def test_parse_string():
         Timestamp._parse_string("notvalid")
 
 
-def test_to_datetime():
-    ref_str = "2022-01-01T10:01:01.123000Z"
-    ref = datetime(2022, 1, 1, 10, 1, 1, 123000, tzinfo=UTC)
-    assert isinstance(Timestamp(ref_str).to_datetime(), datetime)
-    assert Timestamp(ref_str).to_datetime() == ref
+@pytest.mark.parametrize(
+    "input_str,expected_datetime",
+    [
+        pytest.param(
+            "2022-01-01T10:01:01.123000Z", datetime(2022, 1, 1, 10, 1, 1, 123000, tzinfo=UTC), id="milliseconds"
+        ),
+        pytest.param(
+            "2023-12-31T23:59:59.999999Z", datetime(2023, 12, 31, 23, 59, 59, 999999, tzinfo=UTC), id="microseconds"
+        ),
+    ],
+)
+def test_to_datetime(input_str, expected_datetime):
+    assert isinstance(Timestamp(input_str).to_datetime(), datetime)
+    assert Timestamp(input_str).to_datetime() == expected_datetime
+
+
+@pytest.mark.parametrize(
+    "input_str,expected_str,expected_str_no_z",
+    [
+        pytest.param(
+            "2022-01-01T10:01:01.123000Z",
+            "2022-01-01T10:01:01.123Z",
+            "2022-01-01T10:01:01.123000+00:00",
+            id="milliseconds",
+        ),
+        pytest.param(
+            "2023-12-31T23:59:59.999999Z",
+            "2023-12-31T23:59:59.999999Z",
+            "2023-12-31T23:59:59.999999+00:00",
+            id="microseconds",
+        ),
+    ],
+)
+def test_to_string_default(input_str, expected_str, expected_str_no_z):
+    assert isinstance(Timestamp(input_str).to_string(), str)
+    assert Timestamp(input_str).to_string() == expected_str
+    assert Timestamp(input_str).to_string(with_z=False) == expected_str_no_z
 
 
 def test_compare():