vtjson 2.1.4__tar.gz → 2.1.6__tar.gz

{vtjson-2.1.4/src/vtjson.egg-info → vtjson-2.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.4
+Version: 2.1.6
 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
@@ -163,16 +163,16 @@ 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`.
 
-## Validating dictionaries
+## Validating Mapping
 
-For a dictionary schema containing only `const keys` (i.e. keys corresponding to a `const schema`) the interpretation is obvious (see the introductory example above). Below we discuss the validation of an object against a dictionary schema in the general case.
+For a Mapping schema containing only `const keys` (i.e. keys corresponding to a `const schema`) the interpretation is obvious (see the introductory example above). Below we discuss the validation of an object against a Mapping schema in the general case.
 
-- First we verify that the object is also a dictionary. If not then validation fails.
+- First we verify that the type of the object is a subtype of the type of the schema. If not then validation fails.
 - We verify that all non-optional const keys of the schema are also keys of the object. If this is not the case then validation fails.
 - Now we make a list of all the keys of the schema (both optional and non-optional). The result will be called the `key list` below.
 - The object will pass validation if all its keys pass validation. We next discuss how to validate a particular key of the object.

{vtjson-2.1.4 → vtjson-2.1.6}/README.md

@@ -143,16 +143,16 @@ 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`.
 
-## Validating dictionaries
+## Validating Mapping
 
-For a dictionary schema containing only `const keys` (i.e. keys corresponding to a `const schema`) the interpretation is obvious (see the introductory example above). Below we discuss the validation of an object against a dictionary schema in the general case.
+For a Mapping schema containing only `const keys` (i.e. keys corresponding to a `const schema`) the interpretation is obvious (see the introductory example above). Below we discuss the validation of an object against a Mapping schema in the general case.
 
-- First we verify that the object is also a dictionary. If not then validation fails.
+- First we verify that the type of the object is a subtype of the type of the schema. If not then validation fails.
 - We verify that all non-optional const keys of the schema are also keys of the object. If this is not the case then validation fails.
 - Now we make a list of all the keys of the schema (both optional and non-optional). The result will be called the `key list` below.
 - The object will pass validation if all its keys pass validation. We next discuss how to validate a particular key of the object.

{vtjson-2.1.4 → vtjson-2.1.6}/src/vtjson/vtjson.py

@@ -10,9 +10,9 @@ import types
 import typing
 import urllib.parse
 import warnings
-from collections.abc import Sequence, Sized
+from collections.abc import Sequence, Set, Sized
 from dataclasses import dataclass
-from typing import Any, Callable, Type, TypeVar, Union, cast
+from typing import Any, Callable, Container, 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.4"
+__version__ = "2.1.6"
 
 
 @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:
@@ -147,6 +153,16 @@ skip_first = Apply(skip_first=True)
 _dns_resolver: dns.resolver.Resolver | None = None
 
 
+def _generic_name(origin: type, args: tuple[object, ...]) -> str:
+    def to_name(c: object) -> str:
+        if hasattr(c, "__name__"):
+            return str(c.__name__)
+        else:
+            return str(c)
+
+    return to_name(origin) + "[" + ",".join([to_name(arg) for arg in args]) + "]"
+
+
 def _get_type_hints(schema: object) -> dict[str, object]:
     if not supports_structural:
         raise SchemaError(
@@ -159,7 +175,9 @@ def _get_type_hints(schema: object) -> dict[str, object]:
     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")
@@ -225,7 +243,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:
@@ -242,7 +260,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__"):
@@ -293,7 +311,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:
@@ -332,7 +350,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)
@@ -364,7 +382,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 != "":
@@ -396,7 +414,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)
 
@@ -424,7 +442,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)
 
@@ -458,7 +476,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:
@@ -511,7 +529,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)
 
