soia-client 1.0.29__tar.gz → 1.1.0__tar.gz

{soia_client-1.0.29 → soia_client-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soia-client
-Version: 1.0.29
+Version: 1.1.0
 Author-email: Tyler Fibonacci <gepheum@gmail.com>
 License: MIT License
         

{soia_client-1.0.29 → soia_client-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soia-client"
-version = "1.0.29"
+version = "1.1.0"
 description = ""
 readme = "README.md"
 authors = [{ name = "Tyler Fibonacci", email = "gepheum@gmail.com" }]

{soia_client-1.0.29 → soia_client-1.1.0}/soia/__init__.py

@@ -1,5 +1,6 @@
 import typing as _typing
 
+from soia._impl.keep import KEEP, Keep
 from soia._impl.keyed_items import KeyedItems
 from soia._impl.method import Method
 from soia._impl.serializer import Serializer
@@ -16,6 +17,8 @@ _: _typing.Final[_typing.Any] = None
 
 __all__ = [
     "_",
+    "Keep",
+    "KEEP",
     "KeyedItems",
     "Method",
     "RawServiceResponse",

soia_client-1.1.0/soia/_impl/keep.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import Final, cast, final
+
+from soia._impl.never import Never
+
+
+@final
+@dataclass(frozen=True)
+class Keep:
+    """
+    Type of the KEEP constant, which indicates that a value should not be replaced.
+
+    Do not instantiate.
+    """
+
+    def __init__(self, never: Never):
+        pass
+
+
+KEEP: Final = Keep(cast(Never, None))

{soia_client-1.0.29 → soia_client-1.1.0}/soia/_impl/primitives.py

@@ -1,3 +1,4 @@
+import base64
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, Final, final
@@ -280,8 +281,6 @@ STRING_ADAPTER: Final[TypeAdapter] = _StringAdapter()
 
 
 class _BytesAdapter(AbstractPrimitiveAdapter):
-    _fromhex_fn: Final = bytes.fromhex
-
     def default_expr(self) -> ExprLike:
         return 'b""'
 
@@ -296,11 +295,16 @@ class _BytesAdapter(AbstractPrimitiveAdapter):
         in_expr: ExprLike,
         readable: bool,
     ) -> Expr:
-        return Expr.join(in_expr, ".hex()")
+        return Expr.join(
+            Expr.local("b64encode", base64.b64encode),
+            "(",
+            in_expr,
+            ").decode('utf-8')",
+        )
 
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
         return Expr.join(
-            Expr.local("fromhex", _BytesAdapter._fromhex_fn), "(", json_expr, ' or "")'
+            Expr.local("b64decode", base64.b64decode), "(", json_expr, ' or "")'
         )
 
     def get_type(self) -> reflection.Type:

{soia_client-1.0.29 → soia_client-1.1.0}/soia/_impl/structs.py

@@ -14,6 +14,7 @@ from soia._impl.function_maker import (
     Params,
     make_function,
 )
+from soia._impl.keep import KEEP
 from soia._impl.repr import repr_impl
 from soia._impl.type_adapter import TypeAdapter
 
@@ -134,8 +135,12 @@ class StructAdapter(TypeAdapter):
                 simple_class=simple_class,
             ),
         )
-        mutable_class.__init__ = cast(Any, _make_mutable_class_init_fn(fields))
-        frozen_class.whole = _make_whole_static_factory_method(frozen_class)
+        mutable_class.__init__ = _make_mutable_class_init_fn(fields)
+        frozen_class.partial = _make_partial_static_factory_method(
+            fields,
+            frozen_class,
+        )
+        frozen_class.replace = _make_replace_method(fields, frozen_class)
 
         frozen_class.__eq__ = _make_eq_fn(fields)
         frozen_class.__hash__ = cast(Any, _make_hash_fn(fields, self.record_hash))
@@ -270,13 +275,7 @@ def _make_frozen_class_init_fn(
     params: Params = ["_self"]
     if fields:
         params.append("*")
-    for field in fields:
-        params.append(
-            Param(
-                name=field.field.attribute,
-                default=field.type.default_expr(),
-            )
-        )
+    params.extend(field.field.attribute for field in fields)
 
     builder = BodyBuilder()
     # Since __setattr__() was overridden to raise errors in order to make the class
@@ -384,10 +383,85 @@ def _make_mutable_class_init_fn(fields: Sequence[_Field]) -> Callable[..., None]
     )
 
 
