soia-client 1.0.11__tar.gz → 1.0.13__tar.gz

{soia_client-1.0.11 → soia_client-1.0.13}/PKG-INFO

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

{soia_client-1.0.11 → soia_client-1.0.13}/pyproject.toml

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

{soia_client-1.0.11 → soia_client-1.0.13}/soia_client.egg-info/PKG-INFO

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

{soia_client-1.0.11 → soia_client-1.0.13}/soia_client.egg-info/SOURCES.txt

@@ -11,8 +11,10 @@ soialib/keyed_items.py
 soialib/method.py
 soialib/module_initializer.py
 soialib/never.py
+soialib/reflection.py
 soialib/serializer.py
 soialib/serializers.py
+soialib/service.py
 soialib/service_client.py
 soialib/spec.py
 soialib/timestamp.py

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/__init__.py

@@ -6,13 +6,17 @@ from soialib.serializers import (
     optional_serializer,
     primitive_serializer,
 )
+from soialib.service import RequestHeaders, ResponseHeaders, ServiceImpl
 from soialib.service_client import ServiceClient
 from soialib.timestamp import Timestamp
 
 __all__ = [
     "KeyedItems",
     "Method",
+    "RequestHeaders",
+    "ResponseHeaders",
     "Serializer",
+    "ServiceImpl",
     "ServiceClient",
     "Timestamp",
     "array_serializer",

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/impl/arrays.py

@@ -3,6 +3,7 @@ from dataclasses import FrozenInstanceError
 from typing import Generic, Optional
 from weakref import WeakValueDictionary
 
+import soialib.reflection
 from soialib import spec
 from soialib.impl.function_maker import Any, Expr, ExprLike, Line, make_function
 from soialib.impl.type_adapter import TypeAdapter
@@ -18,7 +19,7 @@ def get_array_adapter(
         listuple_class = _new_keyed_items_class(key_attributes, default_expr)
     else:
         listuple_class = _new_listuple_class()
-    array_adapter = _ArrayAdapter(item_adapter, listuple_class)
+    array_adapter = _ArrayAdapter(item_adapter, listuple_class, key_attributes)
     return _item_to_array_adapter.setdefault(
         (item_adapter, key_attributes), array_adapter
     )
@@ -28,6 +29,7 @@ class _ArrayAdapter(TypeAdapter):
     __slots__ = (
         "item_adapter",
         "listuple_class",
+        "key_attributes",
         "empty_listuple",
     )
 
@@ -39,9 +41,11 @@ class _ArrayAdapter(TypeAdapter):
         self,
         item_adapter: TypeAdapter,
         listuple_class: type,
+        key_attributes: tuple[str, ...],
     ):
         self.item_adapter = item_adapter
         self.listuple_class = listuple_class
+        self.key_attributes = key_attributes
         self.empty_listuple = listuple_class()
 
     def default_expr(self) -> ExprLike:
@@ -104,6 +108,21 @@ class _ArrayAdapter(TypeAdapter):
     ) -> None:
         self.item_adapter.finalize(resolve_type_fn)
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.ArrayType(
+            kind="array",
+            value=soialib.reflection.ArrayType.Array(
+                item=self.item_adapter.get_type(),
+                key_chain=self.key_attributes,
+            ),
+        )
+
+    def register_records(
+        self,
+        registry: dict[str, soialib.reflection.Record],
+    ) -> None:
+        self.item_adapter.register_records(registry)
+
 
 _ItemAndKeyAttributes = tuple[TypeAdapter, tuple[str, ...]]
 _ItemToArrayAdapter = WeakValueDictionary[_ItemAndKeyAttributes, _ArrayAdapter]

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/impl/enums.py

@@ -3,6 +3,7 @@ from collections.abc import Callable, Sequence
 from dataclasses import FrozenInstanceError, dataclass
 from typing import Any, Final, Union
 
+import soialib.reflection
 from soialib import spec as _spec
 from soialib.impl.function_maker import BodyBuilder, Expr, ExprLike, Line, make_function
 from soialib.impl.repr import repr_impl
@@ -15,6 +16,7 @@ class EnumAdapter(TypeAdapter):
         "gen_class",
         "private_is_enum_attr",
         "finalization_state",
+        "value_fields",
     )
 
     spec: Final[_spec.Enum]
@@ -22,6 +24,7 @@ class EnumAdapter(TypeAdapter):
     private_is_enum_attr: Final[str]
     # 0: has not started; 1: in progress; 2: done
     finalization_state: int
+    value_fields: tuple["_ValueField", ...]
 
     def __init__(self, spec: _spec.Enum):
         self.finalization_state = 0
@@ -51,10 +54,10 @@ class EnumAdapter(TypeAdapter):
         base_class = self.gen_class
 
         # Resolve the type of every value field.
