vtjson 2.1.5__tar.gz → 2.1.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.5
+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
@@ -168,11 +168,11 @@ A schema can be, in order of precedence:
 - 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.5 → vtjson-2.1.6}/README.md

@@ -148,11 +148,11 @@ A schema can be, in order of precedence:
 - 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.5 → 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, Mapping, Type, TypeVar, Union, cast
+from typing import Any, Callable, Container, Mapping, Type, TypeVar, Union, cast
 
 try:
     from typing import Literal
@@ -121,7 +121,7 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.1.5"
+__version__ = "2.1.6"
 
 
 @dataclass
@@ -153,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(
@@ -1141,14 +1151,14 @@ def _compile(
         )
     elif origin == tuple:
         ret = _Tuple(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
-    elif isinstance(origin, type) and issubclass(origin, Sequence):
-        ret = _List(
-            typing.get_args(schema)[0],
+    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, Mapping):
-        ret = _Dict(
+    elif isinstance(origin, type) and issubclass(origin, Container):
+        ret = _Container(
             typing.get_args(schema),
             type_schema=origin,
             _deferred_compiles=_deferred_compiles,
@@ -1169,7 +1179,7 @@ def _compile(
         ret = _sequence(schema, _deferred_compiles=_deferred_compiles)
     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)
@@ -1841,13 +1851,10 @@ class _sequence(compiled_schema):
     def __init__(
         self,
         schema: Sequence[object],
-        type_schema: type | None = None,
+        #        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.type_schema = type(schema)
         self.schema = [
             _compile(o, _deferred_compiles=_deferred_compiles)
             for o in schema
@@ -1980,13 +1987,9 @@ class _dict(compiled_schema):
     def __init__(
         self,
         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.type_schema = type(schema)
         self.min_keys = set()
         self.const_keys = set()
         self.other_keys = set()
@@ -2059,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(
@@ -2084,7 +2090,11 @@ class _set(compiled_schema):
         strict: bool = True,
         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,
@@ -2094,7 +2104,7 @@ class _set(compiled_schema):
         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)
@@ -2109,8 +2119,8 @@ class _set(compiled_schema):
         strict: bool = True,
         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)
@@ -2182,24 +2192,6 @@ class _Union(compiled_schema):
         )
 
 
-class _List(compiled_schema):
-    def __init__(
-        self,
-        schema: object,
-        type_schema: type | None = None,
-        _deferred_compiles: _mapping | None = None,
-    ) -> None:
-        setattr(
-            self,
-            "__validate__",
-            _sequence(
-                [schema, ...],
-                type_schema=type_schema,
-                _deferred_compiles=_deferred_compiles,
-            ).__validate__,
-        )
-
-
 class _Tuple(compiled_schema):
     def __init__(
         self, schema: tuple[object, ...], _deferred_compiles: _mapping | None = None
@@ -2211,21 +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, ...],
-        type_schema: type | None = None,
+        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}, type_schema=type_schema, _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.5 → vtjson-2.1.6/src/vtjson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.5
+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
@@ -168,11 +168,11 @@ A schema can be, in order of precedence:
 - 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.5 → vtjson-2.1.6}/tests/test_vtjson.py

@@ -8,6 +8,7 @@ from collections.abc import Mapping, Sequence
 from datetime import datetime, timezone
 from typing import (
     Any,
+    Container,
     Dict,
     Generator,
     List,
@@ -1082,10 +1083,30 @@ class TestValidation(unittest.TestCase):
         vtjson.supports_Generic_ABC,
         "Generic base classes were introduced in Pythin 3.9",
     )
-    def test_Sequence(self) -> None:
+    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]
 
@@ -1974,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: