tressed 0.0.1__tar.gz

tressed-0.0.1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: tressed
+Version: 0.0.1
+Summary: Glue types together
+Author-email: Thomas Cellerier <thomascellerier@gmail.com>
+Project-URL: Homepage, https://github.com/thomascellerier/tressed
+Project-URL: Repository, https://github.com/thomascellerier/tressed.git
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# tressed
+
+Serialize and deserialize types, in any order.
+
+## Usage
+
+```Python
+from dataclasses import dataclass, field
+from tressed.loader import Loader
+
+@dataclass
+class SomeDataclass:
+    foo: str
+    bar: str = "bar"
+    baz: list[int] = field(default_factory=lambda: [1, 2, 3])
+    bar_bar: tuple[int, str] = field(metadata={"alias": "barBar"}, kw_only=True)
+
+value = {
+    "foo": "foo",
+    "barBar": (2, "humbug"),
+}
+
+loader = Loader()
+loaded = loader.load(value, SomeDataclass)
+
+assert loaded == SomeDataclass(
+    foo="foo",
+    bar="bar",
+    baz=[1, 2, 3],
+    bar_bar=(2, "humbug"),
+)
+```
+
+## Supported types
+
+The following types are supported out of the box:
+
+- bool
+- int
+- float
+- str
+- tuple[T1, ..., Tn], typing.Tuple[T1, ..., Tn]
+- tuple[T, ...], typing.Tuple[T, ...] a.k.a homogeneous tuple
+- list[T], typing.List[T]
+- set[T], typing.Set[T]
+- frozenset[T], typing.FrozenSet[T]
+- dataclasses.dataclass
+
+It is easy to add support for custom types as needed when creating a loader.
+
+## Installation
+
+Using pip:
+```bash
+pip install tressed
+```
+
+Or using uv:
+```bash
+uv add tressed
+```
+
+Then just import tressed and get coding.
+```Python
+import tressed
+```
+
+## Goals
+
+- Provide easy serialization and deserialization to and from built-in and standard library types.
+- Provide easy way to add support for custom types.
+- Provide easy yet powerful support for serializaiton and deserialization aliases.
+- Pure python, no additional runtime dependencies beyond the standard library.
+- Do as little work as possible to be suitable for CLIs, for example using lazy imports as much as possible.
+
+### Stretch goals
+- Add first class support for concurrent loading and dumping, with support for asyncio and threading, for example deserializing a list of M objects on N threads.
+- Use code generation internally similarly to dataclasses. Instead of doing metaprogramming each time, generate an actual function for the type that does (de)serialization. Interpret the first time, compile the second, using source or ast module, and then reuse the compiled function.

tressed-0.0.1/README.md

@@ -0,0 +1,78 @@
+# tressed
+
+Serialize and deserialize types, in any order.
+
+## Usage
+
+```Python
+from dataclasses import dataclass, field
+from tressed.loader import Loader
+
+@dataclass
+class SomeDataclass:
+    foo: str
+    bar: str = "bar"
+    baz: list[int] = field(default_factory=lambda: [1, 2, 3])
+    bar_bar: tuple[int, str] = field(metadata={"alias": "barBar"}, kw_only=True)
+
+value = {
+    "foo": "foo",
+    "barBar": (2, "humbug"),
+}
+
+loader = Loader()
+loaded = loader.load(value, SomeDataclass)
+
+assert loaded == SomeDataclass(
+    foo="foo",
+    bar="bar",
+    baz=[1, 2, 3],
+    bar_bar=(2, "humbug"),
+)
+```
+
+## Supported types
+
+The following types are supported out of the box:
+
+- bool
+- int
+- float
+- str
+- tuple[T1, ..., Tn], typing.Tuple[T1, ..., Tn]
+- tuple[T, ...], typing.Tuple[T, ...] a.k.a homogeneous tuple
+- list[T], typing.List[T]
+- set[T], typing.Set[T]
+- frozenset[T], typing.FrozenSet[T]
+- dataclasses.dataclass
+
+It is easy to add support for custom types as needed when creating a loader.
+
+## Installation
+
+Using pip:
+```bash
+pip install tressed
+```
+
+Or using uv:
+```bash
+uv add tressed
+```
+
+Then just import tressed and get coding.
+```Python
+import tressed
+```
+
+## Goals
+
+- Provide easy serialization and deserialization to and from built-in and standard library types.
+- Provide easy way to add support for custom types.
+- Provide easy yet powerful support for serializaiton and deserialization aliases.
+- Pure python, no additional runtime dependencies beyond the standard library.
+- Do as little work as possible to be suitable for CLIs, for example using lazy imports as much as possible.
+
+### Stretch goals
+- Add first class support for concurrent loading and dumping, with support for asyncio and threading, for example deserializing a list of M objects on N threads.
+- Use code generation internally similarly to dataclasses. Instead of doing metaprogramming each time, generate an actual function for the type that does (de)serialization. Interpret the first time, compile the second, using source or ast module, and then reuse the compiled function.

