soia-client 1.0.8__tar.gz → 1.0.10__tar.gz

{soia_client-1.0.8 → soia_client-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: soia-client
-Version: 1.0.8
+Version: 1.0.10
 Author-email: Tyler Fibonacci <gepheum@gmail.com>
 License: MIT License
         
@@ -31,3 +31,4 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file

{soia_client-1.0.8 → soia_client-1.0.10}/README

@@ -1 +1,5 @@
 python3 -m unittest tests/**.py
+
+pyright
+flake8
+black-formatter

{soia_client-1.0.8 → soia_client-1.0.10}/pyproject.toml

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

{soia_client-1.0.8 → soia_client-1.0.10}/soia_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: soia-client
-Version: 1.0.8
+Version: 1.0.10
 Author-email: Tyler Fibonacci <gepheum@gmail.com>
 License: MIT License
         
@@ -31,3 +31,4 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file

{soia_client-1.0.8 → soia_client-1.0.10}/soialib/impl/arrays.py

@@ -73,16 +73,13 @@ class _ArrayAdapter(TypeAdapter):
         return attr_expr
 
     def to_json_expr(self, in_expr: ExprLike, readable: bool) -> ExprLike:
-        e = Expr.join("_e")
-        item_to_json = self.item_adapter.to_json_expr(e, readable)
-        if item_to_json == e:
+        item_to_json = self.item_adapter.to_json_expr("_e", readable)
+        if Expr.join(item_to_json) == Expr.join("_e"):
             return in_expr
         return Expr.join(
             "[",
             item_to_json,
-            " for ",
-            e,
-            " in ",
+            " for _e in ",
             in_expr,
             "]",
         )
@@ -93,7 +90,7 @@ class _ArrayAdapter(TypeAdapter):
         return Expr.join(
             listuple_class_local,
             "([",
-            self.item_adapter.from_json_expr(Expr.join("_e")),
+            self.item_adapter.from_json_expr("_e"),
             " for _e in ",
             json_expr,
             "] or ",
@@ -121,14 +118,14 @@ def _new_listuple_class() -> type:
     return Listuple
 
 
-def _new_keyed_items_class(attributes: tuple[str, ...], default_expr: ExprLike):
+def _new_keyed_items_class(key_attributes: tuple[str, ...], default_expr: ExprLike):
     key_items = make_function(
         name="key_items",
         params=["items"],
         body=[
             "ret = {}",
             "for item in items:",
-            f"  ret[item.{'.'.join(attributes)}] = item",
+            f"  ret[item.{'.'.join(key_attributes)}] = item",
             "return ret",
         ],
     )

{soia_client-1.0.8 → soia_client-1.0.10}/soialib/impl/enums.py

@@ -292,7 +292,7 @@ def _make_wrap_fn(field: _ValueField) -> Callable[[Any], Any]:
     builder.append_ln(
         Expr.local("setattr", object.__setattr__),
         "(ret, 'value', ",
-        field.field_type.to_frozen_expr(Expr.join("value")),
+        field.field_type.to_frozen_expr("value"),
         ")",
     )
     builder.append_ln("return ret")
@@ -357,7 +357,7 @@ def _make_from_json_fn(
             number = numbers[0]
             field = key_to_field[number]
             value_class_local = Expr.local("cls?", field.value_class)
-            value_expr = field.field_type.from_json_expr(Expr.join("json[1]"))
+            value_expr = field.field_type.from_json_expr("json[1]")
             builder.append_ln(f"{indent}ret = ", value_class_local, "()")
             builder.append_ln(
                 indent, obj_setattr_local, '(ret, "value", ', value_expr, ")"

{soia_client-1.0.8 → soia_client-1.0.10}/soialib/impl/function_maker.py

@@ -49,12 +49,12 @@ def make_function(
 
     locals = make_locals()
 
-    def line_to_code(l: Union[str, Line]) -> str:
-        if isinstance(l, str):
-            return l
-        return l._to_code(locals)
+    def line_to_code(ln: Union[str, Line]) -> str:
+        if isinstance(ln, str):
+            return ln
+        return ln._to_code(locals)
 
-    body_str = "\n    ".join(line_to_code(l) for l in body) if body else "pass"
+    body_str = "\n    ".join(line_to_code(ln) for ln in body) if body else "pass"
     text = f"""
 def __create_function__({', '.join(locals.locals.keys())}):
   def {name}({', '.join(p._to_code(locals) for p in params)}):
@@ -152,7 +152,7 @@ class BodyBuilder:
         self._lines.append(Line.join(*spans))
 
     def extend(self, other: Iterable[Union[str, Line]], indent: str = ""):
-        self._lines.extend(Line.join(indent, l) for l in other)
+        self._lines.extend(Line.join(indent, ln) for ln in other)
         return self
 
     def build(self) -> Body:

{soia_client-1.0.8 → soia_client-1.0.10}/soialib/impl/primitives.py

@@ -52,44 +52,72 @@ class _AbstractIntAdapter(AbstractPrimitiveAdapter):
         return "0"
 
     def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
-        round_expr = Expr.local("round", round)
         # Must accept float inputs and turn them into ints.
-        return Expr.join("(", arg_expr, " | 0)")
+        return Expr.join("(0).__class__(", arg_expr, ")")
 
     def is_not_default_expr(self, arg_expr: ExprLike, attr_expr: ExprLike) -> ExprLike:
         return arg_expr
 
-    def to_json_expr(self, in_expr: ExprLike, readable: bool) -> ExprLike:
-        return in_expr
-
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
-        # Must accept float inputs and turn them into ints.
+        # Must accept float inputs and string inputs and turn them into ints.
         return Expr.join(
-            "(",
-            json_expr,
-            " if ",
-            json_expr,
-            ".__class__ is (0).__class__ else ",
-            Expr.local("_round", round),
-            "(",
+            "(0).__class__(",
             json_expr,
-            "))",
+            ")",
         )
 
 
 @dataclass(frozen=True)
 class _Int32Adapter(_AbstractIntAdapter):
-    pass
+    def to_json_expr(self, in_expr: ExprLike, readable: bool) -> Expr:
+        return Expr.join(
+            "(-2147483648 if ",
+            in_expr,
+            " <= -2147483648 else ",
+            in_expr,
+            " if ",
+            in_expr,
+            " < 2147483647 else 2147483647)",
+        )
+
+
+def _int64_to_json(i: int) -> int | str:
+    if i < -9007199254740991:  # min safe integer in JavaScript
+        if i <= -9223372036854775808:
+            return "-9223372036854775808"
+        else:
+            return str(i)
+    elif i <= 9007199254740991:  # max safe integer in JavaScript
+        return i
+    elif i < 9223372036854775807:
+        return str(i)
+    else:
+        return "9223372036854775807"
 
 
 @dataclass(frozen=True)
 class _Int64Adapter(_AbstractIntAdapter):
-    pass
+    def to_json_expr(self, in_expr: ExprLike, readable: bool) -> Expr:
+        return Expr.join(Expr.local("int64_to_json", _int64_to_json), "(", in_expr, ")")
+
+
+def _uint64_to_json(i: int) -> int | str:
+    if i <= 0:
+        return 0
+    elif i <= 9007199254740991:  # max safe integer in JavaScript
+        return i
+    elif i < 18446744073709551615:
+        return f"{i}"
+    else:
+        return "18446744073709551615"
 
 
 @dataclass(frozen=True)
 class _Uint64Adapter(_AbstractIntAdapter):
-    pass
+    def to_json_expr(self, in_expr: ExprLike, readable: bool) -> Expr:
+        return Expr.join(
+            Expr.local("uint64_to_json", _uint64_to_json), "(", in_expr, ")"
+        )
 
 
 INT32_ADAPTER: Final[TypeAdapter] = _Int32Adapter()

{soia_client-1.0.8 → soia_client-1.0.10}/soialib/impl/structs.py

@@ -178,7 +178,7 @@ class StructAdapter(TypeAdapter):
         )
 
     def is_not_default_expr(self, arg_expr: ExprLike, attr_expr: ExprLike) -> Expr:
-        return Expr.join(attr_expr, f"._array_len")
+        return Expr.join(attr_expr, "._array_len")
 
     def to_json_expr(
         self,
@@ -286,7 +286,7 @@ def _make_frozen_class_init_fn(
         # Set array length.
         builder.append_ln(
             obj_setattr,
-            f'(_self, "_array_len", ',
+            '(_self, "_array_len", ',
             array_len_expr(),
             ")",
         )
@@ -311,7 +311,7 @@ def _make_frozen_class_init_fn(
         # Set the _unrecognized field.
         builder.append_ln("_self._unrecognized = ()")
         # Set array length.
-        builder.append_ln(f"_self._array_len = ", array_len_expr())
+        builder.append_ln("_self._array_len = ", array_len_expr())
         # Change back the __class__.
         builder.append_ln("_self.__class__ = ", Expr.local("Frozen", frozen_class))
 
@@ -360,7 +360,7 @@ def _make_to_mutable_fn(
     Returns the implementation of the to_mutable() method of the frozen class.
     """
     builder = BodyBuilder()
-    # Create an instance of the simple class. We'll later change its __class__ attribute.
+    # Create an instance of the simple class. We'll later change its __class__ attr.
     builder.append_ln(
         "ret = ",
         Expr.local("Simple", simple_class),
@@ -392,7 +392,7 @@ def _make_to_frozen_fn(
     """
 
     builder = BodyBuilder()
-    # Create an instance of the simple class. We'll later change its __class__ attribute.
+    # Create an instance of the simple class. We'll later change its __class__ attr.
     builder.append_ln(
         "ret = ",
         Expr.local("Simple", simple_class),
@@ -457,6 +457,8 @@ def _make_eq_fn(
     """
 
     builder = BodyBuilder()
+    builder.append_ln("if other is self:")
+    builder.append_ln("  return True")
     builder.append_ln("if other.__class__ is self.__class__:")
     operands: list[ExprLike]
     if fields:
@@ -622,7 +624,7 @@ def _make_from_json_fn(
     )
     builder.append_ln("  else:")
     builder.append_ln(
-        f"    ret._unrecognized = ",
+        "    ret._unrecognized = ",
         Expr.local("deepcopy", copy.deepcopy),
         f"(json[{num_slots}:])",
     )
@@ -638,7 +640,7 @@ def _make_from_json_fn(
         builder.append_ln(f"    array_len = {field.field.number}")
         builder.append_ln(
             f"    {lvalue} = ",
-            field.type.from_json_expr(Expr.join(f'json["{name}"]')),
+            field.type.from_json_expr(f'json["{name}"]'),
         )
         builder.append_ln("  else:")
         builder.append_ln(f"    {lvalue} = ", field.type.default_expr())

{soia_client-1.0.8 → soia_client-1.0.10}/soialib/serializer.py

@@ -39,7 +39,7 @@ class Serializer(Generic[T]):
         )
         object.__setattr__(self, "_from_json_fn", _make_from_json_fn(adapter))
 
-    def to_json(self, input: T, readable=False) -> Any:
+    def to_json(self, input: T, *, readable=False) -> Any:
         if readable:
             return self._to_readable_json_fn(input)
         else:

{soia_client-1.0.8 → soia_client-1.0.10}/soialib/serializers.py

@@ -1,4 +1,4 @@
-from typing import Final, Literal, Optional, TypeVar, overload
+from typing import Final, Literal, TypeVar, overload
 
 from soialib.impl import primitives
 from soialib.impl.arrays import get_array_adapter
@@ -38,6 +38,8 @@ def primitive_serializer(primitive: Literal["timestamp"]) -> Serializer[Timestam
 def primitive_serializer(primitive: Literal["string"]) -> Serializer[str]: ...
 @overload
 def primitive_serializer(primitive: Literal["bytes"]) -> Serializer[bytes]: ...
+
+
 def primitive_serializer(
     primitive: (
         Literal["bool"]

{soia_client-1.0.8 → soia_client-1.0.10}/soialib/timestamp.py

@@ -54,6 +54,7 @@ class Timestamp:
     def __sub__(self, other: datetime.timedelta) -> "Timestamp": ...
     @overload
     def __sub__(self, other: "Timestamp") -> datetime.timedelta: ...
+
     def __sub__(
         self, other: Union["Timestamp", datetime.timedelta]
     ) -> Union["Timestamp", datetime.timedelta]:
@@ -111,7 +112,7 @@ class Timestamp:
     def _iso_format(self) -> str:
         try:
             dt = self.to_datetime_or_raise()
-        except:
+        except Exception:
             return ""
         if dt:
             ret = dt.isoformat()

{soia_client-1.0.8 → soia_client-1.0.10}/tests/test_module_initializer.py

@@ -294,6 +294,21 @@ class ModuleInitializerTestCase(unittest.TestCase):
                         ),
                     ),
                 ),
+                spec.Struct(
+                    id="my/module.soia:Rec",
+                    fields=(
+                        spec.Field(
+                            name="r",
+                            number=0,
+                            type="my/module.soia:Rec",
+                        ),
+                        spec.Field(
+                            name="x",
+                            number=1,
+                            type=spec.PrimitiveType.INT32,
+                        ),
+                    ),
+                ),
                 spec.Struct(
                     id="my/module.soia:Foobar",
                     fields=(
@@ -530,6 +545,14 @@ class ModuleInitializerTestCase(unittest.TestCase):
         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))
+        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)")
+
     def test_struct_ctor_accepts_mutable_struct(self):
         module = self.init_test_module()
         segment_cls = module["Segment"]

soia_client-1.0.10/tests/test_serializers.py

@@ -0,0 +1,155 @@
+import unittest
+
+from soialib import (
+    Timestamp,
+    array_serializer,
+    optional_serializer,
+    primitive_serializer,
+)
+
+
+class TimestampTestCase(unittest.TestCase):
+    def test_primitive_serializers(self):
+        self.assertEqual(primitive_serializer("bool").to_json_code(True), "1")
+        self.assertEqual(
+            primitive_serializer("bool").to_json_code(True, readable=True),
+            "true",
+        )
+        self.assertEqual(primitive_serializer("bool").from_json_code("true"), True)
+        self.assertEqual(primitive_serializer("bool").from_json_code("false"), False)
+        self.assertEqual(primitive_serializer("bool").from_json_code("0"), False)
+
+        self.assertEqual(primitive_serializer("int32").to_json_code(7), "7")
+        self.assertEqual(
+            primitive_serializer("int32").to_json_code(7, readable=True), "7"
+        )
+        self.assertEqual(
+            primitive_serializer("int32").to_json_code(2147483648), "2147483647"
+        )
+        self.assertEqual(
+            primitive_serializer("int32").to_json_code(-2147483649), "-2147483648"
+        )
+        self.assertEqual(primitive_serializer("int32").from_json_code("0"), 0)
+        self.assertEqual(primitive_serializer("int32").from_json_code('"7"'), 7)
+        self.assertEqual(primitive_serializer("int32").from_json_code("3.14"), 3)
+        self.assertEqual(primitive_serializer("int32").from_json_code("-3.14"), -3)
+
+        self.assertEqual(
+            primitive_serializer("int64").to_json_code(2147483648), "2147483648"
+        )
+        self.assertEqual(
+            primitive_serializer("int64").to_json_code(9007199254740991),
+            "9007199254740991",
+        )
+        self.assertEqual(
+            primitive_serializer("int64").to_json_code(9007199254740992),
+            '"9007199254740992"',
+        )
+        self.assertEqual(
+            primitive_serializer("int64").to_json_code(9223372036854775808),
+            '"9223372036854775807"',
+        )
+        self.assertEqual(
+            primitive_serializer("int64").to_json_code(-9007199254740991),
+            "-9007199254740991",
+        )
+        self.assertEqual(
+            primitive_serializer("int64").to_json_code(-9007199254740992),
+            '"-9007199254740992"',
+        )
+        self.assertEqual(
+            primitive_serializer("int64").to_json_code(-9223372036854775809),
+            '"-9223372036854775808"',
+        )
+        self.assertEqual(primitive_serializer("int64").from_json_code("0"), 0)
+        self.assertEqual(primitive_serializer("int64").from_json_code('"7"'), 7)
+        self.assertEqual(primitive_serializer("int64").from_json_code("3.14"), 3)
+        self.assertEqual(primitive_serializer("int64").from_json_code("-3.14"), -3)
+
+        self.assertEqual(
+            primitive_serializer("uint64").to_json_code(2147483648),
+            "2147483648",
+        )
+        self.assertEqual(
+            primitive_serializer("uint64").to_json_code(-1),
+            "0",
+        )
+        self.assertEqual(
+            primitive_serializer("uint64").to_json_code(9007199254740991),
+            "9007199254740991",
+        )
+        self.assertEqual(
+            primitive_serializer("uint64").to_json_code(9007199254740992),
+            '"9007199254740992"',
+        )
+        self.assertEqual(primitive_serializer("uint64").from_json_code("0"), 0)
+        self.assertEqual(primitive_serializer("uint64").from_json_code('"7"'), 7)
+        self.assertEqual(primitive_serializer("uint64").from_json_code("3.14"), 3)
+        self.assertEqual(primitive_serializer("uint64").from_json_code("-3.14"), -3)
+
+        self.assertEqual(primitive_serializer("float32").to_json_code(3.14), "3.14")
+        self.assertEqual(
+            primitive_serializer("float32").to_json_code(float("inf")), "Infinity"
+        )
+        self.assertEqual(
+            primitive_serializer("float32").to_json_code(-float("inf")), "-Infinity"
+        )
+        self.assertEqual(
+            primitive_serializer("float32").to_json_code(float("nan")), "NaN"
+        )
+        self.assertEqual(primitive_serializer("float64").to_json_code(3.14), "3.14")
+        self.assertEqual(
+            primitive_serializer("float64").to_json_code(3.14, readable=True),
+            "3.14",
+        )
+
+        self.assertEqual(
+            primitive_serializer("timestamp").to_json_code(
+                Timestamp.from_unix_millis(3)
+            ),
+            "3",
+        )
+        self.assertEqual(
+            primitive_serializer("timestamp").to_json_code(
+                Timestamp.from_unix_millis(3), readable=True
+            ),
+            '{\n  "unix_millis": 3,\n  "formatted": "1970-01-01T00:00:00.003000Z"\n}',
+        )
+        self.assertEqual(
+            primitive_serializer("timestamp").from_json_code("3"),
+            Timestamp.from_unix_millis(3),
+        )
+        self.assertEqual(
+            primitive_serializer("timestamp").from_json_code(
+                '{\n  "unix_millis": 3,\n  "formatted": "FOO",\n  "bar": true\n}'
+            ),
+            Timestamp.from_unix_millis(3),
+        )
+
+    def test_array_serializer(self):
+        self.assertEqual(
+            array_serializer(primitive_serializer("bool")).to_json_code((True, False)),
+            "[1,0]",
+        )
+        self.assertEqual(
+            array_serializer(primitive_serializer("bool")).to_json_code(
+                (True, False), readable=True
+            ),
+            "[\n  true,\n  false\n]",
+        )
+
+    def test_optional_serializer(self):
+        self.assertEqual(
+            optional_serializer(primitive_serializer("bool")).to_json_code(True),
+            "1",
+        )
+        self.assertEqual(
+            optional_serializer(primitive_serializer("bool")).to_json_code(
+                True, readable=True
+            ),
+            "true",
+        )
+        self.assertEqual(
+            optional_serializer(primitive_serializer("bool")).to_json_code(None),
+            "null",
+        )

{soia_client-1.0.8 → soia_client-1.0.10}/tests/test_timestamp.py

@@ -87,7 +87,7 @@ class TimestampTestCase(unittest.TestCase):
         try:
             Timestamp.MIN.to_datetime_or_raise()
             self.fail("Expected to fail with OverflowError or ValueError")
-        except Exception as e:
+        except Exception:
             pass
 
     def test_add_timedelta(self):

soia_client-1.0.8/tests/test_serializers.py

@@ -1,76 +0,0 @@
-import unittest
-
-from soialib import (
-    Timestamp,
-    array_serializer,
-    optional_serializer,
-    primitive_serializer,
-)
-
-
-class TimestampTestCase(unittest.TestCase):
-    def test_primitive_serializers(self):
-        self.assertEqual(primitive_serializer("bool").to_json_code(True), "1")
-        self.assertEqual(
-            primitive_serializer("bool").to_json_code(True, readable=True),
-            "true",
-        )
-        self.assertEqual(primitive_serializer("int32").to_json_code(7), "7")
-        self.assertEqual(
-            primitive_serializer("int32").to_json_code(7, readable=True), "7"
-        )
-        self.assertEqual(
-            primitive_serializer("int64").to_json_code(2147483648), "2147483648"
-        )
-        self.assertEqual(
-            primitive_serializer("uint64").to_json_code(2147483648),
-            "2147483648",
-        )
-        self.assertEqual(primitive_serializer("float32").to_json_code(3.14), "3.14")
-        self.assertEqual(primitive_serializer("float64").to_json_code(3.14), "3.14")
-        self.assertEqual(
-            primitive_serializer("float64").to_json_code(3.14, readable=True),
-            "3.14",
-        )
-        self.assertEqual(
-            primitive_serializer("timestamp").to_json_code(
-                Timestamp.from_unix_millis(3)
-            ),
-            "3",
-        )
-        self.assertEqual(
-            primitive_serializer("timestamp").to_json_code(
-                Timestamp.from_unix_millis(3), readable=True
-            ),
-            '{\n  "unix_millis": 3,\n  "formatted": "1970-01-01T00:00:00.003000Z"\n}',
-        )
-        self.assertEqual(primitive_serializer("string").to_json_code("foo"), '"foo"')
-        self.assertEqual(primitive_serializer("bytes").to_json_code(b"foo"), '"666f6f"')
-
-    def test_array_serializer(self):
-        self.assertEqual(
-            array_serializer(primitive_serializer("bool")).to_json_code((True, False)),
-            "[1,0]",
-        )
-        self.assertEqual(
-            array_serializer(primitive_serializer("bool")).to_json_code(
-                (True, False), readable=True
-            ),
-            "[\n  true,\n  false\n]",
-        )
-
-    def test_optional_serializer(self):
-        self.assertEqual(
-            optional_serializer(primitive_serializer("bool")).to_json_code(True),
-            "1",
-        )
-        self.assertEqual(
-            optional_serializer(primitive_serializer("bool")).to_json_code(
-                True, readable=True
-            ),
-            "true",
-        )
-        self.assertEqual(
-            optional_serializer(primitive_serializer("bool")).to_json_code(None),
-            "null",
-        )