-        value_fields = [
+        self.value_fields = value_fields = tuple(
             _make_value_field(f, resolve_type_fn(f.type), base_class)
             for f in self.spec.value_fields
-        ]
+        )
 
         # Aim to have dependencies finalized *before* the dependent. It's not always
         # possible, because there can be cyclic dependencies.
@@ -116,6 +119,35 @@ class EnumAdapter(TypeAdapter):
                 Expr.local("_cls?", self.gen_class), f".{fn_name}(", json_expr, ")"
             )
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.RecordType(
+            kind="record",
+            value=self.spec.id,
+        )
+
+    def register_records(
+        self,
+        registry: dict[str, soialib.reflection.Record],
+    ) -> None:
+        record_id = self.spec.id
+        if record_id in registry:
+            return
+        registry[record_id] = soialib.reflection.Record(
+            kind="enum",
+            id=record_id,
+            fields=tuple(
+                soialib.reflection.Field(
+                    name=field.spec.name,
+                    number=field.spec.number,
+                    type=field.field_type.get_type(),
+                )
+                for field in self.value_fields
+            ),
+            removed_fields=self.spec.removed_numbers,
+        )
+        for field in self.value_fields:
+            field.field_type.register_records(registry)
+
 
 def _make_base_class(spec: _spec.Enum) -> type:
     record_hash = hash(spec.id)

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/impl/optionals.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from typing import TypeVar
 from weakref import WeakValueDictionary
 
+import soialib.reflection
 from soialib import spec
 from soialib.impl.function_maker import Expr, ExprLike
 from soialib.impl.type_adapter import TypeAdapter
@@ -67,6 +68,18 @@ class _OptionalAdapter(TypeAdapter):
     ) -> None:
         self.other_adapter.finalize(resolve_type_fn)
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.OptionalType(
+            kind="optional",
+            value=self.other_adapter.get_type(),
+        )
+
+    def register_records(
+        self,
+        registry: dict[str, soialib.reflection.Record],
+    ) -> None:
+        self.other_adapter.register_records(registry)
+
 
 _other_adapter_to_optional_adapter: WeakValueDictionary[TypeAdapter, TypeAdapter] = (
     WeakValueDictionary()

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/impl/primitives.py

@@ -2,6 +2,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, Final, final
 
+import soialib.reflection
 from soialib import spec
 from soialib.impl.function_maker import Expr, ExprLike
 from soialib.impl.type_adapter import TypeAdapter
@@ -16,6 +17,13 @@ class AbstractPrimitiveAdapter(TypeAdapter):
     ) -> None:
         pass
 
+    @final
+    def register_records(
+        self,
+        records: dict[str, soialib.reflection.Record],
+    ) -> None:
+        pass
+
 
 class _BoolAdapter(AbstractPrimitiveAdapter):
     def default_expr(self) -> ExprLike:
@@ -40,6 +48,12 @@ class _BoolAdapter(AbstractPrimitiveAdapter):
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
         return Expr.join("(True if ", json_expr, " else False)")
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="bool",
+        )
+
 
 BOOL_ADAPTER: Final[TypeAdapter] = _BoolAdapter()
 
@@ -80,6 +94,12 @@ class _Int32Adapter(_AbstractIntAdapter):
             " < 2147483647 else 2147483647)",
         )
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="int32",
+        )
+
 
 def _int64_to_json(i: int) -> int | str:
     if i < -9007199254740991:  # min safe integer in JavaScript
@@ -100,6 +120,12 @@ class _Int64Adapter(_AbstractIntAdapter):
     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 get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="int64",
+        )
+
 
 def _uint64_to_json(i: int) -> int | str:
     if i <= 0:
@@ -119,6 +145,12 @@ class _Uint64Adapter(_AbstractIntAdapter):
             Expr.local("uint64_to_json", _uint64_to_json), "(", in_expr, ")"
         )
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="uint64",
+        )
+
 
 INT32_ADAPTER: Final[TypeAdapter] = _Int32Adapter()
 INT64_ADAPTER: Final[TypeAdapter] = _Int64Adapter()
@@ -149,11 +181,23 @@ class _AbstractFloatAdapter(AbstractPrimitiveAdapter):
 class _Float32Adapter(_AbstractFloatAdapter):
     """Type adapter implementation for float32."""
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="float32",
+        )
+
 
 @dataclass(frozen=True)
 class _Float64Adapter(_AbstractFloatAdapter):
     """Type adapter implementation for float32."""
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="float64",
+        )
+
 
 FLOAT32_ADAPTER: Final[TypeAdapter] = _Float32Adapter()
 FLOAT64_ADAPTER: Final[TypeAdapter] = _Float64Adapter()
