soia-client 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

{soia_client-1.0.7.dist-info → soia_client-1.0.9.dist-info}/METADATA

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

soia_client-1.0.9.dist-info/RECORD

@@ -0,0 +1,23 @@
+soia_client-1.0.9.dist-info/licenses/LICENSE,sha256=SaAftKkX6hfSOiPdENQPS70tifH3PDHgazq8eK2Pwfw,1064
+soialib/__init__.py,sha256=h_ENkLJEdrh1mGhCoKgIadDasSulW3zK9_qhEsTviXY,429
+soialib/keyed_items.py,sha256=q7MCn82obf-0jh7FcAhuw4eh9-wtuHIpkEFcSfc8EaY,338
+soialib/method.py,sha256=2qWG4jMqYhS3hA8y8YDu3iqzhXA_AKebpB38RWNmsYQ,452
+soialib/module_initializer.py,sha256=Riq6B6cS9HUG1W8tyaa0GkiG3F4fGX70bKU0UOCnrRw,4205
+soialib/never.py,sha256=bYU63XyNX4e2wOUXQHhHWGO-an4IFr9_ur1ut6GmGN0,47
+soialib/serializer.py,sha256=jSDanuJ4TEPWEO0ssYSKy2CDLUPV0zwCUzNGHk6uFRQ,3122
+soialib/serializers.py,sha256=vNLNsfuu6dF0ivJF6v7wQj5Yr6uo2kZHXG5tMrYiVTA,2564
+soialib/spec.py,sha256=w-eMMUqOchOlCJaXppyAa2JpSBrMo9lrMvqz8VaEX4I,3699
+soialib/timestamp.py,sha256=lXBNH8mPmzflkNjSKZSBl2XS-ot9N8N92B_zGO2SMtU,4078
+soialib/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+soialib/impl/arrays.py,sha256=4p-4FoM_hrQfwSIF1KmYGjJyP6SGyV7rD_L7D46d9Z4,4863
+soialib/impl/enums.py,sha256=kSH0Puub0pZJ4hAVw52y0ktDX1IkHpPan3IDp6OHIIs,15990
+soialib/impl/function_maker.py,sha256=MvCDv1WwzKGJzZbNCnJ_8-MP3m1xTIabumXA-9Ydd9M,5639
+soialib/impl/optionals.py,sha256=pWuhfTIYM7669Rko-oVlBhHLqO3vgASW7fL0Yos3AWM,2076
+soialib/impl/primitives.py,sha256=AHMVvs3BWvPfggsdFnY5dwwqAwiNVFYJa_rJ-WjMJfk,7424
+soialib/impl/repr.py,sha256=7WX0bEAVENTjlyZIcbT8TcJylS7IRIyafGCmqaIMxFM,1413
+soialib/impl/structs.py,sha256=GKTw6p_HasS9E520l74QFldIjUhjxM8sm4poPnR7fFg,25539
+soialib/impl/type_adapter.py,sha256=e72nBDqOP0uWNY10EtG7qOvRTzujA-LUVA30Ff7eeac,1935
+soia_client-1.0.9.dist-info/METADATA,sha256=ACwdLcQ3vRHTS1sWzLRk1A14mQxlhEP7WX0KtQU_8FY,1666
+soia_client-1.0.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+soia_client-1.0.9.dist-info/top_level.txt,sha256=2vPmAo5G0SrCxYrNdJKJJVdpalYppgjO2mmz2PtsFUI,8
+soia_client-1.0.9.dist-info/RECORD,,

{soia_client-1.0.7.dist-info → soia_client-1.0.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

soialib/impl/arrays.py

@@ -73,16 +73,13 @@ class _ArrayAdapter(TypeAdapter):
         return attr_expr
 
     def to_json_expr(self, in_expr: ExprLike, readable: bool) -> ExprLike:
-        e = Expr.join("_e")
-        item_to_json = self.item_adapter.to_json_expr(e, readable)
-        if item_to_json == e:
+        item_to_json = self.item_adapter.to_json_expr("_e", readable)
+        if Expr.join(item_to_json) == Expr.join("_e"):
             return in_expr
         return Expr.join(
             "[",
             item_to_json,
-            " for ",
-            e,
-            " in ",
+            " for _e in ",
             in_expr,
             "]",
         )
@@ -93,8 +90,8 @@ class _ArrayAdapter(TypeAdapter):
         return Expr.join(
             listuple_class_local,
             "([",
-            self.item_adapter.from_json_expr(Expr.join("_e")),
-            " for e in ",
+            self.item_adapter.from_json_expr("_e"),
+            " for _e in ",
             json_expr,
             "] or ",
             empty_listuple_local,

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

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

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
 

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

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)

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,
@@ -174,7 +178,7 @@ class StructAdapter(TypeAdapter):
         )
 
     def is_not_default_expr(self, arg_expr: ExprLike, attr_expr: ExprLike) -> Expr:
-        return Expr.join(attr_expr, f"._array_len")
+        return Expr.join(attr_expr, "._array_len")
 
     def to_json_expr(
         self,
@@ -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,10 +281,12 @@ 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,
-            f'(_self, "_array_len", ',
+            '(_self, "_array_len", ',
             array_len_expr(),
             ")",
         )
