soia-client 1.1.5__py3-none-any.whl → 1.1.20__py3-none-any.whl

soia/_impl/primitives.py

@@ -1,15 +1,30 @@
 import base64
+import math
+import struct
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, Final, final
 
 from soia import _spec, reflection
+from soia._impl.binary import (
+    decode_bool,
+    decode_float,
+    decode_int32,
+    decode_int64,
+    decode_uint64,
+    encode_float32,
+    encode_float64,
+    encode_int32,
+    encode_int64,
+    encode_length_prefix,
+    encode_uint64,
+)
 from soia._impl.function_maker import Expr, ExprLike
 from soia._impl.timestamp import Timestamp
-from soia._impl.type_adapter import TypeAdapter
+from soia._impl.type_adapter import ByteStream, T, TypeAdapter
 
 
-class AbstractPrimitiveAdapter(TypeAdapter):
+class AbstractPrimitiveAdapter(TypeAdapter[T]):
     @final
     def finalize(
         self,
@@ -29,7 +44,7 @@ class AbstractPrimitiveAdapter(TypeAdapter):
         return None
 
 
-class _BoolAdapter(AbstractPrimitiveAdapter):
+class _BoolAdapter(AbstractPrimitiveAdapter[bool]):
     def default_expr(self) -> ExprLike:
         return "False"
 
@@ -49,8 +64,23 @@ class _BoolAdapter(AbstractPrimitiveAdapter):
         else:
             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)")
+    def from_json_expr(
+        self, json_expr: ExprLike, keep_unrecognized_expr: ExprLike
+    ) -> Expr:
+        return Expr.join("(", json_expr, " not in (0, '0'))")
+
+    @staticmethod
+    def encode(
+        value: bool,
+        buffer: bytearray,
+    ) -> None:
+        buffer.append(1 if value else 0)
+
+    def encode_fn(self) -> Callable[[bool, bytearray], None]:
+        return _BoolAdapter.encode
+
+    def decode_fn(self) -> Callable[[ByteStream], bool]:
+        return decode_bool
 
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
@@ -59,11 +89,11 @@ class _BoolAdapter(AbstractPrimitiveAdapter):
         )
 
 
-BOOL_ADAPTER: Final[TypeAdapter] = _BoolAdapter()
+BOOL_ADAPTER: Final[TypeAdapter[bool]] = _BoolAdapter()
 
 
 @dataclass(frozen=True)
-class _AbstractIntAdapter(AbstractPrimitiveAdapter):
+class _AbstractIntAdapter(AbstractPrimitiveAdapter[int]):
     """Type adapter implementation for int32, int64 and uint64."""
 
     def default_expr(self) -> ExprLike:
@@ -76,7 +106,9 @@ class _AbstractIntAdapter(AbstractPrimitiveAdapter):
     def is_not_default_expr(self, arg_expr: ExprLike, attr_expr: ExprLike) -> ExprLike:
         return arg_expr
 
-    def from_json_expr(self, json_expr: ExprLike) -> Expr:
+    def from_json_expr(
+        self, json_expr: ExprLike, keep_unrecognized_expr: ExprLike
+    ) -> Expr:
         # Must accept float inputs and string inputs and turn them into ints.
         return Expr.join(
             "(0).__class__(",
@@ -98,6 +130,12 @@ class _Int32Adapter(_AbstractIntAdapter):
             " < 2147483647 else 2147483647)",
         )
 
+    def encode_fn(self) -> Callable[[int, bytearray], None]:
+        return encode_int32
+
+    def decode_fn(self) -> Callable[[ByteStream], int]:
+        return decode_int32
+
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
             kind="primitive",
@@ -124,6 +162,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 encode_fn(self) -> Callable[[int, bytearray], None]:
+        return encode_int64
+
+    def decode_fn(self) -> Callable[[ByteStream], int]:
+        return decode_int64
+
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
             kind="primitive",
@@ -149,6 +193,12 @@ class _Uint64Adapter(_AbstractIntAdapter):
             Expr.local("uint64_to_json", _uint64_to_json), "(", in_expr, ")"
         )
 
+    def encode_fn(self) -> Callable[[int, bytearray], None]:
+        return encode_uint64
+
+    def decode_fn(self) -> Callable[[ByteStream], int]:
+        return decode_uint64
+
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
             kind="primitive",
