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

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

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

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

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

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

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

{soia_client-1.0.7 → soia_client-1.0.8}/soia_client.egg-info/SOURCES.txt

@@ -16,7 +16,6 @@ soialib/spec.py
 soialib/timestamp.py
 soialib/impl/__init__.py
 soialib/impl/arrays.py
-soialib/impl/encoding.py
 soialib/impl/enums.py
 soialib/impl/function_maker.py
 soialib/impl/optionals.py

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

@@ -94,7 +94,7 @@ class _ArrayAdapter(TypeAdapter):
             listuple_class_local,
             "([",
             self.item_adapter.from_json_expr(Expr.join("_e")),
-            " for e in ",
+            " for _e in ",
             json_expr,
             "] or ",
             empty_listuple_local,

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

@@ -1,20 +1,10 @@
-# TODO: test
-# TODO: unrecognized fields (and handles removed fields)
-
+import copy
 from collections.abc import Callable, Sequence
 from dataclasses import FrozenInstanceError, dataclass
 from typing import Any, Final, Union
 
 from soialib import spec as _spec
-from soialib.impl import primitives
-from soialib.impl.function_maker import (
-    BodyBuilder,
-    BodySpan,
-    Expr,
-    ExprLike,
-    Line,
-    make_function,
-)
+from soialib.impl.function_maker import BodyBuilder, Expr, ExprLike, Line, make_function
 from soialib.impl.repr import repr_impl
 from soialib.impl.type_adapter import TypeAdapter
 
@@ -40,7 +30,6 @@ class EnumAdapter(TypeAdapter):
 
         private_is_enum_attr = _name_private_is_enum_attr(spec.id)
         self.private_is_enum_attr = private_is_enum_attr
-        # TODO: comment
         setattr(base_class, private_is_enum_attr, True)
 
         # Add the constants.
@@ -81,7 +70,10 @@ class EnumAdapter(TypeAdapter):
             setattr(base_class, f"wrap_{value_field.spec.name}", wrap_fn)
 
         base_class._fj = _make_from_json_fn(
-            self.all_constant_fields, value_fields, base_class
+            self.all_constant_fields,
+            value_fields,
+            set(self.spec.removed_numbers),
+            base_class,
         )
 
         # Mark finalization as done.
@@ -116,7 +108,6 @@ class EnumAdapter(TypeAdapter):
 
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
         fn_name = "_fj"
-        # TODO: comment
         from_json_fn = getattr(self.gen_class, fn_name, None)
         if from_json_fn:
             return Expr.join(Expr.local("_fj?", from_json_fn), "(", json_expr, ")")
@@ -149,7 +140,6 @@ def _make_base_class(spec: _spec.Enum) -> type:
             raise FrozenInstanceError(self.__class__.__qualname__)
 
         def __eq__(self, other: Any) -> bool:
-            # TODO: make it work with unrecognized versus UNKNOWN
             if isinstance(other, BaseClass):
                 return other.kind == self.kind and other.value == self.value
             return NotImplemented
@@ -164,7 +154,7 @@ def _make_base_class(spec: _spec.Enum) -> type:
 
 
 def _make_constant_class(base_class: type, spec: _spec.ConstantField) -> type:
-    class ConstantClass(base_class):
+    class Constant(base_class):
         __slots__ = ()
 
         kind: Final[str] = spec.name
@@ -183,7 +173,37 @@ def _make_constant_class(base_class: type, spec: _spec.ConstantField) -> type:
         def __repr__(self) -> str:
             return f"{base_class.__qualname__}.{spec.attribute}"
 
