structtype 0.6.0__tar.gz → 0.7.0__tar.gz

{structtype-0.6.0/src/structtype.egg-info → structtype-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structtype
-Version: 0.6.0
+Version: 0.7.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.6.0 → structtype-0.7.0}/src/structtype/__init__.py

@@ -3,16 +3,23 @@ from ._core import (  # type: ignore
     ALL_BUILTIN_TYPES,
     NODEFAULT,
     UNSET,
+    BytesValidator,
+    CollectionValidator,
     DecodeError,
     EncodeError,
     Factory,
     Field,
+    NumericValidator,
     Raw,
+    Serializer,
     Struct,
     StructConfig,
     StructMeta,
+    StrValidator,
+    TimezoneValidator,
     UnsetType,
     ValidationError,
+    Validator,
 )
 from ._inspect import FieldInfo, fields
 from ._json_schema import json_schema, json_schema_components, json_schema_dump
@@ -22,18 +29,25 @@ __all__ = [
     "ALL_BUILTIN_TYPES",
     "NODEFAULT",
     "UNSET",
+    "BytesValidator",
+    "CollectionValidator",
     "DecodeError",
     "EncodeError",
     "Factory",
     "Field",
     "FieldInfo",
+    "NumericValidator",
     "Raw",
+    "Serializer",
+    "StrValidator",
     "Struct",
     "StructAdapter",
     "StructConfig",
     "StructMeta",
+    "TimezoneValidator",
     "UnsetType",
     "ValidationError",
+    "Validator",
     "__version__",
     "fields",
     "json_schema",

{structtype-0.6.0 → structtype-0.7.0}/src/structtype/__init__.pyi

@@ -179,107 +179,95 @@ class Factory:
 
 @final
 class Field:
-    # Numeric:
-    @overload
     def __init__(
         self,
         *,
-        gt: int | float | None = None,
-        lt: int | float | None = None,
-        multiple_of: int | float | None = None,
         alias: str | None = None,
         title: str | None = None,
         description: str | None = None,
         json_schema_extra: dict[str, Any] | None = None,
         examples: list[Any] | None = None,
         deprecated: bool | None = None,
-        dump: Callable[[Any], Any] | None = None,
-        validate: Callable[[Any], Any] | None = None,
     ) -> None: ...
-    @overload
+    alias: Final[str | None]
+    title: Final[str | None]
+    description: Final[str | None]
+    examples: Final[list[Any] | None]
+    deprecated: Final[bool | None]
+    json_schema_extra: Final[dict[str, Any] | None]
+    def __rich_repr__(self) -> list[tuple[str, Any]]: ...
+
+@final
+class Serializer:
     def __init__(
         self,
         *,
-        gt: int | float | None = None,
-        le: int | float | None = None,
-        multiple_of: int | float | None = None,
-        alias: str | None = None,
-        title: str | None = None,
-        description: str | None = None,
-        json_schema_extra: dict[str, Any] | None = None,
-        examples: list[Any] | None = None,
-        deprecated: bool | None = None,
+        load: Callable[[Any], Any] | None = None,
         dump: Callable[[Any], Any] | None = None,
-        validate: Callable[[Any], Any] | None = None,
     ) -> None: ...
-    @overload
+    load: Final[Callable[[Any], Any] | None]
+    dump: Final[Callable[[Any], Any] | None]
+
+class Validator:
+    def __init__(self, fn: Callable[[Any], Any] | None = None) -> None: ...
+    def __call__(self, value: Any) -> None: ...
+
+@final
+class NumericValidator(Validator):
     def __init__(
         self,
         *,
+        gt: int | float | None = None,
         ge: int | float | None = None,
         lt: int | float | None = None,
+        le: int | float | None = None,
         multiple_of: int | float | None = None,
-        alias: str | None = None,
-        title: str | None = None,
-        description: str | None = None,
-        json_schema_extra: dict[str, Any] | None = None,
-        examples: list[Any] | None = None,
-        deprecated: bool | None = None,
-        dump: Callable[[Any], Any] | None = None,
-        validate: Callable[[Any], Any] | None = None,
     ) -> None: ...
-    @overload
+    gt: Final[int | float | None]
+    ge: Final[int | float | None]
+    lt: Final[int | float | None]
+    le: Final[int | float | None]
+    multiple_of: Final[int | float | None]
+
+@final
+class StrValidator(Validator):
     def __init__(
         self,
         *,
-        ge: int | float | None = None,
-        le: int | float | None = None,
-        multiple_of: int | float | None = None,
-        alias: str | None = None,
-        title: str | None = None,
-        description: str | None = None,
-        json_schema_extra: dict[str, Any] | None = None,
-        examples: list[Any] | None = None,
-        deprecated: bool | None = None,
-        dump: Callable[[Any], Any] | None = None,
-        validate: Callable[[Any], Any] | None = None,
+        pattern: str | None = None,
+        min_length: _NonNegativeInt | None = None,
+        max_length: _NonNegativeInt | None = None,
     ) -> None: ...
-    # Other (string/datetime):
-    @overload
+    pattern: Final[str | None]
+    min_length: Final[int | None]
+    max_length: Final[int | None]
+
+@final
+class BytesValidator(Validator):
     def __init__(
         self,
         *,
-        pattern: str | None = None,
         min_length: _NonNegativeInt | None = None,
         max_length: _NonNegativeInt | None = None,
-        tz: bool | None = None,
-        alias: str | None = None,
-        title: str | None = None,
-        description: str | None = None,
-        json_schema_extra: dict[str, Any] | None = None,
-        examples: list[Any] | None = None,
-        deprecated: bool | None = None,
-        dump: Callable[[Any], Any] | None = None,
-        validate: Callable[[Any], Any] | None = None,
     ) -> None: ...
-    alias: Final[str | None]
-    gt: Final[int | float | None]
-    ge: Final[int | float | None]
-    lt: Final[int | float | None]
-    le: Final[int | float | None]
-    multiple_of: Final[int | float | None]
-    pattern: Final[str | None]
     min_length: Final[int | None]
     max_length: Final[int | None]
-    tz: Final[int | None]
-    title: Final[str | None]
-    description: Final[str | None]
-    examples: Final[list[Any] | None]
-    deprecated: Final[bool | None]
-    json_schema_extra: Final[dict[str, Any] | None]
-    dump: Final[Callable[[Any], Any] | None]
-    validate: Final[Callable[[Any], Any] | None]
-    def __rich_repr__(self) -> list[tuple[str, Any]]: ...
+
+@final
+class CollectionValidator(Validator):
+    def __init__(
+        self,
+        *,
+        min_length: _NonNegativeInt | None = None,
+        max_length: _NonNegativeInt | None = None,
+    ) -> None: ...
+    min_length: Final[int | None]
+    max_length: Final[int | None]
+
+@final
+class TimezoneValidator(Validator):
+    def __init__(self, *, tz: bool) -> None: ...
+    tz: Final[bool]
 
 class FieldInfo(Struct):
     name: str

{structtype-0.6.0 → structtype-0.7.0}/src/structtype/_adapter.py

@@ -1,7 +1,7 @@
 from typing import Any, get_args
 
 from ._core import (  # type: ignore
-    Field as _Field,
+    Serializer as _Serializer,
 )
 from ._core import (  # type: ignore
     _dump,
@@ -11,22 +11,22 @@ from ._core import (  # type: ignore
 )
 
 
-def _has_codec(ann):
-    """True if the annotation carries a ``Field`` with ``dump``/``validate``."""
+def _has_serializer(ann):
+    """True if the annotation carries a ``Serializer`` with ``load``/``dump``."""
     metadata = getattr(ann, "__metadata__", None)
     if metadata is not None:
         for meta in metadata:
-            if isinstance(meta, _Field) and (
-                meta.dump is not None or meta.validate is not None
+            if isinstance(meta, _Serializer) and (
+                meta.load is not None or meta.dump is not None
             ):
                 return True
     supertype = getattr(ann, "__supertype__", None)  # NewType
-    if supertype is not None and _has_codec(supertype):
+    if supertype is not None and _has_serializer(supertype):
         return True
     value = getattr(ann, "__value__", None)  # PEP 695 type alias
-    if value is not None and _has_codec(value):
+    if value is not None and _has_serializer(value):
         return True
-    return any(_has_codec(arg) for arg in get_args(ann))
+    return any(_has_serializer(arg) for arg in get_args(ann))
 
 
 class StructAdapter:
@@ -35,8 +35,8 @@ class StructAdapter:
     Useful when you want to validate or serialize plain Python types
     (e.g. ``list[int]``) without defining a full ``Struct`` subclass.
 
-    ``Field(dump=...)`` / ``Field(validate=...)`` codecs are not supported on
-    ``StructAdapter`` — annotations carrying one are rejected. Implement the
+    ``Serializer(load=...)`` / ``Serializer(dump=...)`` codecs are not supported
+    on ``StructAdapter`` — annotations carrying one are rejected. Implement the
     ``struct_dump`` / ``struct_validate`` protocol methods on the custom type,
     or use a ``Struct``.
 
@@ -49,11 +49,12 @@ class StructAdapter:
     __slots__ = ("_type",)
 
     def __init__(self, type: Any):
-        if _has_codec(type):
+        if _has_serializer(type):
             raise TypeError(
-                "`Field(dump=...)`/`Field(validate=...)` codecs are not supported "
-                "on StructAdapter; define `struct_dump`/`struct_validate` methods "
-                "on the custom type, or use a `Struct` instead"
+                "`Serializer(load=...)`/`Serializer(dump=...)` codecs are not "
+                "supported on StructAdapter; define `struct_dump`/"
+                "`struct_validate` methods on the custom type, or use a "
+                "`Struct` instead"
             )
         self._type = type