structtype 0.1.0__tar.gz → 0.3.0__tar.gz

{structtype-0.1.0 → structtype-0.3.0}/AGENTS.md

@@ -41,22 +41,24 @@ All commands go through `make`.
 - `structtype.Struct` — base class with config options (frozen, tag, rename, etc.)
 - `structtype.Field` — field constraints (gt, ge, lt, le, min_length, etc.)
 - `structtype.Raw` — lazy JSON passthrough
+- `structtype.fields(type_or_instance)` — get FieldInfo tuple for a struct type/instance
 - `structtype._inspect.type_info()` / `multi_type_info()` — type introspection
 
 ### Struct Methods
 
-- `obj.struct_dump_json()` — serialize to JSON bytes
-- `obj.struct_dump()` — convert to built-in Python types
-- `obj.struct_to_dict()` — shallow field dict
-- `obj.struct_to_tuple()` — shallow field tuple
+- `obj.struct_dump_json(*, enc_hook=None, decimal_format=None, uuid_format=None, order=None)` — serialize to JSON bytes
+- `obj.struct_dump()` — convert to built-in Python types (uses `encode_name` for keys)
 - `obj.struct_force_setattr(name, value)` — set attr on frozen struct
-- `obj.struct_check()` — validate field values against types + constraints
-- `cls.struct_validate_json(buf)` — deserialize from JSON
-- `cls.struct_validate_jsonln(buf)` — deserialize newline-delimited JSON to a list of structs
-- `cls.struct_dump_jsonln(items)` — serialize a list of structs as newline-delimited JSON
-- `cls.struct_validate(obj)` — convert built-in types to struct
+- `obj.struct_validate_self()` — validate field values against types + constraints
+- `cls.struct_validate_json(buf, *, strict=True, dec_hook=None)` — deserialize from JSON
+- `cls.struct_validate(obj, *, strict=True, from_attributes=False, dec_hook=None)` — convert built-in types to struct
+
+### Dict & Iteration Protocol
+
+Struct instances support the mapping protocol:
+- `dict(p)` — shallow dict of Python field names to values (iterates `(name, value)` pairs)
+- `list(p)` / `iter(p)` — iterate `(name, value)` 2-tuples in declaration order
 
 ## Gotchas
 
-- `pytest-randomly` shuffles test order
 - `make test-lf` reinstalls the C extension before running (last-failed first)

{structtype-0.1.0 → structtype-0.3.0}/MANIFEST.in

@@ -5,4 +5,3 @@ prune docs
 prune examples
 prune scripts
 exclude .*
-include .cibuildwheel.toml

{structtype-0.1.0 → structtype-0.3.0}/Makefile

@@ -13,6 +13,10 @@ docs: ## build docs
 	rm -rf .doctrees site
 	uv run --group docs sphinx-build -d .doctrees -b html docs site --fail-on-warning
 
+.PHONY: wheels
+wheels: ## build wheels
+	uvx --from cibuildwheel==4.1.1 cibuildwheel
+
 ##@ Quality
 .PHONY: test-cov
 test-cov: ## Run tests with coverage
@@ -22,6 +26,10 @@ test-cov: ## Run tests with coverage
 test-lf: ## Run tests in current Python
 	uv run --reinstall pytest --lf
 
+.PHONY: test-doc
+test-doc: ## Run doctests
+	uv run pytest --doctest-modules --pyargs structtype
+
 .PHONY: test-all
 test-all: ## Run tests in all supporte Python versions
 	for py_v in $(PY_VERSIONS); do \
@@ -49,8 +57,7 @@ format: ## Format files using ruff format
 ##@ Benchmark
 .PHONY: bench
 bench: ## run benchmarks
-	uv run --group bench benchmarks/bench_compare.py
-	uv run --group bench benchmarks/bench_libs.py
+	uv run benchmarks/bench_libs.py
 
 ##@ Utility
 .PHONY: clean

{structtype-0.1.0/src/structtype.egg-info → structtype-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structtype
-Version: 0.1.0
+Version: 0.3.0
 Summary: Fast Struct type with validation and JSON serialization for Python.
 Maintainer-email: Wolfgang Langner <tds333@mailbox.org>
 License-Expression: BSD-3-Clause

{structtype-0.1.0 → structtype-0.3.0}/pyproject.toml

@@ -46,17 +46,6 @@ dev = [
   "pytest>=9",
   "pytest-coverage>=0.0",
 ]
-bench = [
-  "cattrs==25.3.0",
-  "mashumaro==3.17",
-  "msgspec",
-  "orjson==3.11.4",
-  "pydantic==2.12.4",
-  "pysimdjson==7.0.2",
-  "python-rapidjson==1.22",
-  "requests",
-  "ujson==5.11.0",
-]
 docs = [
   "furo",
   "ipython",
@@ -65,11 +54,6 @@ docs = [
   "sphinx-copybutton",
   "sphinx-design",
 ]
-hooks = [
-  "codespell==2.4.1",
-  "prek>=0.2.13",
-  "ruff==0.15.16",
-]
 
 [build-system]
 requires = [
@@ -96,3 +80,12 @@ parentdir_prefix_version = "structtype-"
 
 [tool.uv.config-settings]
 editable_mode = "compat"
+
+[tool.cibuildwheel]
+build = "cp3*"
+skip = ["pp*", "*-manylinux_i686", "*-musllinux*", "*-win32"]
+enable = ["cpython-prerelease"]
+test-command = "pip install pytest>=9 && pytest {project}/tests"
+
+[tool.ruff]
+target-version = "py310"

{structtype-0.1.0 → structtype-0.3.0}/setup.py

@@ -36,6 +36,12 @@ if DEBUG:
     extra_compile_args.extend(["-O0", "-g", "-UNDEBUG"])
 elif sys.platform != "win32":
     extra_compile_args.extend(["-g0"])
+    extra_compile_args.extend([
+        "-Wextra",
+        "-Wno-unused-parameter",
+        "-Wno-missing-field-initializers",
+        "-Wno-cast-function-type",
+    ])
     if sys.platform == "darwin" and platform.machine().lower() == "arm64":
         extra_compile_args.extend(["-flto=thin"])
         extra_link_args.extend(["-flto=thin"])
@@ -53,15 +59,15 @@ libraries = []
 if sys.platform != "win32":
     libraries.append("m")
 
-    ext_modules = [
-        Extension(
-            "structtype._core",
-            [os.path.join("src", "structtype", "_core.c")],
-            libraries=libraries,
-            extra_compile_args=extra_compile_args,
-            extra_link_args=extra_link_args,
-        )
-    ]
+ext_modules = [
+    Extension(
+        "structtype._core",
+        [os.path.join("src", "structtype", "_core.c")],
+        libraries=libraries,
+        extra_compile_args=extra_compile_args,
+        extra_link_args=extra_link_args,
+    )
+]
 
 setup(
     ext_modules=ext_modules,

{structtype-0.1.0 → structtype-0.3.0}/src/structtype/__init__.py

@@ -1,3 +1,4 @@
+from ._adapter import StrAdapter, StructAdapter
 from ._core import (
     NODEFAULT,
     UNSET,
@@ -11,7 +12,6 @@ from ._core import (
     UnsetType,
     ValidationError,
 )
-from ._adapter import StructAdapter
 from ._inspect import FieldInfo, fields
-from ._json_schema import json_schema, json_schema_dump, json_schema_components
+from ._json_schema import json_schema, json_schema_components, json_schema_dump
 from ._version import __version__

{structtype-0.1.0 → structtype-0.3.0}/src/structtype/__init__.pyi

@@ -1,23 +1,11 @@
 import enum
-from collections.abc import Callable, Iterable, Mapping
+from collections.abc import Callable, Iterable, Iterator, Mapping
 from inspect import Signature
-from typing import (
-    Any,
-    ClassVar,
-    Final,
-    Literal,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    final,
-    overload,
-)
+from typing import Any, ClassVar, Final, Literal, TypeAlias, TypeVar, final, overload
 
-from typing_extensions import Buffer, Self, TypeAlias, dataclass_transform
+from typing_extensions import Buffer, Self, dataclass_transform
 
-from . import _inspect
+from . import StructConfig
 
 # PEP 673 explicitly rejects using Self in metaclass definitions:
 # https://peps.python.org/pep-0673/#valid-locations-for-self
@@ -34,7 +22,7 @@ class StructMeta(type):
     @property
     def __signature__(self) -> Signature: ...
     @property
-    def __struct_config__(self) -> structs.StructConfig: ...
+    def __struct_config__(self) -> StructConfig: ...
     def __new__(
         mcls: type[_SM],
         name: str,
@@ -85,6 +73,7 @@ class Struct(metaclass=StructMeta):
     __struct_fields__: ClassVar[tuple[str, ...]]
     __struct_config__: ClassVar[StructConfig]
     __struct_encode_fields__: ClassVar[tuple[str, ...]]
+    __struct_defaults__: ClassVar[tuple[Any, ...]]
     __match_args__: ClassVar[tuple[str, ...]]
     # A default __init__ so that Structs with unknown field types
     # won't error on every call to `__init__`
@@ -114,25 +103,30 @@ class Struct(metaclass=StructMeta):
         validate_on_init: bool = False,
     ) -> None: ...
     def __rich_repr__(self) -> list[tuple[str, Any]]: ...
+    def __copy__(self) -> Self: ...
+    def __reduce__(self) -> tuple: ...
     def __replace__(self, **changes: Any) -> Self: ...
+    def __iter__(self) -> Iterator[tuple[str, Any]]: ...
     def struct_dump_json(
         self,
         *,
         enc_hook: Callable[[Any], Any] | None = None,
-        decimal_format: Literal["string", "number"] | Callable[[Any], Any] | None = None,
+        decimal_format: Literal["string", "number"]
+        | Callable[[Any], Any]
+        | None = None,
         uuid_format: Literal["canonical", "hex"] | None = None,
         order: Literal["deterministic", "sorted"] | None = None,
     ) -> bytes: ...
-    def struct_dump(self) -> dict[str, Any]: ...
-    def struct_to_dict(self) -> dict[str, Any]: ...
-    def struct_to_tuple(self) -> tuple[Any, ...]: ...
-    def struct_force_setattr(self, name: str, value: Any) -> None: ...
-    def struct_check(
+    def struct_dump(
         self,
         *,
-        strict: bool = True,
-        dec_hook: Callable[[type[Any], Any], Any] | None = None,
-    ) -> None: ...
+        enc_hook: Callable[[Any], Any] | None = None,
+        order: Literal["deterministic", "sorted"] | None = None,
+        str_keys: bool = False,
+        builtin_types: Iterable[type] | None = None,
+    ) -> dict[str, Any] | list[Any]: ...
+    def struct_force_setattr(self, name: str, value: Any) -> None: ...
+    def struct_validate_self(self) -> None: ...
     @classmethod
     def struct_validate_json(
         cls: type[_T],
@@ -150,24 +144,6 @@ class Struct(metaclass=StructMeta):
         from_attributes: bool = False,
         dec_hook: Callable[[type[Any], Any], Any] | None = None,
     ) -> _T: ...
-    @classmethod
-    def struct_validate_jsonln(
-        cls: type[_T],
-        buf: str | Buffer,
-        *,
-        strict: bool = True,
-        dec_hook: Callable[[type[Any], Any], Any] | None = None,
-    ) -> list[_T]: ...
-    @classmethod
-    def struct_dump_jsonln(
-        cls,
-        items: Iterable[Any],
-        *,
-        enc_hook: Callable[[Any], Any] | None = None,
-        decimal_format: Literal["string", "number"] | Callable[[Any], Any] | None = None,
-        uuid_format: Literal["canonical", "hex"] | None = None,
-        order: Literal["deterministic", "sorted"] | None = None,
-    ) -> bytes: ...
 
 # Lie and say `Raw` is a subclass of `bytes`, so mypy will accept it in most
 # places where an object that implements the buffer protocol is valid
@@ -340,7 +316,9 @@ class StructAdapter:
         obj: Any,
         *,
         enc_hook: Callable[[Any], Any] | None = None,
-        decimal_format: Literal["string", "number"] | Callable[[Any], Any] | None = None,
+        decimal_format: Literal["string", "number"]
+        | Callable[[Any], Any]
+        | None = None,
         uuid_format: Literal["canonical", "hex"] | None = None,
         order: Literal["deterministic", "sorted"] | None = None,
     ) -> bytes: ...
@@ -352,7 +330,18 @@ class StructAdapter:
         dec_hook: Callable[[type[Any], Any], Any] | None = None,
         from_attributes: bool = False,
     ) -> Any: ...
-    def struct_dump(self, obj: Any) -> Any: ...
+    def struct_dump(
+        self,
+        obj: Any,
+        *,
+        enc_hook: Callable[[Any], Any] | None = None,
+        order: Literal["deterministic", "sorted"] | None = None,
+        str_keys: bool = False,
+        builtin_types: Iterable[type] | None = None,
+    ) -> Any: ...
+
+class StrAdapter:
+    def __new__(cls, type: type[Any]) -> type[str]: ...
 
 class EncodeError(ValueError): ...
 class DecodeError(ValueError): ...

structtype-0.3.0/src/structtype/_adapter.py

@@ -0,0 +1,128 @@
+from typing import Any
+
+from ._core import _dump, _json_decode, _json_encode, _validate
+
+
+class StructAdapter:
+    """Adapter for validating and serializing types without subclassing ``Struct``.
+
+    Useful when you want to validate or serialize plain Python types
+    (e.g. ``list[int]``) without defining a full ``Struct`` subclass.
+
+    >>> from structtype import StructAdapter
+    >>> adapter = StructAdapter(list[int])
+    >>> adapter.struct_validate_json(b"[1, 2, 3]")
+    [1, 2, 3]
+    """
+
+    __slots__ = ("_type",)
+
+    def __init__(self, type: Any):
+        self._type = type
+
+    def struct_validate_json(self, buf, *, strict=True, dec_hook=None):
+        """Validate JSON bytes and decode into the adapter's type.
+
+        Parameters
+        ----------
+        buf : str or bytes
+            The JSON message to decode.
+        strict : bool, optional
+            If True (default), unmatched fields cause an error.
+        dec_hook : callable, optional
+            A callback for customizing decoding of specific types.
+        """
+        return _json_decode(buf, type=self._type, strict=strict, dec_hook=dec_hook)
+
+    def struct_dump_json(
+        self, obj, *, enc_hook=None, decimal_format=None, uuid_format=None, order=None
+    ):
+        """Encode a validated object to JSON bytes.
+
+        Parameters
+        ----------
+        obj : Any
+            A value to encode. Must match the adapter's type.
+        enc_hook : callable, optional
+            A callback for customizing encoding of specific types.
+        decimal_format : str or callable, optional
+            Controls how ``Decimal`` values are encoded.
+        uuid_format : str, optional
+            Controls how ``UUID`` values are encoded.
+        order : str, optional
+            Determines key ordering in JSON objects.
+        """
+        return _json_encode(
+            obj,
+            enc_hook=enc_hook,
+            decimal_format=decimal_format,
+            uuid_format=uuid_format,
+            order=order,
+        )
+
+    def struct_validate(
+        self, obj, *, strict=True, dec_hook=None, from_attributes=False
+    ):
+        """Validate a Python object against the adapter's type.
+
+        Parameters
+        ----------
+        obj : Any
+            A Python object to validate and convert.
+        strict : bool, optional
+            If True (default), unmatched fields cause an error.
+        dec_hook : callable, optional
+            A callback for customizing decoding of specific types.
+        from_attributes : bool, optional
+            If True, accept objects with attributes instead of dict keys.
+        """
+        return _validate(
+            obj,
+            self._type,
+            strict=strict,
+            dec_hook=dec_hook,
+            from_attributes=from_attributes,
+        )
+
+    def struct_dump(
+        self, obj, *, enc_hook=None, order=None, str_keys=False, builtin_types=None
+    ):
+        """Convert a validated object to built-in Python types (``dict``, ``list``, etc.)."""
+        return _dump(
+            obj,
+            builtin_types=builtin_types,
+            str_keys=str_keys,
+            enc_hook=enc_hook,
+            order=order,
+        )
+
+
+class StrAdapter:
+    """Create a ``str`` subclass wrapper for validating a type during
+    structtype serialization.
+
+    Wraps a type that has a single-argument string constructor
+    (e.g. ``HttpUrl``, ``EmailStr``, ``IPv4Address``) into a ``str``
+    subclass. The wrapped value is stored as a string but validated by
+    calling ``typ(value)`` on construction. During structtype
+    validation and serialization, the wrapper is treated as a native
+    ``str``.
+
+    >>> from structtype import StrAdapter, Struct
+    >>> from ipaddress import IPv4Address
+    >>>
+    >>> class Config(Struct):
+    ...     ip: StrAdapter(IPv4Address)
+    """
+
+    __slots__ = ()
+
+    def __new__(cls, typ):
+        return type(
+            f"_Wrapped_{typ.__name__}",
+            (str,),
+            {
+                "__slots__": (),
+                "__new__": lambda self, v: str.__new__(self, str(typ(v))),
+            },
+        )