-    return ConstantClass
+    return Constant
+
+
+def _make_unrecognized_class(base_class: type) -> type:
+    """Wraps around an unrecognized dense JSON.
+
+    Looks and acts just like the UNKNOWN constant, except that its JSON representation
+    is the original unrecognized dense JSON.
+    """
+
+    class Unrecognized(base_class):
+        __slots__ = ("_dj",)
+
+        kind: Final[str] = "?"
+        _number: Final[int] = 0
+        # dense JSON
+        _dj: Any
+        # readable JSON
+        _rj: Final[str] = "?"
+        # has value
+        _hv: Final[bool] = False
+
+        def __init__(self, dj: Any):
+            # Do not call super().__init__().
+            object.__setattr__(self, "_dj", copy.deepcopy(dj))
+            object.__setattr__(self, "value", None)
+
+        def __repr__(self) -> str:
+            return f"{base_class.__qualname__}.UNKNOWN"
+
+    return Unrecognized
 
 
 def _make_value_class(
@@ -193,7 +213,7 @@ def _make_value_class(
 ) -> type:
     number = field_spec.number
 
-    class ValueClass(base_class):
+    class Value(base_class):
         __slots__ = ()
 
         kind: Final[str] = field_spec.name
@@ -213,7 +233,7 @@ def _make_value_class(
                 body = value_repr.repr
             return f"{base_class.__qualname__}.wrap_{field_spec.name}({body})"
 
-    ret = ValueClass
+    ret = Value
 
     ret._dj = property(
         make_function(
@@ -286,9 +306,13 @@ def _make_wrap_fn(field: _ValueField) -> Callable[[Any], Any]:
 def _make_from_json_fn(
     constant_fields: Sequence[_spec.ConstantField],
     value_fields: Sequence[_ValueField],
+    removed_numbers: set[int],
     base_class: type,
 ) -> Callable[[Any], Any]:
+    unrecognized_class = _make_unrecognized_class(base_class)
+    unrecognized_class_local = Expr.local("Unrecognized", unrecognized_class)
     obj_setattr_local = Expr.local("obj_settatr", object.__setattr__)
+    removed_numbers_local = Expr.local("removed_numbers", removed_numbers)
 
     key_to_constant: dict[Union[int, str], Any] = {}
     for field in constant_fields:
@@ -318,12 +342,15 @@ def _make_from_json_fn(
         builder.append_ln("  if json == 0:")
         builder.append_ln("    return ", unknown_constant_local)
     else:
+        # `json.__class__ is int` is significantly faster than `isinstance(json, int)`
         builder.append_ln("  if json.__class__ is int:")
         builder.append_ln("    try:")
         builder.append_ln("      return ", key_to_constant_local, "[json]")
         builder.append_ln("    except:")
-        # TODO: handle unrecognized fields!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-        builder.append_ln("      return ...")
+        if removed_numbers:
+            builder.append_ln("      if json in ", removed_numbers_local, ":")
+            builder.append_ln("        return ", unknown_constant_local)
+        builder.append_ln("      return ", unrecognized_class_local, "(json)")
 
     def append_number_branches(numbers: list[int], indent: str) -> None:
         if len(numbers) == 1:
@@ -332,7 +359,9 @@ def _make_from_json_fn(
             value_class_local = Expr.local("cls?", field.value_class)
             value_expr = field.field_type.from_json_expr(Expr.join("json[1]"))
             builder.append_ln(f"{indent}ret = ", value_class_local, "()")
-            builder.append_ln(indent, obj_setattr_local, "(ret, ", value_expr, ")")
+            builder.append_ln(
+                indent, obj_setattr_local, '(ret, "value", ', value_expr, ")"
+            )
             builder.append_ln(f"{indent}return ret")
         else:
             indented = f"  {indent}"
@@ -344,18 +373,24 @@ def _make_from_json_fn(
             builder.append_ln(f"{indent}else:")
             append_number_branches(numbers[mid_index:], indented)
 
+    # `json.__class__ is list` is significantly faster than `isinstance(json, list)`
     builder.append_ln("  elif json.__class__ is list:")
+    builder.append_ln("    number = json[0]")
     if not value_fields:
-        # TODO: handle unrecognized fields!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-        builder.append_ln("    return ...")
+        # The field was either removed or is an unrecognized field.
+        if removed_numbers:
+            builder.append_ln("    if number in ", removed_numbers_local, ":")
+            builder.append_ln("      return ", unknown_constant_local)
+        builder.append_ln("    return ", unrecognized_class_local, "(json)")
     else:
         if len(value_fields) == 1:
             builder.append_ln(f"    if number != {value_fields[0].spec.number}:")
         else:
             builder.append_ln("    if number not in ", value_keys_local, ":")
-        # TODO: handle unrecognized fields!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-        builder.append_ln("      return ...")
-        builder.append_ln("    number = json[0]")
+        if removed_numbers:
+            builder.append_ln("      if number in ", removed_numbers_local, ":")
+            builder.append_ln("        return ", unknown_constant_local)
+        builder.append_ln("      return ", unrecognized_class_local, "(json)")
         append_number_branches(sorted(numbers), "    ")
 
     # READABLE FORMAT
@@ -367,7 +402,7 @@ def _make_from_json_fn(
         builder.append_ln("    try:")
         builder.append_ln("      return ", key_to_constant_local, "[json]")
         builder.append_ln("    except:")
-        # TODO: comment
+        # In readable mode, drop unrecognized values and use UNKNOWN instead.
         builder.append_ln("      return ", unknown_constant_local)
 
     def append_name_branches(names: list[str], indent: str) -> None:
@@ -377,30 +412,38 @@ def _make_from_json_fn(
             value_class_local = Expr.local("cls?", field.value_class)
             value_expr = field.field_type.from_json_expr("json['value']")
             builder.append_ln(f"{indent}ret = ", value_class_local, "()")
-            builder.append_ln(indent, obj_setattr_local, "(ret, ", value_expr, ")")
+            builder.append_ln(
+                indent, obj_setattr_local, '(ret, "value", ', value_expr, ")"
+            )
             builder.append_ln(f"{indent}return ret")
         else:
             indented = f"  {indent}"
             mid_index = int(len(names) / 2)
             mid_name = names[mid_index - 1]
             operator = "==" if mid_index == 1 else "<="
-            builder.append_ln(f"{indent}if name {operator} '{mid_name}':")
+            builder.append_ln(f"{indent}if kind {operator} '{mid_name}':")
             append_name_branches(names[0:mid_index], indented)
             builder.append_ln(f"{indent}else:")
             append_name_branches(names[mid_index:], indented)
 
     builder.append_ln("  elif isinstance(json, dict):")
     if not value_fields:
-        # TODO: comment
         builder.append_ln("    return ", unknown_constant_local)
     else:
-        builder.append_ln("    name = json['name']")
-        builder.append_ln("    if name not in ", value_keys_local, ":")
-        # TODO: comment
+        builder.append_ln("    kind = json['kind']")
+        builder.append_ln("    if kind not in ", value_keys_local, ":")
         builder.append_ln("      return ", unknown_constant_local)
         builder.append_ln("    else:")
         append_name_branches(sorted(names), "      ")
 
+    # In the unlikely event that json.loads() returns an instance of a subclass of int.
+    builder.append_ln("  elif isinstance(json, int):")
+    builder.append_ln("    json = int(json)")
+    builder.append_ln("  elif isinstance(json, list):")
+    builder.append_ln("    json = list(json)")
+    builder.append_ln("  else:")
+    builder.append_ln("    return TypeError()")
+
     return make_function(
         name="from_json",
         params=["json"],

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

@@ -1,6 +1,6 @@
 import itertools
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union
+from typing import Any, Callable, Iterable, Optional, Sequence, Union
 
 
 def make_function(
@@ -120,15 +120,11 @@ class LineSpan:
 _EMPTY_LINE_SPAN = LineSpan(())
 
 
-# TODO: comment
 LineSpanLike = Union[str, LineSpan]
 
 
 # A type alias to use when the line span is a Python expression.
 Expr = LineSpan
-
-
-# TODO: comment
 ExprLike = LineSpanLike
 
 

{soia_client-1.0.7 → soia_client-1.0.8}/soialib/impl/optionals.py

@@ -4,7 +4,6 @@ from typing import TypeVar
 from weakref import WeakValueDictionary
 
 from soialib import spec
-from soialib.impl.encoding import NULL_WIRE
 from soialib.impl.function_maker import Expr, ExprLike
 from soialib.impl.type_adapter import TypeAdapter
 

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

@@ -33,9 +33,9 @@ class _BoolAdapter(AbstractPrimitiveAdapter):
         readable: bool,
     ) -> ExprLike:
         if readable:
-            return Expr.join("(1 if ", in_expr, " else 0)")
+            return Expr.join("(True if ", in_expr, " else False)")
         else:
-            return in_expr
+            return Expr.join("(1 if ", in_expr, " else 0)")
 
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
         return Expr.join("(True if ", json_expr, " else False)")
@@ -52,6 +52,8 @@ 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)")
 
     def is_not_default_expr(self, arg_expr: ExprLike, attr_expr: ExprLike) -> ExprLike:
@@ -61,7 +63,18 @@ class _AbstractIntAdapter(AbstractPrimitiveAdapter):
         return in_expr
 
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
-        return Expr.join("(", json_expr, " | 0)")
+        # Must accept float inputs and turn them into ints.
+        return Expr.join(
+            "(",
+            json_expr,
+            " if ",
+            json_expr,
+            ".__class__ is (0).__class__ else ",
+            Expr.local("_round", round),
+            "(",
+            json_expr,
+            "))",
+        )
 
 
 @dataclass(frozen=True)
@@ -203,7 +216,7 @@ class _BytesAdapter(AbstractPrimitiveAdapter):
 
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
         return Expr.join(
-            Expr.local("fromhex", _BytesAdapter._fromhex_fn), "(", json_expr, ")"
+            Expr.local("fromhex", _BytesAdapter._fromhex_fn), "(", json_expr, ' or "")'
         )
 
 

{soia_client-1.0.7 → soia_client-1.0.8}/soialib/impl/repr.py

@@ -31,7 +31,6 @@ def repr_impl(input: Any) -> ReprResult:
             return ReprResult(f"[\n{body}]", complex=True)
     elif isinstance(input, str):
         if "\n" in input:
-            # TODO: comment
             lines = input.split("\n")
             body = "".join(f"  {repr(line)},\n" for line in lines)
             return ReprResult(f"'\\n'.join([\n{body}])", complex=True)

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

@@ -1,12 +1,11 @@
+import copy
 from collections.abc import Callable, Sequence
 from dataclasses import FrozenInstanceError, dataclass
-from typing import Any, Final, Union
+from typing import Any, Final, Union, cast
 
 from soialib import spec as _spec
-from soialib.impl.encoding import ARRAY_WIRE, LEN_BYTES, SMALL_ARRAY_WIRES
 from soialib.impl.function_maker import (
     BodyBuilder,
-    BodySpan,
     Expr,
     ExprLike,
     Line,
@@ -50,8 +49,8 @@ class StructAdapter(TypeAdapter):
         self.private_is_frozen_attr = _name_private_is_frozen_attr(spec.id)
 
         slots = tuple(f.attribute for f in self.spec.fields) + (
-            # Unknown fields encountered during deserialization.
-            "_unknown",
+            # Unrecognized fields encountered during deserialization.
+            "_unrecognized",
             # Lowest number greater than the number of every field with a non-default
             # value.
             "_array_len",
@@ -59,8 +58,8 @@ class StructAdapter(TypeAdapter):
         frozen_class = self.gen_class = _make_dataclass(slots)
         frozen_class.__name__ = spec.class_name
         frozen_class.__qualname__ = spec.class_qualname
-        frozen_class.__setattr__ = _Frozen.__setattr__
-        frozen_class.__delattr__ = _Frozen.__delattr__
+        frozen_class.__setattr__ = cast(Any, _Frozen.__setattr__)
+        frozen_class.__delattr__ = cast(Any, _Frozen.__delattr__)
         # We haven't added an __init__ method to the frozen class yet, so frozen_class()
         # returns an object with no attribute set. We'll set the attributes of DEFAULT
         # at the finalization step.
@@ -98,7 +97,6 @@ class StructAdapter(TypeAdapter):
             )
         )
 
-        # TODO: do I even need this?
         # Aim to have dependencies finalized *before* the dependent. It's not always
         # possible, because there can be cyclic dependencies.
         # The function returned by the do_x_fn() method of a dependency is marginally
@@ -125,16 +123,21 @@ class StructAdapter(TypeAdapter):
         setattr(frozen_class, self.private_is_frozen_attr, True)
         setattr(mutable_class, self.private_is_frozen_attr, False)
 
-        frozen_class.__init__ = _make_frozen_class_init_fn(
-            fields,
-            frozen_class=frozen_class,
-            simple_class=simple_class,
+        frozen_class.__init__ = cast(
+            Any,
+            _make_frozen_class_init_fn(
+                fields,
+                frozen_class=frozen_class,
+                simple_class=simple_class,
+            ),
         )
-        mutable_class.__init__ = _make_mutable_class_init_fn(fields)
+        mutable_class.__init__ = cast(Any, _make_mutable_class_init_fn(fields))
 
         frozen_class.__eq__ = _make_eq_fn(fields)
-        frozen_class.__hash__ = _make_hash_fn(fields, self.record_hash)
-        frozen_class.__repr__ = mutable_class.__repr__ = _make_repr_fn(fields)
+        frozen_class.__hash__ = cast(Any, _make_hash_fn(fields, self.record_hash))
+        frozen_class.__repr__ = mutable_class.__repr__ = cast(
+            Any, _make_repr_fn(fields)
+        )
 
         frozen_class._tdj = _make_to_dense_json_fn(fields=fields)
         frozen_class._trj = _make_to_readable_json_fn(fields=fields)
@@ -162,7 +165,8 @@ class StructAdapter(TypeAdapter):
         return Expr.local("_d?", self.gen_class.DEFAULT)
 
     def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
-        # TODO: comment
+        # The goal of referring to private_is_frozen_attr is to raise an error if the
+        # struct has the wrong type.
         return Expr.join(
             "(",
             arg_expr,
@@ -185,7 +189,7 @@ class StructAdapter(TypeAdapter):
 
     def from_json_expr(self, json_expr: ExprLike) -> Expr:
         fn_name = "_fj"
-        # TODO: comment
+        # The _fj method may not have been added to the class yet.
         from_json_fn = getattr(self.gen_class, fn_name, None)
         if from_json_fn:
             return Expr.join(Expr.local("_fj?", from_json_fn), "(", json_expr, ")")
@@ -231,6 +235,8 @@ def _make_frozen_class_init_fn(
 
     # Set the params.
     params: Params = ["_self"]
+    if fields:
+        params.append("*")
     for field in fields:
         params.append(
             Param(
@@ -262,8 +268,8 @@ def _make_frozen_class_init_fn(
         spans.append("0")
         return Expr.join(*spans)
 
-    if len(fields) < 4:
-        # If the class has less than 4 fields, it is faster to assign every field with
+    if len(fields) < 3:
+        # If the class has less than 3 fields, it is faster to assign every field with
         # object.__setattr__().
         for field in fields:
             attribute = field.field.attribute
@@ -275,6 +281,8 @@ def _make_frozen_class_init_fn(
                 field.type.to_frozen_expr(attribute),
                 ")",
             )
+        # Set the _unrecognized field.
+        builder.append_ln(obj_setattr, '(_self, "_unrecognized", ())')
         # Set array length.
         builder.append_ln(
             obj_setattr,
@@ -300,6 +308,8 @@ def _make_frozen_class_init_fn(
                 " = ",
                 field.type.to_frozen_expr(attribute),
             )
+        # Set the _unrecognized field.
+        builder.append_ln("_self._unrecognized = ()")
         # Set array length.
         builder.append_ln(f"_self._array_len = ", array_len_expr())
         # Change back the __class__.
@@ -333,6 +343,7 @@ def _make_mutable_class_init_fn(fields: Sequence[_Field]) -> Callable[[Any], Non
             " = ",
             attribute,
         )
+    builder.append_ln("_self._unrecognized = ()")
     return make_function(
         name="__init__",
         params=params,
@@ -358,7 +369,7 @@ def _make_to_mutable_fn(
     for field in fields:
         attribute = field.field.attribute
         builder.append_ln("ret.", attribute, " = self.", attribute)
-    # TODO: unknown field
+    builder.append_ln("ret._unrecognized = self._unrecognized")
     builder.append_ln(
         "ret.__class__ = ",
         Expr.local("mutable_class", mutable_class),
@@ -396,10 +407,18 @@ def _make_to_frozen_fn(
             field.type.to_frozen_expr(f"self.{attribute}"),
         )
 
-    # TODO: unknown field
+    # Set the _unrecognized field.
+    builder.append_ln("ret._unrecognized = self._unrecognized")
 
     def array_len_expr() -> Expr:
         spans: list[LineSpanLike] = []
+        spans.append(
+            LineSpan.join(
+                f"{_get_num_slots(fields)} + ",
+                Expr.local("_len", len),
+                "(ret._unrecognized) if ret._unrecognized else ",
+            )
+        )
         # Fields are sorted by number.
         for field in reversed(fields):
             attr_expr = f"ret.{field.field.attribute}"
@@ -413,8 +432,10 @@ def _make_to_frozen_fn(
         spans.append("0")
         return Expr.join(*spans)
 
+    # Set the _unrecognized field.
+    builder.append_ln("ret._unrecognized = self._unrecognized")
     # Set array length.
-    builder.append_ln(f"ret._array_len = ", array_len_expr())
+    builder.append_ln("ret._array_len = ", array_len_expr())
 
     builder.append_ln(
         "ret.__class__ = ",
@@ -461,7 +482,6 @@ def _make_hash_fn(
     """
 
     components: list[ExprLike] = []
-    # TODO: comment
     components.append(str(record_hash))
     for field in fields:
         components.append(f"self.{field.field.attribute}")
@@ -487,8 +507,7 @@ def _make_repr_fn(fields: Sequence[_Field]) -> Callable[[Any], Any]:
     repr_local = Expr.local("repr", repr_impl)
     for field in fields:
         attribute = field.field.attribute
-        # TODO: comment, is_not_default_expr only works on a frozen expression...
-        # TODO: comment; we use try because maybe in mutable we have the wrong type and we still want to be able to repr it
+        # is_not_default_expr only works on a frozen expression.
         to_frozen_expr = field.type.to_frozen_expr(f"(self.{attribute})")
         is_not_default_expr = field.type.is_not_default_expr(
             to_frozen_expr, to_frozen_expr
@@ -512,7 +531,7 @@ def _make_repr_fn(fields: Sequence[_Field]) -> Callable[[Any], Any]:
 
 def _make_to_dense_json_fn(fields: Sequence[_Field]) -> Callable[[Any], Any]:
     builder = BodyBuilder()
-    builder.append_ln(f"l = self._array_len")
+    builder.append_ln("l = self._array_len")
     builder.append_ln("ret = [0] * l")
     for field in fields:
         builder.append_ln(f"if l <= {field.field.number}:")
@@ -524,7 +543,10 @@ def _make_to_dense_json_fn(fields: Sequence[_Field]) -> Callable[[Any], Any]:
                 readable=False,
             ),
         )
-    # TODO: unknown fields
+    num_slots = _get_num_slots(fields)
+    builder.append_ln(f"if l <= {num_slots}:")
+    builder.append_ln("  return ret")
+    builder.append_ln(f"ret[{num_slots}:] = self._unrecognized")
     builder.append_ln("return ret")
     return make_function(
         name="to_dense_json",
@@ -550,7 +572,6 @@ def _make_to_readable_json_fn(fields: Sequence[_Field]) -> Callable[[Any], Any]:
                 readable=True,
             ),
         )
-    # TODO: unknown fields
     builder.append_ln("return ret")
     return make_function(
         name="to_readable_json",
@@ -592,10 +613,20 @@ def _make_from_json_fn(
             f" if array_len <= {number} else ",
             field.type.from_json_expr(item_expr),
         )
+    num_slots = _get_num_slots(fields)
+    builder.append_ln(f"  if array_len <= {num_slots}:")
+    builder.append_ln("    ret._unrecognized = ()")
     builder.append_ln(
-        f"  ret._array_len = ",
+        "    ret._array_len = ",
         _adjust_array_len_expr("array_len", removed_numbers),
     )
+    builder.append_ln("  else:")
+    builder.append_ln(
+        f"    ret._unrecognized = ",
+        Expr.local("deepcopy", copy.deepcopy),
+        f"(json[{num_slots}:])",
+    )
+    builder.append_ln("    ret._array_len = array_len")
 
     builder.append_ln("else:")
     builder.append_ln("  array_len = 0")
@@ -611,7 +642,9 @@ def _make_from_json_fn(
         )
         builder.append_ln("  else:")
         builder.append_ln(f"    {lvalue} = ", field.type.default_expr())
-    builder.append_ln(f"  ret._array_len = array_len")
+    # Drop unrecognized fields in readable mode.
+    builder.append_ln("  ret._unrecognized = ()")
+    builder.append_ln("  ret._array_len = array_len")
 
     builder.append_ln("ret.__class__ = ", Expr.local("Frozen", frozen_class))
     builder.append_ln("return ret")
@@ -683,6 +716,7 @@ def _init_default(default: Any, fields: Sequence[_Field]) -> None:
             body=(Line.join("return ", field.type.default_expr()),),
         )
         object.__setattr__(default, attribute, get_field_default())
+    object.__setattr__(default, "_unrecognized", ())
     object.__setattr__(default, "_array_len", 0)
 
 
@@ -728,3 +762,7 @@ def _name_private_is_frozen_attr(record_id: str) -> str:
     record_name = _spec.RecordId.parse(record_id).name
     hex_hash = hex(abs(hash(record_id)))[:6]
     return f"_is_{record_name}_{hex_hash}"
+
+
+def _get_num_slots(fields: Sequence[_Field]) -> int:
+    return (fields[-1].field.number + 1) if fields else 0

{soia_client-1.0.7 → soia_client-1.0.8}/soialib/impl/type_adapter.py

@@ -49,7 +49,6 @@ class TypeAdapter(Protocol):
         """
         ...
 
-    # TODO: comment!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     def finalize(
         self,
         resolve_type_fn: Callable[[spec.Type], "TypeAdapter"],

{soia_client-1.0.7 → soia_client-1.0.8}/soialib/module_initializer.py

@@ -77,7 +77,6 @@ def init_module(
         else:
             globals[class_name] = gen_class
             gen_class._parent_class = None
-        # TODO: comment
         gen_class.SERIALIZER = make_serializer(adapter)
 
     # Now that al the classes have been initialized, create the methods.

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

@@ -39,14 +39,17 @@ class Serializer(Generic[T]):
         )
         object.__setattr__(self, "_from_json_fn", _make_from_json_fn(adapter))
 
-    def to_json(self, input: T, readable_flavor=False) -> Any:
-        if readable_flavor:
+    def to_json(self, input: T, readable=False) -> Any:
+        if readable:
             return self._to_readable_json_fn(input)
         else:
             return self._to_dense_json_fn(input)
 
-    def to_json_code(self, input: T, readable_flavor=False) -> str:
-        return jsonlib.dumps(self.to_json(input, readable_flavor))
+    def to_json_code(self, input: T, readable=False) -> str:
+        if readable:
+            return jsonlib.dumps(self._to_readable_json_fn(input), indent=2)
+        else:
+            return jsonlib.dumps(self._to_dense_json_fn(input), separators=(",", ":"))
 
     def from_json(self, json: Any) -> T:
         return self._from_json_fn(json)

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

@@ -97,7 +97,7 @@ class Timestamp:
 
     def _trj(self) -> Any:
         """To readable JSON."""
-        iso = self._iso_format
+        iso = self._iso_format()
         if iso:
             return {
                 "unix_millis": self.unix_millis,

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

@@ -1,5 +1,4 @@
-# TODO: test from JSON
-
+import dataclasses
 import unittest
 from typing import Any
 
@@ -25,10 +24,11 @@ class ModuleInitializerTestCase(unittest.TestCase):
                         ),
                         spec.Field(
                             name="y",
-                            number=1,
+                            number=2,
                             type=spec.PrimitiveType.FLOAT32,
                         ),
                     ),
+                    removed_numbers=(1,),
                 ),
                 spec.Struct(
                     id="my/module.soia:Segment",
@@ -115,6 +115,17 @@ class ModuleInitializerTestCase(unittest.TestCase):
                         ),
                     ),
                 ),
+                spec.Struct(
+                    id="my/module.soia:After",
+                    fields=(
+                        spec.Field(
+                            name="points",
+                            number=0,
+                            type=spec.ArrayType("my/module.soia:Point"),
+                            has_mutable_getter=True,
+                        ),
+                    ),
+                ),
                 spec.Enum(
                     id="my/module.soia:PrimaryColor",
                     constant_fields=(
@@ -137,7 +148,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
                     constant_fields=(
                         spec.ConstantField(
                             name="OK",
-                            number=0,
+                            number=1,
                         ),
                     ),
                     value_fields=(
@@ -154,36 +165,40 @@ class ModuleInitializerTestCase(unittest.TestCase):
                     constant_fields=(
                         spec.ConstantField(
                             name="NULL",
-                            number=0,
+                            number=1,
                         ),
                     ),
                     value_fields=(
                         spec.ValueField(
                             name="bool",
-                            number=1,
+                            number=2,
                             type=spec.PrimitiveType.BOOL,
                         ),
                         spec.ValueField(
                             name="number",
-                            number=2,
+                            number=3,
                             type=spec.PrimitiveType.FLOAT64,
                         ),
                         spec.ValueField(
                             name="string",
-                            number=3,
+                            number=4,
                             type=spec.PrimitiveType.STRING,
                         ),
                         spec.ValueField(
                             name="array",
-                            number=4,
+                            number=5,
                             type=spec.ArrayType("my/module.soia:JsonValue"),
                         ),
                         spec.ValueField(
                             name="object",
-                            number=5,
+                            number=6,
                             type="my/module.soia:JsonValue.Object",
                         ),
                     ),
+                    removed_numbers=(
+                        100,
+                        101,
+                    ),
                 ),
                 spec.Struct(
                     id="my/module.soia:JsonValue.Object",
@@ -279,6 +294,27 @@ class ModuleInitializerTestCase(unittest.TestCase):
                         ),
                     ),
                 ),
+                spec.Struct(
+                    id="my/module.soia:Foobar",
+                    fields=(
+                        spec.Field(
+                            name="a",
+                            number=1,
+                            type=spec.PrimitiveType.INT32,
+                        ),
+                        spec.Field(
+                            name="b",
+                            number=3,
+                            type=spec.PrimitiveType.INT32,
+                        ),
+                        spec.Field(
+                            name="point",
+                            number=4,
+                            type="my/module.soia:Point",
+                        ),
+                    ),
+                    removed_numbers=(0, 2),
+                ),
             ),
             methods=(
                 spec.Method(
@@ -299,7 +335,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
                 spec.Constant(
                     name="C",
                     type="my/module.soia:Point",
-                    json_code="[1.5, 2.5]",
+                    json_code="[1.5, 0, 2.5]",
                 ),
             ),
             globals=globals,
@@ -338,7 +374,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         point_cls = self.init_test_module()["Point"]
         point_cls.OrMutable
 
-    def test_default_values(self):
+    def test_primitives_default_values(self):
         primitives_cls = self.init_test_module()["Primitives"]
         a = primitives_cls(
             bool=False,
@@ -351,29 +387,148 @@ class ModuleInitializerTestCase(unittest.TestCase):
             t=Timestamp.EPOCH,
         )
         b = primitives_cls()
+        self.assertEqual(a, b)
         self.assertEqual(hash(a), hash(b))
 
-    def test_to_dense_json(self):
+    def test_primitives_to_json(self):
+        primitives_cls = self.init_test_module()["Primitives"]
+        serializer = primitives_cls.SERIALIZER
+        p = primitives_cls(
+            bool=True,
+            bytes=b"a",
+            f32=3.14,
+            f64=3.14,
+            i32=1,
+            i64=2,
+            u64=3,
+            t=Timestamp.from_unix_millis(4),
+        )
+        self.assertEqual(serializer.to_json(p), [1, "61", 3.14, 3.14, 1, 2, 3, "", 4])
+
+    def test_primitives_from_json(self):
+        primitives_cls = self.init_test_module()["Primitives"]
+        serializer = primitives_cls.SERIALIZER
+        json = [0] * 100
+        self.assertEqual(serializer.from_json(json), primitives_cls.DEFAULT)
+        self.assertEqual(
+            serializer.from_json([1, "61", 3.14, 3.14, 1, 2, 3, "", 4]),
+            primitives_cls(
+                bool=True,
+                bytes=b"a",
+                f32=3.14,
+                f64=3.14,
+                i32=1,
+                i64=2,
+                u64=3,
+                t=Timestamp.from_unix_millis(4),
+            ),
+        )
+
+    def test_primitives_repr(self):
+        primitives_cls = self.init_test_module()["Primitives"]
+        serializer = primitives_cls.SERIALIZER
+        p = primitives_cls(
+            bool=True,
+            bytes=b"a",
+            f32=3.14,
+            f64=3.14,
+            i32=1,
+            i64=2,
+            u64=3,
+            t=Timestamp.from_unix_millis(4),
+        )
+        self.assertEqual(
+            str(p),
+            "Primitives(\n  bool=True,\n  bytes=b'a',\n  f32=3.14,\n  f64=3.14,\n  i32=1,\n  i64=2,\n  u64=3,\n  t=Timestamp(\n    unix_millis=4,\n    _formatted='1970-01-01T00:00:00.004000Z',\n  ),\n)",
+        )
+
+    def test_from_json_converts_between_ints_and_floats(self):
+        primitives_cls = self.init_test_module()["Primitives"]
+        serializer = primitives_cls.SERIALIZER
+        p = serializer.from_json([0, 0, 3])
+        self.assertEqual(p.f32, 3.0)
+        self.assertIsInstance(p.f32, float)
+        p = serializer.from_json({"i32": 1.2})
+        self.assertEqual(p.i32, 1)
+        self.assertIsInstance(p.i32, int)
+
+    def test_cannot_mutate_frozen_class(self):
         point_cls = self.init_test_module()["Point"]
+        serializer = point_cls.SERIALIZER
         point = point_cls(x=1.5, y=2.5)
-        json = point_cls.SERIALIZER.to_json(point)
-        self.assertEqual(json, [1.5, 2.5])
+        try:
+            point.x = 3.5
+            self.fail("expected to raise FrozenInstanceError")
+        except dataclasses.FrozenInstanceError:
+            pass
+        self.assertEqual(point.x, 1.5)
 
-    def test_to_readable_json(self):
+    def test_point_to_dense_json(self):
         point_cls = self.init_test_module()["Point"]
+        serializer = point_cls.SERIALIZER
         point = point_cls(x=1.5, y=2.5)
-        json = point_cls.SERIALIZER.to_json(point, readable_flavor=True)
+        self.assertEqual(serializer.to_json(point), [1.5, 0, 2.5])
+        self.assertEqual(serializer.to_json(point, readable=False), [1.5, 0, 2.5])
+        self.assertEqual(serializer.to_json_code(point), "[1.5,0,2.5]")
+        point = point_cls(x=1.5, y=0.0)
+        self.assertEqual(serializer.to_json(point), [1.5])
+
+    def test_point_to_readable_json(self):
+        point_cls = self.init_test_module()["Point"]
+        point = point_cls(x=1.5, y=2.5)
+        json = point_cls.SERIALIZER.to_json(point, readable=True)
         self.assertEqual(json, {"x": 1.5, "y": 2.5})
+        json_code = point_cls.SERIALIZER.to_json_code(point, readable=True)
+        self.assertEqual(json_code, '{\n  "x": 1.5,\n  "y": 2.5\n}')
 
-    def test_from_dense_json(self):
+    def test_point_from_dense_json(self):
         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))
+        serializer = point_cls.SERIALIZER
+        self.assertEqual(serializer.from_json([1.5, 0, 2.5]), point_cls(x=1.5, y=2.5))
+        self.assertEqual(serializer.from_json([1.5]), point_cls(x=1.5))
+        self.assertEqual(serializer.from_json([0.0]), point_cls.DEFAULT)
+        self.assertEqual(serializer.from_json(0), point_cls.DEFAULT)
 
-    def test_from_readable_json(self):
+    def test_point_from_readable_json(self):
         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))
+        point = point_cls.SERIALIZER.from_json_code('{"x":1.5,"y":2.5}')
+        self.assertEqual(point, point_cls(x=1.5, y=2.5))
+        point = point_cls.SERIALIZER.from_json_code('{"x":1.5,"y":2.5,"z":[]}')
+        self.assertEqual(point, point_cls(x=1.5, y=2.5))
+        point = point_cls.SERIALIZER.from_json_code('{"x":1,"y":2}')
+        self.assertEqual(point.x, 1.0)
+        self.assertIsInstance(point.x, float)
+
+    def test_point_with_unrecognized_and_removed_fields(self):
+        point_cls = self.init_test_module()["Point"]
+        serializer = point_cls.SERIALIZER
+        point = serializer.from_json([1.5, 1, 2.5, True])
+        self.assertEqual(point, point_cls(x=1.5, y=2.5))
+        self.assertEqual(serializer.to_json(point), [1.5, 0, 2.5, True])
+        point = point.to_mutable().to_frozen()
+        self.assertEqual(serializer.to_json(point), [1.5, 0, 2.5, True])
+
+    def test_struct_to_dense_json_with_removed_fields(self):
+        test_module = self.init_test_module()
+        foobar_cls = test_module["Foobar"]
+        point_cls = test_module["Point"]
+        serializer = foobar_cls.SERIALIZER
+        foobar = foobar_cls()
+        self.assertEqual(serializer.to_json_code(foobar), "[]")
+        self.assertEqual(serializer.from_json_code("[]"), foobar)
+        foobar = foobar_cls(a=3)
+        self.assertEqual(serializer.to_json_code(foobar), "[0,3]")
+        self.assertEqual(serializer.from_json_code("[0,3]"), foobar)
+        self.assertEqual(serializer.from_json_code("[0,3.1]"), foobar)
+        foobar = foobar_cls(b=3, point=point_cls.DEFAULT)
+        self.assertEqual(serializer.to_json_code(foobar), "[0,0,0,3]")
+        self.assertEqual(serializer.from_json_code("[0,0,0,3]"), foobar)
+        self.assertEqual(serializer.from_json_code("[0,0,0,3.1]"), foobar)
+        foobar = foobar_cls(point=point_cls(x=2))
+        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_struct_ctor_accepts_mutable_struct(self):
         module = self.init_test_module()
@@ -488,7 +643,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertIs(unknown.union, unknown)
         serializer = primary_color_cls.SERIALIZER
         self.assertEqual(serializer.to_json(unknown), 0)
-        self.assertEqual(serializer.to_json(unknown, readable_flavor=True), "?")
+        self.assertEqual(serializer.to_json(unknown, readable=True), "?")
 
     def test_enum_user_defined_constant(self):
         module = self.init_test_module()
@@ -499,7 +654,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         self.assertIs(red.union, red)
         serializer = primary_color_cls.SERIALIZER
         self.assertEqual(serializer.to_json(red), 10)
-        self.assertEqual(serializer.to_json(red, readable_flavor=True), "RED")
+        self.assertEqual(serializer.to_json(red, readable=True), "RED")
 
     def test_enum_wrap(self):
         module = self.init_test_module()
@@ -511,7 +666,7 @@ class ModuleInitializerTestCase(unittest.TestCase):
         serializer = status_cls.SERIALIZER
         self.assertEqual(serializer.to_json(error), [2, "An error occurred"])
         self.assertEqual(
-            serializer.to_json(error, readable_flavor=True),
+            serializer.to_json(error, readable=True),
             {"kind": "error", "value": "An error occurred"},
         )
 
@@ -526,6 +681,121 @@ class ModuleInitializerTestCase(unittest.TestCase):
             json_object, json_value_cls.wrap_object(json_object_cls.DEFAULT)
         )
 
+    def test_enum_to_json(self):
+        module = self.init_test_module()
+        status_cls = module["Status"]
+        serializer = status_cls.SERIALIZER
+        self.assertEqual(serializer.to_json(status_cls.UNKNOWN), 0)
+        self.assertEqual(serializer.to_json(status_cls.UNKNOWN, readable=True), "?")
+        self.assertEqual(serializer.to_json(status_cls.OK), 1)
+        self.assertEqual(serializer.to_json(status_cls.OK, readable=True), "OK")
+        self.assertEqual(serializer.to_json(status_cls.OK, readable=False), 1)
+        self.assertEqual(serializer.to_json(status_cls.wrap_error("E")), [2, "E"])
+        self.assertEqual(
+            serializer.to_json(status_cls.wrap_error("E"), readable=True),
+            {"kind": "error", "value": "E"},
+        )
+
+    def test_enum_from_json(self):
+        module = self.init_test_module()
+        status_cls = module["Status"]
+        serializer = status_cls.SERIALIZER
+        self.assertEqual(serializer.from_json(0), status_cls.UNKNOWN)
+        self.assertEqual(serializer.from_json("?"), status_cls.UNKNOWN)
+        self.assertEqual(serializer.from_json(1), status_cls.OK)
+        self.assertEqual(serializer.from_json("OK"), status_cls.OK)
+        self.assertEqual(serializer.from_json([2, "E"]), status_cls.wrap_error("E"))
+        self.assertEqual(
+            serializer.from_json({"kind": "error", "value": "E"}),
+            status_cls.wrap_error("E"),
+        )
+
+    def test_complex_enum_from_json(self):
+        module = self.init_test_module()
+        json_value_cls = module["JsonValue"]
+        serializer = json_value_cls.SERIALIZER
+        json_value = serializer.from_json(
+            [
+                5,
+                [
+                    0,
+                    1,
+                    [2, True],
+                    [3, 3.14],
+                    [4, "foo"],
+                    [
+                        6,
+                        [["a", 0], ["b", 0]],
+                    ],
+                    [5, [[5, []]]],
+                ],
+            ]
+        )
+        self.assertEqual(
+            json_value,
+            json_value_cls.wrap_array(
+                [
+                    json_value_cls.UNKNOWN,
+                    json_value_cls.NULL,
+                    json_value_cls.wrap_bool(True),
+                    json_value_cls.wrap_number(3.14),
+                    json_value_cls.wrap_string("foo"),
+                    json_value_cls.wrap_object(
+                        json_value_cls.Object(
+                            entries=[
+                                json_value_cls.ObjectEntry(),
+                                json_value_cls.ObjectEntry.DEFAULT,
+                            ],
+                        )
+                    ),
+                    json_value_cls.wrap_array(
+                        [
+                            json_value_cls.wrap_array([]),
+                        ]
+                    ),
+                ]
+            ),
+        )
+        self.assertEqual(
+            serializer.from_json(
+                {
+                    "kind": "array",
+                    "value": [
+                        "?",
+                        "NULL",
+                        {"kind": "bool", "value": True},
+                        {"kind": "number", "value": 3.14},
+                        {"kind": "string", "value": "foo"},
+                        {"kind": "object", "value": {"entries": [{}, {}]}},
+                        {"kind": "array", "value": [{"kind": "array", "value": []}]},
+                    ],
+                }
+            ),
+            json_value,
+        )
+
+    def test_struct_with_enum_field(self):
+        json_value_cls = self.init_test_module()["JsonValue"]
+        json_object_entry_cls = json_value_cls.ObjectEntry
+        self.assertEqual(json_object_entry_cls.DEFAULT.value, json_value_cls.UNKNOWN)
+        self.assertEqual(json_object_entry_cls().value, json_value_cls.UNKNOWN)
+
+    def test_enum_with_unrecognized_and_removed_fields(self):
+        json_value_cls = self.init_test_module()["JsonValue"]
+        serializer = json_value_cls.SERIALIZER
+        json_value = serializer.from_json(100)  # removed
+        self.assertEqual(json_value, json_value_cls.UNKNOWN)
+        self.assertEqual(serializer.to_json(json_value), 0)
+        json_value = serializer.from_json([101, True])  # removed
+        self.assertEqual(json_value, json_value_cls.UNKNOWN)
+        self.assertEqual(serializer.to_json(json_value), 0)
+        json_value = serializer.from_json(102)  # unrecognized
+        self.assertEqual(json_value, json_value_cls.UNKNOWN)
+        self.assertEqual(serializer.to_json(json_value), 102)
+        json_value = serializer.from_json([102, True])  # unrecognized
+        self.assertEqual(json_value, json_value_cls.UNKNOWN)
+        self.assertEqual(serializer.to_json(json_value), [102, True])
+
     def test_class_name(self):
         module = self.init_test_module()
         shape_cls = module["Shape"]
@@ -822,4 +1092,4 @@ class ModuleInitializerTestCase(unittest.TestCase):
         module = self.init_test_module()
         c = module["C"]
         Point = module["Point"]
-        self.assertEqual(c, Point(1.5, 2.5))
+        self.assertEqual(c, Point(x=1.5, y=2.5))

{soia_client-1.0.7 → soia_client-1.0.8}/tests/test_serializers.py

@@ -10,8 +10,15 @@ from soialib import (
 
 class TimestampTestCase(unittest.TestCase):
     def test_primitive_serializers(self):
-        self.assertEqual(primitive_serializer("bool").to_json_code(True), "true")
+        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"
         )
@@ -21,24 +28,46 @@ class TimestampTestCase(unittest.TestCase):
         )
         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]),
-            "[true, false]",
+            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(

soia_client-1.0.7/soialib/impl/encoding.py

@@ -1,41 +0,0 @@
-from struct import pack
-from typing import Final
-
-from soialib.impl.function_maker import Expr
-
-EMPTY_STRING_WIRE: Final[Expr] = Expr.local("EMPTY_STRING_WIRE", bytes([242]))
-STRING_WIRE: Final[Expr] = Expr.local("STRING_WIRE", bytes([243]))
-EMPTY_BYTE_STRING_WIRE: Final[Expr] = Expr.local("EMPTY_BYTE_STRING_WIRE", bytes([244]))
-BYTE_STRING_WIRE: Final[Expr] = Expr.local("BYTE_STRING_WIRE", bytes([245]))
-SMALL_ARRAY_WIRES: Final[Expr] = Expr.local(
-    "SMALL_ARRAY_WIRES", tuple(bytes(b) for b in range(246, 250))
-)
-ARRAY_WIRE: Final[Expr] = Expr.local("ARRAY_WIRE", bytes(250))
-NULL_WIRE: Final[Expr] = Expr.local("NULL_WIRE", bytes([255]))
-
-_LOW_INT_BYTES: Final[tuple[bytes, ...]] = tuple([bytes([i]) for i in range(232)])
-_ZERO_BYTES: Final[bytes] = _LOW_INT_BYTES[0]
-_ONE_BYTES: Final[bytes] = _LOW_INT_BYTES[1]
-
-LOW_INT_BYTES: Final[Expr] = Expr.local("LOW_INT_BYTES", _LOW_INT_BYTES)
-ZERO_BYTES: Final[Expr] = Expr.local("ZERO_BYTES_LOCAL", _ZERO_BYTES)
-ONE_BYTES: Final[Expr] = Expr.local("ONE_BYTES_LOCAL", _ONE_BYTES)
-
-PACK: Final[Expr] = Expr.local("pack", pack)
-
-
-def _len_bytes_high(l: int) -> bytes:
-    if l < 65536:
-        return pack("H", l)
-    elif l < 2147483648:
-        return pack("I", l)
-    raise OverflowError(f"len={l}")
-
-
-LEN_BYTES: Final[Expr] = Expr.join(
-    "(",
-    LOW_INT_BYTES,
-    "[l] if l < 232 else ",
-    Expr.local("len_bytes_high", _len_bytes_high),
-    "(l))",
-)