-def _make_whole_static_factory_method(frozen_class: type) -> Callable[..., Any]:
-    def whole(**kwargs):
-        return frozen_class(**kwargs)
-    return whole
+def _make_partial_static_factory_method(
+    fields: Sequence[_Field],
+    frozen_class: type,
+) -> Callable[..., None]:
+    """
+    Returns the implementation of the partial() method of the frozen class.
+    """
+
+    params: Params = []
+    if fields:
+        params.append("*")
+    params.extend(
+        Param(
+            name=field.field.attribute,
+            default=field.type.default_expr(),
+        )
+        for field in fields
+    )
+
+    builder = BodyBuilder()
+    builder.append_ln(
+        "return ",
+        Expr.local("Frozen", frozen_class),
+        "(",
+        ", ".join(
+            f"{field.field.attribute}={field.field.attribute}" for field in fields
+        ),
+        ")",
+    )
+
+    return make_function(
+        name="partial",
+        params=params,
+        body=builder.build(),
+    )
+
+
+def _make_replace_method(
+    fields: Sequence[_Field],
+    frozen_class: type,
+) -> Callable[..., None]:
+    """
+    Returns the implementation of the replace() method of the frozen class.
+    """
+
+    keep_local = Expr.local("KEEP", KEEP)
+    params: Params = []
+    if fields:
+        params.append("*")
+    params.extend(
+        Param(
+            name=field.field.attribute,
+            default=keep_local,
+        )
+        for field in fields
+    )
+
+    def field_to_arg_assigment(attr: str) -> LineSpan:
+        return LineSpan.join(
+            f"{attr}=self.{attr} if {attr} is ", keep_local, " else {attr}"
+        )
+
+    builder = BodyBuilder()
+    builder.append_ln(
+        "return ",
+        Expr.local("Frozen", frozen_class),
+        "(",
+        LineSpan.join(
+            *(field_to_arg_assigment(field.field.attribute) for field in fields),
+            separator=", ",
+        ),
+        ")",
+    )
+
+    return make_function(
+        name="partial",
+        params=params,
+        body=builder.build(),
+    )
 
 
 def _make_to_mutable_fn(
@@ -549,14 +623,9 @@ def _make_repr_fn(fields: Sequence[_Field]) -> Callable[[Any], str]:
     for field in fields:
         attribute = field.field.attribute
         # is_not_default_expr only works on a frozen expression.
-        to_frozen_expr = field.type.to_frozen_expr(f"(self.{attribute})")
-        is_not_default_expr = field.type.is_not_default_expr(
-            to_frozen_expr, to_frozen_expr
-        )
-        builder.append_ln("if is_mutable or ", is_not_default_expr, ":")
-        builder.append_ln("  r = ", repr_local, f"(self.{attribute})")
-        builder.append_ln(f"  assignments.append(f'{attribute}={{r.indented}}')")
-        builder.append_ln("  any_complex = any_complex or r.complex")
+        builder.append_ln("r = ", repr_local, f"(self.{attribute})")
+        builder.append_ln(f"assignments.append(f'{attribute}={{r.indented}}')")
+        builder.append_ln("any_complex = any_complex or r.complex")
     builder.append_ln("if len(assignments) <= 1 and not any_complex:")
     builder.append_ln("  body = ''.join(assignments)")
     builder.append_ln("else:")

{soia_client-1.0.29 → soia_client-1.1.0}/soia/_impl/timestamp.py

@@ -5,6 +5,14 @@ from typing import Any, Final, Union, cast, final, overload
 
 @final
 class Timestamp:
+    """
+    A number of milliseconds since the Unix epoch (1970-01-01T00:00:00Z).
+
+    Does not contain any timezone information.
+    Convertible to and from datetime objects.
+    Immutable.
+    """
+
     __slots__ = ("unix_millis",)
 
     unix_millis: int
@@ -26,7 +34,14 @@ class Timestamp:
 
     @staticmethod
     def from_datetime(dt: datetime.datetime) -> "Timestamp":
-        return Timestamp.from_unix_seconds(dt.timestamp())
+        # dt.timestamp() mail fail if the year is not in [1970, 2038]
+        if dt.tzinfo is None:
+            timestamp = (
+                dt - _EPOCH_DT.astimezone().replace(tzinfo=None)
+            ).total_seconds()
+        else:
+            timestamp = (dt - _EPOCH_DT).total_seconds()
+        return Timestamp.from_unix_seconds(timestamp)
 
     @staticmethod
     def now() -> "Timestamp":
@@ -41,9 +56,26 @@ class Timestamp:
         return self.unix_millis / 1000.0
 
     def to_datetime_or_raise(self) -> datetime.datetime:
-        return datetime.datetime.fromtimestamp(
-            self.unix_seconds, tz=datetime.timezone.utc
-        )
+        """
+        Returns a datetime object representing the timestamp in UTC timezone.
+
+        Raises an exception if the timestamp is out of bounds for datetime.
+        If you don't want the exception, use 'to_datetime_or_limit()' instead.
+        """
+        return _EPOCH_DT + datetime.timedelta(seconds=self.unix_seconds)
+
+    def to_datetime_or_limit(self) -> datetime.datetime:
+        """
+        Returns a datetime object representing the timestamp in UTC timezone.
+
+        Clamps the timestamp to the minimum or maximum datetime if it is out of bounds.
+        """
+        if self.unix_seconds <= (_MIN_DT_UTC - _EPOCH_DT).total_seconds():
+            return datetime.datetime.min.replace(tzinfo=datetime.timezone.utc)
+        elif self.unix_seconds >= (_MAX_DT_UTC - _EPOCH_DT).total_seconds():
+            return datetime.datetime.max.replace(tzinfo=datetime.timezone.utc)
+        else:
+            return self.to_datetime_or_raise()
 
     def __add__(self, td: datetime.timedelta) -> "Timestamp":
         return Timestamp(
@@ -126,3 +158,8 @@ class Timestamp:
 setattr(Timestamp, "EPOCH", Timestamp.from_unix_millis(0))
 setattr(Timestamp, "MIN", Timestamp.from_unix_millis(-8640000000000000))
 setattr(Timestamp, "MAX", Timestamp.from_unix_millis(8640000000000000))
+
+
+_EPOCH_DT: Final = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
+_MIN_DT_UTC: Final = datetime.datetime.min.replace(tzinfo=datetime.timezone.utc)
+_MAX_DT_UTC: Final = datetime.datetime.max.replace(tzinfo=datetime.timezone.utc)

{soia_client-1.0.29 → soia_client-1.1.0}/soia_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soia-client
-Version: 1.0.29
+Version: 1.1.0
 Author-email: Tyler Fibonacci <gepheum@gmail.com>
 License: MIT License
         

{soia_client-1.0.29 → soia_client-1.1.0}/soia_client.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ soia/_impl/__init__.py
 soia/_impl/arrays.py
 soia/_impl/enums.py
 soia/_impl/function_maker.py
+soia/_impl/keep.py
 soia/_impl/keyed_items.py
 soia/_impl/method.py
 soia/_impl/never.py

{soia_client-1.0.29 → soia_client-1.1.0}/tests/test_module_initializer.py

@@ -363,11 +363,11 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertEqual(point.x, 1.5)
         self.assertEqual(point.y, 2.5)
 
-    def test_whole_static_factory_method(self):
+    def test_partial_static_factory_method(self):
         point_cls = self.init_test_module()["Point"]
-        point = point_cls.whole(x=1.5, y=2.5)
+        point = point_cls.partial(x=1.5)
         self.assertEqual(point.x, 1.5)
-        self.assertEqual(point.y, 2.5)
+        self.assertEqual(point.y, 0.0)
 
     def test_to_mutable(self):
         point_cls = self.init_test_module()["Point"]
@@ -388,7 +388,8 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertEqual(hash(a), hash(b))
         self.assertNotEqual(a, c)
         self.assertNotEqual(a, "foo")
-        self.assertEqual(point_cls(), point_cls(x=0.0, y=0.0))
+        self.assertEqual(point_cls.partial(), point_cls(x=0.0, y=0.0))
+        self.assertEqual(point_cls.DEFAULT, point_cls(x=0.0, y=0.0))
 
     def test_or_mutable(self):
         point_cls = self.init_test_module()["Point"]
@@ -405,8 +406,9 @@ class ModuleInitializerTestCase(unittest.TestCase):
             i64=0,
             u64=0,
             t=Timestamp.EPOCH,
+            s="",
         )
-        b = primitives_cls()
+        b = primitives_cls.partial()
         self.assertEqual(a, b)
         self.assertEqual(hash(a), hash(b))
 
@@ -422,8 +424,9 @@ class ModuleInitializerTestCase(unittest.TestCase):
             i64=2,
             u64=3,
             t=Timestamp.from_unix_millis(4),
+            s="",
         )
