vtjson 2.1.3__py3-none-any.whl → 2.1.5__py3-none-any.whl

vtjson/vtjson.py

@@ -12,7 +12,7 @@ import urllib.parse
 import warnings
 from collections.abc import Sequence, Sized
 from dataclasses import dataclass
-from typing import Any, Callable, Type, TypeVar, Union, cast
+from typing import Any, Callable, Mapping, Type, TypeVar, Union, cast
 
 try:
     from typing import Literal
@@ -45,6 +45,12 @@ if hasattr(typing, "get_origin"):
 else:
     supports_Generics = False
 
+try:
+    Sequence[str]
+    supports_Generic_ABC = True
+except Exception:
+    supports_Generic_ABC = False
+
 try:
     typing.get_type_hints(int, include_extras=True)
     supports_structural = True
@@ -83,7 +89,7 @@ class compiled_schema:
         object_: object,
         name: str,
         strict: bool,
-        subs: dict[str, object],
+        subs: Mapping[str, object],
     ) -> str:
         return ""
 
@@ -115,14 +121,14 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.1.3"
+__version__ = "2.1.5"
 
 
 @dataclass
 class Apply:
     skip_first: bool | None = None
     name: str | None = None
-    labels: list[str] | None = None
+    labels: Sequence[str] | None = None
 
     def __call__(self, schemas: tuple[object, ...]) -> object:
         if len(schemas) == 0:
@@ -152,13 +158,16 @@ def _get_type_hints(schema: object) -> dict[str, object]:
         raise SchemaError(
             "Structural subtyping in not supported in this " "Python version"
         )
-    type_hints = {}
     if isinstance(schema, type) and hasattr(schema, "__annotations__"):
         type_hints = typing.get_type_hints(schema, include_extras=True)
+    else:
+        raise SchemaError("The schema does not have type hints")
     return type_hints
 
 
-def _to_dict(type_hints: dict[str, object], total: bool = True) -> dict[object, object]:
+def _to_dict(
+    type_hints: Mapping[str, object], total: bool = True
+) -> dict[object, object]:
     d: dict[object, object] = {}
     if not supports_Generics:
         raise SchemaError("Generic types are not supported")
@@ -224,7 +233,7 @@ def _wrong_type_message(
 class _validate_meta(type):
     __schema__: object
     __strict__: bool
-    __subs__: dict[str, object]
+    __subs__: Mapping[str, object]
     __dbg__: bool
 
     def __instancecheck__(cls, object_: object) -> bool:
@@ -241,7 +250,7 @@ def make_type(
     name: str | None = None,
     strict: bool = True,
     debug: bool = False,
-    subs: dict[str, object] = {},
+    subs: Mapping[str, object] = {},
 ) -> _validate_meta:
     if name is None:
         if hasattr(schema, "__name__"):
@@ -292,7 +301,7 @@ class _union(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         messages = []
         for schema in self.schemas:
@@ -331,7 +340,7 @@ class _intersect(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         for schema in self.schemas:
             message = schema.__validate__(object_, name=name, strict=strict, subs=subs)
@@ -363,7 +372,7 @@ class _complement(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         message = self.schema.__validate__(object_, name=name, strict=strict, subs=subs)
         if message != "":
@@ -395,7 +404,7 @@ class _lax(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         return self.schema.__validate__(object_, name=name, strict=False, subs=subs)
 
@@ -423,7 +432,7 @@ class _strict(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         return self.schema.__validate__(object_, name=name, strict=True, subs=subs)
 
@@ -457,7 +466,7 @@ class _set_label(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         common_labels = tuple(set(subs.keys()).intersection(self.labels))
         if len(common_labels) >= 2:
@@ -510,7 +519,7 @@ class quote(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         return self.schema.__validate__(object_, name=name, strict=strict, subs=subs)
 
@@ -536,7 +545,7 @@ class _set_name(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         message = self.schema.__validate__(object_, name=name, strict=strict, subs=subs)
         if message != "":
@@ -607,7 +616,7 @@ class regex(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, str):
             return _wrong_type_message(object_, name, self.__name__)
@@ -646,7 +655,7 @@ class glob(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, str):
             return _wrong_type_message(object_, name, self.__name__)
@@ -682,7 +691,7 @@ class magic(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, (str, bytes)):
             return _wrong_type_message(object_, name, self.__name__)
@@ -731,7 +740,7 @@ class div(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, int):
             return _wrong_type_message(object_, name, "int")
@@ -778,7 +787,7 @@ class close_to(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, (float, int)):
             return _wrong_type_message(object_, name, "number")
@@ -808,7 +817,7 @@ class gt(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         try:
             if self.lb < object_:
@@ -839,7 +848,7 @@ class ge(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         try:
             if self.lb <= object_:
@@ -870,7 +879,7 @@ class lt(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         try:
             if self.ub > object_:
@@ -901,7 +910,7 @@ class le(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         try:
             if self.ub >= object_:
@@ -1005,7 +1014,7 @@ class size(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, Sized):
             return f"{name} (value:{_c(object_)}) has no len()"
@@ -1028,7 +1037,7 @@ class _deferred(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if self.key not in self.collection:
             raise ValidationError(f"{name}: key {self.key} is unknown")
@@ -1110,11 +1119,19 @@ def _compile(
         ret = schema
     elif supports_TypedDict and typing.is_typeddict(schema):
         ret = _compile(
-            structural(schema, dict=True), _deferred_compiles=_deferred_compiles
+            protocol(schema, dict=True), _deferred_compiles=_deferred_compiles
         )
     elif isinstance(schema, type) and hasattr(schema, "_is_protocol"):
         assert hasattr(schema, "__name__") and isinstance(schema.__name__, str)
-        ret = _compile(structural(schema), _deferred_compiles=_deferred_compiles)
+        ret = _compile(protocol(schema), _deferred_compiles=_deferred_compiles)
+    elif (
+        isinstance(schema, type)
+        and issubclass(schema, tuple)
+        and hasattr(schema, "_fields")
+    ):
+        ret = _compile(
+            intersect(tuple, protocol(schema)), _deferred_compiles=_deferred_compiles
+        )
     elif schema == Any:
         ret = anything()
     elif hasattr(schema, "__name__") and hasattr(schema, "__supertype__"):
@@ -1122,12 +1139,20 @@ def _compile(
             schema,
             _deferred_compiles=_deferred_compiles,
         )
-    elif origin == list:
-        ret = _List(typing.get_args(schema)[0], _deferred_compiles=_deferred_compiles)
     elif origin == tuple:
         ret = _Tuple(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
-    elif origin == dict:
-        ret = _Dict(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
+    elif isinstance(origin, type) and issubclass(origin, Sequence):
+        ret = _List(
+            typing.get_args(schema)[0],
+            type_schema=origin,
+            _deferred_compiles=_deferred_compiles,
+        )
+    elif isinstance(origin, type) and issubclass(origin, Mapping):
+        ret = _Dict(
+            typing.get_args(schema),
+            type_schema=origin,
+            _deferred_compiles=_deferred_compiles,
+        )
     elif origin == Union:
         ret = _Union(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
     elif supports_Literal and origin == Literal:
@@ -1140,9 +1165,9 @@ def _compile(
         ret = _type(schema)
     elif callable(schema):
         ret = _callable(schema)
-    elif isinstance(schema, tuple) or isinstance(schema, list):
+    elif isinstance(schema, Sequence) and not isinstance(schema, str):
         ret = _sequence(schema, _deferred_compiles=_deferred_compiles)
-    elif isinstance(schema, dict):
+    elif isinstance(schema, Mapping):
         ret = _dict(schema, _deferred_compiles=_deferred_compiles)
     elif isinstance(schema, set):
         ret = _set(schema, _deferred_compiles=_deferred_compiles)
@@ -1162,7 +1187,7 @@ def _validate(
     object_: object,
     name: str = "object",
     strict: bool = True,
-    subs: dict[str, object] = {},
+    subs: Mapping[str, object] = {},
 ) -> str:
     return compile(schema).__validate__(object_, name=name, strict=strict, subs=subs)
 
@@ -1172,7 +1197,7 @@ def validate(
     object_: object,
     name: str = "object",
     strict: bool = True,
-    subs: dict[str, object] = {},
+    subs: Mapping[str, object] = {},
 ) -> None:
     message = _validate(
         schema,
@@ -1201,7 +1226,7 @@ class number(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if isinstance(object_, (int, float)):
             return ""
@@ -1224,7 +1249,7 @@ class email(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, str):
             return _wrong_type_message(
@@ -1261,7 +1286,7 @@ class ip_address(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, (int, str, bytes)):
             return _wrong_type_message(object_, name, self.__name__)
@@ -1278,7 +1303,7 @@ class url(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, str):
             return _wrong_type_message(object_, name, "url")
@@ -1304,7 +1329,7 @@ class date_time(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, str):
             return _wrong_type_message(object_, name, self.__name__)
@@ -1327,7 +1352,7 @@ class date(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, str):
             return _wrong_type_message(object_, name, "date")
@@ -1344,7 +1369,7 @@ class time(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, str):
             return _wrong_type_message(object_, name, "date")
@@ -1361,7 +1386,7 @@ class nothing(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         return _wrong_type_message(object_, name, "nothing")
 
@@ -1372,7 +1397,7 @@ class anything(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         return ""
 
@@ -1403,7 +1428,7 @@ class domain_name(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, str):
             return _wrong_type_message(object_, name, self.__name__)
@@ -1439,9 +1464,9 @@ class at_least_one_of(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, dict):
+        if not isinstance(object_, Mapping):
             return _wrong_type_message(object_, name, self.__name__)
         try:
             if any([a in object_ for a in self.args]):
@@ -1466,9 +1491,9 @@ class at_most_one_of(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, dict):
+        if not isinstance(object_, Mapping):
             return _wrong_type_message(object_, name, self.__name__)
         try:
             if sum([a in object_ for a in self.args]) <= 1:
@@ -1493,9 +1518,9 @@ class one_of(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, dict):
+        if not isinstance(object_, Mapping):
             return _wrong_type_message(object_, name, self.__name__)
         try:
             if sum([a in object_ for a in self.args]) == 1:
@@ -1517,10 +1542,10 @@ class keys(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, dict):
-            return _wrong_type_message(object_, name, "dict")  # TODO: __name__
+        if not isinstance(object_, Mapping):
+            return _wrong_type_message(object_, name, "Mapping")  # TODO: __name__
         for k in self.args:
             if k not in object_:
                 return f"{name}[{repr(k)}] is missing"
@@ -1553,7 +1578,7 @@ class _ifthen(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if (
             self.if_schema.__validate__(object_, name=name, strict=strict, subs=subs)
@@ -1615,7 +1640,7 @@ class _cond(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         for c in self.conditions:
             if c[0].__validate__(object_, name=name, strict=strict, subs=subs) == "":
@@ -1640,7 +1665,7 @@ class _fields(compiled_schema):
     d: dict[str, compiled_schema]
 
     def __init__(
-        self, d: dict[str, object], _deferred_compiles: _mapping | None = None
+        self, d: Mapping[str, object], _deferred_compiles: _mapping | None = None
     ) -> None:
         self.d = {}
         for k, v in d.items():
@@ -1651,7 +1676,7 @@ class _fields(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         for k, v in self.d.items():
             name_ = f"{name}.{k}"
@@ -1667,8 +1692,8 @@ class _fields(compiled_schema):
 
 class fields:
     def __init__(self, d: object) -> None:
-        if not isinstance(d, dict):
-            raise SchemaError(f"{repr(d)} is not a dictionary")
+        if not isinstance(d, Mapping):
+            raise SchemaError(f"{repr(d)} is not a Mapping")
         for k in d:
             if not isinstance(k, str):
                 raise SchemaError(f"key {repr(k)} in {repr(d)} is not a string")
@@ -1707,7 +1732,7 @@ class _filter(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         try:
             object_ = self.filter(object_)
@@ -1766,7 +1791,7 @@ class _type(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         try:
             if self.schema == float and isinstance(object_, int):
@@ -1783,7 +1808,7 @@ class _type(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         # consider int as a subtype of float
         if isinstance(object_, (int, float)):
@@ -1796,7 +1821,7 @@ class _type(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         # consider int, float as subtypes of complex
         if isinstance(object_, (int, float, complex)):
@@ -1815,10 +1840,14 @@ class _sequence(compiled_schema):
 
     def __init__(
         self,
-        schema: list[object] | tuple[object, ...],
+        schema: Sequence[object],
+        type_schema: type | None = None,
         _deferred_compiles: _mapping | None = None,
     ) -> None:
-        self.type_schema = type(schema)
+        if type_schema is None:
+            self.type_schema = type(schema)
+        else:
+            self.type_schema = type_schema
         self.schema = [
             _compile(o, _deferred_compiles=_deferred_compiles)
             for o in schema
@@ -1838,10 +1867,10 @@ class _sequence(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, type(self.schema).__name__)
+            return _wrong_type_message(object_, name, self.type_schema.__name__)
         ls = len(self.schema)
         lo = len(object_)
         if strict:
@@ -1861,10 +1890,10 @@ class _sequence(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, type(self.schema).__name__)
+            return _wrong_type_message(object_, name, self.type_schema.__name__)
         ls = len(self.schema)
         lo = len(object_)
         if ls > lo:
@@ -1901,7 +1930,7 @@ class _const(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if object_ != self.schema:
             return self.message(name, object_)
@@ -1927,7 +1956,7 @@ class _callable(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         try:
             if self.schema(object_):
@@ -1946,12 +1975,18 @@ class _dict(compiled_schema):
     const_keys: set[object]
     other_keys: set[compiled_schema]
     schema: dict[object, compiled_schema]
+    type_schema: Type[Mapping[object, object]]
 
     def __init__(
         self,
-        schema: dict[object, object],
+        schema: Mapping[object, object],
+        type_schema: type | None = None,
         _deferred_compiles: _mapping | None = None,
     ) -> None:
+        if type_schema is None:
+            self.type_schema = type(schema)
+        else:
+            self.type_schema = type_schema
         self.min_keys = set()
         self.const_keys = set()
         self.other_keys = set()
@@ -1981,10 +2016,10 @@ class _dict(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, dict):
-            return _wrong_type_message(object_, name, "dict")
+        if not isinstance(object_, self.type_schema):
+            return _wrong_type_message(object_, name, self.type_schema.__name__)
 
         for k in self.min_keys:
             if k not in object_:
@@ -2047,7 +2082,7 @@ class _set(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         return self.schema.__validate__(object_, name=name, strict=True, subs=subs)
 
@@ -2056,7 +2091,7 @@ class _set(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, set):
             return _wrong_type_message(object_, name, "set")
@@ -2072,7 +2107,7 @@ class _set(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(object_, set):
             return _wrong_type_message(object_, name, "set")
@@ -2087,7 +2122,7 @@ class _set(compiled_schema):
         return str(self.schema_)
 
 
-class structural:
+class protocol:
     type_dict: dict[object, object]
     dict: bool
     __name__: str
@@ -2101,16 +2136,17 @@ class structural:
         if hasattr(schema, "__total__") and isinstance(schema.__total__, bool):
             total = schema.__total__
         self.type_dict = _to_dict(type_hints, total=total)
-        assert hasattr(schema, "__name__") and isinstance(schema.__name__, str)
-        self.__name__ = schema.__name__
+        if hasattr(schema, "__name__") and isinstance(schema.__name__, str):
+            self.__name__ = schema.__name__
+        else:
+            self.__name__ = "schema"
 
     def __compile__(
         self, _deferred_compiles: _mapping | None = None
     ) -> compiled_schema:
         if not self.dict:
-            type_dict_ = cast(dict[str, object], self.type_dict)
             return _set_name(
-                fields(type_dict_),
+                fields(self.type_dict),
                 self.__name__,
                 reason=True,
                 _deferred_compiles=_deferred_compiles,
@@ -2148,13 +2184,18 @@ class _Union(compiled_schema):
 
 class _List(compiled_schema):
     def __init__(
-        self, schema: object, _deferred_compiles: _mapping | None = None
+        self,
+        schema: object,
+        type_schema: type | None = None,
+        _deferred_compiles: _mapping | None = None,
     ) -> None:
         setattr(
             self,
             "__validate__",
             _sequence(
-                [schema, ...], _deferred_compiles=_deferred_compiles
+                [schema, ...],
+                type_schema=type_schema,
+                _deferred_compiles=_deferred_compiles,
             ).__validate__,
         )
 
@@ -2172,13 +2213,18 @@ class _Tuple(compiled_schema):
 
 class _Dict(compiled_schema):
     def __init__(
-        self, schema: tuple[object, ...], _deferred_compiles: _mapping | None = None
+        self,
+        schema: tuple[object, ...],
+        type_schema: type | None = None,
+        _deferred_compiles: _mapping | None = None,
     ) -> None:
         k, v = schema
         setattr(
             self,
             "__validate__",
-            _dict({k: v}, _deferred_compiles=_deferred_compiles).__validate__,
+            _dict(
+                {k: v}, type_schema=type_schema, _deferred_compiles=_deferred_compiles
+            ).__validate__,
         )
 
 

{vtjson-2.1.3.dist-info → vtjson-2.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.3
+Version: 2.1.5
 Summary: A lightweight package for validating JSON like Python objects
 Author-email: Michel Van den Bergh <michel.vandenbergh@uhasselt.be>
 Project-URL: Homepage, https://github.com/vdbergh/vtjson
@@ -70,8 +70,8 @@ A wrapper takes one or more schemas as arguments and produces a new schema.
 - An object matches the schema `complement(schema)` if it does not match `schema`.
 - An object matches the schema `lax(schema)` if it matches `schema` when validated with `strict=False`.
 - An object matches the schema `strict(schema)` if it matches `schema` when validated with `strict=True`.
-- An object matches the schema `set_name(schema, name)` if it matches `schema`. But the `name` argument will be used in non-validation messages.
-- An object matches the schema `quote(schema)` if it is equal to `schema`. For example the schema `str` matches strings but the schema `quote(str)` matches the object `str`.
+- An object matches the schema `set_name(schema, name, reason=False)` if it matches `schema`, but the `name` argument will be used in non-validation messages. Unless `reason` is `True` the original non-validation message will be suppressed.
+- An object matches the schema `protocol(schema, dict=False)` if `schema` is a class and its fields are annotated with schemas which validate the corresponding fields in the object. If `dict` is `True` then the object is validated as a `dict`.
 - An object matches the schema `set_label(schema, label1, ..., labelN, debug=False)` if it matches `schema`, unless the schema is replaced by a different one via the `subs` argument to `validate`. If the optional argument `debug` is `True` then a message will be printed on the console if the schema was changed.
 
 ## Built-ins
@@ -163,8 +163,8 @@ A schema can be, in order of precedence:
 - A Python type hint such as `list[str]`. This is discussed further below.
 - A Python type. In that case validation is done by checking membership. By convention the schema `float` matches both ints and floats. Similarly the schema `complex` matches ints and floats besides of course complex numbers.
 - A callable. Validation is done by applying the callable to the object. If applying the callable throws an exception then the corresponding message will be part of the non-validation message.
-- A `list` or a `tuple`. Validation is done by first checking membership of the corresponding types, and then performing validation for each of the entries of the object being validated against the corresponding entries of the schema.
-- A dictionary. Validation is done by first checking membership of the `dict` type, and then performing validation for each of the values of the object being validated against the corresponding values of the schema. Keys are themselves considered as schemas. E.g. `{str: str}` represents a dictionary whose keys and values are both strings. A more elaborate discussion of validation of dictionaries is given below.
+- An instance of `Sequence` that is not an instance of `str` (e.g a `list` or a `tuple`). Validation is done by first checking membership of the schema type, and then performing validation for each of the entries of the object being validated against the corresponding entries of the schema.
+- An instance of `Mapping`. Validation is done by first checking membership of the schema type, and then performing validation for each of the values of the object being validated against the corresponding values of the schema. Keys are themselves considered as schemas. E.g. `{str: str}` represents a dictionary whose keys and values are both strings. A more elaborate discussion of validation of dictionaries is given below.
 - A `set`. A set validates an object if the object is a set and the elements of the object are validated by an element of the schema.
 - An arbitrary Python object. Validation is done by checking equality of the schema and the object, except when the schema is `float`, in which case `math.isclose` is used. Below we call such an object a `const schema`.
 
@@ -190,7 +190,7 @@ A consequence of this algorithm is that non-const keys are automatically optiona
 
 ```python
 Annotated, dict[...], Dict[...], list[...], List[...], tuple[...], Tuple[...],
-Protocol, Literal, NewType, TypedDict, Union (or the equivalent operator |).
+Protocol, NamedTuple, Literal, NewType, TypedDict, Union (or the equivalent operator |).
 ```
 
 For example `dict[str, str]` is translated internally into the schema `{str: str}`. See below for more information.
@@ -256,6 +256,16 @@ Note that Python imposes strong restrictions on what constitutes a valid type hi
 
   internally becomes `fields({"title": str, "price": float})`.
 
+- `NamedTuple`. A `NamedTuple` class is translated as the intersection of a `tuple` schema and a fields schema. E.g.
+
+  ```python
+  class Movie(NamedTuple):
+      title: str
+      price: float
+  ```
+
+  internally becomes `intersect(tuple, fields({"title": str, "price": float}))`.
+
 - `Annotated` has already been discussed. It is translated into a suitable `intersect` schema. The handling of `Annotated` schemas can be influenced by `Apply` objects (see below).
 
 - `NewType` is translated into a `set_name` schema. E.g. `NewType('Movie', str)` becomes `set_name(str, 'Movie')`

vtjson-2.1.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+vtjson/__init__.py,sha256=oLX4JH6_R7dYtTiGfBG3pQGR21IArspifdmZilbuGOw,68
+vtjson/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vtjson/vtjson.py,sha256=xq5w9FrmPf6ctjLml2To0nEfd5Okm3ijND44GLWarr0,67357
+vtjson-2.1.5.dist-info/AUTHORS,sha256=qmxaXxaIO-YPNHJAZ0dcCrnPCs1x9ocbtMksiy4i80M,21
+vtjson-2.1.5.dist-info/LICENSE,sha256=n7xW-zX8xBLHzCdqWIMRuMzBD_ACLcNCwio0LEkKt1o,1077
+vtjson-2.1.5.dist-info/METADATA,sha256=eALkzFzpWaZECpnduYIsaT1KSCREWw-fTXjLqCbyrjg,24035
+vtjson-2.1.5.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
+vtjson-2.1.5.dist-info/top_level.txt,sha256=9DlSF3l63igcvnYPcj117F2hzOW4Nx0N-JBoW3jjBZM,7
+vtjson-2.1.5.dist-info/RECORD,,

{vtjson-2.1.3.dist-info → vtjson-2.1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

vtjson-2.1.3.dist-info/RECORD

@@ -1,8 +0,0 @@
-vtjson/__init__.py,sha256=oLX4JH6_R7dYtTiGfBG3pQGR21IArspifdmZilbuGOw,68
-vtjson/vtjson.py,sha256=bCndIajECAc65M4aeNcjDJRZ8cLv4Jz4H7ryt7XHwio,65935
-vtjson-2.1.3.dist-info/AUTHORS,sha256=qmxaXxaIO-YPNHJAZ0dcCrnPCs1x9ocbtMksiy4i80M,21
-vtjson-2.1.3.dist-info/LICENSE,sha256=n7xW-zX8xBLHzCdqWIMRuMzBD_ACLcNCwio0LEkKt1o,1077
-vtjson-2.1.3.dist-info/METADATA,sha256=hoLkMLs5Kh6GVA-Xw8QX1TlCJDB7gSrzRSYrjzj9OqM,23506
-vtjson-2.1.3.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-vtjson-2.1.3.dist-info/top_level.txt,sha256=9DlSF3l63igcvnYPcj117F2hzOW4Nx0N-JBoW3jjBZM,7
-vtjson-2.1.3.dist-info/RECORD,,