@@ -192,6 +236,12 @@ class _TimestampAdapter(AbstractPrimitiveAdapter):
         fn = Expr.local("_timestamp_from_json", _timestamp_from_json)
         return Expr.join(fn, "(", json_expr, ")")
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="timestamp",
+        )
+
 
 def _timestamp_from_json(json: Any) -> Timestamp:
     if json.__class__ is int or isinstance(json, int):
@@ -219,6 +269,12 @@ class _StringAdapter(AbstractPrimitiveAdapter):
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
         return Expr.join("('' + (", json_expr, " or ''))")
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="string",
+        )
+
 
 STRING_ADAPTER: Final[TypeAdapter] = _StringAdapter()
 
@@ -247,5 +303,11 @@ class _BytesAdapter(AbstractPrimitiveAdapter):
             Expr.local("fromhex", _BytesAdapter._fromhex_fn), "(", json_expr, ' or "")'
         )
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.PrimitiveType(
+            kind="primitive",
+            value="bytes",
+        )
+
 
 BYTES_ADAPTER: Final[TypeAdapter] = _BytesAdapter()

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/impl/structs.py

@@ -3,6 +3,7 @@ from collections.abc import Callable, Sequence
 from dataclasses import FrozenInstanceError, dataclass
 from typing import Any, Final, Union, cast
 
+import soialib.reflection
 from soialib import spec as _spec
 from soialib.impl.function_maker import (
     BodyBuilder,
@@ -28,6 +29,7 @@ class StructAdapter(TypeAdapter):
         "simple_class",
         "private_is_frozen_attr",
         "finalization_state",
+        "fields",
     )
 
     spec: Final[_spec.Struct]
@@ -40,6 +42,7 @@ class StructAdapter(TypeAdapter):
 
     # 0: has not started; 1: in progress; 2: done
     finalization_state: int
+    fields: tuple["_Field", ...]
 
     def __init__(self, spec: _spec.Struct):
         self.finalization_state = 0
@@ -90,7 +93,7 @@ class StructAdapter(TypeAdapter):
         self.finalization_state = 1
 
         # Resolve the type of every field.