@@ -156,13 +206,27 @@ class _Uint64Adapter(_AbstractIntAdapter):
         )
 
 
-INT32_ADAPTER: Final[TypeAdapter] = _Int32Adapter()
-INT64_ADAPTER: Final[TypeAdapter] = _Int64Adapter()
-UINT64_ADAPTER: Final[TypeAdapter] = _Uint64Adapter()
+INT32_ADAPTER: Final[TypeAdapter[int]] = _Int32Adapter()
+INT64_ADAPTER: Final[TypeAdapter[int]] = _Int64Adapter()
+UINT64_ADAPTER: Final[TypeAdapter[int]] = _Uint64Adapter()
+
+
+_SPECIAL_FLOAT_TO_STRING: Final[dict[str, str]] = {
+    "nan": "NaN",
+    "inf": "Infinity",
+    "-inf": "-Infinity",
+}
+
+
+_STRING_TO_SPECIAL_FLOAT: Final[dict[str, float]] = {
+    "NaN": float("nan"),
+    "Infinity": float("inf"),
+    "-Infinity": float("-inf"),
+}
 
 
 @dataclass(frozen=True)
-class _AbstractFloatAdapter(AbstractPrimitiveAdapter):
+class _AbstractFloatAdapter(AbstractPrimitiveAdapter[float]):
     """Type adapter implementation for float32 and float64."""
 
     def default_expr(self) -> ExprLike:
@@ -175,16 +239,52 @@ class _AbstractFloatAdapter(AbstractPrimitiveAdapter):
         return arg_expr
 
     def to_json_expr(self, in_expr: ExprLike, readable: bool) -> ExprLike:
-        return in_expr
+        return Expr.join(
+            "(",
+            in_expr,
+            " if ",
+            Expr.local("_isfinite", math.isfinite),
+            "(",
+            in_expr,
+            ") else ",
+            Expr.local(
+                "_SPECIAL_FLOAT_TO_STRING",
+                _SPECIAL_FLOAT_TO_STRING,
+            ),
+            "[f'{",
+            in_expr,
+            "}'])",
+        )
+
+    def from_json_expr(
+        self, json_expr: ExprLike, keep_unrecognized_expr: ExprLike
+    ) -> Expr:
+        return Expr.join(
+            "(",
+            Expr.local(
+                "_STRING_TO_SPECIAL_FLOAT",
+                _STRING_TO_SPECIAL_FLOAT,
+            ),
+            "[",
+            json_expr,
+            "] if ",
+            json_expr,
+            " in ('NaN', 'Infinity', '-Infinity') else (",
+            json_expr,
+            " + 0.0))",
+        )
 
-    def from_json_expr(self, json_expr: ExprLike) -> Expr:
-        return Expr.join("(", json_expr, " + 0.0)")
+    def decode_fn(self) -> Callable[[ByteStream], float]:
+        return decode_float
 
 
 @dataclass(frozen=True)
 class _Float32Adapter(_AbstractFloatAdapter):
     """Type adapter implementation for float32."""
 
+    def encode_fn(self) -> Callable[[float, bytearray], None]:
+        return encode_float32
+
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
             kind="primitive",
@@ -194,7 +294,10 @@ class _Float32Adapter(_AbstractFloatAdapter):
 
 @dataclass(frozen=True)
 class _Float64Adapter(_AbstractFloatAdapter):
-    """Type adapter implementation for float32."""
+    """Type adapter implementation for float64."""
+
+    def encode_fn(self) -> Callable[[float, bytearray], None]:
+        return encode_float64
 
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
@@ -203,11 +306,16 @@ class _Float64Adapter(_AbstractFloatAdapter):
         )
 
 
-FLOAT32_ADAPTER: Final[TypeAdapter] = _Float32Adapter()
-FLOAT64_ADAPTER: Final[TypeAdapter] = _Float64Adapter()
+FLOAT32_ADAPTER: Final[TypeAdapter[float]] = _Float32Adapter()
+FLOAT64_ADAPTER: Final[TypeAdapter[float]] = _Float64Adapter()
+
 
