vtjson 2.2.2__py3-none-any.whl → 2.2.4__py3-none-any.whl

vtjson/vtjson.py

@@ -204,7 +204,7 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.2.2"
+__version__ = "2.2.4"
 
 
 @dataclass
@@ -323,7 +323,7 @@ T = TypeVar("T")
 
 
 @overload
-def _canonize_key(key: str | optional_key[str]) -> optional_key[str]: ...
+def _canonize_key(key: StringKeyType) -> optional_key[str]: ...
 
 
 @overload
@@ -445,6 +445,9 @@ class optional_key(Generic[K]):
         return hash(self.key)
 
 
+StringKeyType = TypeVar("StringKeyType", bound=Union[str, optional_key[str]])
+
+
 class _union(compiled_schema):
     schemas: list[compiled_schema]
 
@@ -725,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):
@@ -786,9 +789,8 @@ class _set_name(compiled_schema):
 
 class set_name(wrapper):
     """
-    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.
+    An object matches the schema `set_name(schema, name)` if it matches `schema`,
+    but the `name` argument will be used in non-validation messages.
     """
 
     reason: bool
@@ -799,11 +801,15 @@ class set_name(wrapper):
         """
         :param schema: the original schema
         :param name: name for use in non-validation messages
-        :param reason: indicates whether the original non-validation message
-          should be suppressed
+        :param reason: if `True` then the original non-validation message
+          will not be suppressed
         """
         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
@@ -1493,7 +1499,9 @@ def _compile(
         origin = object()
 
     ret: compiled_schema
-    if isinstance(schema, type) and issubclass(schema, compiled_schema):
+    if isinstance(schema, compiled_schema):
+        ret = schema
+    elif isinstance(schema, type) and issubclass(schema, compiled_schema):
         try:
             ret = schema()
         except Exception:
@@ -1504,8 +1512,6 @@ def _compile(
         ret = _validate_schema(schema)
     elif isinstance(schema, wrapper):
         ret = schema.__compile__(_deferred_compiles=_deferred_compiles)
-    elif isinstance(schema, compiled_schema):
-        ret = schema
     elif supports_TypedDict and typing.is_typeddict(schema):
         ret = _compile(
             protocol(schema, dict=True), _deferred_compiles=_deferred_compiles
@@ -2037,7 +2043,7 @@ class one_of(compiled_schema):
 class keys(compiled_schema):
     """
     This represents a dictionary containing all the keys in a collection of
-    keys
+    keys.
     """
 
     args: tuple[object, ...]
@@ -2199,12 +2205,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,
@@ -2234,23 +2241,22 @@ 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, ...,
-    schemaN` respectively
+    schemaN` respectively.
     """
 
-    d: dict[optional_key[str], object]
+    d: Mapping[StringKeyType, object]
 
-    def __init__(self, d: Mapping[str | optional_key[str], object]) -> None:
+    def __init__(self, d: Mapping[StringKeyType, object]) -> None:
         """
         :param d: a dictionary associating fields with schemas
 
         :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():
@@ -2259,8 +2265,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)
@@ -2682,6 +2687,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
@@ -2689,9 +2736,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):
         """
@@ -2704,34 +2750,14 @@ class protocol(wrapper):
         """
         if not isinstance(dict, bool):
             raise SchemaError("bool flag is not a bool")
-        type_hints = _get_type_hints(schema)
+
         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.2.dist-info → vtjson-2.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.2.2
+Version: 2.2.4
 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
@@ -78,7 +78,7 @@ class book_schema(TypedDict):
     year: int
 ```
 
-Attempting to validate the bad book would raise the same exception as before.
+Attempting to validate the bad book would raise a similar exception as before.
 
 Schemas can of course be more complicated and in particular they can be nested.
 Here is an example that shows more of the features of `vtjson`.
@@ -126,7 +126,7 @@ class person_schema(TypedDict):
 class book_schema(TypedDict):
     title: str
     authors: list[person_schema]
-    editor: NotRequired[list[person_schema]]
+    editor: NotRequired[person_schema]
     year: Annotated[int, ge(1900)]
 ```
 

vtjson-2.2.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+vtjson/__init__.py,sha256=oLX4JH6_R7dYtTiGfBG3pQGR21IArspifdmZilbuGOw,68
+vtjson/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vtjson/vtjson.py,sha256=-9xIldrpAY6Pf2PDtP9C5d81qb_9cRe4caxZ_Mk9Lj8,86872
+vtjson-2.2.4.dist-info/AUTHORS,sha256=qmxaXxaIO-YPNHJAZ0dcCrnPCs1x9ocbtMksiy4i80M,21
+vtjson-2.2.4.dist-info/LICENSE,sha256=n7xW-zX8xBLHzCdqWIMRuMzBD_ACLcNCwio0LEkKt1o,1077
+vtjson-2.2.4.dist-info/METADATA,sha256=6xmw9KzIW_gMfBAcRJXJlGDfIjv1UxhPJBgmDxCX5Z4,3958
+vtjson-2.2.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+vtjson-2.2.4.dist-info/top_level.txt,sha256=9DlSF3l63igcvnYPcj117F2hzOW4Nx0N-JBoW3jjBZM,7
+vtjson-2.2.4.dist-info/RECORD,,

vtjson-2.2.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-vtjson/__init__.py,sha256=oLX4JH6_R7dYtTiGfBG3pQGR21IArspifdmZilbuGOw,68
-vtjson/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vtjson/vtjson.py,sha256=_NcOEWxuqZiVJQSn0ZoI9eGxL5GsbtacWIb-BwTPzTY,86274
-vtjson-2.2.2.dist-info/AUTHORS,sha256=qmxaXxaIO-YPNHJAZ0dcCrnPCs1x9ocbtMksiy4i80M,21
-vtjson-2.2.2.dist-info/LICENSE,sha256=n7xW-zX8xBLHzCdqWIMRuMzBD_ACLcNCwio0LEkKt1o,1077
-vtjson-2.2.2.dist-info/METADATA,sha256=reeTR8tvW1KdngstUC6dTdOas_8NXHqdRroKLH_eUfU,3963
-vtjson-2.2.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-vtjson-2.2.2.dist-info/top_level.txt,sha256=9DlSF3l63igcvnYPcj117F2hzOW4Nx0N-JBoW3jjBZM,7
-vtjson-2.2.2.dist-info/RECORD,,