-        fields = tuple(
+        self.fields = fields = tuple(
             sorted(
                 (_Field(f, resolve_type_fn(f.type)) for f in self.spec.fields),
                 key=lambda f: f.field.number,
@@ -198,6 +201,35 @@ class StructAdapter(TypeAdapter):
                 Expr.local("_cls?", self.gen_class), f".{fn_name}(", json_expr, ")"
             )
 
+    def get_type(self) -> soialib.reflection.Type:
+        return soialib.reflection.RecordType(
+            kind="record",
+            value=self.spec.id,
+        )
+
+    def register_records(
+        self,
+        registry: dict[str, soialib.reflection.Record],
+    ) -> None:
+        record_id = self.spec.id
+        if record_id in registry:
+            return
+        registry[record_id] = soialib.reflection.Record(
+            kind="struct",
+            id=record_id,
+            fields=tuple(
+                soialib.reflection.Field(
+                    name=field.field.name,
+                    number=field.field.number,
+                    type=field.type.get_type(),
+                )
+                for field in self.fields
+            ),
+            removed_fields=self.spec.removed_numbers,
+        )
+        for field in self.fields:
+            field.type.register_records(registry)
+
 
 class _Frozen:
     def __setattr__(self, name: str, value: Any):

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/impl/type_adapter.py

@@ -1,6 +1,7 @@
 from collections.abc import Callable
 from typing import Protocol
 
+import soialib.reflection
 from soialib import spec
 from soialib.impl.function_maker import ExprLike
 
@@ -53,3 +54,10 @@ class TypeAdapter(Protocol):
         self,
         resolve_type_fn: Callable[[spec.Type], "TypeAdapter"],
     ) -> None: ...
+
+    def get_type(self) -> soialib.reflection.Type: ...
+
+    def register_records(
+        self,
+        registry: dict[str, soialib.reflection.Record],
+    ) -> None: ...

soia_client-1.0.13/soialib/reflection.py

@@ -0,0 +1,343 @@
+import json
+import typing
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Callable,
+    Final,
+    Generic,
+    Literal,
+    Mapping,
+    Optional,
+    TypeAlias,
+    TypeVar,
+    Union,
+    cast,
+)
+
+
+@dataclass(frozen=True)
+class TypeDescriptor:
+    type: "Type"
+    records: tuple["Record", ...]
+
+    def as_json(self) -> Any:
+        return _TYPE_DESCRIPTOR_SERIALIZER.to_json(self)
+
+    def as_json_code(self) -> str:
+        return json.dumps(self.as_json(), indent=2)
+
+    @staticmethod
+    def from_json(json: Any) -> "TypeDescriptor":
+        return _TYPE_DESCRIPTOR_SERIALIZER.from_json(json)
+
+    @staticmethod
+    def from_json_code(json_code: str) -> "TypeDescriptor":
+        return _TYPE_DESCRIPTOR_SERIALIZER.from_json(json.loads(json_code))
+
+
+@dataclass(frozen=True)
+class PrimitiveType:
+    kind: Literal["primitive"]
+    value: Literal[
+        "bool",
+        "int32",
+        "int64",
+        "uint64",
+        "float32",
+        "float64",
+        "timestamp",
+        "string",
+        "bytes",
+    ]
+
+
+@dataclass(frozen=True)
+class OptionalType:
+    kind: Literal["optional"]
+    value: "Type"
+
+
+@dataclass(frozen=True)
+class ArrayType:
+    kind: Literal["array"]
+
+    @dataclass(frozen=True)
+    class Array:
+        item: "Type"
+        key_chain: tuple[str, ...]
+
+    value: Array
+
+
+@dataclass(frozen=True)
+class RecordType:
+    kind: Literal["record"]
+    value: str
+
+
+Type: TypeAlias = Union[PrimitiveType, OptionalType, ArrayType, RecordType]
+
+
+@dataclass(frozen=True)
+class Field:
+    name: str
+    type: Optional[Type]
+    number: int
+
+
+@dataclass(frozen=True)
+class Record:
+    kind: Literal["struct", "enum"]
+    id: str
+    fields: tuple[Field, ...]
+    removed_fields: tuple[int, ...]
+
+
+# ==============================================================================
+# INTERNAL: JSON serialization framework
+# ==============================================================================
+
+
+_T = TypeVar("_T")
+
+
+@dataclass(frozen=True)
+class _Serializer(Generic[_T]):
+    to_json: Callable[[_T], Any]
+    from_json: Callable[[Any], _T]
+
+
+@dataclass(frozen=True)
+class _FieldSerializer(Generic[_T]):
+    name: str
+    serializer: _Serializer[_T]
+    default: Optional[_T] = None
+
+
+def _primitive_serializer(check_type_fn: Callable[[Any], _T]) -> _Serializer[_T]:
+    return _Serializer(check_type_fn, check_type_fn)
+
+
+def _literal_union_serializer(s: set[_T]) -> _Serializer[_T]:
+    def check_in(input: _T) -> _T:
+        if input not in s:
+            raise ValueError(f"{input} is not in {s}")
+        return input
+
+    return _Serializer(check_in, check_in)
+
+
+def _dataclass_serializer(
+    type: typing.Type[_T], fields: Iterable[_FieldSerializer]
+) -> _Serializer[_T]:
+    def to_json(obj: _T) -> dict[str, Any]:
+        json = {}
+        for field in fields:
+            value = getattr(obj, field.name)
+            if value != field.default:
+                json[field.name] = field.serializer.to_json(value)
+        return json
+
+    def from_json(json: dict[str, Any]) -> _T:
+        def field_from_json(field: _FieldSerializer) -> Any:
+            value_json = json.get(field.name)
+            if value_json is None:
+                if field.default is not None:
+                    return field.default
+                else:
+                    # Will raise an exception.
+                    json[field.name]
+            return field.serializer.from_json(value_json)
+
+        return type(**{f.name: field_from_json(f) for f in fields})
+
+    return _Serializer(to_json, from_json)
+
+
+def _union_serializer(
+    kind_to_serializer: Mapping[str, _Serializer],
+) -> _Serializer:
+    def to_json(input: Any) -> dict[str, Any]:
+        kind = cast(Any, input).kind
+        serializer = kind_to_serializer[kind]
+        return serializer.to_json(input)
+
+    def from_json(json: dict[str, Any]) -> Any:
+        kind = json["kind"]
+        serializer = kind_to_serializer[kind]
+        return serializer.from_json(json)
+
+    return _Serializer(to_json, from_json)
+
+
+def _listuple_serializer(
+    item_serializer: _Serializer[_T],
+) -> _Serializer[tuple[_T, ...]]:
+    def to_json(input: tuple[_T, ...]) -> list[Any]:
+        return [item_serializer.to_json(e) for e in input]
+
+    def from_json(json: list[Any]) -> tuple[_T, ...]:
+        return tuple(item_serializer.from_json(e) for e in json)
+
+    return _Serializer(to_json, from_json)
+
+
+def _forwarding_serializer(
+    get_serializer_fn: Callable[[], _Serializer[_T]],
+) -> _Serializer[_T]:
+    def to_json(input: _T) -> Any:
+        return get_serializer_fn().to_json(input)
+
+    def from_json(json: Any) -> _T:
+        return get_serializer_fn().from_json(json)
+
+    return _Serializer(to_json, from_json)
+
+
+# ==============================================================================
+# INTERNAL: JSON serialization of TypeDescriptor
+# ==============================================================================
+
+
+def _type_serializer() -> _Serializer[Type]:
+    return _TYPE_SERIALIZER
+
+
+_TYPE_SERIALIZER: Final = _union_serializer(
+    {
+        "primitive": _dataclass_serializer(
+            PrimitiveType,
+            [
+                _FieldSerializer("kind", _literal_union_serializer({"primitive"})),
+                _FieldSerializer(
+                    "value",
+                    _literal_union_serializer(
+                        {
+                            "bool",
+                            "int32",
+                            "int64",
+                            "uint64",
+                            "float32",
+                            "float64",
+                            "timestamp",
+                            "string",
+                            "bytes",
+                        }
+                    ),
+                ),
+            ],
+        ),
+        "optional": _dataclass_serializer(
+            OptionalType,
+            [
+                _FieldSerializer(
+                    "kind",
+                    _literal_union_serializer({"optional"}),
+                ),
+                _FieldSerializer(
+                    "value",
+                    _forwarding_serializer(_type_serializer),
+                ),
+            ],
+        ),
+        "array": _dataclass_serializer(
+            ArrayType,
+            [
+                _FieldSerializer(
+                    "kind",
+                    _literal_union_serializer({"array"}),
+                ),
+                _FieldSerializer(
+                    "value",
+                    _dataclass_serializer(
+                        ArrayType.Array,
+                        [
+                            _FieldSerializer(
+                                "item",
+                                _forwarding_serializer(_type_serializer),
+                            ),
+                            _FieldSerializer(
+                                "key_chain",
+                                _listuple_serializer(_primitive_serializer(str)),
+                                default=(),
+                            ),
+                        ],
+                    ),
+                ),
+            ],
+        ),
+        "record": _dataclass_serializer(
+            RecordType,
+            [
+                _FieldSerializer(
+                    "kind",
+                    _literal_union_serializer({"record"}),
+                ),
+                _FieldSerializer(
+                    "value",
+                    _primitive_serializer(str),
+                ),
+            ],
+        ),
+    }
+)
+
+
+_FIELD_SERIALIZER: Final = _dataclass_serializer(
+    Field,
+    [
+        _FieldSerializer(
+            "name",
+            _primitive_serializer(str),
+        ),
+        _FieldSerializer(
+            "type",
+            _forwarding_serializer(_type_serializer),
+        ),
+        _FieldSerializer(
+            "number",
+            _primitive_serializer(int),
+        ),
+    ],
+)
+
+
+_RECORD_SERIALIZER: Final = _dataclass_serializer(
+    Record,
+    [
+        _FieldSerializer(
+            "kind",
+            _literal_union_serializer({"struct", "enum"}),
+        ),
+        _FieldSerializer(
+            "id",
+            _primitive_serializer(str),
+        ),
+        _FieldSerializer(
+            "fields",
+            _listuple_serializer(_FIELD_SERIALIZER),
+        ),
+        _FieldSerializer(
+            "removed_fields",
+            _listuple_serializer(_primitive_serializer(int)),
+            default=(),
+        ),
+    ],
+)
+
+
+_TYPE_DESCRIPTOR_SERIALIZER = _dataclass_serializer(
+    TypeDescriptor,
+    [
+        _FieldSerializer(
+            "type",
+            _TYPE_SERIALIZER,
+        ),
+        _FieldSerializer(
+            "records",
+            _listuple_serializer(_RECORD_SERIALIZER),
+        ),
+    ],
+)

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/serializer.py

