vtjson 2.1.2__tar.gz → 2.1.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.2
+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
@@ -31,7 +31,7 @@ The following conventions are used:
 - As in typescript, a (string) key ending in `?` represents an optional key. The corresponding schema (the item the key points to) will only be used for validation when the key is present in the object that should be validated. A key can also be made optional by wrapping it as `optional_key(key)`.
 - If in a list/tuple the last entry is `...` (ellipsis) it means that the next to last entry will be repeated zero or more times. In this way generic types can be created. For example the schema `[str, ...]` represents a list of strings.
 
-As of version 2.1, a suitable adapted `vtjson` schema can be used as a Python type hint. Here is the above [example](https://github.com/vdbergh/vtjson/blob/main/docs/example2.md) rewritten in a way that is compatible with type hints. E.g. if one wants to ensure that a run object obtained via an api has the correct type one can do
+As of version 2.1, a suitable adapted `vtjson` schema can be used as a Python type hint. Here is the above [example](https://raw.githubusercontent.com/vdbergh/vtjson/refs/heads/main/docs/example2.md) rewritten in a way that is compatible with type hints. E.g. if one wants to ensure that a run object obtained via an api has the correct type one can do
 
 ```python
 from typing import assert_type
@@ -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.2 → vtjson-2.1.4}/README.md

@@ -11,7 +11,7 @@ The following conventions are used:
 - As in typescript, a (string) key ending in `?` represents an optional key. The corresponding schema (the item the key points to) will only be used for validation when the key is present in the object that should be validated. A key can also be made optional by wrapping it as `optional_key(key)`.
 - If in a list/tuple the last entry is `...` (ellipsis) it means that the next to last entry will be repeated zero or more times. In this way generic types can be created. For example the schema `[str, ...]` represents a list of strings.
 
-As of version 2.1, a suitable adapted `vtjson` schema can be used as a Python type hint. Here is the above [example](https://github.com/vdbergh/vtjson/blob/main/docs/example2.md) rewritten in a way that is compatible with type hints. E.g. if one wants to ensure that a run object obtained via an api has the correct type one can do
+As of version 2.1, a suitable adapted `vtjson` schema can be used as a Python type hint. Here is the above [example](https://raw.githubusercontent.com/vdbergh/vtjson/refs/heads/main/docs/example2.md) rewritten in a way that is compatible with type hints. E.g. if one wants to ensure that a run object obtained via an api has the correct type one can do
 
 ```python
 from typing import assert_type
@@ -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.2 → vtjson-2.1.4}/src/vtjson/vtjson.py

@@ -115,7 +115,7 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.1.2"
+__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.2 → vtjson-2.1.4/src/vtjson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.2
+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
@@ -31,7 +31,7 @@ The following conventions are used:
 - As in typescript, a (string) key ending in `?` represents an optional key. The corresponding schema (the item the key points to) will only be used for validation when the key is present in the object that should be validated. A key can also be made optional by wrapping it as `optional_key(key)`.
 - If in a list/tuple the last entry is `...` (ellipsis) it means that the next to last entry will be repeated zero or more times. In this way generic types can be created. For example the schema `[str, ...]` represents a list of strings.
 
-As of version 2.1, a suitable adapted `vtjson` schema can be used as a Python type hint. Here is the above [example](https://github.com/vdbergh/vtjson/blob/main/docs/example2.md) rewritten in a way that is compatible with type hints. E.g. if one wants to ensure that a run object obtained via an api has the correct type one can do
+As of version 2.1, a suitable adapted `vtjson` schema can be used as a Python type hint. Here is the above [example](https://raw.githubusercontent.com/vdbergh/vtjson/refs/heads/main/docs/example2.md) rewritten in a way that is compatible with type hints. E.g. if one wants to ensure that a run object obtained via an api has the correct type one can do
 
 ```python
 from typing import assert_type
@@ -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.2 → 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)