soia-client 1.0.4__tar.gz → 1.0.5__tar.gz

{soia_client-1.0.4 → soia_client-1.0.5}/PKG-INFO

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

{soia_client-1.0.4 → soia_client-1.0.5}/pyproject.toml

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

{soia_client-1.0.4 → soia_client-1.0.5}/soia_client.egg-info/PKG-INFO

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

{soia_client-1.0.4 → soia_client-1.0.5}/soia_client.egg-info/SOURCES.txt

@@ -7,9 +7,11 @@ soia_client.egg-info/dependency_links.txt
 soia_client.egg-info/top_level.txt
 soialib/__init__.py
 soialib/keyed_items.py
+soialib/method.py
 soialib/module_initializer.py
 soialib/never.py
 soialib/serializer.py
+soialib/serializers.py
 soialib/spec.py
 soialib/timestamp.py
 soialib/impl/__init__.py
@@ -23,4 +25,5 @@ soialib/impl/repr.py
 soialib/impl/structs.py
 soialib/impl/type_adapter.py
 tests/test_module_initializer.py
+tests/test_serializers.py
 tests/test_timestamp.py

soia_client-1.0.5/soialib/__init__.py

@@ -0,0 +1,19 @@
+from soialib.keyed_items import KeyedItems
+from soialib.method import Method
+from soialib.serializer import Serializer
+from soialib.serializers import (
+    array_serializer,
+    optional_serializer,
+    primitive_serializer,
+)
+from soialib.timestamp import Timestamp
+
+__all__ = [
+    "KeyedItems",
+    "Method",
+    "Serializer",
+    "Timestamp",
+    "array_serializer",
+    "optional_serializer",
+    "primitive_serializer",
+]

{soia_client-1.0.4 → soia_client-1.0.5}/soialib/impl/arrays.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from dataclasses import FrozenInstanceError
 from typing import Generic, Optional
-from weakref import WeakKeyDictionary
+from weakref import WeakValueDictionary
 
 from soialib import spec
 from soialib.impl.function_maker import Any, Expr, ExprLike, Line, make_function