tressed-0.0.1/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "tressed"
+authors = [
+  { name="Thomas Cellerier", email="thomascellerier@gmail.com" },
+]
+version = "0.0.1"
+description = "Glue types together"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/thomascellerier/tressed"
+Repository = "https://github.com/thomascellerier/tressed.git"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.1",
+    "pytest-benchmark>=5.2.3",
+    "pytest-mock>=3.15.1",
+    "ruff>=0.14.6",
+    "ty>=0.0.1a28",
+]
+
+[tool.uv.build-backend]
+module-name = "tressed"
+module-root = "src"
+
+[tool.ruff]
+src = ["src", "tests"]
+
+[tool.ty.environment]
+root = ["./src"]
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "src"
+]
+

tressed-0.0.1/setup.cfg

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

tressed-0.0.1/src/tressed/__init__.py

@@ -0,0 +1 @@
+__all__ = []

tressed-0.0.1/src/tressed/__version__.py

@@ -0,0 +1,13 @@
+__all__ = ["__version__"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    __version__: str
+
+
+def __getattr__(name: str) -> str:
+    if name == "__version__":
+        from importlib.metadata import version
+
+        return version("tressed")
+    raise AttributeError(f"Package 'tressed.__version__' has no attribute '{name}'")

tressed-0.0.1/src/tressed/exceptions.py

@@ -0,0 +1,13 @@
+__all__ = ["TressedError", "TressedTypeError", "TressedValueError"]
+
+
+class TressedError(Exception):
+    pass
+
+
+class TressedTypeError(TressedError, TypeError):
+    pass
+
+
+class TressedValueError(TressedError, ValueError):
+    pass

tressed-0.0.1/src/tressed/loader/__init__.py

@@ -0,0 +1,14 @@
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from tressed.loader.loader import Loader
+
+__all__ = ["Loader"]
+
+
+def __getattr__(name: str) -> type[Loader]:
+    if name == "Loader":
+        from tressed.loader.loader import Loader
+
+        return Loader
+
+    raise AttributeError(f"Package 'tressed.loader' has no attribute '{name}'")

tressed-0.0.1/src/tressed/loader/loader.py

@@ -0,0 +1,152 @@
+# TODO: Use python3.15+ lazy imports instead
+# TODO: Switch to TypeForm https://peps.python.org/pep-0747/ once available
+from __future__ import annotations
+
+from tressed.exceptions import TressedTypeError, TressedValueError
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from typing import Any, Final
+
+    from tressed.loader.types import TypeLoaderFn, TypePath
+    from tressed.predicates import TypePredicate
+
+
+__all__ = [
+    "Loader",
+]
+
+
+def _default_type_loaders():
+    from tressed.loader.loaders import load_simple_scalar
+
+    return {
+        bool: load_simple_scalar,
+        int: load_simple_scalar,
+        float: load_simple_scalar,
+        str: load_simple_scalar,
+        type(None): load_simple_scalar,
+    }
+
+
+def _default_type_mappers(specialize: bool) -> Mapping[TypePredicate, TypeLoaderFn]:
+    from tressed.loader.loaders import (
+        load_dataclass,
+        load_simple_collection,
+        load_tuple,
+    )
+    from tressed.predicates import (
+        is_dataclass_type,
+        is_frozenset_type,
+        is_homogeneous_tuple_type,
+        is_list_type,
+        is_set_type,
+        is_tuple_type,
+    )
+
+    load_tuple_ = load_tuple
+    load_simple_collection_ = load_simple_collection
+    if specialize:
+        from tressed.loader.specializer import SpecializingLoader
+        from tressed.loader.specializers import (
+            specialize_load_simple_collection,
+            specialize_load_tuple,
+        )
+
+        load_tuple_ = SpecializingLoader(load_tuple, specialize_load_tuple)
+        load_simple_collection_ = SpecializingLoader(
+            load_simple_collection, specialize_load_simple_collection
+        )
+
+    # Note that the order matters as some predicates match several types,
+    # put the most specific match first.
+    return {
+        is_homogeneous_tuple_type: load_simple_collection_,
+        is_tuple_type: load_tuple_,
+        is_list_type: load_simple_collection_,
+        is_set_type: load_simple_collection_,
+        is_frozenset_type: load_simple_collection_,
+        is_dataclass_type: load_dataclass,
+    }
+
+
+type Alias = str
+
+
+class Loader:
+    def __init__(
+        self,
+        type_loaders: Mapping[type, TypeLoaderFn] | None = None,
+        type_mappers: Mapping[TypePredicate, TypeLoaderFn] | None = None,
+        enable_specialization: bool = False,
+        alias_field: str = "alias",
+    ) -> None:
+        # Map a type to its loader
+        if type_loaders is None:
+            self._type_loaders: dict[type, TypeLoaderFn] = _default_type_loaders()
+        else:
+            self._type_loaders = dict(type_loaders)
+
+        # Mapping of type predicate to a loader
+        if type_mappers is None:
+            self._type_mappers: Mapping[TypePredicate, TypeLoaderFn] = (
+                _default_type_mappers(enable_specialization)
+            )
+        else:
+            self._type_mappers = dict(type_mappers)
+
+        self._alias_field: Final = alias_field
+        # Mapping of (type, type_form, name) to alias
+        self._alias_cache: dict[tuple[type, TypePath, str], Alias] = {}
+
+    def _resolve_alias_no_cache[T](
+        self, type_form: type[T], type_path: TypePath, name: str
+    ) -> Alias:
+        # TODO: Also have a type mapper for alias resolvers
+        if fields := getattr(type_form, "__dataclass_fields__", None):
+            field = fields[name]
+            alias = field.metadata.get(self._alias_field)
+        if alias is None:
+            return name
+        return alias
+
+    def _resolve_alias[T](
+        self, type_form: type[T], type_path: TypePath, name: str
+    ) -> Alias:
+        cache_key = (type_form, type_path, name)
+        if (alias := self._alias_cache.get(cache_key)) is not None:
+            return alias
+
+        alias = self._resolve_alias_no_cache(type_form, type_path, name)
+        self._alias_cache[cache_key] = alias
+        return alias
+
+    def _load[T](self, value: Any, type_form: type[T], type_path: TypePath) -> T:
+        if (type_loader := self._type_loaders.get(type_form)) is None:
+            for type_predicate, type_loader in self._type_mappers.items():
+                if type_predicate(type_form):
+                    break
+            else:
+                type_loader = None
+            if type_loader is None:
+                raise TressedTypeError(
+                    f"Unhandled type form {type_form!r} at path {type_path!r} for value {value!r}"
+                )
+
+            # Cache lookup for next time
+            self._type_loaders[type_form] = type_loader
+
+        try:
+            return type_loader(value, type_form, type_path, self)  # type: ignore[call-non-callable]
+        except TressedValueError:
+            raise
+        except Exception as e:
+            error = TressedValueError(
+                f"Failed to load value {value!r} at path {type_path!r} into type form {type_form!r}"
+            )
+            error.add_note(f"{type(e)}: {e}")
+            raise error from e
+
+    def load[T](self, value: Any, type_form: type[T]) -> T:
+        return self._load(value, type_form, ())

tressed-0.0.1/src/tressed/loader/loaders.py

@@ -0,0 +1,80 @@
+from tressed.exceptions import TressedValueError
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Any
+
+    from tressed.loader.types import LoaderProtocol, TypePath
+
+__all__ = [
+    "load_simple_scalar",
+    "load_simple_collection",
+    "load_tuple",
+    "load_dataclass",
+]
+
+
+def load_simple_scalar[T](
+    value: Any, type_form: type[T], type_path: TypePath, loader: LoaderProtocol
+) -> T:
+    if type(value) is type_form:
+        return value
+    raise TressedValueError(
+        f"Cannot to load value {value!r} at path {type_path!r} into {type_form.__name___}"
+    )
+
+
+def load_simple_collection[T](
+    value: Any, type_form: type[T], type_path: TypePath, loader: LoaderProtocol
+) -> T:
+    from tressed.predicates import get_args, get_origin
+
+    origin = get_origin(type_form)
+    num_expected_args = 2 if origin is tuple else 1
+    args = get_args(type_form)
+    if origin is None or args is None or len(args) != num_expected_args:
+        raise TressedValueError(
+            f"Cannot to load value {value!r} at path {type_path!r}, "
+            f"{getattr(type_form, '__name__', type_form)} is not a homogeneous generic type"
+        )
+
+    item_type = args[0]
+    return origin(
+        loader._load(item, item_type, (*type_path, pos))
+        for pos, item in enumerate(value)
+    )
+
+
+def load_tuple[*Ts](
+    value: Any, type_form: tuple[*Ts], type_path: TypePath, loader: LoaderProtocol
+) -> tuple[*Ts]:
+    from tressed.predicates import get_args, get_origin
+
+    origin = get_origin(type_form)
+    args = get_args(type_form)
+    if origin is None or args is None:
+        raise TressedValueError(
+            f"Cannot to load value {value!r} at path {type_path!r}, "
+            f"{getattr(type_form, '__name__', type_form)} is not a generic type"
+        )
+
+    return tuple(
+        loader._load(item, args[pos], (*type_path, pos))
+        for pos, item in enumerate(value)
+    )
+
+
+def load_dataclass[T](
+    value: Any, type_form: type[T], type_path: TypePath, loader: LoaderProtocol
+) -> T:
+    from dataclasses import MISSING, fields
+
+    loaded = {}
+
+    for field in fields(type_form):
+        field_name = field.name
+        alias = loader._resolve_alias(type_form, type_path, field_name)
+        if (field_value := value.get(alias, MISSING)) is not MISSING:
+            loaded[field_name] = field_value
+
+    return type_form(**loaded)

tressed-0.0.1/src/tressed/loader/specializer.py

@@ -0,0 +1,52 @@
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Any
+
+    from tressed.loader.types import LoaderProtocol, TypePath
+
+__all__ = ["SpecializingLoader"]
+
+
+class SpecializingLoader:
+    def __init__(self, loader, specializer) -> None:
+        self._loader = loader
+        self._specialized_loaders: dict = {}
+        self._specializer = specializer
+        self._threshold: int = 3
+
+    def __call__[T](
+        self,
+        value: Any,
+        type_form: type[T],
+        type_path: TypePath,
+        loader: LoaderProtocol,
+    ) -> T:
+        key = (type_form, type_path)
+        specialized_loader = self._specialized_loaders.get(key)
+        if type(specialized_loader) is type(None) or type(specialized_loader) is int:
+            if type(specialized_loader) is int and specialized_loader > 0:
+                count = specialized_loader + 1
+            else:
+                count = 1
+            self._specialized_loaders[key] = count
+            specialized_loader = None
+
+            # Specialize!
+            if count > self._threshold:
+                specializer_fn_code = self._specializer(*key)
+                if specializer_fn_code is None:
+                    # zero means we can't specialize this
+                    self._specialized_loaders[key] = 0
+                else:
+                    globals_ = {}
+                    locals_ = {}
+
+                    exec(specializer_fn_code, globals_, locals_)
+
+                    specialized_loader = locals_["__specialized_fn"]
+                    self._specialized_loaders[key] = specialized_loader
+
+        if specialized_loader is None:
+            return self._loader(value, type_form, type_path, loader)
+        else:
+            return specialized_loader(value, loader)

tressed-0.0.1/src/tressed/loader/specializers.py

@@ -0,0 +1,219 @@
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import Final
+
+    from tressed.loader.types import TypeLoaderFn, TypePath, TypePathItem
+
+__all__ = [
+    "specialize_load_tuple",
+    "specialize_load_simple_collection",
+]
+
+
+class Codegen:
+    __slots__ = ("fn_name", "indent", "_parts", "_cached_code")
+
+    def __init__(self, fn_name: str = "__specialized_fn") -> None:
+        self.fn_name: Final = fn_name
+        self.indent: Final = "    "
+
+        self._parts = []
+        self._cached_code: str | None = None
+
+    def code(self) -> str:
+        if cached_code := self._cached_code:
+            return cached_code
+        import io
+
+        builder = io.StringIO()
+        builder.write(f"def {self.fn_name}(value, loader):\n")
+        for line in self._parts:
+            builder.write(line)
+        builder.write("\n")
+        cached_code = builder.getvalue()
+
+        self._cached_code = cached_code
+        self._parts.clear()
+        return cached_code
+
+    def exec(self) -> TypeLoaderFn:
+        # NOTE: This relies on the source being executed being only trusted and validated inputs.
+        globals_ = {}
+        locals_ = {}
+        exec(self.code(), globals_, locals_)
+        return locals_[self.fn_name]
+
+    def _emit(self, part: str) -> None:
+        self._parts.append(part)
+
+    def _emit_indent(self, indent: int = 0) -> None:
+        self._emit(self.indent * (indent + 1))
+
+    def _emit_newline(self) -> None:
+        self._emit("\n")
+
+    def _emit_line(self, line: str, indent: int = 0) -> None:
+        self._emit_indent(indent)
+        self._emit(line)
+        self._emit_newline()
+
+    def emit_unpack_args(
+        self, ident: str, args: tuple[type, ...]
+    ) -> tuple[tuple[str, type], ...]:
+        # TODO: Allocate identifiers!
+        items = tuple((f"_item_{pos}", type_form) for pos, type_form in enumerate(args))
+        match items:
+            case []:
+                pass
+            case [(item_ident, _)]:
+                self._emit_line(f"{item_ident}, = {ident}")
+            case [*_]:
+                self._emit_line(
+                    f"{', '.join(item_ident for item_ident, _ in items)} = {ident}"
+                )
+        return items
+
+    def emit_load_fn(self, ident: str = "_load") -> str:
+        self._emit_line(f"{ident} = loader._load")
+        return ident
+
+    def emit_load(
+        self,
+        loader_ident: str,
+        ident: str,
+        type_form: type,
+        type_path: TypePath,
+        type_path_item: TypePathItem,
+    ) -> str:
+        # TODO: Allocate identifiers!
+        loaded_ident = f"{ident}_loaded"
+        # TODO: Handle type forms!
+        self._emit_line(
+            f"{loaded_ident} = _load({ident}, {type_form.__qualname__}, {_type_path_repr(*type_path, type_path_item)})"
+        )
+        return loaded_ident
+
+    def emit_tuple(self, idents: Iterable[str], *, compact: bool = False) -> None:
+        self._emit("(")
+        if not compact:
+            self._emit_newline()
+        for ident in idents:
+            if not compact:
+                self._emit_indent(indent=1)
+            self._emit(f"{ident},")
+            if not compact:
+                self._emit_newline()
+        if not compact:
+            self._emit_indent()
+        self._emit(")")
+        self._emit_newline()
+
+    def emit_return(self) -> None:
+        self._emit_indent()
+        self._emit("return ")
+
+
+def specialize_load_tuple[T](
+    type_form: type[T],
+    type_path: TypePath,
+) -> str | None:
+    """
+    Generate specialized function for given type at given path.
+    """
+    from tressed.predicates import get_args
+
+    args = get_args(type_form)
+    assert args is not None
+
+    codegen = Codegen()
+    items = codegen.emit_unpack_args("value", args)
+    load_fn = codegen.emit_load_fn()
+    loaded = []
+    for pos, (item, arg_type_form) in enumerate(items):
+        loaded.append(codegen.emit_load(load_fn, item, arg_type_form, type_path, pos))
+    codegen.emit_return()
+    codegen.emit_tuple(loaded)
+    return codegen.code()
+
+
+def _type_form_repr(type_form) -> str:
+    from tressed.predicates import get_args, get_origin
+
+    origin = get_origin(type_form)
+    if origin is not None:
+        args = get_args(type_form)
+        assert args is not None
+        return _generic_type_repr(origin, args)
+
+    return type_form.__qualname__
+
+
+def _generic_type_repr(origin: type, args: tuple[type, ...]) -> str:
+    if len(args) == 0:
+        args_str = "()"
+    else:
+        args_str = ", ".join(map(_type_form_repr, args))
+    return f"{origin.__qualname__}[{args_str}]"
+
+
+class Ident:
+    __slots__ = ("name",)
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+
+def _type_path_repr(*args: TypePathItem | Ident) -> str:
+    items = []
+    for arg in args:
+        match arg:
+            case Ident():
+                items.append(arg.name)
+            case _:
+                items.append(repr(arg))
+
+    match items:
+        case [item]:
+            # Special case for single item tuple
+            return f"({item},)"
+        case _:
+            return f"({', '.join(items)})"
+
+
+def specialize_load_simple_collection[T](
+    type_form: type[T],
+    type_path: TypePath,
+) -> str | None:
+    """
+    Generate specialized function for given type at given path.
+    """
+    from tressed.predicates import get_args, get_origin
+
+    origin = get_origin(type_form)
+    assert origin is not None
+
+    args = get_args(type_form)
+    assert args is not None
+    arg_type_form = args[0]
+
+    codegen = Codegen()
+
+    load_fn = codegen.emit_load_fn()
+    codegen.emit_return()
+    if origin is list:
+        open, close = "[", "]"
+    elif origin is set:
+        open, close = "{", "}"
+    elif origin is frozenset:
+        open, close = "({", "})"
+    else:
+        open, close = f"{origin.__qualname__}([", "])"
+
+    codegen._emit(f"""{open}
+        {load_fn}(item, {_type_form_repr(arg_type_form)}, {_type_path_repr(*type_path, Ident("pos"))})
+        for pos, item
+        in enumerate(value)
+    {close}
+""")
+    return codegen.code()

tressed-0.0.1/src/tressed/loader/types.py

@@ -0,0 +1,26 @@
+__all__ = []
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from typing import Any, Protocol
+
+    type TypePathItem = str | int
+    type TypePath = tuple[TypePathItem, ...]
+
+    class LoaderProtocol(Protocol):
+        def _load[T](
+            self, value: Any, type_form: type[T], type_path: TypePath
+        ) -> T: ...
+        def _resolve_alias[T](
+            self, type_form: type[T], type_path: TypePath, name: str
+        ) -> str: ...
+
+    type TypeLoaderFn[T] = Callable[[Any, type[T], TypePath, LoaderProtocol], T]
+
+    __all__ += [
+        "TypePathItem",
+        "TypePath",
+        "LoaderProtocol",
+        "TypeLoaderFn",
+    ]

tressed-0.0.1/src/tressed/predicates.py

@@ -0,0 +1,128 @@
+"""
+Type predicates.
+
+Do not import modules if not absolutely required. Instead, take advantage of the fact
+that a type from a module can only be instantiated if it already has been imported.
+
+For example to check if a type is an instance of foo.Bar, do not do:
+
+    def is_foo_bar[T: type](type_form: T) -> bool:
+        import foo
+
+        return subclass(t, foo.Bar)
+
+But instead:
+
+    def is_foo_bar[T: type](type_form: T) -> bool:
+        if foo := sys.modules.get("foo"):
+            retur issubclass(t, foo.Bar)
+"""
+
+import sys
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from typing import Any
+
+__all__ = [
+    "get_origin",
+    "get_args",
+    "is_tuple_type",
+    "is_homogeneous_tuple_type",
+    "is_list_type",
+    "is_set_type",
+    "is_frozenset_type",
+    "is_dataclass_type",
+]
+
+if TYPE_CHECKING:
+    # TODO: Use actual typing.TypeForm once it has made its way into python.
+    # Experimental support is coming in mypy 1.19, the PEP (747) is not accepted yet as of the time of writing.
+    type TypeForm = Any
+    type TypePredicate[T: TypeForm] = Callable[[T], bool]
+
+    __all__ += [
+        "TypeForm",
+        "TypePredicate",
+    ]
+
+
+def get_origin(type_form: TypeForm) -> type | None:
+    # Avoid importing typing module if possible.
+    # TODO: Handle annotated, generic etc...
+    return getattr(type_form, "__origin__", None)
+
+
+def get_args(type_form: TypeForm) -> tuple[type, ...] | None:
+    # Avoid importing typing module if possible.
+    # TODO: Handle annotated, generic etc...
+    return getattr(type_form, "__args__", None)
+
+
+def is_homogeneous_tuple_type(type_form: TypeForm) -> bool:
+    """
+    The given type form matches tuple[T, ...] or typing.Tuple[T, ...]
+    """
+    origin = get_origin(type_form)
+    if origin is None:
+        return False
+    if origin is tuple or (
+        (typing := sys.modules.get("typing")) and origin is typing.Tuple
+    ):
+        args = get_args(type_form)
+        if args is None:
+            return False
+        return len(args) == 2 and args[1] == Ellipsis
+    return False
+
+
+def is_tuple_type(type_form: TypeForm) -> bool:
+    origin = get_origin(type_form)
+    if origin is None:
+        return False
+    if origin is tuple:
+        return True
+    if typing := sys.modules.get("typing"):
+        return origin is typing.Tuple
+    return False
+
+
+def is_list_type(type_form: TypeForm) -> bool:
+    origin = get_origin(type_form)
+    if origin is None:
+        return False
+    if origin is list:
+        return True
+    if typing := sys.modules.get("typing"):
+        return origin is typing.List
+    return False
+
+
+def is_set_type(type_form: TypeForm) -> bool:
+    origin = get_origin(type_form)
+    if origin is None:
+        return False
+    if origin is set:
+        return True
+    if typing := sys.modules.get("typing"):
+        return origin is typing.Set
+    return False
+
+
+def is_frozenset_type(type_form: TypeForm) -> bool:
+    origin = get_origin(type_form)
+    if origin is None:
+        return False
+    if origin is frozenset:
+        return True
+    if typing := sys.modules.get("typing"):
+        return origin is typing.FrozenSet
+    return False
+
+
+def is_dataclass_type(type_form: TypeForm) -> bool:
+    if dataclasses := sys.modules.get("dataclasses"):
+        # We want to match only dataclass types, not instances
+        return dataclasses.is_dataclass(type_form) and isinstance(type_form, type)
+    return False

tressed-0.0.1/src/tressed.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: tressed
+Version: 0.0.1
+Summary: Glue types together
+Author-email: Thomas Cellerier <thomascellerier@gmail.com>
+Project-URL: Homepage, https://github.com/thomascellerier/tressed
+Project-URL: Repository, https://github.com/thomascellerier/tressed.git
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# tressed
+
+Serialize and deserialize types, in any order.
+
+## Usage
+
+```Python
+from dataclasses import dataclass, field
+from tressed.loader import Loader
+
+@dataclass
+class SomeDataclass:
+    foo: str
+    bar: str = "bar"
+    baz: list[int] = field(default_factory=lambda: [1, 2, 3])
+    bar_bar: tuple[int, str] = field(metadata={"alias": "barBar"}, kw_only=True)
+
+value = {
+    "foo": "foo",
+    "barBar": (2, "humbug"),
+}
+
+loader = Loader()
+loaded = loader.load(value, SomeDataclass)
+
+assert loaded == SomeDataclass(
+    foo="foo",
+    bar="bar",
+    baz=[1, 2, 3],
+    bar_bar=(2, "humbug"),
+)
+```
+
+## Supported types
+
+The following types are supported out of the box:
+
+- bool
+- int
+- float
+- str
+- tuple[T1, ..., Tn], typing.Tuple[T1, ..., Tn]
+- tuple[T, ...], typing.Tuple[T, ...] a.k.a homogeneous tuple
+- list[T], typing.List[T]
+- set[T], typing.Set[T]
+- frozenset[T], typing.FrozenSet[T]
+- dataclasses.dataclass
+
+It is easy to add support for custom types as needed when creating a loader.
+
+## Installation
+
+Using pip:
+```bash
+pip install tressed
+```
+
+Or using uv:
+```bash
+uv add tressed
+```
+
+Then just import tressed and get coding.
+```Python
+import tressed
+```
+
+## Goals
+
+- Provide easy serialization and deserialization to and from built-in and standard library types.
+- Provide easy way to add support for custom types.
+- Provide easy yet powerful support for serializaiton and deserialization aliases.
+- Pure python, no additional runtime dependencies beyond the standard library.
+- Do as little work as possible to be suitable for CLIs, for example using lazy imports as much as possible.
+
+### Stretch goals
+- Add first class support for concurrent loading and dumping, with support for asyncio and threading, for example deserializing a list of M objects on N threads.
+- Use code generation internally similarly to dataclasses. Instead of doing metaprogramming each time, generate an actual function for the type that does (de)serialization. Interpret the first time, compile the second, using source or ast module, and then reuse the compiled function.

tressed-0.0.1/src/tressed.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+pyproject.toml
+src/tressed/__init__.py
+src/tressed/__version__.py
+src/tressed/exceptions.py
+src/tressed/predicates.py
+src/tressed/py.typed
+src/tressed.egg-info/PKG-INFO
+src/tressed.egg-info/SOURCES.txt
+src/tressed.egg-info/dependency_links.txt
+src/tressed.egg-info/top_level.txt
+src/tressed/loader/__init__.py
+src/tressed/loader/loader.py
+src/tressed/loader/loaders.py
+src/tressed/loader/specializer.py
+src/tressed/loader/specializers.py
+src/tressed/loader/types.py
+tests/test_gluetypes.py
+tests/test_loader.py
+tests/test_specializers.py

tressed-0.0.1/src/tressed.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tressed-0.0.1/src/tressed.egg-info/top_level.txt

@@ -0,0 +1 @@
+tressed

tressed-0.0.1/tests/test_gluetypes.py

@@ -0,0 +1,36 @@
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_import_tressed(tmp_path: Path) -> None:
+    """
+    Make sure tressed uses lazy imports by default.
+    Note that this is not fully reliable as pytest itself already loads a ton of modules.
+    """
+    prog = """\
+import sys
+
+def audit(event: str, args: tuple) -> None:
+    match event:
+        case "import":
+            print(args[0])
+
+sys.addaudithook(audit)
+
+import tressed
+"""
+    prog_path = tmp_path / "prog.py"
+    prog_path.write_text(prog)
+
+    # Use audit hooks to detect imports, audit hooks cannot be removed so do it in a sub-process
+    src_path = Path(__file__).parent.parent / "src"
+    process = subprocess.run(
+        [sys.executable, "-S", prog_path],
+        check=True,
+        capture_output=True,
+        env={"PYTHONPATH": str(src_path)},
+    )
+    loaded_modules = set(process.stdout.decode("utf-8").splitlines(keepends=False))
+
+    assert loaded_modules == {"tressed"}

tressed-0.0.1/tests/test_loader.py

@@ -0,0 +1,188 @@
+import gc
+import sys
+from unittest.mock import call
+
+import pytest
+from pytest_benchmark.fixture import BenchmarkFixture
+from pytest_mock import MockerFixture
+
+from tressed.exceptions import TressedTypeError, TressedValueError
+from tressed.loader import Loader
+
+
+def test_load_simple_scalar() -> None:
+    loader = Loader()
+    assert loader.load(1, int) == 1
+    assert loader.load(1.1, float) == 1.1
+    assert loader.load(True, bool) is True
+    assert loader.load(False, bool) is False
+    assert loader.load("foo", str) == "foo"
+    assert loader.load(None, type(None)) is None
+
+    with pytest.raises(TressedValueError):
+        loader.load(1, str)
+
+
+def test_load_list() -> None:
+    loader = Loader()
+    assert loader.load([1, 2, 3], list[int]) == [1, 2, 3]
+
+    with pytest.raises(TressedTypeError):
+        loader.load(["foo", "bar"], list)
+
+    with pytest.raises(TressedValueError):
+        loader.load(["foo", "bar"], list[int])
+
+
+def test_load_set() -> None:
+    loader = Loader()
+    loaded = loader.load([1, 2, 3, 2], set[int])
+    assert type(loaded) is set
+    assert loaded == {1, 2, 3}
+
+    with pytest.raises(TressedTypeError):
+        loader.load(["foo", "bar"], set)
+
+    with pytest.raises(TressedValueError):
+        loader.load(["foo", "bar"], set[int])
+
+
+def test_load_frozenset() -> None:
+    loader = Loader()
+    loaded = loader.load([1, 2, 3, 2], frozenset[int])
+    assert type(loaded) is frozenset
+    assert loaded == frozenset({1, 2, 3})
+
+    with pytest.raises(TressedTypeError):
+        loader.load(["foo", "bar"], frozenset)
+
+    with pytest.raises(TressedValueError):
+        loader.load(["foo", "bar"], frozenset[int])
+
+
+def test_load_homogeneous_tuple() -> None:
+    loader = Loader()
+    assert loader.load([1, 2, 3], tuple[int, ...]) == (1, 2, 3)
+
+    with pytest.raises(TressedTypeError):
+        loader.load(["foo", "bar"], tuple)
+
+    with pytest.raises(TressedValueError):
+        loader.load(["foo", "bar"], tuple[int, ...])
+
+
+def test_load_tuple() -> None:
+    loader = Loader()
+    assert loader.load([], tuple[()]) == ()
+    assert loader.load([1], tuple[int]) == (1,)
+    assert loader.load([1, True], tuple[int, bool]) == (1, True)
+    assert loader.load([1, True, 1.1], tuple[int, bool, float]) == (1, True, 1.1)
+
+    with pytest.raises(TressedValueError):
+        loader.load([1, True, "foo"], tuple[int, bool, float])
+
+
+def test_load_tuple_benchmark(benchmark: BenchmarkFixture) -> None:
+    loader = Loader()
+    benchmark(loader.load, [1, True, 1.1], tuple[int, bool, float])
+
+
+def test_load_tuple_specialized_benchmark(benchmark: BenchmarkFixture) -> None:
+    loader = Loader(enable_specialization=True)
+    benchmark(loader.load, [1, True, 1.1], tuple[int, bool, float])
+
+
+def test_load_set_benchmark(benchmark: BenchmarkFixture) -> None:
+    loader = Loader()
+    benchmark(loader.load, [[1, "two", 3.3]] * 30, set[tuple[int, str, float]])
+
+
+def test_load_set_specialized_benchmark(benchmark: BenchmarkFixture) -> None:
+    loader = Loader(enable_specialization=True)
+    benchmark(loader.load, [[1, "two", 3.3]] * 30, set[tuple[int, str, float]])
+
+
+def test_load_unknown_type() -> None:
+    # Loading an unknown type will go through all the predicates,
+    # make sure the predicates do not load any additional modules.
+    if "dataclasses" in sys.modules:
+        del sys.modules["dataclasses"]
+        gc.collect()
+
+    modules_before = frozenset(sys.modules.keys())
+    assert "dataclasses" not in modules_before
+
+    loader = Loader()
+
+    class MadeupType:
+        pass
+
+    with pytest.raises(TressedTypeError):
+        loader.load(1, MadeupType)
+
+    modules_after = frozenset(sys.modules.keys())
+    new_modules = frozenset(
+        {
+            module
+            for module in modules_after - modules_after
+            # Ignore internal modules
+            if not module.startswith("tressed.")
+        }
+    )
+    assert new_modules == frozenset()
+
+
+def test_load_dataclass(mocker: MockerFixture) -> None:
+    from dataclasses import dataclass, field
+
+    @dataclass
+    class SomeDataclass:
+        foo: str
+        bar: str = "bar"
+        baz: list[int] = field(default_factory=lambda: [1, 2, 3])
+        bar_bar: tuple[int, str] = field(metadata={"alias": "barBar"}, kw_only=True)
+
+    value = {
+        "foo": "foo",
+        "barBar": (2, "humbug"),
+    }
+    expected = SomeDataclass(
+        foo="foo",
+        bar="bar",
+        baz=[1, 2, 3],
+        bar_bar=(2, "humbug"),
+    )
+    expected_cache = {
+        (SomeDataclass, (), "foo"): "foo",
+        (SomeDataclass, (), "bar"): "bar",
+        (SomeDataclass, (), "baz"): "baz",
+        (SomeDataclass, (), "bar_bar"): "barBar",
+    }
+
+    loader = Loader()
+
+    spy_resolve_alias = mocker.spy(loader, loader._resolve_alias.__name__)
+    spy_resolve_alias_no_cache = mocker.spy(
+        loader, loader._resolve_alias_no_cache.__name__
+    )
+
+    assert loader.load(value, SomeDataclass) == expected
+
+    # First, call make sure that the cache is created
+    assert loader._alias_cache == expected_cache
+
+    expected_calls = [
+        call(SomeDataclass, (), "foo"),
+        call(SomeDataclass, (), "bar"),
+        call(SomeDataclass, (), "baz"),
+        call(SomeDataclass, (), "bar_bar"),
+    ]
+    assert spy_resolve_alias.call_args_list == expected_calls
+    assert spy_resolve_alias_no_cache.call_args_list == expected_calls
+
+    assert loader.load(value, SomeDataclass) == expected
+
+    # Second, call make sure that the cache is used created
+    assert loader._alias_cache == expected_cache
+    assert spy_resolve_alias.call_args_list == expected_calls * 2
+    assert spy_resolve_alias_no_cache.call_args_list == expected_calls

tressed-0.0.1/tests/test_specializers.py

@@ -0,0 +1,58 @@
+def test_specialize_load_tuple() -> None:
+    from tressed.loader import Loader
+    from tressed.loader.specializers import specialize_load_tuple
+
+    code = specialize_load_tuple(tuple[int, float, str], ("foo", 1))
+    assert (
+        code
+        == """\
+def __specialized_fn(value, loader):
+    _item_0, _item_1, _item_2 = value
+    _load = loader._load
+    _item_0_loaded = _load(_item_0, int, ('foo', 1, 0))
+    _item_1_loaded = _load(_item_1, float, ('foo', 1, 1))
+    _item_2_loaded = _load(_item_2, str, ('foo', 1, 2))
+    return (
+        _item_0_loaded,
+        _item_1_loaded,
+        _item_2_loaded,
+    )
+
+"""
+    )
+    loader = Loader()
+    globals_ = {}
+    locals_ = {}
+    exec(code, globals_, locals_)
+    specialized_fn = locals_["__specialized_fn"]
+    assert specialized_fn([1, 1.1, "foobar"], loader) == (1, 1.1, "foobar")
+
+
+def test_specialize_load_simple_collection() -> None:
+    from tressed.loader import Loader
+    from tressed.loader.specializers import specialize_load_simple_collection
+
+    code = specialize_load_simple_collection(
+        set[tuple[int, str, float]], ("foo", 0, "bar")
+    )
+    assert (
+        code
+        == """\
+def __specialized_fn(value, loader):
+    _load = loader._load
+    return {
+        _load(item, tuple[int, str, float], ('foo', 0, 'bar', pos))
+        for pos, item
+        in enumerate(value)
+    }
+
+"""
+    )
+    loader = Loader()
+    globals_ = {}
+    locals_ = {}
+    exec(code, globals_, locals_)
+    specialized_fn = locals_["__specialized_fn"]
+    assert specialized_fn(
+        [[1, "two", 3.3], [4, "five", 5.5], [1, "two", 3.3]], loader
+    ) == {(1, "two", 3.3), (4, "five", 5.5)}