@@ -300,8 +308,10 @@ 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())
+        builder.append_ln("_self._array_len = ", array_len_expr())
         # Change back the __class__.
         builder.append_ln("_self.__class__ = ", Expr.local("Frozen", frozen_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,
@@ -349,7 +360,7 @@ def _make_to_mutable_fn(
     Returns the implementation of the to_mutable() method of the frozen class.
     """
     builder = BodyBuilder()
-    # Create an instance of the simple class. We'll later change its __class__ attribute.
+    # Create an instance of the simple class. We'll later change its __class__ attr.
     builder.append_ln(
         "ret = ",
         Expr.local("Simple", simple_class),
@@ -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),
@@ -381,7 +392,7 @@ def _make_to_frozen_fn(
     """
 
     builder = BodyBuilder()
-    # Create an instance of the simple class. We'll later change its __class__ attribute.
+    # Create an instance of the simple class. We'll later change its __class__ attr.
     builder.append_ln(
         "ret = ",
         Expr.local("Simple", simple_class),
@@ -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(
+        "    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")
@@ -607,11 +638,13 @@ def _make_from_json_fn(
         builder.append_ln(f"    array_len = {field.field.number}")
         builder.append_ln(
             f"    {lvalue} = ",
-            field.type.from_json_expr(Expr.join(f'json["{name}"]')),
+            field.type.from_json_expr(f'json["{name}"]'),
         )
         builder.append_ln("  else:")
         builder.append_ln(f"    {lvalue} = ", field.type.default_expr())
-    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

soialib/impl/type_adapter.py

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

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.

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)

soialib/serializers.py

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

soialib/timestamp.py

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

soia_client-1.0.7.dist-info/RECORD

@@ -1,24 +0,0 @@
-soialib/__init__.py,sha256=h_ENkLJEdrh1mGhCoKgIadDasSulW3zK9_qhEsTviXY,429
-soialib/keyed_items.py,sha256=q7MCn82obf-0jh7FcAhuw4eh9-wtuHIpkEFcSfc8EaY,338
-soialib/method.py,sha256=2qWG4jMqYhS3hA8y8YDu3iqzhXA_AKebpB38RWNmsYQ,452
-soialib/module_initializer.py,sha256=dDdYtlWlN7kEWlxuI0lguPsI-7zXAShswjw9j-_-AWY,4229
-soialib/never.py,sha256=bYU63XyNX4e2wOUXQHhHWGO-an4IFr9_ur1ut6GmGN0,47
-soialib/serializer.py,sha256=2R1BYEvpG3eDYMFXSKljPTMweOiuu8OMq7Xf1Bv2Wsk,3008
-soialib/serializers.py,sha256=7zmCdtaUkuy1vIGP1OBn06x8FryYep15bujrFoeGw9A,2572
-soialib/spec.py,sha256=w-eMMUqOchOlCJaXppyAa2JpSBrMo9lrMvqz8VaEX4I,3699
-soialib/timestamp.py,sha256=6VNKAJs7EwxBm3tEEk1Cy1FhAD6lSNdlB3K2Sg6QHIA,4065
-soialib/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soialib/impl/arrays.py,sha256=NOKIfD3tvYnWycVk00aaf4m5Nx4_G5sVxdh2cwu4-l0,4902
-soialib/impl/encoding.py,sha256=8k2j0nhGloFIBUEZLiiHANwhopusaQcDRePPS4sUhPc,1413
-soialib/impl/enums.py,sha256=o3KylHoh66jcb1TUHeOorjaxHPoqHkbk7PXR5hKldrI,14121
-soialib/impl/function_maker.py,sha256=PYqHqnZf8nELfEnRcoyyUbPAHyr99ROHhmHGj9ldB6U,5684
-soialib/impl/optionals.py,sha256=QUcxx0i7oAQl7IcnxKyNW11xi7fbs2hmuSP1pfrTSTY,2120
-soialib/impl/primitives.py,sha256=X_ywRmVZI_Q5tatb1Qil6Xvdyh1J4ElfI-LOCn671Zk,5975
-soialib/impl/repr.py,sha256=z-_jGNKuY__DfwQKW40xzZFf_eG6wGMJvuY_2hJrETA,1441
-soialib/impl/structs.py,sha256=vkOklmPzvWyFLFkMYbuDF8Rv_lkhzA66J-Uo9FJcVQc,24028
-soialib/impl/type_adapter.py,sha256=IP3jF3wPgwKhWd7LKMmbbv1qUTv1HBAyMdpVrIg0_S0,2063
-soia_client-1.0.7.dist-info/LICENSE,sha256=SaAftKkX6hfSOiPdENQPS70tifH3PDHgazq8eK2Pwfw,1064
-soia_client-1.0.7.dist-info/METADATA,sha256=s5Ll-b2a11xX7z7c1yWbXt1-zu4BZEh9ZxOP5y8jXsA,1645
-soia_client-1.0.7.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-soia_client-1.0.7.dist-info/top_level.txt,sha256=2vPmAo5G0SrCxYrNdJKJJVdpalYppgjO2mmz2PtsFUI,8
-soia_client-1.0.7.dist-info/RECORD,,

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))",
-)