+def _clamp_unix_millis(unix_millis: int) -> int:
+    """Clamp unix milliseconds to valid range for JavaScript dates."""
+    return max(-8640000000000000, min(unix_millis, 8640000000000000))
 
-class _TimestampAdapter(AbstractPrimitiveAdapter):
+
+class _TimestampAdapter(AbstractPrimitiveAdapter[Timestamp]):
     def default_expr(self) -> Expr:
         return Expr.local("_EPOCH", Timestamp.EPOCH)
 
@@ -236,10 +344,34 @@ class _TimestampAdapter(AbstractPrimitiveAdapter):
         else:
             return Expr.join(in_expr, ".unix_millis")
 
-    def from_json_expr(self, json_expr: ExprLike) -> Expr:
+    def from_json_expr(
+        self, json_expr: ExprLike, keep_unrecognized_expr: ExprLike
+    ) -> Expr:
         fn = Expr.local("_timestamp_from_json", _timestamp_from_json)
         return Expr.join(fn, "(", json_expr, ")")
 
+    @staticmethod
+    def encode(
+        value: Timestamp,
+        buffer: bytearray,
+    ) -> None:
+        unix_millis = _clamp_unix_millis(value.unix_millis)
+        if unix_millis == 0:
+            buffer.append(0)
+        else:
+            buffer.append(239)
+            buffer.extend(struct.pack("<q", unix_millis))
+
+    def encode_fn(self) -> Callable[[Timestamp, bytearray], None]:
+        return _TimestampAdapter.encode
+
+    @staticmethod
+    def decode(stream: ByteStream) -> Timestamp:
+        return Timestamp(unix_millis=_clamp_unix_millis(decode_int64(stream)))
+
+    def decode_fn(self) -> Callable[[ByteStream], Timestamp]:
+        return _TimestampAdapter.decode
+
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
             kind="primitive",
@@ -250,14 +382,16 @@ class _TimestampAdapter(AbstractPrimitiveAdapter):
 def _timestamp_from_json(json: Any) -> Timestamp:
     if json.__class__ is int or isinstance(json, int):
         return Timestamp(unix_millis=json)
+    elif isinstance(json, float) or isinstance(json, str):
+        return Timestamp(unix_millis=int(json))
     else:
         return Timestamp(unix_millis=json["unix_millis"])
 
 
-TIMESTAMP_ADAPTER: Final[TypeAdapter] = _TimestampAdapter()
+TIMESTAMP_ADAPTER: Final[TypeAdapter[Timestamp]] = _TimestampAdapter()
 
 
-class _StringAdapter(AbstractPrimitiveAdapter):
+class _StringAdapter(AbstractPrimitiveAdapter[str]):
     def default_expr(self) -> ExprLike:
         return '""'
 
@@ -270,9 +404,42 @@ class _StringAdapter(AbstractPrimitiveAdapter):
     def to_json_expr(self, in_expr: ExprLike, readable: bool) -> ExprLike:
         return in_expr
 
-    def from_json_expr(self, json_expr: ExprLike) -> Expr:
+    def from_json_expr(
+        self, json_expr: ExprLike, keep_unrecognized_expr: ExprLike
+    ) -> Expr:
         return Expr.join("('' + (", json_expr, " or ''))")
 
+    @staticmethod
+    def encode(
+        value: str,
+        buffer: bytearray,
+    ) -> None:
+        if not value:
+            buffer.append(242)
+        else:
+            buffer.append(243)
+            bytes_data = value.encode("utf-8")
+            length = len(bytes_data)
+            encode_length_prefix(length, buffer)
+            buffer.extend(bytes_data)
+
+    def encode_fn(self) -> Callable[[str, bytearray], None]:
+        return _StringAdapter.encode
+
+    @staticmethod
+    def decode(stream: ByteStream) -> str:
+        wire = stream.read(1)[0]
+        if wire in (0, 242):
+            return ""
+        else:
+            # Should be wire 243
+            length = decode_int64(stream)
+            bytes_data = stream.read(length)
+            return bytes_data.decode("utf-8")
+
+    def decode_fn(self) -> Callable[[ByteStream], str]:
+        return _StringAdapter.decode
+
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
             kind="primitive",
@@ -283,7 +450,14 @@ class _StringAdapter(AbstractPrimitiveAdapter):
 STRING_ADAPTER: Final[TypeAdapter] = _StringAdapter()
 
 
-class _BytesAdapter(AbstractPrimitiveAdapter):
+def _bytes_from_json(json: str) -> bytes:
+    if json.startswith("hex:"):
+        return bytes.fromhex(json[4:])
+    else:
+        return base64.b64decode(json)
+
+
+class _BytesAdapter(AbstractPrimitiveAdapter[bytes]):
     def default_expr(self) -> ExprLike:
         return 'b""'
 
@@ -297,18 +471,56 @@ class _BytesAdapter(AbstractPrimitiveAdapter):
         self,
         in_expr: ExprLike,
         readable: bool,
+    ) -> Expr:
+        if readable:
+            return Expr.join(
+                "('hex:' + ",
+                in_expr,
+                ".hex())",
+            )
+        else:
+            return Expr.join(
+                Expr.local("b64encode", base64.b64encode),
+                "(",
+                in_expr,
+                ").decode('utf-8')",
+            )
+
+    def from_json_expr(
+        self, json_expr: ExprLike, keep_unrecognized_expr: ExprLike
     ) -> Expr:
         return Expr.join(
-            Expr.local("b64encode", base64.b64encode),
-            "(",
-            in_expr,
-            ").decode('utf-8')",
+            Expr.local("bytes_from_json", _bytes_from_json), "(", json_expr, ' or "")'
         )
 
-    def from_json_expr(self, json_expr: ExprLike) -> Expr:
-        return Expr.join(
-            Expr.local("b64decode", base64.b64decode), "(", json_expr, ' or "")'
-        )
+    @staticmethod
+    def encode(
+        value: bytes,
+        buffer: bytearray,
+    ) -> None:
+        if len(value) == 0:
+            buffer.append(244)
+        else:
+            buffer.append(245)
+            length = len(value)
+            encode_length_prefix(length, buffer)
+            buffer.extend(value)
+
+    def encode_fn(self) -> Callable[[bytes, bytearray], None]:
+        return _BytesAdapter.encode
+
+    @staticmethod
+    def decode(stream: ByteStream) -> bytes:
+        wire = stream.read_wire()
+        if wire in (0, 244):
+            return b""
+        else:
+            # Should be wire 245
+            length = decode_int64(stream)
+            return stream.read(length)
+
+    def decode_fn(self) -> Callable[[ByteStream], bytes]:
+        return _BytesAdapter.decode
 
     def get_type(self) -> reflection.Type:
         return reflection.PrimitiveType(
@@ -317,4 +529,4 @@ class _BytesAdapter(AbstractPrimitiveAdapter):
         )
 
 
-BYTES_ADAPTER: Final[TypeAdapter] = _BytesAdapter()
+BYTES_ADAPTER: Final[TypeAdapter[bytes]] = _BytesAdapter()

soia/_impl/serializer.py

@@ -8,7 +8,7 @@ from weakref import WeakValueDictionary
 from soia import reflection
 from soia._impl.function_maker import Expr, LineSpan, make_function
 from soia._impl.never import Never
-from soia._impl.type_adapter import TypeAdapter
+from soia._impl.type_adapter import ByteStream, TypeAdapter
 
 T = TypeVar("T")
 
@@ -21,26 +21,33 @@ class Serializer(Generic[T]):
         "_to_dense_json_fn",
         "_to_readable_json_fn",
         "_from_json_fn",
+        "_encode_fn",
+        "_decode_fn",
         "__dict__",
     )
 
-    _adapter: TypeAdapter
+    _adapter: TypeAdapter[T]
     _to_dense_json_fn: Callable[[T], Any]
     _to_readable_json_fn: Callable[[T], Any]
-    _from_json_fn: Callable[[Any], T]
+    _from_json_fn: Callable[[Any, bool], T]
+    _encode_fn: Callable[[T, bytearray], None]
+    _decode_fn: Callable[[ByteStream], T]
 
     def __init__(self, adapter: Never):
         # Use Never (^) as a trick to make the constructor internal.