@@ -1,9 +1,11 @@
 import json as jsonlib
 from collections.abc import Callable
 from dataclasses import FrozenInstanceError
+from functools import cached_property
 from typing import Any, Generic, TypeVar, cast, final
 from weakref import WeakValueDictionary
 
+import soialib.reflection
 from soialib.impl.function_maker import Expr, LineSpan, make_function
 from soialib.impl.type_adapter import TypeAdapter
 from soialib.never import Never
@@ -19,6 +21,7 @@ class Serializer(Generic[T]):
         "_to_dense_json_fn",
         "_to_readable_json_fn",
         "_from_json_fn",
+        "__dict__",
     )
 
     _adapter: TypeAdapter
@@ -57,6 +60,15 @@ class Serializer(Generic[T]):
     def from_json_code(self, json_code: str) -> T:
         return self._from_json_fn(jsonlib.loads(json_code))
 
+    @cached_property
+    def type_descriptor(self) -> soialib.reflection.TypeDescriptor:
+        records: dict[str, soialib.reflection.Record] = {}
+        self._adapter.register_records(records)
+        return soialib.reflection.TypeDescriptor(
+            type=self._adapter.get_type(),
+            records=tuple(records.values()),
+        )
+
     def __setattr__(self, name: str, value: Any):
         raise FrozenInstanceError(self.__class__.__qualname__)
 

soia_client-1.0.13/soialib/service.py

@@ -0,0 +1,147 @@
+import inspect
+import json
+from dataclasses import dataclass
+from typing import Any, Callable, Generic, Literal, Mapping, TypeAlias, Union, cast
+
+from soialib.method import Method, Request, Response
+
+RequestHeaders: TypeAlias = Mapping[str, str]
+ResponseHeaders: TypeAlias = dict[str, str]
+
+
+class ServiceImpl:
+    _number_to_method_impl: dict[int, "_MethodImpl"]
+
+    def add_method(
+        self,
+        method: Method[Request, Response],
+        impl: Union[
+            Callable[[Request], Response],
+            Callable[[Request, RequestHeaders], Response],
+            Callable[[Request, RequestHeaders, ResponseHeaders], Response],
+        ],
+    ) -> "ServiceImpl":
+        signature = inspect.Signature.from_callable(impl)
+        num_positional_params = 0
+        for param in signature.parameters.values():
+            if param.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.POSITIONAL_ONLY,
+            ):
+                num_positional_params += 1
+            if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                raise ValueError("Method implementation cannot accept *args")
+        if num_positional_params not in range(1, 4):
+            raise ValueError(
+                "Method implementation must accept 1 to 3 positional parameters"
+            )
+
+        def resolved_impl(
+            req: Request, req_headers: RequestHeaders, res_headers: ResponseHeaders
+        ) -> Response:
+            if num_positional_params == 1:
+                return cast(Callable[[Request], Response], impl)(req)
+            elif num_positional_params == 2:
+                return cast(Callable[[Request, RequestHeaders], Response], impl)(
+                    req, req_headers
+                )
+            else:
+                return cast(
+                    Callable[[Request, RequestHeaders, ResponseHeaders], Response], impl
+                )(req, req_headers, res_headers)
+
+        number = method.number
+        if number in self._number_to_method_impl:
+            raise ValueError(
+                f"Method with the same number already registered ({number})"
+            )
+        self._number_to_method_impl[number] = _MethodImpl(
+            method=method,
+            impl=resolved_impl,
+        )
+        return self
+
+    @dataclass(frozen=True)
+    class RawResponse:
+        data: str
+        type: Literal["ok-json", "bad-request", "server-error"]
+
+    def handle_request(
+        self,
+        req_body: str,
+        req_headers: RequestHeaders,
+        res_headers: ResponseHeaders | None,
+    ) -> RawResponse:
+        if req_body == "list":
+
+            def method_to_json(method: Method) -> Any:
+                return {
+                    "method": method.name,
+                    "number": method.number,
+                    "request": method.request_serializer.type_descriptor.as_json(),
+                    "response": method.response_serializer.type_descriptor.as_json(),
+                }
+
+            json_code = json.dumps(
+                {
+                    "methods": [
+                        method_to_json(method_impl.method)
+                        for method_impl in self._number_to_method_impl.values()
+                    ]
+                },
+                indent=2,
+            )
+            return self.RawResponse(json_code, "ok-json")
+
+        parts = req_body.split(":", 3)
+        if len(parts) != 4:
+            return self.RawResponse(
+                "bad request: invalid request format", "bad-request"
+            )
+        method_name = parts[0]
+        method_number_str = parts[1]
+        format = parts[2]
+        request_data = parts[3]
+        try:
+            method_number = int(method_number_str)
+        except Exception:
+            return self.RawResponse(
+                "bad request: can't parse method number", "bad-request"
+            )
+        method_impl = self._number_to_method_impl.get(method_number)
+        if not method_impl:
+            return self.RawResponse(
+                f"bad request: method not found: {method_name}; number: {method_number}",
+                "bad-request",
+            )
+
+        try:
+            req: Any = method_impl.method.request_serializer.from_json_code(
+                request_data
+            )
+        except Exception as e:
+            return self.RawResponse(
+                f"bad request: can't parse JSON: {e}", "bad-request"
+            )
+
+        try:
+            res: Any = method_impl.impl(req, req_headers, res_headers or {})
+        except Exception as e:
+            return self.RawResponse(f"server error: {e}", "server-error")
+
+        try:
+            res_json = method_impl.method.response_serializer.to_json_code(
+                res, readable=(format == "readable")
+            )
+        except Exception as e:
+            return self.RawResponse(
+                f"server error: can't serialize response to JSON: {e}", "server-error"
+            )
+
+        return self.RawResponse(res_json, "ok-json")
+
+
+@dataclass(frozen=True)
+class _MethodImpl(Generic[Request, Response]):
+    method: Method[Request, Response]
+    impl: Callable[[Request, RequestHeaders, ResponseHeaders], Response]

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/service_client.py

@@ -1,11 +1,9 @@
 import http.client
-from typing import Final, Mapping, TypeVar
+from typing import Final, Mapping
 from urllib.parse import urlparse
 
 from soialib import Method
-
-Request = TypeVar("Request")
-Response = TypeVar("Response")
+from soialib.method import Request, Response
 
 
 class ServiceClient:
@@ -13,7 +11,7 @@ class ServiceClient:
     _host: Final[str]  # May include the port
     _path: Final[str]
 
-    def __init__(self, service_url: str, use_https: bool = False):
+    def __init__(self, service_url: str):
         parsed_url = urlparse(service_url)
         if parsed_url.query:
             raise ValueError("Service URL must not contain a query string")

{soia_client-1.0.11 → soia_client-1.0.13}/soialib/spec.py

@@ -18,7 +18,6 @@ class PrimitiveType(enum.Enum):
 @dataclass(frozen=True)
 class ArrayType:
     item: "Type"
-    # TODO: comment
     key_attributes: tuple[str, ...] = ()
 
 
@@ -27,7 +26,6 @@ class OptionalType:
     other: "Type"
 
 
-# TODO: comment
 Type = Union[PrimitiveType, ArrayType, OptionalType, str]
 
 

{soia_client-1.0.11 → soia_client-1.0.13}/tests/test_module_initializer.py

@@ -6,6 +6,7 @@ from soialib import spec
 from soialib.keyed_items import KeyedItems
 from soialib.method import Method
 from soialib.module_initializer import init_module
+from soialib.reflection import TypeDescriptor
 from soialib.timestamp import Timestamp
 
 
