vtjson 2.2.3__tar.gz → 2.2.5__tar.gz

{vtjson-2.2.3/src/vtjson.egg-info → vtjson-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: vtjson
-Version: 2.2.3
+Version: 2.2.5
 Summary: An easy to use validation library compatible with Python type annotations
 Author-email: Michel Van den Bergh <michel.vandenbergh@uhasselt.be>
 Project-URL: Homepage, https://github.com/vdbergh/vtjson
@@ -17,6 +17,7 @@ Requires-Dist: email_validator
 Requires-Dist: idna
 Requires-Dist: python-magic
 Requires-Dist: typing_extensions
+Dynamic: license-file
 
 # vtjson
 

{vtjson-2.2.3 → vtjson-2.2.5}/src/vtjson/vtjson.py

@@ -204,7 +204,7 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.2.3"
+__version__ = "2.2.5"
 
 
 @dataclass
@@ -728,29 +728,29 @@ class set_label(wrapper):
         )
 
 
-class quote(compiled_schema):
+class _quote(compiled_schema):
+
+    def __init__(self, schema: object) -> None:
+        setattr(self, "__validate__", _const(schema, strict_eq=True).__validate__)
+
+
+class quote(wrapper):
     """
     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`.
     """
 
-    schema: _const
+    schema: object
 
     def __init__(self, schema: object) -> None:
         """
         :param schema: the schema to be quoted
         """
-        self.schema = _const(schema, strict_eq=True)
+        self.schema = schema
 
-    def __validate__(
-        self,
-        obj: object,
-        name: str = "object",
-        strict: bool = True,
-        subs: Mapping[str, object] = {},
-    ) -> str:
-        return self.schema.__validate__(obj, name=name, strict=strict, subs=subs)
+    def __compile__(self, _deferred_compiles: _mapping | None = None) -> _quote:
+        return _quote(self.schema)
 
 
 class _set_name(compiled_schema):
@@ -806,6 +806,10 @@ class set_name(wrapper):
         """
         if not isinstance(name, str):
             raise SchemaError(f"The name {_c(name)} is not a string")
+        if not isinstance(reason, bool):
+            raise SchemaError(
+                f"The parameter 'reason' (value:{repr(reason)}) is not a boolean"
+            )
         self.schema = schema
         self.name = name
         self.reason = reason
@@ -2171,6 +2175,7 @@ class _cond(compiled_schema):
 
 class cond(wrapper):
     """
+    Args is a list of tuples `(if_schema, then_schema)`.
     An object is successively validated against `if_schema1`, `if_schema2`,
     ... until a validation succeeds. When this happens the object should match
     the corresponding `then_schema`. If no `if_schema` succeeds then the
@@ -2201,12 +2206,13 @@ class _fields(compiled_schema):
 
     def __init__(
         self,
-        d: Mapping[optional_key[str], object],
+        d: Mapping[StringKeyType, object],
         _deferred_compiles: _mapping | None = None,
     ) -> None:
         self.d = {}
         for k, v in d.items():
-            self.d[k] = _compile(v, _deferred_compiles=_deferred_compiles)
+            key_ = _canonize_key(k)
+            self.d[key_] = _compile(v, _deferred_compiles=_deferred_compiles)
 
     def __validate__(
         self,
@@ -2236,14 +2242,15 @@ class _fields(compiled_schema):
         return ""
 
 
-class fields(wrapper):
+class fields(wrapper, Generic[StringKeyType]):
     """
-    Matches Python objects with attributes `field1, field2, ..., fieldN` whose
-    corresponding values should validate against `schema1, schema2, ...,
+    `d` is a dictionary `{"field1": schema1, ...}`.
+    This matches Python objects with attributes `field1, field2, ..., fieldN`
+    whose corresponding values should validate against `schema1, schema2, ...,
     schemaN` respectively.
     """
 
-    d: dict[optional_key[str], object]
+    d: Mapping[StringKeyType, object]
 
     def __init__(self, d: Mapping[StringKeyType, object]) -> None:
         """
@@ -2252,7 +2259,6 @@ class fields(wrapper):
         :raises SchemaError: exception thrown when the schema definition is
           found to contain an error
         """
-        self.d = {}
         if not isinstance(d, Mapping):
             raise SchemaError(f"{repr(d)} is not a Mapping")
         for k, v in d.items():
@@ -2261,8 +2267,7 @@ class fields(wrapper):
                     f"key {repr(k)} in {repr(d)} is not an instance of"
                     " optional_key and not a string"
                 )
-            key_ = _canonize_key(k)
-            self.d[key_] = v
+        self.d = d
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _fields:
         return _fields(self.d, _deferred_compiles=_deferred_compiles)
@@ -2303,16 +2308,16 @@ class _filter(compiled_schema):
             obj = self.filter(obj)
         except Exception as e:
             return (
-                f"Applying {self.filter_name} to {name} "
+                f"Applying {repr(self.filter_name)} to {name} "
                 f"(value: {_c(obj)}) failed: {str(e)}"
             )
         name = f"{self.filter_name}({name})"