-        self.assertEqual(serializer.to_json(p), [1, "61", 3.14, 3.14, 1, 2, 3, "", 4])
+        self.assertEqual(serializer.to_json(p), [1, "YQ==", 3.14, 3.14, 1, 2, 3, "", 4])
 
     def test_primitives_from_json(self):
         primitives_cls = self.init_test_module()["Primitives"]
@@ -431,7 +434,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         json = [0] * 100
         self.assertEqual(serializer.from_json(json), primitives_cls.DEFAULT)
         self.assertEqual(
-            serializer.from_json([1, "61", 3.14, 3.14, 1, 2, 3, "", 4]),
+            serializer.from_json([1, "YQ==", 3.14, 3.14, 1, 2, 3, "", 4]),
             primitives_cls(
                 bool=True,
                 bytes=b"a",
@@ -441,6 +444,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
                 i64=2,
                 u64=3,
                 t=Timestamp.from_unix_millis(4),
+                s="",
             ),
         )
 
@@ -455,10 +459,11 @@ class ModuleInitializerTestCase(unittest.TestCase):
             i64=2,
             u64=3,
             t=Timestamp.from_unix_millis(4),
+            s="",
         )
         self.assertEqual(
             str(p),
-            "Primitives(\n  bool=True,\n  bytes=b'a',\n  f32=3.14,\n  f64=3.14,\n  i32=1,\n  i64=2,\n  u64=3,\n  t=Timestamp(\n    unix_millis=4,\n    _formatted='1970-01-01T00:00:00.004000Z',\n  ),\n)",
+            "Primitives(\n  bool=True,\n  bytes=b'a',\n  f32=3.14,\n  f64=3.14,\n  i32=1,\n  i64=2,\n  u64=3,\n  s='',\n  t=Timestamp(\n    unix_millis=4,\n    _formatted='1970-01-01T00:00:00.004000Z',\n  ),\n)",
         )
 
     def test_from_json_converts_between_ints_and_floats(self):
@@ -503,7 +508,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         point_cls = self.init_test_module()["Point"]
         serializer = point_cls.SERIALIZER
         self.assertEqual(serializer.from_json([1.5, 0, 2.5]), point_cls(x=1.5, y=2.5))
-        self.assertEqual(serializer.from_json([1.5]), point_cls(x=1.5))
+        self.assertEqual(serializer.from_json([1.5]), point_cls(x=1.5, y=0.0))
         self.assertEqual(serializer.from_json([0.0]), point_cls.DEFAULT)
         self.assertEqual(serializer.from_json(0), point_cls.DEFAULT)
 
@@ -534,28 +539,30 @@ class ModuleInitializerTestCase(unittest.TestCase):
         foobar_cls = test_module["Foobar"]
         point_cls = test_module["Point"]
         serializer = foobar_cls.SERIALIZER
-        foobar = foobar_cls()
+        foobar = foobar_cls.partial()
         self.assertEqual(serializer.to_json_code(foobar), "[]")
         self.assertEqual(serializer.from_json_code("[]"), foobar)
-        foobar = foobar_cls(a=3)
+        foobar = foobar_cls.partial(a=3)
         self.assertEqual(serializer.to_json_code(foobar), "[0,3]")
         self.assertEqual(serializer.from_json_code("[0,3]"), foobar)
         self.assertEqual(serializer.from_json_code("[0,3.1]"), foobar)