@@ -537,7 +555,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 != "":
@@ -608,7 +626,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__)
@@ -647,7 +665,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__)
@@ -683,7 +701,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__)
@@ -732,7 +750,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")
@@ -779,7 +797,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")
@@ -809,7 +827,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_:
@@ -840,7 +858,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_:
@@ -871,7 +889,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_:
@@ -902,7 +920,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_:
@@ -1006,7 +1024,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()"
@@ -1029,7 +1047,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")
@@ -1131,12 +1149,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, Mapping):
+        ret = _Mapping(
+            typing.get_args(schema),
+            type_schema=origin,
+            _deferred_compiles=_deferred_compiles,
+        )
+    elif isinstance(origin, type) and issubclass(origin, Container):
+        ret = _Container(
+            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:
@@ -1149,11 +1175,11 @@ 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):
+    elif isinstance(schema, Set):
         ret = _set(schema, _deferred_compiles=_deferred_compiles)
     else:
         ret = _const(schema)
@@ -1171,7 +1197,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)
 
@@ -1181,7 +1207,7 @@ def validate(
     object_: object,
     name: str = "object",
     strict: bool = True,
-    subs: dict[str, object] = {},
+    subs: Mapping[str, object] = {},
 ) -> None:
     message = _validate(
         schema,
@@ -1210,7 +1236,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 ""
@@ -1233,7 +1259,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(
@@ -1270,7 +1296,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__)
@@ -1287,7 +1313,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")
@@ -1313,7 +1339,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__)
@@ -1336,7 +1362,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")
@@ -1353,7 +1379,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")
@@ -1370,7 +1396,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")
 
@@ -1381,7 +1407,7 @@ class anything(compiled_schema):
         object_: object,
         name: str = "object",
         strict: bool = True,
-        subs: dict[str, object] = {},
+        subs: Mapping[str, object] = {},
     ) -> str:
         return ""
 
@@ -1412,7 +1438,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__)
@@ -1448,9 +1474,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]):
@@ -1475,9 +1501,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:
@@ -1502,9 +1528,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:
@@ -1526,10 +1552,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"
@@ -1562,7 +1588,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)
@@ -1624,7 +1650,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) == "":
@@ -1649,7 +1675,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():
@@ -1660,7 +1686,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}"
@@ -1676,8 +1702,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")
@@ -1716,7 +1742,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_)
@@ -1775,7 +1801,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):
@@ -1792,7 +1818,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)):
@@ -1805,7 +1831,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)):
@@ -1824,7 +1850,8 @@ 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)
@@ -1847,10 +1874,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:
@@ -1870,10 +1897,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:
@@ -1910,7 +1937,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_)
@@ -1936,7 +1963,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_):
@@ -1955,12 +1982,14 @@ 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],
         _deferred_compiles: _mapping | None = None,
     ) -> None:
+        self.type_schema = type(schema)
         self.min_keys = set()
         self.const_keys = set()
         self.other_keys = set()
@@ -1990,10 +2019,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_:
@@ -2033,15 +2062,18 @@ class _dict(compiled_schema):
 
 
 class _set(compiled_schema):
+    type_schema: Type[Set[object]]
     schema: compiled_schema
-    schema_: set[object]
+    schema_: Set[object]
 
     def __init__(
-        self, schema: set[object], _deferred_compiles: _mapping | None = None
+        self,
+        schema: Set[object],
+        _deferred_compiles: _mapping | None = None,
     ) -> None:
+        self.type_schema = type(schema)
         self.schema_ = schema
         if len(schema) == 0:
-            self.schema = _const(set())
             setattr(self, "__validate__", self.__validate_empty_set__)
         elif len(schema) == 1:
             self.schema = _compile(
@@ -2056,19 +2088,23 @@ 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)
+        if not isinstance(object_, self.type_schema):
+            return _wrong_type_message(object_, name, self.type_schema.__name__)
+        if len(object_) != 0:
+            return f"{name} (value:{_c(object_)}) is not empty"
+        return ""
 
     def __validate_singleton__(
         self,
         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")
+            return _wrong_type_message(object_, name, self.type_schema.__name__)
         for i, o in enumerate(object_):
             name_ = f"{name}{{{i}}}"
             v = self.schema.__validate__(o, name=name_, strict=True, subs=subs)
@@ -2081,10 +2117,10 @@ 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")
+        if not isinstance(object_, self.type_schema):
+            return _wrong_type_message(object_, name, self.type_schema.__name__)
         for i, o in enumerate(object_):
             name_ = f"{name}{{{i}}}"
             v = self.schema.__validate__(o, name=name_, strict=True, subs=subs)
@@ -2119,9 +2155,8 @@ class protocol:
         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,
@@ -2157,19 +2192,6 @@ class _Union(compiled_schema):
         )
 
 