-        return self.schema.__validate__(obj, name="object", strict=strict, subs=subs)
+        return self.schema.__validate__(obj, name=name, strict=strict, subs=subs)
 
 
 class filter(wrapper):
     """
-    Applies `callable` to the object and validates the result with `schema`.
+    Applies `filter` to the object and validates the result with `schema`.
     If the callable throws an exception then validation fails.
     """
 
@@ -2684,6 +2689,48 @@ class _set(compiled_schema):
         return str(self.schema_)
 
 
+class _protocol(compiled_schema):
+
+    def __init__(
+        self,
+        schema: object,
+        dict: bool = False,
+        _deferred_compiles: _mapping | None = None,
+    ) -> None:
+        type_hints = _get_type_hints(schema)
+        total = True
+        if hasattr(schema, "__total__") and isinstance(schema.__total__, bool):
+            total = schema.__total__
+        type_dict = _to_dict(type_hints, total=total)
+        if hasattr(schema, "__name__") and isinstance(schema.__name__, str):
+            name = schema.__name__
+        else:
+            name = "schema"
+
+        if not dict:
+            setattr(
+                self,
+                "__validate__",
+                _set_name(
+                    fields(type_dict),
+                    name,
+                    reason=True,
+                    _deferred_compiles=_deferred_compiles,
+                ).__validate__,
+            )
+        else:
+            setattr(
+                self,
+                "__validate__",
+                _set_name(
+                    type_dict,
+                    name,
+                    reason=True,
+                    _deferred_compiles=_deferred_compiles,
+                ).__validate__,
+            )
+
+
 class protocol(wrapper):
     """
     An object matches the schema `protocol(schema, dict=False)` if `schema` is
@@ -2691,9 +2738,8 @@ class protocol(wrapper):
     which validate the corresponding fields in the object.
     """
 
-    type_dict: dict[optional_key[str], object]
+    schema: object
     dict: bool
-    __name__: str
 
     def __init__(self, schema: object, dict: bool = False):
         """
@@ -2706,34 +2752,17 @@ class protocol(wrapper):
         """
         if not isinstance(dict, bool):
             raise SchemaError("bool flag is not a bool")
-        type_hints = _get_type_hints(schema)
+
+        if not hasattr(schema, "__annotations__"):
+            raise SchemaError("schema does not have type annotations")
+
         self.dict = dict
-        total = True
-        if hasattr(schema, "__total__") and isinstance(schema.__total__, bool):
-            total = schema.__total__
-        self.type_dict = _to_dict(type_hints, total=total)
-        if hasattr(schema, "__name__") and isinstance(schema.__name__, str):
-            self.__name__ = schema.__name__
-        else:
-            self.__name__ = "schema"
+        self.schema = schema
 
     def __compile__(
         self, _deferred_compiles: _mapping | None = None
     ) -> compiled_schema:
-        if not self.dict:
-            return _set_name(
-                fields(self.type_dict),
-                self.__name__,
-                reason=True,
-                _deferred_compiles=_deferred_compiles,
-            )
-        else:
-            return _set_name(
-                dict(self.type_dict),
-                self.__name__,
-                reason=True,
-                _deferred_compiles=_deferred_compiles,
-            )
+        return _protocol(self.schema, self.dict)
 
 
 class _Literal(compiled_schema):

{vtjson-2.2.3 → vtjson-2.2.5/src/vtjson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: vtjson
-Version: 2.2.3
+Version: 2.2.5
 Summary: An easy to use validation library compatible with Python type annotations
 Author-email: Michel Van den Bergh <michel.vandenbergh@uhasselt.be>
 Project-URL: Homepage, https://github.com/vdbergh/vtjson
@@ -17,6 +17,7 @@ Requires-Dist: email_validator
 Requires-Dist: idna
 Requires-Dist: python-magic
 Requires-Dist: typing_extensions
+Dynamic: license-file
 
 # vtjson
 

{vtjson-2.2.3 → vtjson-2.2.5}/tests/test_vtjson.py

@@ -941,6 +941,10 @@ class TestValidation(unittest.TestCase):
         self.assertTrue("datetime" in str(mc.exception))
         self.assertTrue("dummy" in str(mc.exception))
 
+        with self.assertRaises(SchemaError) as mc_:
+            set_name("a", "b", reason="c")  # type: ignore
+        show(mc_)
+
     def test_lax(self) -> None:
         schema: object
         object_: object
@@ -960,7 +964,6 @@ class TestValidation(unittest.TestCase):
     def test_make_type(self) -> None:
         schema: object
         object_: object
-        global url
         schema = {"a": 1}
         t = make_type(schema, "example", debug=True)
         self.assertTrue(t.__name__ == "example")
@@ -2310,6 +2313,7 @@ class TestValidation(unittest.TestCase):
         if not vtjson.supports_structural:
             with self.assertRaises(SchemaError) as mc_:
                 schema = protocol(dummy)
+                compile(schema)
             show(mc_)
             return