soia-client 1.0.0__tar.gz

soia_client-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: soia-client
+Version: 1.0.0
+Summary: Read the latest Real Python tutorials
+Author-email: Tyler Fibonacci <gepheum@gmail.com>
+Project-URL: Homepage, https://github.com/realpython/reader
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

soia_client-1.0.0/README

@@ -0,0 +1 @@
+python3 -m unittest tests/**.py

soia_client-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires      = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "soia-client"
+version = "1.0.0"
+description = "Read the latest Real Python tutorials"
+readme = "README.md"
+authors = [{ name = "Tyler Fibonacci", email = "gepheum@gmail.com" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = []
+dependencies = []
+requires-python = ">=3.10"
+
+[project.urls]
+Homepage = "https://github.com/realpython/reader"

soia_client-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

soia_client-1.0.0/soia_client.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: soia-client
+Version: 1.0.0
+Summary: Read the latest Real Python tutorials
+Author-email: Tyler Fibonacci <gepheum@gmail.com>
+Project-URL: Homepage, https://github.com/realpython/reader
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

soia_client-1.0.0/soia_client.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README
+pyproject.toml
+soia_client.egg-info/PKG-INFO
+soia_client.egg-info/SOURCES.txt
+soia_client.egg-info/dependency_links.txt
+soia_client.egg-info/top_level.txt
+soialib/__init__.py
+soialib/keyed_items.py
+soialib/module_initializer.py
+soialib/never.py
+soialib/serializer.py
+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
+soialib/impl/primitives.py
+soialib/impl/repr.py
+soialib/impl/structs.py
+soialib/impl/type_adapter.py
+tests/test_module_initializer.py
+tests/test_timestamp.py

soia_client-1.0.0/soia_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

soia_client-1.0.0/soia_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+soialib

soia_client-1.0.0/soialib/impl/arrays.py

@@ -0,0 +1,163 @@
+from collections.abc import Callable
+from dataclasses import FrozenInstanceError
+from typing import Generic, Optional
+from weakref import WeakKeyDictionary
+
+from soialib import spec
+from soialib.impl.function_maker import Any, Expr, ExprLike, Line, make_function
+from soialib.impl.type_adapter import TypeAdapter
+from soialib.keyed_items import Item, Key, KeyedItems
+
+
+def get_array_adapter(
+    item_adapter: TypeAdapter,
+    key_attributes: tuple[str, ...],
+) -> TypeAdapter:
+    if key_attributes:
+        default_expr = item_adapter.default_expr()
+        listuple_class = _new_keyed_items_class(key_attributes, default_expr)
+    else:
+        listuple_class = _new_listuple_class()
+    array_adapter = _ArrayAdapter(item_adapter, listuple_class)
+    key_spec_to_array_adapter = _item_to_array_adapters.setdefault(item_adapter, {})
+    return key_spec_to_array_adapter.setdefault(key_attributes, array_adapter)
+
+
+class _ArrayAdapter(TypeAdapter):
+    __slots__ = (
+        "item_adapter",
+        "listuple_class",
+        "empty_listuple",
+    )
+
+    item_adapter: TypeAdapter
+    listuple_class: type
+    empty_listuple: tuple[()]
+
+    def __init__(
+        self,
+        item_adapter: TypeAdapter,
+        listuple_class: type,
+    ):
+        self.item_adapter = item_adapter
+        self.listuple_class = listuple_class
+        self.empty_listuple = listuple_class()
+
+    def default_expr(self) -> ExprLike:
+        return "()"
+
+    def to_frozen_expr(self, arg_expr: ExprLike) -> Expr:
+        listuple_class_local = Expr.local("_lstpl?", self.listuple_class)
+        empty_listuple_local = Expr.local("_emp?", self.empty_listuple)
+        return Expr.join(
+            "(",
+            arg_expr,
+            " if ",
+            arg_expr,
+            ".__class__ is ",
+            listuple_class_local,
+            " else (",
+            listuple_class_local,
+            "([",
+            self.item_adapter.to_frozen_expr("_e"),
+            " for _e in ",
+            arg_expr,
+            "]) or ",
+            empty_listuple_local,
+            "))",
+        )
+
+    def is_not_default_expr(self, arg_expr: ExprLike, attr_expr: ExprLike) -> ExprLike:
+        # Can't use arg_expr, an empty iterable is not guaranteed to evaluate to False.
+        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:
+            return in_expr
+        return Expr.join(
+            "[",
+            item_to_json,
+            " for ",
+            e,
+            " in ",
+            in_expr,
+            "]",
+        )
+
+    def from_json_expr(self, json_expr: ExprLike) -> Expr:
+        listuple_class_local = Expr.local("_lstpl?", self.listuple_class)
+        empty_listuple_local = Expr.local("_emp?", self.empty_listuple)
+        return Expr.join(
+            listuple_class_local,
+            "([",
+            self.item_adapter.from_json_expr(Expr.join("_e")),
+            " for e in ",
+            json_expr,
+            "] or ",
+            empty_listuple_local,
+            ")",
+        )
+
+    def finalize(
+        self,
+        resolve_type_fn: Callable[[spec.Type], "TypeAdapter"],
+    ) -> None:
+        self.item_adapter.finalize(resolve_type_fn)
+
+
+_KeyAttributesToArrayAdapter = dict[tuple[str, ...], _ArrayAdapter]
+_ItemToArrayAdapters = WeakKeyDictionary[TypeAdapter, _KeyAttributesToArrayAdapter]
+
+_item_to_array_adapters: _ItemToArrayAdapters = WeakKeyDictionary()
+
+
+def _new_listuple_class() -> type:
+    class Listuple(Generic[Item], tuple[Item, ...]):
+        __slots__ = ()
+
+    return Listuple
+
+
+def _new_keyed_items_class(attributes: tuple[str, ...], default_expr: ExprLike):
+    key_items = make_function(
+        name="key_items",
+        params=["items"],
+        body=[
+            "ret = {}",
+            "for item in items:",
+            f"  ret[item.{'.'.join(attributes)}] = item",
+            "return ret",
+        ],
+    )
+
+    default = make_function(
+        name="get_default",
+        params="",
+        body=[Line.join("return ", default_expr)],
+    )()
+
+    class KeyedItemsImpl(KeyedItems[Item, Key]):
+        # nonempty __slots__ not supported for subtype of 'tuple'
+
+        _key_to_item: dict[Key, Item]
+
+        def find(self, key: Key) -> Optional[Item]:
+            try:
+                key_to_item = self._key_to_item
+            except AttributeError:
+                key_to_item = key_items(self)
+                object.__setattr__(self, "_key_to_item", key_to_item)
+            return key_to_item.get(key)
+
+        def find_or_default(self, key: Key) -> Any:
+            return self.find(key) or default
+
+        def __setattr__(self, name: str, value: Any):
+            raise FrozenInstanceError(self.__class__.__qualname__)
+
+        def __delattr__(self, name: str):
+            raise FrozenInstanceError(self.__class__.__qualname__)
+
+    return KeyedItemsImpl

soia_client-1.0.0/soialib/impl/encoding.py

@@ -0,0 +1,41 @@
+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))",
+)