-class _List(compiled_schema):
-    def __init__(
-        self, schema: object, _deferred_compiles: _mapping | None = None
-    ) -> None:
-        setattr(
-            self,
-            "__validate__",
-            _sequence(
-                [schema, ...], _deferred_compiles=_deferred_compiles
-            ).__validate__,
-        )
-
-
 class _Tuple(compiled_schema):
     def __init__(
         self, schema: tuple[object, ...], _deferred_compiles: _mapping | None = None
@@ -2181,16 +2203,89 @@ class _Tuple(compiled_schema):
         )
 
 
-class _Dict(compiled_schema):
+class _Mapping(compiled_schema):
+    type_schema: Type[Mapping[object, object]]
+    key: compiled_schema
+    value: compiled_schema
+    __name__: str
+
     def __init__(
-        self, schema: tuple[object, ...], _deferred_compiles: _mapping | None = None
+        self,
+        schema: tuple[object, ...],
+        type_schema: type,
+        _deferred_compiles: _mapping | None = None,
     ) -> None:
+        if len(schema) != 2:
+            raise SchemaError("Number of arguments of mapping is not two")
         k, v = schema
-        setattr(
-            self,
-            "__validate__",
-            _dict({k: v}, _deferred_compiles=_deferred_compiles).__validate__,
-        )
+        self.key = _compile(k, _deferred_compiles=_deferred_compiles)
+        self.value = _compile(v, _deferred_compiles=_deferred_compiles)
+        self.type_schema = type_schema
+        self.__name__ = _generic_name(type_schema, schema)
+
+    def __validate__(
+        self,
+        object_: object,
+        name: str = "object",
+        strict: bool = True,
+        subs: Mapping[str, object] = {},
+    ) -> str:
+
+        if not isinstance(object_, self.type_schema):
+            return _wrong_type_message(object_, name, self.__name__)
+
+        for k, v in object_.items():
+            _name = f"{name}[{repr(k)}]"
+            message = self.key.__validate__(k, name=str(k), strict=strict, subs=subs)
+            if message != "":
+                return f"{_name} is not in the schema"
+            message = self.value.__validate__(v, name=_name, strict=strict, subs=subs)
+            if message != "":
+                return message
+
+        return ""
+
+
+class _Container(compiled_schema):
+    type_schema: Type[Mapping[object, object]]
+    schema: compiled_schema
+    __name__: str
+
+    def __init__(
+        self,
+        schema: tuple[object, ...],
+        type_schema: type,
+        _deferred_compiles: _mapping | None = None,
+    ) -> None:
+        if len(schema) != 1:
+            raise SchemaError("Number of arguments of Generic type is not one")
+        self.schema = _compile(schema[0], _deferred_compiles=_deferred_compiles)
+        self.type_schema = type_schema
+        self.__name__ = _generic_name(type_schema, schema)
+
+    def __validate__(
+        self,
+        object_: object,
+        name: str = "object",
+        strict: bool = True,
+        subs: Mapping[str, object] = {},
+    ) -> str:
+
+        if not isinstance(object_, self.type_schema):
+            return _wrong_type_message(object_, name, self.type_schema.__name__)
+
+        try:
+            for i, o in enumerate(object_):
+                _name = f"{name}[{i}]"
+                message = self.schema.__validate__(
+                    o, name=_name, strict=strict, subs=subs
+                )
+                if message != "":
+                    return message
+        except Exception as e:
+            return _wrong_type_message(object_, name, self.__name__, explanation=str(e))
+
+        return ""
 
 
 class _NewType(compiled_schema):