-        object.__setattr__(self, "_adapter", adapter)
+        as_adapter = cast(TypeAdapter[T], adapter)
+        object.__setattr__(self, "_adapter", as_adapter)
         object.__setattr__(
-            self, "_to_dense_json_fn", _make_to_json_fn(adapter, readable=False)
+            self, "_to_dense_json_fn", _make_to_json_fn(as_adapter, readable=False)
         )
         object.__setattr__(
             self,
             "_to_readable_json_fn",
-            _make_to_json_fn(adapter, readable=True),
+            _make_to_json_fn(as_adapter, readable=True),
         )
-        object.__setattr__(self, "_from_json_fn", _make_from_json_fn(adapter))
+        object.__setattr__(self, "_from_json_fn", _make_from_json_fn(as_adapter))
+        object.__setattr__(self, "_encode_fn", as_adapter.encode_fn())
+        object.__setattr__(self, "_decode_fn", as_adapter.decode_fn())
 
     def to_json(self, input: T, *, readable=False) -> Any:
         if readable:
@@ -54,11 +61,26 @@ class Serializer(Generic[T]):
         else:
             return jsonlib.dumps(self._to_dense_json_fn(input), separators=(",", ":"))
 
-    def from_json(self, json: Any) -> T:
-        return self._from_json_fn(json)
+    def from_json(self, json: Any, keep_unrecognized_fields: bool = False) -> T:
+        return self._from_json_fn(json, keep_unrecognized_fields)
 
-    def from_json_code(self, json_code: str) -> T:
-        return self._from_json_fn(jsonlib.loads(json_code))
+    def from_json_code(
+        self, json_code: str, keep_unrecognized_fields: bool = False
+    ) -> T:
+        return self._from_json_fn(jsonlib.loads(json_code), keep_unrecognized_fields)
+
+    def to_bytes(self, input: T) -> bytes:
+        buffer = bytearray(b"soia")
+        self._encode_fn(input, buffer)
+        return bytes(buffer)
+
+    def from_bytes(self, bytes: bytes, keep_unrecognized_fields: bool = False) -> T:
+        if bytes.startswith(b"soia"):
+            stream = ByteStream(
+                bytes, position=4, keep_unrecognized_fields=keep_unrecognized_fields
+            )
+            return self._decode_fn(stream)
+        return self.from_json_code(bytes.decode("utf-8"))
 
     @cached_property
     def type_descriptor(self) -> reflection.TypeDescriptor:
@@ -82,13 +104,13 @@ _type_adapter_to_serializer: WeakValueDictionary[TypeAdapter, Serializer] = (
 )
 
 
-def make_serializer(adapter: TypeAdapter) -> Serializer:
+def make_serializer(adapter: TypeAdapter[T]) -> Serializer[T]:
     return _type_adapter_to_serializer.setdefault(
         adapter, Serializer(cast(Never, adapter))
     )
 
 
-def _make_to_json_fn(adapter: TypeAdapter, readable: bool) -> Callable[[Any], Any]:
+def _make_to_json_fn(adapter: TypeAdapter[T], readable: bool) -> Callable[[T], Any]:
     return make_function(
         name="to_json",
         params=["input"],
@@ -104,11 +126,13 @@ def _make_to_json_fn(adapter: TypeAdapter, readable: bool) -> Callable[[Any], An
     )
 
 
-def _make_from_json_fn(adapter: TypeAdapter) -> Callable[[Any], Any]:
+def _make_from_json_fn(adapter: TypeAdapter[T]) -> Callable[[Any, bool], T]:
     return make_function(
         name="from_json",
-        params=["json"],
+        params=["json", "keep_unrecognized_fields"],
         body=[
-            LineSpan.join("return ", adapter.from_json_expr(Expr.join("json"))),
+            LineSpan.join(
+                "return ", adapter.from_json_expr("json", "keep_unrecognized_fields")
+            ),
         ],
     )

soia/_impl/service.py

@@ -130,9 +130,7 @@ class _HandleRequestFlow(Generic[Request, Response, RequestHeaders, ResponseHead
             try:
                 req_body_json = json.loads(self.req_body)
             except json.JSONDecodeError:
-                return RawServiceResponse(
-                    "bad request: invalid JSON", "bad-request"
-                )
+                return RawServiceResponse("bad request: invalid JSON", "bad-request")
             method = req_body_json.get("method", ())
             if method == ():
                 return RawServiceResponse(