@@ -19,8 +19,9 @@ def get_array_adapter(
     else:
         listuple_class = _new_listuple_class()
     array_adapter = _ArrayAdapter(item_adapter, listuple_class)
-    key_spec_to_array_adapter = _item_to_array_adapters.setdefault(item_adapter, {})
-    return key_spec_to_array_adapter.setdefault(key_attributes, array_adapter)
+    return _item_to_array_adapter.setdefault(
+        (item_adapter, key_attributes), array_adapter
+    )
 
 
 class _ArrayAdapter(TypeAdapter):
@@ -107,10 +108,10 @@ class _ArrayAdapter(TypeAdapter):
         self.item_adapter.finalize(resolve_type_fn)
 
 
-_KeyAttributesToArrayAdapter = dict[tuple[str, ...], _ArrayAdapter]
-_ItemToArrayAdapters = WeakKeyDictionary[TypeAdapter, _KeyAttributesToArrayAdapter]
+_ItemAndKeyAttributes = tuple[TypeAdapter, tuple[str, ...]]
+_ItemToArrayAdapter = WeakValueDictionary[_ItemAndKeyAttributes, _ArrayAdapter]
 
-_item_to_array_adapters: _ItemToArrayAdapters = WeakKeyDictionary()
+_item_to_array_adapter: _ItemToArrayAdapter = WeakValueDictionary()
 
 
 def _new_listuple_class() -> type:

{soia_client-1.0.4 → soia_client-1.0.5}/soialib/impl/optionals.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import TypeVar
-from weakref import WeakKeyDictionary
+from weakref import WeakValueDictionary
 
 from soialib import spec
 from soialib.impl.encoding import NULL_WIRE
@@ -69,6 +69,6 @@ class _OptionalAdapter(TypeAdapter):
         self.other_adapter.finalize(resolve_type_fn)
 
 
-_other_adapter_to_optional_adapter: WeakKeyDictionary[TypeAdapter, TypeAdapter] = (
-    WeakKeyDictionary()
+_other_adapter_to_optional_adapter: WeakValueDictionary[TypeAdapter, TypeAdapter] = (
+    WeakValueDictionary()
 )

soia_client-1.0.5/soialib/method.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+from soialib.serializer import Serializer
+
+Request = TypeVar("Request")
+Response = TypeVar("Response")
+
+
+@dataclass(frozen=True)
+class Method(Generic[Request, Response]):
+    """Identifies a procedure (the "P" in "RPC") on both client side and server side."""
+
+    name: str
+    number: int
+    request_serializer: Serializer[Request]
+    response_serializer: Serializer[Response]

{soia_client-1.0.4 → soia_client-1.0.5}/soialib/module_initializer.py

@@ -1,6 +1,6 @@
 from typing import Any, Union
 
-from soialib import spec
+from soialib import method, spec
 from soialib.impl import arrays, enums, optionals, primitives, structs
 from soialib.impl.type_adapter import TypeAdapter
 from soialib.serializer import make_serializer
@@ -11,8 +11,10 @@ RecordAdapter = Union[structs.StructAdapter, enums.EnumAdapter]
 _record_id_to_adapter: dict[str, RecordAdapter] = {}
 
 
-def init_module_classes(
+def init_module(
     records: tuple[spec.Record, ...],
+    methods: tuple[spec.Method, ...],
+    constants: tuple[spec.Constant, ...],
     globals: dict[str, Any],
     # For testing
     record_id_to_adapter: dict[str, RecordAdapter] = _record_id_to_adapter,
@@ -77,3 +79,22 @@ def init_module_classes(
             gen_class._parent_class = None
         # TODO: comment
         gen_class.SERIALIZER = make_serializer(adapter)
+
+    # Now that al the classes have been initialized, create the methods.
+    for method_spec in methods:
+        var_name = method_spec._var_name or method_spec.name
+        request_serializer = make_serializer(resolve_type(method_spec.request_type))
+        response_serializer = make_serializer(resolve_type(method_spec.response_type))
+        globals[var_name] = method.Method(
+            name=method_spec.name,
+            number=method_spec.number,
+            request_serializer=request_serializer,
+            response_serializer=response_serializer,
+        )
+        del var_name, request_serializer, response_serializer
+
+    # Create the constants.
+    for constant in constants:
+        serializer = make_serializer(resolve_type(constant.type))
+        globals[constant.name] = serializer.from_json_code(constant.json_code)
+        del serializer

{soia_client-1.0.4 → soia_client-1.0.5}/soialib/serializer.py

@@ -2,6 +2,7 @@ import json as jsonlib
 from collections.abc import Callable
 from dataclasses import FrozenInstanceError
 from typing import Any, Generic, TypeVar, cast, final
+from weakref import WeakValueDictionary
 
 from soialib.impl.function_maker import Expr, LineSpan, make_function
 from soialib.impl.type_adapter import TypeAdapter
@@ -13,17 +14,21 @@ T = TypeVar("T")
 @final
 class Serializer(Generic[T]):
     __slots__ = (
+        "__weakref__",
+        "_adapter",
         "_to_dense_json_fn",
         "_to_readable_json_fn",
         "_from_json_fn",
     )
 
+    _adapter: TypeAdapter
     _to_dense_json_fn: Callable[[T], Any]
     _to_readable_json_fn: Callable[[T], Any]
     _from_json_fn: Callable[[Any], T]
 
     def __init__(self, adapter: Never):
         # Use Never (^) as a trick to make the constructor internal.
+        object.__setattr__(self, "_adapter", adapter)
         object.__setattr__(
             self, "_to_dense_json_fn", _make_to_json_fn(adapter, readable=False)
         )
@@ -56,8 +61,16 @@ class Serializer(Generic[T]):
         raise FrozenInstanceError(self.__class__.__qualname__)
 
 
+# A cache to make sure we only create one Serializer for each TypeAdapter.
+_type_adapter_to_serializer: WeakValueDictionary[TypeAdapter, Serializer] = (
+    WeakValueDictionary()
+)
+
+
 def make_serializer(adapter: TypeAdapter) -> Serializer:
-    return Serializer(cast(Never, adapter))
+    return _type_adapter_to_serializer.setdefault(
+        adapter, Serializer(cast(Never, adapter))
+    )
 
 
 def _make_to_json_fn(adapter: TypeAdapter, readable: bool) -> Callable[[Any], Any]:

soia_client-1.0.5/soialib/serializers.py

@@ -0,0 +1,74 @@
+from typing import Final, Literal, Optional, TypeVar, overload
+
+from soialib.impl import primitives
+from soialib.impl.arrays import get_array_adapter
+from soialib.impl.optionals import get_optional_adapter
+from soialib.serializer import Serializer, make_serializer
+from soialib.timestamp import Timestamp
+
+Item = TypeVar("Item")
+Other = TypeVar("Other")
+
+
+def array_serializer(item_serializer: Serializer[Item]) -> Serializer[tuple[Item, ...]]:
+    return make_serializer(get_array_adapter(item_serializer._adapter, ()))
+
+
+def optional_serializer(
+    other_serializer: Serializer[Other],
+) -> Serializer[Other | None]:
+    return make_serializer(get_optional_adapter(other_serializer._adapter))
+
+
+@overload
+def primitive_serializer(primitive: Literal["bool"]) -> Serializer[bool]: ...
+@overload
+def primitive_serializer(primitive: Literal["int32"]) -> Serializer[int]: ...
+@overload
+def primitive_serializer(primitive: Literal["int64"]) -> Serializer[int]: ...
+@overload
+def primitive_serializer(primitive: Literal["uint64"]) -> Serializer[int]: ...
+@overload
+def primitive_serializer(primitive: Literal["float32"]) -> Serializer[float]: ...
+@overload
+def primitive_serializer(primitive: Literal["float64"]) -> Serializer[float]: ...
+@overload
+def primitive_serializer(primitive: Literal["timestamp"]) -> Serializer[Timestamp]: ...
+@overload
+def primitive_serializer(primitive: Literal["string"]) -> Serializer[str]: ...
+@overload
+def primitive_serializer(primitive: Literal["bytes"]) -> Serializer[bytes]: ...
+def primitive_serializer(
+    primitive: (
+        Literal["bool"]
+        | Literal["int32"]
+        | Literal["int64"]
+        | Literal["uint64"]
+        | Literal["float32"]
+        | Literal["float64"]
+        | Literal["timestamp"]
+        | Literal["string"]
+        | Literal["bytes"]
+    ),
+) -> (
+    Serializer[bool]
+    | Serializer[int]
+    | Serializer[float]
+    | Serializer[Timestamp]
+    | Serializer[str]
+    | Serializer[bytes]
+):
+    return _PRIMITIVE_TO_SERIALIZER[primitive]
+
+
+_PRIMITIVE_TO_SERIALIZER: Final = {
+    "bool": make_serializer(primitives.BOOL_ADAPTER),
+    "int32": make_serializer(primitives.INT32_ADAPTER),
+    "int64": make_serializer(primitives.INT64_ADAPTER),
+    "uint64": make_serializer(primitives.UINT64_ADAPTER),
+    "float32": make_serializer(primitives.FLOAT32_ADAPTER),
+    "float64": make_serializer(primitives.FLOAT64_ADAPTER),
+    "timestamp": make_serializer(primitives.TIMESTAMP_ADAPTER),
+    "string": make_serializer(primitives.STRING_ADAPTER),
+    "bytes": make_serializer(primitives.BYTES_ADAPTER),
+}

{soia_client-1.0.4 → soia_client-1.0.5}/soialib/spec.py

@@ -141,3 +141,19 @@ class RecordId:
             qualname=parent_qualname,
             name_parts=parent_name_parts,
         )
+
+
+@dataclass(frozen=True)
+class Method:
+    name: str
+    number: int
+    request_type: Type
+    response_type: Type
+    _var_name: str = ""  # If different from 'name'
+
+
+@dataclass(frozen=True)
+class Constant:
+    name: str
+    type: Type
+    json_code: str

{soia_client-1.0.4 → soia_client-1.0.5}/tests/test_module_initializer.py

@@ -5,15 +5,16 @@ from typing import Any
 
 from soialib import spec
 from soialib.keyed_items import KeyedItems
-from soialib.module_initializer import init_module_classes
+from soialib.method import Method
+from soialib.module_initializer import init_module
 from soialib.timestamp import Timestamp
 
 
 class ModuleInitializerTestCase(unittest.TestCase):
-    def init_test_module_classes(self) -> dict[str, Any]:
+    def init_test_module(self) -> dict[str, Any]:
         globals: dict[str, Any] = {}
-        init_module_classes(
-            (
+        init_module(
+            records=(
                 spec.Struct(
                     id="my/module.soia:Point",
                     fields=(
@@ -259,19 +260,41 @@ class ModuleInitializerTestCase(unittest.TestCase):
                     ),
                 ),
             ),
+            methods=(
+                spec.Method(
+                    name="FirstMethod",
+                    number=-300,
+                    request_type="my/module.soia:Point",
+                    response_type="my/module.soia:Shape",
+                ),
+                spec.Method(
+                    name="SecondMethod",
+                    number=-301,
+                    request_type="my/module.soia:Point",
+                    response_type="my/module.soia:Shape",
+                    _var_name="MethodVar",
+                ),
+            ),
+            constants=(
+                spec.Constant(
+                    name="C",
+                    type="my/module.soia:Point",
+                    json_code="[1.5, 2.5]",
+                ),
+            ),
             globals=globals,
             record_id_to_adapter={},
         )
         return globals
 
     def test_struct_getters(self):
-        point_cls = self.init_test_module_classes()["Point"]
+        point_cls = self.init_test_module()["Point"]
         point = point_cls(x=1.5, y=2.5)
         self.assertEqual(point.x, 1.5)
         self.assertEqual(point.y, 2.5)
 
     def test_to_mutable(self):
-        point_cls = self.init_test_module_classes()["Point"]
+        point_cls = self.init_test_module()["Point"]
         point = point_cls(x=1.5, y=2.5)
         mutable = point.to_mutable()
         mutable.x = 4.0
@@ -281,7 +304,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertIs(point.to_frozen(), point)
 
     def test_struct_eq(self):
-        point_cls = self.init_test_module_classes()["Point"]
+        point_cls = self.init_test_module()["Point"]
         a = point_cls(x=1.5, y=2.5)
         b = point_cls(x=1.5, y=2.5)
         c = point_cls(x=1.5, y=3.0)
@@ -292,11 +315,11 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertEqual(point_cls(), point_cls(x=0.0, y=0.0))
 
     def test_or_mutable(self):
-        point_cls = self.init_test_module_classes()["Point"]
+        point_cls = self.init_test_module()["Point"]
         point_cls.OrMutable
 
     def test_default_values(self):
-        primitives_cls = self.init_test_module_classes()["Primitives"]
+        primitives_cls = self.init_test_module()["Primitives"]
         a = primitives_cls(
             bool=False,
             bytes=b"",
@@ -311,29 +334,29 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertEqual(hash(a), hash(b))
 
     def test_to_dense_json(self):
-        point_cls = self.init_test_module_classes()["Point"]
+        point_cls = self.init_test_module()["Point"]
         point = point_cls(x=1.5, y=2.5)
         json = point_cls.SERIALIZER.to_json(point)
         self.assertEqual(json, [1.5, 2.5])
 
     def test_to_readable_json(self):
-        point_cls = self.init_test_module_classes()["Point"]
+        point_cls = self.init_test_module()["Point"]
         point = point_cls(x=1.5, y=2.5)
         json = point_cls.SERIALIZER.to_json(point, readable_flavor=True)
         self.assertEqual(json, {"x": 1.5, "y": 2.5})
 
     def test_from_dense_json(self):
-        point_cls = self.init_test_module_classes()["Point"]
+        point_cls = self.init_test_module()["Point"]
         point = point_cls.SERIALIZER.from_json([1.5, 2.5])
         self.assertEqual(point, point_cls(x=1.5, y=2.5))
 
     def test_from_readable_json(self):
-        point_cls = self.init_test_module_classes()["Point"]
+        point_cls = self.init_test_module()["Point"]
         point = point_cls.SERIALIZER.from_json({"x": 1.5, "y": 2.5})
         self.assertEqual(point, point_cls(x=1.5, y=2.5))
 
     def test_struct_ctor_accepts_mutable_struct(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         segment_cls = module["Segment"]
         point_cls = module["Point"]
         segment = segment_cls(
@@ -350,7 +373,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         )
 
     def test_struct_ctor_checks_type_of_struct_param(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         segment_cls = module["Segment"]
         try:
             segment_cls(
@@ -362,11 +385,11 @@ class ModuleInitializerTestCase(unittest.TestCase):
             self.assertIn("Point", str(e))
 
     def test_struct_ctor_raises_error_if_unknown_arg(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         segment_cls = module["Segment"]
 
     def test_to_frozen_checks_type_of_struct_field(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         segment_cls = module["Segment"]
         mutable = segment_cls.Mutable()
         mutable.a = segment_cls.DEFAULT  # Should be a Point
@@ -377,7 +400,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
             self.assertIn("Point", str(e))
 
     def test_struct_ctor_accepts_mutable_list(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         shape_cls = module["Shape"]
         point_cls = module["Point"]
         shape = shape_cls(
@@ -397,7 +420,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         )
 
     def test_listuple_not_copied(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         shape_cls = module["Shape"]
         point_cls = module["Point"]
         shape = shape_cls(
@@ -412,7 +435,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertIsNot(other_shape.points.__class__, tuple)
 
     def test_single_empty_listuple_instance(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         shape_cls = module["Shape"]
         shape = shape_cls(
             points=[],
@@ -422,7 +445,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertIsNot(shape.points, ())
 
     def test_optional(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         segment_cls = module["Segment"]
         point_cls = module["Point"]
         segment = segment_cls(
@@ -437,7 +460,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         )
 
     def test_enum_unknown_constant(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         primary_color_cls = module["PrimaryColor"]
         unknown = primary_color_cls.UNKNOWN
         self.assertEqual(unknown.kind, "?")
@@ -448,7 +471,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertEqual(serializer.to_json(unknown, readable_flavor=True), "?")
 
     def test_enum_user_defined_constant(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         primary_color_cls = module["PrimaryColor"]
         red = primary_color_cls.RED
         self.assertEqual(red.kind, "RED")
@@ -459,7 +482,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertEqual(serializer.to_json(red, readable_flavor=True), "RED")
 
     def test_enum_wrap(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         status_cls = module["Status"]
         error = status_cls.wrap_error("An error occurred")
         self.assertEqual(error.kind, "error")
@@ -473,7 +496,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         )
 
     def test_enum_wrap_around_mutable_struct(self):
-        module = self.init_test_module_classes()
+        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())
@@ -484,7 +507,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         )
 
     def test_class_name(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         shape_cls = module["Shape"]
         json_value_cls = module["JsonValue"]
         json_object_cls = json_value_cls.Object
@@ -496,7 +519,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertEqual(json_object_cls.__qualname__, "JsonValue.Object")
 
     def test_struct_repr(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         point_cls = module["Point"]
         self.assertEqual(
             repr(point_cls(x=1.5)),
@@ -609,7 +632,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         )
 
     def test_enum_constant_repr(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         primary_color_cls = module["PrimaryColor"]
         parent_cls = module["Parent"]
         nested_enum_cls = parent_cls.NestedEnum
@@ -618,7 +641,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertEqual(repr(nested_enum_cls.UNKNOWN), "Parent.NestedEnum.UNKNOWN")
 
     def test_enum_value_repr(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         status_cls = module["Status"]
         json_value_cls = module["JsonValue"]
         json_object_cls = json_value_cls.Object
@@ -656,7 +679,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         )
 
     def test_find_in_keyed_items(self):
-        json_value_cls = self.init_test_module_classes()["JsonValue"]
+        json_value_cls = self.init_test_module()["JsonValue"]
         object_cls = json_value_cls.Object
         entry_cls = json_value_cls.ObjectEntry
         json_object = object_cls(
@@ -688,7 +711,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertIs(entries.find_or_default("zoo"), entry_cls.DEFAULT)
 
     def test_find_in_keyed_items_with_complex_path(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         stuff_cls = module["Stuff"]
         enum_wrapper_cls = module["EnumWrapper"]
         status_cls = module["Status"]
@@ -714,14 +737,14 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertIs(enum_wrappers.find("error"), enum_wrappers[1])
 
     def test_name_overrides(self):
-        name_overrides_cls = self.init_test_module_classes()["Stuff"].NameOverrides
+        name_overrides_cls = self.init_test_module()["Stuff"].NameOverrides
         name_overrides = name_overrides_cls(y=3)
         self.assertEqual(name_overrides.y, 3)
         self.assertEqual(name_overrides_cls.__name__, "NameOverrides")
         self.assertEqual(name_overrides_cls.__qualname__, "Stuff.NameOverrides")
 
     def test_mutable_getter_of_struct(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         segment_cls = module["Segment"]
         point_cls = module["Point"]
         segment = segment_cls(
@@ -739,7 +762,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
             self.assertEqual(str(e), "expected: Point or Point.Mutable; found: str")
 
     def test_mutable_getter_of_array(self):
-        module = self.init_test_module_classes()
+        module = self.init_test_module()
         shape_cls = module["Shape"]
         point_cls = module["Point"]
         shape = shape_cls(
@@ -751,3 +774,32 @@ class ModuleInitializerTestCase(unittest.TestCase):
         points = shape.mutable_points
         self.assertIsInstance(points, list)
         self.assertIs(shape.mutable_points, points)
+
+    def test_methods(self):
+        module = self.init_test_module()
+        first_method = module["FirstMethod"]
+        self.assertEqual(
+            first_method,
+            Method(
+                name="FirstMethod",
+                number=-300,
+                request_serializer=module["Point"].SERIALIZER,
+                response_serializer=module["Shape"].SERIALIZER,
+            ),
+        )
+        second_method = module["MethodVar"]
+        self.assertEqual(
+            second_method,
+            Method(
+                name="SecondMethod",
+                number=-301,
+                request_serializer=module["Point"].SERIALIZER,
+                response_serializer=module["Shape"].SERIALIZER,
+            ),
+        )
+
+    def test_constants(self):
+        module = self.init_test_module()
+        c = module["C"]
+        Point = module["Point"]
+        self.assertEqual(c, Point(1.5, 2.5))

soia_client-1.0.5/tests/test_serializers.py

@@ -0,0 +1,47 @@
+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), "true")
+        self.assertEqual(primitive_serializer("int32").to_json_code(7), "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("timestamp").to_json_code(
+                Timestamp.from_unix_millis(3)
+            ),
+            "3",
+        )
+        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]),
+            "[true, false]",
+        )
+
+    def test_optional_serializer(self):
+        self.assertEqual(
+            optional_serializer(primitive_serializer("bool")).to_json_code(True),
+            "true",
+        )
+        self.assertEqual(
+            optional_serializer(primitive_serializer("bool")).to_json_code(None),
+            "null",
+        )

{soia_client-1.0.4 → soia_client-1.0.5}/tests/test_timestamp.py

@@ -3,6 +3,7 @@ import unittest
 from datetime import datetime, timedelta, timezone
 from typing import Any
 
+import soialib
 from soialib.timestamp import Timestamp
 
 
@@ -121,3 +122,6 @@ class TimestampTestCase(unittest.TestCase):
             repr(Timestamp.MIN),
             "Timestamp(unix_millis=-8640000000000000)",
         )
+
+    def test_exported_from_soialib(self):
+        self.assertIs(soialib.Timestamp, Timestamp)

soia_client-1.0.4/soialib/__init__.py

@@ -1,5 +0,0 @@
-from soialib.keyed_items import KeyedItems
-from soialib.serializer import Serializer
-from soialib.timestamp import Timestamp
-
-__all__ = ["KeyedItems", "Serializer", "Timestamp"]