-        foobar = foobar_cls(b=3, point=point_cls.DEFAULT)
+        foobar = foobar_cls(a=0, b=3, point=point_cls.DEFAULT)
         self.assertEqual(serializer.to_json_code(foobar), "[0,0,0,3]")
         self.assertEqual(serializer.from_json_code("[0,0,0,3]"), foobar)
         self.assertEqual(serializer.from_json_code("[0,0,0,3.1]"), foobar)
-        foobar = foobar_cls(point=point_cls(x=2))
+        foobar = foobar_cls.partial(point=point_cls.partial(x=2))
         self.assertEqual(serializer.to_json_code(foobar), "[0,0,0,0,[2.0]]")
         self.assertEqual(serializer.from_json_code("[0,0,0,0,[2.0]]"), foobar)
 
     def test_recursive_struct(self):
         rec_cls = self.init_test_module()["Rec"]
-        r = rec_cls(r=rec_cls(r=rec_cls.DEFAULT, x=1))
+        r = rec_cls.partial(r=rec_cls(r=rec_cls.DEFAULT, x=1))
         serializer = rec_cls.SERIALIZER
         self.assertEqual(serializer.to_json_code(r), "[[[],1]]")
         self.assertEqual(serializer.from_json_code("[[[],1]]"), r)
-        self.assertEqual(str(r), "Rec(\n  r=Rec(x=1),\n)")
+        self.assertEqual(
+            str(r), "Rec(\n  r=Rec(\n    r=Rec.DEFAULT,\n    x=1,\n  ),\n  x=0,\n)"
+        )
 
     def test_struct_ctor_accepts_mutable_struct(self):
         module = self.init_test_module()