@@ -96,12 +97,12 @@ class ModuleInitializerTestCase(unittest.TestCase):
                         spec.Field(
                             name="i64",
                             number=5,
-                            type=spec.PrimitiveType.INT32,
+                            type=spec.PrimitiveType.INT64,
                         ),
                         spec.Field(
                             name="u64",
                             number=6,
-                            type=spec.PrimitiveType.INT32,
+                            type=spec.PrimitiveType.UINT64,
                         ),
                         spec.Field(
                             name="s",
@@ -1119,3 +1120,249 @@ class ModuleInitializerTestCase(unittest.TestCase):
         c = module["C"]
         Point = module["Point"]
         self.assertEqual(c, Point(x=1.5, y=2.5))
+
+    def test_enum_type_descriptor(self):
+        module = self.init_test_module()
+        json_value_cls = module["JsonValue"]
+        type_descriptor = json_value_cls.SERIALIZER.type_descriptor
+        self.assertEqual(
+            type_descriptor.as_json(),
+            {
+                "type": {"kind": "record", "value": "my/module.soia:JsonValue"},
+                "records": [
+                    {
+                        "kind": "enum",
+                        "id": "my/module.soia:JsonValue",
+                        "fields": [
+                            {
+                                "name": "bool",
+                                "type": {"kind": "primitive", "value": "bool"},
+                                "number": 2,
+                            },
+                            {
+                                "name": "number",
+                                "type": {"kind": "primitive", "value": "float64"},
+                                "number": 3,
+                            },
+                            {
+                                "name": "string",
+                                "type": {"kind": "primitive", "value": "string"},
+                                "number": 4,
+                            },
+                            {
+                                "name": "array",
+                                "type": {
+                                    "kind": "array",
+                                    "value": {
+                                        "item": {
+                                            "kind": "record",
+                                            "value": "my/module.soia:JsonValue",
+                                        },
+                                    },
+                                },
+                                "number": 5,
+                            },
+                            {
+                                "name": "object",
+                                "type": {
+                                    "kind": "record",
+                                    "value": "my/module.soia:JsonValue.Object",
+                                },
+                                "number": 6,
+                            },
+                        ],
+                        "removed_fields": [100, 101],
+                    },
+                    {
+                        "kind": "struct",
+                        "id": "my/module.soia:JsonValue.Object",
+                        "fields": [
+                            {
+                                "name": "entries",
+                                "type": {
+                                    "kind": "array",
+                                    "value": {
+                                        "item": {
+                                            "kind": "record",
+                                            "value": "my/module.soia:JsonValue.ObjectEntry",
+                                        },
+                                        "key_chain": ["name"],
+                                    },
+                                },
+                                "number": 0,
+                            }
+                        ],
+                    },
+                    {
+                        "kind": "struct",
+                        "id": "my/module.soia:JsonValue.ObjectEntry",
+                        "fields": [
+                            {
+                                "name": "name",
+                                "type": {"kind": "primitive", "value": "string"},
+                                "number": 0,
+                            },
+                            {
+                                "name": "value",
+                                "type": {
+                                    "kind": "record",
+                                    "value": "my/module.soia:JsonValue",
+                                },
+                                "number": 1,
+                            },
+                        ],
+                    },
+                ],
+            },
+        )
+        self.assertEqual(
+            str(TypeDescriptor.from_json(type_descriptor.as_json())),
+            str(type_descriptor),
+        )
+        self.assertEqual(
+            TypeDescriptor.from_json(type_descriptor.as_json()),
+            type_descriptor,
+        )
+
+    def test_optional_type_descriptor(self):
+        module = self.init_test_module()
+        segment_cls = module["Segment"]
+        type_descriptor = segment_cls.SERIALIZER.type_descriptor
+        self.assertEqual(
+            type_descriptor.as_json(),
+            {
+                "type": {"kind": "record", "value": "my/module.soia:Segment"},
+                "records": [
+                    {
+                        "kind": "struct",
+                        "id": "my/module.soia:Segment",
+                        "fields": [
+                            {
+                                "name": "a",
+                                "type": {
+                                    "kind": "record",
+                                    "value": "my/module.soia:Point",
+                                },
+                                "number": 0,
+                            },
+                            {
+                                "name": "bb",
+                                "type": {
+                                    "kind": "record",
+                                    "value": "my/module.soia:Point",
+                                },
+                                "number": 1,
+                            },
+                            {
+                                "name": "c",
+                                "type": {
+                                    "kind": "optional",
+                                    "value": {
+                                        "kind": "record",
+                                        "value": "my/module.soia:Point",
+                                    },
+                                },
+                                "number": 2,
+                            },
+                        ],
+                    },
+                    {
+                        "kind": "struct",
+                        "id": "my/module.soia:Point",
+                        "fields": [
+                            {
+                                "name": "x",
+                                "type": {"kind": "primitive", "value": "float32"},
+                                "number": 0,
+                            },
+                            {
+                                "name": "y",
+                                "type": {"kind": "primitive", "value": "float32"},
+                                "number": 2,
+                            },
+                        ],
+                        "removed_fields": [1],
+                    },
+                ],
+            },
+        )
+        self.assertEqual(
+            str(TypeDescriptor.from_json(type_descriptor.as_json())),
+            str(type_descriptor),
+        )
+        self.assertEqual(
+            TypeDescriptor.from_json(type_descriptor.as_json()),
+            type_descriptor,
+        )
+
+    def test_primitive_type_descriptor(self):
+        module = self.init_test_module()
+        segment_cls = module["Primitives"]
+        type_descriptor = segment_cls.SERIALIZER.type_descriptor
+        self.assertEqual(
+            type_descriptor.as_json(),
+            {
+                "type": {"kind": "record", "value": "my/module.soia:Primitives"},
+                "records": [
+                    {
+                        "kind": "struct",
+                        "id": "my/module.soia:Primitives",
+                        "fields": [
+                            {
+                                "name": "bool",
+                                "type": {"kind": "primitive", "value": "bool"},
+                                "number": 0,
+                            },
+                            {
+                                "name": "bytes",
+                                "type": {"kind": "primitive", "value": "bytes"},
+                                "number": 1,
+                            },
+                            {
+                                "name": "f32",
+                                "type": {"kind": "primitive", "value": "float32"},
+                                "number": 2,
+                            },
+                            {
+                                "name": "f64",
+                                "type": {"kind": "primitive", "value": "float64"},
+                                "number": 3,
+                            },
+                            {
+                                "name": "i32",
+                                "type": {"kind": "primitive", "value": "int32"},
+                                "number": 4,
+                            },
+                            {
+                                "name": "i64",
+                                "type": {"kind": "primitive", "value": "int64"},
+                                "number": 5,
+                            },
+                            {
+                                "name": "u64",
+                                "type": {"kind": "primitive", "value": "uint64"},
+                                "number": 6,
+                            },
+                            {
+                                "name": "s",
+                                "type": {"kind": "primitive", "value": "string"},
+                                "number": 7,
+                            },
+                            {
+                                "name": "t",
+                                "type": {"kind": "primitive", "value": "timestamp"},
+                                "number": 8,
+                            },
+                        ],
+                    }
+                ],
+            },
+        )
+        self.assertEqual(
+            str(TypeDescriptor.from_json(type_descriptor.as_json())),
+            str(type_descriptor),
+        )
+        self.assertEqual(
+            TypeDescriptor.from_json(type_descriptor.as_json()),
+            type_descriptor,
+        )