soia-client 1.0.0__py3-none-any.whl

soialib/impl/function_maker.py

@@ -0,0 +1,196 @@
+import itertools
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union
+
+
+def make_function(
+    name: str,
+    params: Sequence[Union[str, "Param"]],
+    body: Sequence[Union[str, "Line"]],
+) -> Callable:
+    params = [Param(p, default=None) if isinstance(p, str) else p for p in params]
+
+    def make_locals() -> _Locals:
+        # First, collect all the (key, value) pairs.
+        # There may be both key duplicates and value duplicates. They will be resolved
+        # later.
+        all_pieces: list[Union[str, _Local]] = []
+        for param in params:
+            if param._default is not None:
+                all_pieces.extend(param._default._pieces)
+        for line in body:
+            if isinstance(line, LineSpan):
+                all_pieces.extend(line._pieces)
+        all_locals = (p for p in all_pieces if isinstance(p, _Local))
+
+        locals: dict[str, Any] = {}
+        reversed: dict[int, str] = {}
+        prefix_to_count: dict[str, int] = {}
+        for local in all_locals:
+            name = local.name
+            value = local.value
+            if id(value) in reversed:
+                # We already have this value, either under the same name or under a
+                # different name. Either way, we can reuse the name we already have.
+                continue
+            if name.endswith("?"):
+                # Replace the "?" suffix with a number obtained from a sequence so there
+                # is no name conflict.
+                prefix = name[0:-1]
+                count = prefix_to_count.get(prefix, 0)
+                prefix_to_count[prefix] = count + 1
+                name = prefix + str(count)
+            if name in locals:
+                raise ValueError(f"Duplicate local: name={name}; value={value}")
+            locals[name] = value
+            reversed[id(value)] = name
+
+        return _Locals(locals, reversed)
+
+    locals = make_locals()
+
+    def line_to_code(l: Union[str, Line]) -> str:
+        if isinstance(l, str):
+            return l
+        return l._to_code(locals)
+
+    body_str = "\n    ".join(line_to_code(l) for l 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)}):
+    {body_str}
+  return {name}
+"""
+    ns = {}
+    exec(text, None, ns)
+    return ns["__create_function__"](**locals.locals)
+
+
+@dataclass(frozen=True)
+class LineSpan:
+    "An immutable span within a line of Python code."
+
+    _pieces: tuple[Union[str, "_Local"], ...]
+
+    @staticmethod
+    def join(*spans: Union[str, "LineSpan"], separator: str = "") -> "LineSpan":
+        def get_pieces(
+            span: Union[str, "LineSpan"],
+        ) -> tuple[Union[str, "_Local"], ...]:
+            if isinstance(span, LineSpan):
+                return span._pieces
+            return ((span),)
+
+        # Remove empty strings.
+        spans = tuple(s for s in spans if s)
+        if len(spans) == 0:
+            return _EMPTY_LINE_SPAN
+        elif len(spans) == 1:
+            only_span = spans[0]
+            if isinstance(only_span, LineSpan):
+                return only_span
+            return LineSpan((only_span,))
+        if separator:
+            pieces = itertools.chain(
+                get_pieces(spans[0]),
+                *itertools.chain(
+                    itertools.chain((separator,), get_pieces(s)) for s in spans[1:]
+                ),
+            )
+        else:
+            pieces = itertools.chain(*(get_pieces(s) for s in spans))
+        return LineSpan(tuple(pieces))
+
+    @staticmethod
+    def local(name: str, value: Any):
+        return LineSpan((_Local(name, value),))
+
+    def _to_code(self, locals: "_Locals") -> str:
+        ret = ""
+        for piece in self._pieces:
+            if isinstance(piece, _Local):
+                # Look up the resolved name for the value.
+                # It migth be different from `piece.name` in some edge cases.
+                ret += locals.reversed[id(piece.value)]
+            else:
+                ret += piece
+        return ret
+
+
+_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
+
+
+# A type alias to use when the line span is the whole line.
+Line = LineSpan
+
+
+# An immutable sequence of lines.
+BodySpan = tuple[Union[str, Line], ...]
+
+
+# A type alias to use when the lines constitute the whole body of a function.
+Body = BodySpan
+
+
+class BodyBuilder:
+    """Arnold Schwarzenegger."""
+
+    _lines: list[LineSpan]
+
+    def __init__(self):
+        self._lines = []
+
+    def append_ln(self, *spans: Union[str, LineSpan]):
+        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)
+        return self
+
+    def build(self) -> Body:
+        return tuple(self._lines)
+
+
+@dataclass(frozen=True)
+class Param:
+    name: str
+    default: Optional[ExprLike] = None
+
+    def _to_code(self, locals: "_Locals") -> str:
+        if self._default is None:
+            return self.name
+        return f"{self.name}={self._default._to_code(locals)}"
+
+    @property
+    def _default(self) -> Optional[Expr]:
+        if self.default is None:
+            return None
+        else:
+            return Expr.join(self.default)
+
+
+Params = list[Union[str, Param]]
+
+
+@dataclass(frozen=True)
+class _Local:
+    name: str
+    value: Any
+
+
+@dataclass(frozen=True)
+class _Locals:
+    locals: dict[str, Any]
+    reversed: dict[Any, str]

soialib/impl/optionals.py

@@ -0,0 +1,74 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TypeVar
+from weakref import WeakKeyDictionary
+
+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
+
+Other = TypeVar("Other")
+
+
+def get_optional_adapter(other_adapter: TypeAdapter) -> TypeAdapter:
+    return _other_adapter_to_optional_adapter.setdefault(
+        other_adapter, _OptionalAdapter(other_adapter)
+    )
+
+
+@dataclass(frozen=True)
+class _OptionalAdapter(TypeAdapter):
+    __slots__ = ("other_adapter",)
+
+    other_adapter: TypeAdapter
+
+    def default_expr(self) -> ExprLike:
+        return "None"
+
+    def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
+        return Expr.join(
+            "(None if ",
+            arg_expr,
+            " is None else ",
+            self.other_adapter.to_frozen_expr(arg_expr),
+            ")",
+        )
+
+    def is_not_default_expr(self, arg_expr: ExprLike, attr_expr: ExprLike) -> Expr:
+        return Expr.join(arg_expr, " is not None")
+
+    def to_json_expr(self, in_expr: ExprLike, readable: bool) -> ExprLike:
+        other_to_json = self.other_adapter.to_json_expr(in_expr, readable)
+        if other_to_json == in_expr:
+            return in_expr
+        return Expr.join(
+            "(None if ",
+            in_expr,
+            " is None else ",
+            other_to_json,
+            ")",
+        )
+
+    def from_json_expr(self, json_expr: ExprLike) -> ExprLike:
+        other_from_json = self.other_adapter.from_json_expr(json_expr)
+        if other_from_json == json_expr:
+            return json_expr
+        return Expr.join(
+            "(None if ",
+            json_expr,
+            " is None else ",
+            other_from_json,
+            ")",
+        )
+
+    def finalize(
+        self,
+        resolve_type_fn: Callable[[spec.Type], "TypeAdapter"],
+    ) -> None:
+        self.other_adapter.finalize(resolve_type_fn)
+
+
+_other_adapter_to_optional_adapter: WeakKeyDictionary[TypeAdapter, TypeAdapter] = (
+    WeakKeyDictionary()
+)

soialib/impl/primitives.py

@@ -0,0 +1,210 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Final, final
+
+from soialib import spec
+from soialib.impl.function_maker import Expr, ExprLike
+from soialib.impl.type_adapter import TypeAdapter
+from soialib.timestamp import Timestamp
+
+
+class AbstractPrimitiveAdapter(TypeAdapter):
+    @final
+    def finalize(
+        self,
+        resolve_type_fn: Callable[[spec.Type], "TypeAdapter"],
+    ) -> None:
+        pass
+
+
+class _BoolAdapter(AbstractPrimitiveAdapter):
+    def default_expr(self) -> ExprLike:
+        return "False"
+
+    def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
+        return Expr.join("(True if ", arg_expr, " else False)")
+
+    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:
+        if readable:
+            return Expr.join("(1 if ", in_expr, " else 0)")
+        else:
+            return in_expr
+
+    def from_json_expr(self, json_expr: ExprLike) -> Expr:
+        return Expr.join("(True if ", json_expr, " else False)")
+
+
+BOOL_ADAPTER: Final[TypeAdapter] = _BoolAdapter()
+
+
+@dataclass(frozen=True)
+class _AbstractIntAdapter(AbstractPrimitiveAdapter):
+    """Type adapter implementation for int32, int64 and uint64."""
+
+    def default_expr(self) -> ExprLike:
+        return "0"
+
+    def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
+        return Expr.join("(", arg_expr, " | 0)")
+
+    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)")
+
+
+@dataclass(frozen=True)
+class _Int32Adapter(_AbstractIntAdapter):
+    pass
+
+
+@dataclass(frozen=True)
+class _Int64Adapter(_AbstractIntAdapter):
+    pass
+
+
+@dataclass(frozen=True)
+class _Uint64Adapter(_AbstractIntAdapter):
+    pass
+
+
+INT32_ADAPTER: Final[TypeAdapter] = _Int32Adapter()
+INT64_ADAPTER: Final[TypeAdapter] = _Int64Adapter()
+UINT64_ADAPTER: Final[TypeAdapter] = _Uint64Adapter()
+
+
+@dataclass(frozen=True)
+class _AbstractFloatAdapter(AbstractPrimitiveAdapter):
+    """Type adapter implementation for float32 and float64."""
+
+    def default_expr(self) -> ExprLike:
+        return "0.0"
+
+    def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
+        return Expr.join("(", arg_expr, " + 0.0)")
+
+    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.0)")
+
+
+@dataclass(frozen=True)
+class _Float32Adapter(_AbstractFloatAdapter):
+    """Type adapter implementation for float32."""
+
+
+@dataclass(frozen=True)
+class _Float64Adapter(_AbstractFloatAdapter):
+    """Type adapter implementation for float32."""
+
+
+FLOAT32_ADAPTER: Final[TypeAdapter] = _Float32Adapter()
+FLOAT64_ADAPTER: Final[TypeAdapter] = _Float64Adapter()
+
+
+class _TimestampAdapter(AbstractPrimitiveAdapter):
+    def default_expr(self) -> Expr:
+        return Expr.local("_EPOCH", Timestamp.EPOCH)
+
+    def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
+        timestamp_local = Expr.local("Timestamp", Timestamp)
+        return Expr.join(
+            "(",
+            arg_expr,
+            " if ",
+            arg_expr,
+            ".__class__ is ",
+            timestamp_local,
+            " else ",
+            timestamp_local,
+            "(unix_millis=",
+            arg_expr,
+            ".unix_millis))",
+        )
+
+    def is_not_default_expr(self, arg_expr: ExprLike, attr_expr: ExprLike) -> Expr:
+        return Expr.join(arg_expr, ".unix_millis")
+
+    def to_json_expr(self, in_expr: ExprLike, readable: bool) -> Expr:
+        if readable:
+            return Expr.join(in_expr, "._trj()")
+        else:
+            return Expr.join(in_expr, ".unix_millis")
+
+    def from_json_expr(self, json_expr: ExprLike) -> Expr:
+        fn = Expr.local("_timestamp_from_json", _timestamp_from_json)
+        return Expr.join(fn, "(", json_expr, ")")
+
+
+def _timestamp_from_json(json: Any) -> Timestamp:
+    if json.__class__ is int or isinstance(json, int):
+        return Timestamp(unix_millis=json)
+    else:
+        return Timestamp(unix_millis=json["unix_millis"])
+
+
+TIMESTAMP_ADAPTER: Final[TypeAdapter] = _TimestampAdapter()
+
+
+class _StringAdapter(AbstractPrimitiveAdapter):
+    def default_expr(self) -> ExprLike:
+        return '""'
+
+    def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
+        return Expr.join("('' + ", 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, " or ''))")
+
+
+STRING_ADAPTER: Final[TypeAdapter] = _StringAdapter()
+
+
+class _BytesAdapter(AbstractPrimitiveAdapter):
+    _fromhex_fn: Final = bytes.fromhex
+
+    def default_expr(self) -> ExprLike:
+        return 'b""'
+
+    def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
+        return Expr.join("(b'' + ", 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,
+    ) -> Expr:
+        return Expr.join(in_expr, ".hex()")
+
+    def from_json_expr(self, json_expr: ExprLike) -> Expr:
+        return Expr.join(
+            Expr.local("fromhex", _BytesAdapter._fromhex_fn), "(", json_expr, ")"
+        )
+
+
+BYTES_ADAPTER: Final[TypeAdapter] = _BytesAdapter()

soialib/impl/repr.py

@@ -0,0 +1,43 @@
+import re
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class ReprResult:
+    repr: str
+    complex: bool
+
+    @property
+    def indented(self) -> str:
+        if complex:
+            return self.repr.replace("\n", "\n  ")
+        else:
+            return self.repr
+
+
+def repr_impl(input: Any) -> ReprResult:
+    if isinstance(input, list) or isinstance(input, tuple):
+        if len(input) == 0:
+            return ReprResult("[]", complex=False)
+        elif len(input) == 1:
+            only_item_repr = repr_impl(input[0])
+            if only_item_repr.complex:
+                return ReprResult(f"[\n  {only_item_repr.indented},\n]", complex=True)
+            else:
+                return ReprResult(f"[{only_item_repr.repr}]", complex=True)
+        else:
+            body = "".join(f"  {repr_impl(item).indented},\n" for item in input)
+            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)
+        else:
+            return ReprResult(repr(input), complex=False)
+    else:
+        r = repr(input)
+        # Complex if the representation contains '[', '(' or '\n'.
+        return ReprResult(r, complex=re.search(r"[\\[\\(\\\n]", r) is not None)