@@ -564,6 +571,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         segment = segment_cls(
             a=point_cls(x=1.0, y=2.0).to_mutable(),
             b=point_cls(x=3.0, y=4.0),
+            c=None,
         )
         self.assertEqual(
             segment,
@@ -578,7 +586,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         module = self.init_test_module()
         segment_cls = module["Segment"]
         try:
-            segment_cls(
+            segment_cls.partial(
                 # Should be a Point
                 a=segment_cls.DEFAULT,
             )
@@ -588,9 +596,18 @@ class ModuleInitializerTestCase(unittest.TestCase):
 
     def test_struct_ctor_raises_error_if_unknown_arg(self):
         module = self.init_test_module()
-        segment_cls = module["Segment"]
+        point_cls = module["Point"]
         try:
-            segment_cls(foo=4)
+            point_cls(x=1, b=2, foo=4)
+            self.fail("Expected to fail")
+        except Exception:
+            pass
+
+    def test_struct_ctor_raises_error_if_missing_arg(self):
+        module = self.init_test_module()
+        point_cls = module["Point"]
+        try:
+            point_cls(x=1)
             self.fail("Expected to fail")
         except Exception:
             pass
@@ -655,13 +672,13 @@ class ModuleInitializerTestCase(unittest.TestCase):
         module = self.init_test_module()
         segment_cls = module["Segment"]
         point_cls = module["Point"]
-        segment = segment_cls(
+        segment = segment_cls.partial(
             c=point_cls.Mutable(x=1.0, y=2.0),
         )
         other_segment = segment.to_mutable().to_frozen()
         self.assertEqual(
             other_segment,
-            segment_cls(
+            segment_cls.partial(
                 c=point_cls(x=1.0, y=2.0),
             ),
         )
@@ -711,7 +728,9 @@ class ModuleInitializerTestCase(unittest.TestCase):
         module = self.init_test_module()
         json_value_cls = module["JsonValue"]
         json_object_cls = json_value_cls.Object
-        json_object = json_value_cls.wrap_object(json_object_cls().to_mutable())
+        json_object = json_value_cls.wrap_object(
+            json_object_cls(entries=[]).to_mutable()
+        )
         self.assertEqual(json_object.kind, "object")
         self.assertEqual(json_object.value, json_object_cls.DEFAULT)
         self.assertEqual(
@@ -780,7 +799,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
                     json_value_cls.wrap_object(
                         json_value_cls.Object(
                             entries=[
-                                json_value_cls.ObjectEntry(),
+                                json_value_cls.ObjectEntry.partial(),
                                 json_value_cls.ObjectEntry.DEFAULT,
                             ],
                         )
@@ -815,7 +834,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         json_value_cls = self.init_test_module()["JsonValue"]
         json_object_entry_cls = json_value_cls.ObjectEntry
         self.assertEqual(json_object_entry_cls.DEFAULT.value, json_value_cls.UNKNOWN)
-        self.assertEqual(json_object_entry_cls().value, json_value_cls.UNKNOWN)
+        self.assertEqual(json_object_entry_cls.partial().value, json_value_cls.UNKNOWN)
 
     def test_enum_with_unrecognized_and_removed_fields(self):
         json_value_cls = self.init_test_module()["JsonValue"]
@@ -849,11 +868,18 @@ class ModuleInitializerTestCase(unittest.TestCase):
         module = self.init_test_module()
         point_cls = module["Point"]
         self.assertEqual(
-            repr(point_cls(x=1.5)),
-            "Point(x=1.5)",
+            repr(point_cls.partial(x=1.5)),
+            "\n".join(
+                [
+                    "Point(",
+                    "  x=1.5,",
+                    "  y=0.0,",
+                    ")",
+                ]
+            ),
         )
         self.assertEqual(
-            repr(point_cls(x=1.5).to_mutable()),
+            repr(point_cls.partial(x=1.5).to_mutable()),
             "\n".join(
                 [
                     "Point.Mutable(",
@@ -875,8 +901,15 @@ class ModuleInitializerTestCase(unittest.TestCase):
             ),
         )
         self.assertEqual(
-            repr(point_cls()),
-            "Point()",
+            repr(point_cls.partial()),
+            "\n".join(
+                [
+                    "Point(",
+                    "  x=0.0,",
+                    "  y=0.0,",
+                    ")",
+                ]
+            ),
         )
         self.assertEqual(
             repr(point_cls.DEFAULT),
@@ -896,19 +929,22 @@ class ModuleInitializerTestCase(unittest.TestCase):
         shape_cls = module["Shape"]
         self.assertEqual(
             repr(shape_cls(points=[])),
-            "Shape()",
+            "Shape(points=[])",
         )
         self.assertEqual(
             repr(shape_cls(points=[]).to_mutable()),
             "Shape.Mutable(points=[])",
         )
         self.assertEqual(
-            repr(shape_cls(points=[point_cls(x=1.5)])),
+            repr(shape_cls(points=[point_cls(x=1.5, y=0.0)])),
             "\n".join(
                 [
                     "Shape(",
                     "  points=[",
-                    "    Point(x=1.5),",
+                    "    Point(",
+                    "      x=1.5,",
+                    "      y=0.0,",
+                    "    ),",
                     "  ],",
                     ")",
                 ]
@@ -918,8 +954,8 @@ class ModuleInitializerTestCase(unittest.TestCase):
             repr(
                 shape_cls(
                     points=[
-                        point_cls(x=1.5),
-                        point_cls(y=2.5),
+                        point_cls.partial(x=1.5),
+                        point_cls.partial(y=2.5),
                     ],
                 )
             ),
@@ -927,8 +963,14 @@ class ModuleInitializerTestCase(unittest.TestCase):
                 [
                     "Shape(",
                     "  points=[",
-                    "    Point(x=1.5),",
-                    "    Point(y=2.5),",
+                    "    Point(",
+                    "      x=1.5,",
+                    "      y=0.0,",
+                    "    ),",
+                    "    Point(",
+                    "      x=0.0,",
+                    "      y=2.5,",
+                    "    ),",
                     "  ],",
                     ")",
                 ]
@@ -938,8 +980,8 @@ class ModuleInitializerTestCase(unittest.TestCase):
             repr(
                 shape_cls.Mutable(
                     points=[
-                        point_cls(x=1.5),
-                        point_cls(y=2.5).to_mutable(),
+                        point_cls.partial(x=1.5),
+                        point_cls.partial(y=2.5).to_mutable(),
                     ]
                 )
             ),
@@ -947,7 +989,10 @@ class ModuleInitializerTestCase(unittest.TestCase):
                 [
                     "Shape.Mutable(",
                     "  points=[",
-                    "    Point(x=1.5),",
+                    "    Point(",
+                    "      x=1.5,",
+                    "      y=0.0,",
+                    "    ),",
                     "    Point.Mutable(",
                     "      x=0.0,",
                     "      y=2.5,",
@@ -991,15 +1036,15 @@ class ModuleInitializerTestCase(unittest.TestCase):
             ),
         )
         self.assertEqual(
-            repr(json_value_cls.wrap_object(json_object_cls().DEFAULT)),
+            repr(json_value_cls.wrap_object(json_object_cls.DEFAULT)),
             "JsonValue.wrap_object(JsonValue.Object.DEFAULT)",
         )
         self.assertEqual(
-            repr(json_value_cls.wrap_object(json_object_cls())),
+            repr(json_value_cls.wrap_object(json_object_cls.partial())),
             "\n".join(
                 [
                     "JsonValue.wrap_object(",
-                    "  JsonValue.Object()",
+                    "  JsonValue.Object(entries=[])",
                     ")",
                 ]
             ),
@@ -1082,6 +1127,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         segment = segment_cls(
             a=point_cls(x=1.0, y=2.0),
             b=point_cls(x=3.0, y=4.0),
+            c=None,
         ).to_mutable()
         a = segment.mutable_a
         self.assertIsInstance(a, point_cls.Mutable)

{soia_client-1.0.29 → soia_client-1.1.0}/tests/test_timestamp.py

@@ -2,6 +2,7 @@ import dataclasses
 import unittest
 from datetime import datetime, timedelta, timezone
 from typing import Any
+from zoneinfo import ZoneInfo
 
 from soia import Timestamp
 
@@ -23,6 +24,14 @@ class TimestampTestCase(unittest.TestCase):
     def test_from_datetime(self):
         ts = Timestamp.from_datetime(datetime.fromtimestamp(200, tz=timezone.utc))
         self.assertEqual(ts.unix_millis, 200000)
+        ts = Timestamp.from_datetime(
+            datetime.fromtimestamp(200, tz=ZoneInfo("America/New_York"))
+        )
+        self.assertEqual(ts.unix_millis, 200000)
+        ts = Timestamp.from_datetime(datetime.fromtimestamp(200))
+        self.assertEqual(ts.unix_millis, 200000)
+        ts = Timestamp.from_datetime(datetime.min)
+        ts = Timestamp.from_datetime(datetime.max)
 
     def test_epoch(self):
         self.assertEqual(Timestamp.EPOCH.unix_millis, 0)
@@ -76,11 +85,12 @@ class TimestampTestCase(unittest.TestCase):
             pass
 
     def test_to_datetime(self):
-        ts = Timestamp.from_unix_seconds(200)
         self.assertEqual(
-            ts.to_datetime_or_raise(),
+            Timestamp.from_unix_seconds(200).to_datetime_or_raise(),
             datetime.fromtimestamp(200, tz=timezone.utc),
         )
+        Timestamp.from_datetime(datetime.min + timedelta(days=1)).to_datetime_or_raise()
+        Timestamp.from_datetime(datetime.max - timedelta(days=1)).to_datetime_or_raise()
 
     def test_to_datetime_out_of_bound(self):
         try:
@@ -88,6 +98,14 @@ class TimestampTestCase(unittest.TestCase):
             self.fail("Expected to fail with OverflowError or ValueError")
         except Exception:
             pass
+        self.assertEqual(
+            Timestamp.MIN.to_datetime_or_limit(),
+            datetime.min.replace(tzinfo=timezone.utc),
+        )
+        self.assertEqual(
+            Timestamp.MAX.to_datetime_or_limit(),
+            datetime.max.replace(tzinfo=timezone.utc),
+        )
 
     def test_add_timedelta(self):
         ts = Timestamp.from_unix_seconds(200)