vtjson 2.1.3__tar.gz → 2.1.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.3
+Version: 2.1.4
 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
@@ -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.3 → vtjson-2.1.4}/README.md

@@ -50,8 +50,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
@@ -170,7 +170,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.
@@ -236,6 +236,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.3 → vtjson-2.1.4}/src/vtjson/vtjson.py

@@ -115,7 +115,7 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.1.3"
+__version__ = "2.1.4"
 
 
 @dataclass
@@ -152,9 +152,10 @@ 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
 
 
@@ -1110,11 +1111,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__"):
@@ -2087,7 +2096,7 @@ class _set(compiled_schema):
         return str(self.schema_)
 
 
-class structural:
+class protocol:
     type_dict: dict[object, object]
     dict: bool
     __name__: str
@@ -2101,8 +2110,10 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.3
+Version: 2.1.4
 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
@@ -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.3 → vtjson-2.1.4}/tests/test_vtjson.py

@@ -5,7 +5,7 @@ import re
 import sys
 import unittest
 from datetime import datetime, timezone
-from typing import Any, Dict, List, NewType, Tuple, Union
+from typing import Any, Dict, List, NamedTuple, NewType, Tuple, Union
 from urllib.parse import urlparse
 
 import vtjson
@@ -79,6 +79,7 @@ from vtjson import (
     number,
     one_of,
     optional_key,
+    protocol,
     quote,
     regex,
     safe_cast,
@@ -86,7 +87,6 @@ from vtjson import (
     set_name,
     size,
     strict,
-    structural,
     time,
     union,
     url,
@@ -2045,7 +2045,39 @@ class TestValidation(unittest.TestCase):
 
         validate(dummy, w())
 
-    def test_structural(self) -> None:
+    def test_NamedTuple(self) -> None:
+        class dummy(NamedTuple):
+            b: int = 0
+            c: str = ""
+
+            def f(self, i: float) -> bool:
+                return i == i
+
+        class x(NamedTuple):
+            b: str = ""
+            c: str = ""
+
+        if not vtjson.supports_structural:
+            with self.assertRaises(SchemaError) as mc_:
+                compile(dummy)
+            show(mc_)
+            return
+
+        with self.assertRaises(ValidationError) as mc:
+            validate(dummy, x())
+        show(mc)
+        self.assertTrue("dummy" in str(mc.exception))
+
+        class w(NamedTuple):
+            b: int = 1
+            c: str = ""
+
+            def g(self) -> bool:
+                return True
+
+        validate(dummy, w())
+
+    def test_protocol(self) -> None:
         class dummy:
             b: int = 0
             c: str = ""
@@ -2055,11 +2087,19 @@ class TestValidation(unittest.TestCase):
 
         if not vtjson.supports_structural:
             with self.assertRaises(SchemaError) as mc_:
-                schema = structural(dummy)
+                schema = protocol(dummy)
             show(mc_)
             return
 
-        schema = structural(dummy)
+        with self.assertRaises(SchemaError) as mc_:
+            schema = protocol(dummy, dict=None)  # type: ignore
+        show(mc_)
+
+        with self.assertRaises(SchemaError) as mc_:
+            schema = protocol({})
+        show(mc_)
+
+        schema = protocol(dummy)
 
         class x:
             b: str = ""
@@ -2079,13 +2119,29 @@ class TestValidation(unittest.TestCase):
 
         validate(schema, w())
 
-        schema = structural(dummy, dict=True)
+        schema = protocol(dummy, dict=True)
         validate(schema, {"b": 1, "c": ""})
 
         with self.assertRaises(ValidationError):
             validate(schema, w())
         show(mc)
 
+        if sys.version_info >= (3, 11):
+
+            class dummy2:
+                # oh, horror
+                a: {"b": int}  # type: ignore # noqa: F821
+
+            class u:
+                def __init__(self, v: object) -> None:
+                    self.a = {"b": v}
+
+            validate(protocol(dummy2), u(5))
+
+            with self.assertRaises(ValidationError) as mc:
+                validate(protocol(dummy2), u(""))
+            show(mc)
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)