{vtjson-2.1.4 → vtjson-2.1.6/src/vtjson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.4
+Version: 2.1.6
 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
@@ -163,16 +163,16 @@ 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`.
 
-## Validating dictionaries
+## Validating Mapping
 
-For a dictionary schema containing only `const keys` (i.e. keys corresponding to a `const schema`) the interpretation is obvious (see the introductory example above). Below we discuss the validation of an object against a dictionary schema in the general case.
+For a Mapping schema containing only `const keys` (i.e. keys corresponding to a `const schema`) the interpretation is obvious (see the introductory example above). Below we discuss the validation of an object against a Mapping schema in the general case.
 
-- First we verify that the object is also a dictionary. If not then validation fails.
+- First we verify that the type of the object is a subtype of the type of the schema. If not then validation fails.
 - We verify that all non-optional const keys of the schema are also keys of the object. If this is not the case then validation fails.
 - Now we make a list of all the keys of the schema (both optional and non-optional). The result will be called the `key list` below.
 - The object will pass validation if all its keys pass validation. We next discuss how to validate a particular key of the object.

{vtjson-2.1.4 → vtjson-2.1.6}/src/vtjson.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ LICENSE
 README.md
 pyproject.toml
 src/vtjson/__init__.py
+src/vtjson/py.typed
 src/vtjson/vtjson.py
 src/vtjson.egg-info/PKG-INFO
 src/vtjson.egg-info/SOURCES.txt

{vtjson-2.1.4 → vtjson-2.1.6}/tests/test_vtjson.py

@@ -4,8 +4,21 @@ import json
 import re
 import sys
 import unittest
+from collections.abc import Mapping, Sequence
 from datetime import datetime, timezone
-from typing import Any, Dict, List, NamedTuple, NewType, Tuple, Union
+from typing import (
+    Any,
+    Container,
+    Dict,
+    Generator,
+    List,
+    NamedTuple,
+    NewType,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
 from urllib.parse import urlparse
 
 import vtjson
@@ -1066,6 +1079,200 @@ class TestValidation(unittest.TestCase):
             validate(schema, object_)
         show(mc)
 
+    @unittest.skipUnless(
+        vtjson.supports_Generic_ABC,
+        "Generic base classes were introduced in Pythin 3.9",
+    )
+    def test_Container(self) -> None:
+
+        T = TypeVar("T")
+
+        class dumb(Container):  # type: ignore
+            def __contains__(a):  # type: ignore
+                return True
+
+            def __str__(b):  # type: ignore
+                return "dumb Container"
+
+        with self.assertRaises(ValidationError) as mc:
+            validate(Container[str], dumb())
+        show(mc)
+
+        if vtjson.supports_UnionType:
+            with self.assertRaises(ValidationError) as mc:
+                validate(Container[int | str], dumb())
+            show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            validate(Container[Union[int, str]], dumb())
+        show(mc)
+
+        class dummy(Sequence[T]):
+            L: Sequence[T]
+
+            def __init__(self, L: Sequence[T] = ()) -> None:
+                self.L = L
+
+            @overload
+            def __getitem__(self, index: int) -> T: ...
+
+            @overload
+            def __getitem__(self, index: slice) -> dummy[T]: ...
+
+            def __getitem__(self, index: int | slice) -> T | dummy[T]:
+                if isinstance(index, int):
+                    return self.L[index]
+                return dummy(self.L[index])
+
+            def __len__(self) -> int:
+                return len(self.L)
+
+        class dummy_ex(dummy[T]):
+            pass
+
+        schema: object
+        object_: object
+
+        object_ = dummy((1, 2))
+        schema = dummy((1, 2))
+        validate(schema, object_)
+
+        schema = dummy([1, 2])
+        validate(schema, object_)
+
+        with self.assertRaises(ValidationError) as mc:
+            object_ = [1, 2]
+            validate(schema, object_)
+        show(mc)
+
+        validate(schema, dummy_ex([1, 2]))
+
+        with self.assertRaises(ValidationError) as mc:
+            object_ = dummy(["a", "b"])
+            validate(schema, object_)
+        show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            object_ = dummy(["a", "b", None, "c"])
+            validate(schema, object_)
+        show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            schema = dummy(["a", int, ...])
+            object_ = dummy(["a", "c", 1])
+            validate(schema, object_)
+        show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            schema = dummy_ex((1, 2))
+            object_ = dummy((1, 2))
+            validate(schema, object_)
+        show(mc)
+        self.assertTrue("dummy_ex" in str(mc.exception))
+
+        schema = dummy[str]
+        object_ = dummy(("a", "b"))
+        validate(schema, object_)
+
+        object_ = dummy_ex(("a", "b"))
+        validate(schema, object_)
+
+        with self.assertRaises(ValidationError) as mc:
+            object_ = dummy((1, 2))
+            validate(schema, object_)
+        show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            schema = dummy_ex[str]
+            object_ = dummy(("a", "b"))
+            validate(schema, object_)
+        show(mc)
+        self.assertTrue("dummy_ex" in str(mc.exception))
+
+    @unittest.skipUnless(
+        vtjson.supports_Generic_ABC,
+        "Generic base classes were introduced in Pythin 3.9",
+    )
+    def test_Mapping(self) -> None:
+
+        S = TypeVar("S")
+        T = TypeVar("T")
+
+        class dummy(Mapping[S, T]):
+            L: Mapping[S, T]
+
+            def __init__(self, L: Mapping[S, T] = {}) -> None:
+                self.L = L
+
+            def __getitem__(self, key: S) -> T:
+                return self.L[key]
+
+            def __iter__(self) -> Generator[S]:
+                for key in self.L:
+                    yield key
+
+            def __len__(self) -> int:
+                return len(self.L)
+
+        class dummy_ex(dummy[S, T]):
+            pass
+
+        schema: object
+        object_: object
+
+        schema = dummy({1: 2})
+        object_ = dummy({1: 2})
+        validate(schema, object_)
+
+        with self.assertRaises(ValidationError) as mc:
+            object_ = [1, 2]
+            validate(schema, object_)
+        show(mc)
+
+        validate(schema, dummy_ex({1: 2}))
+
+        with self.assertRaises(ValidationError) as mc:
+            object_ = dummy(["a", "b"])  # type: ignore
+            validate(schema, object_)
+        show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            object_ = dummy({1: "b"})
+            validate(schema, object_)
+        show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            schema = dummy({"a": int})
+            object_ = dummy({"a": "c"})
+            validate(schema, object_)
+        show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            schema = dummy_ex({1: 2})
+            object_ = dummy({1: 2})
+            validate(schema, object_)
+        show(mc)
+        self.assertTrue("dummy_ex" in str(mc.exception))
+
+        schema = dummy[str, str]
+        object_ = dummy({"a": "b"})
+        validate(schema, object_)
+
+        object_ = dummy_ex({"a": "b"})
+        validate(schema, object_)
+
+        with self.assertRaises(ValidationError) as mc:
+            object_ = dummy({1: 2})
+            validate(schema, object_)
+        show(mc)
+
+        with self.assertRaises(ValidationError) as mc:
+            schema = dummy_ex[str, str]
+            object_ = dummy({"a": "b"})
+            validate(schema, object_)
+        show(mc)
+        self.assertTrue("dummy_ex" in str(mc.exception))
+
     def test_validate(self) -> None:
         schema: object
         object_: object
@@ -1114,7 +1321,7 @@ class TestValidation(unittest.TestCase):
                 object_: object,
                 name: str,
                 strict: bool,
-                subs: Dict[str, object],
+                subs: Mapping[str, object],
             ) -> str:
                 if not isinstance(object_, str):
                     return f"{name} (value:{object_}) is not of type str"
@@ -1788,6 +1995,11 @@ class TestValidation(unittest.TestCase):
         "Parametrized types were introduced in Python 3.9",
     )
     def test_generic_list(self) -> None:
+        schema: object
+        with self.assertRaises(SchemaError) as mc_:
+            schema = list[str, str]  # type: ignore
+            validate(schema, "")
+        show(mc_)
         schema = list[str]
         validate(schema, ["a", "b"])
         with self.assertRaises(ValidationError) as mc: