vtjson 2.1.9__tar.gz → 2.2.1__tar.gz

{vtjson-2.1.9/src/vtjson.egg-info → vtjson-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.9
+Version: 2.2.1
 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
@@ -130,4 +130,4 @@ class book_schema(TypedDict):
     year: Annotated[int, ge(1900)]
 ```
 
-For comprehensive documentation about `vtjson` see [https://www.cantate.be/vtjson](https://www.cantate.be/vtjson).
+For comprehensive documentation about `vtjson` see [https://www.cantate.be/vtjson](https://www.cantate.be/vtjson) (canonical reference) or [https://vtjson.readthedocs.io](https://vtjson.readthedocs.io).

{vtjson-2.1.9 → vtjson-2.2.1}/README.md

@@ -110,4 +110,4 @@ class book_schema(TypedDict):
     year: Annotated[int, ge(1900)]
 ```
 
-For comprehensive documentation about `vtjson` see [https://www.cantate.be/vtjson](https://www.cantate.be/vtjson).
+For comprehensive documentation about `vtjson` see [https://www.cantate.be/vtjson](https://www.cantate.be/vtjson) (canonical reference) or [https://vtjson.readthedocs.io](https://vtjson.readthedocs.io).

{vtjson-2.1.9 → vtjson-2.2.1}/src/vtjson/vtjson.py

@@ -22,6 +22,7 @@ from typing import (
     TypeVar,
     Union,
     cast,
+    overload,
 )
 
 try:
@@ -85,8 +86,6 @@ import dns.resolver
 import email_validator
 import idna
 
-T = TypeVar("T")
-
 
 def safe_cast(schema: Type[T], obj: Any) -> T:
     """
@@ -205,7 +204,7 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.1.9"
+__version__ = "2.2.1"
 
 
 @dataclass
@@ -273,13 +272,13 @@ def _get_type_hints(schema: object) -> dict[str, object]:
 
 def _to_dict(
     type_hints: Mapping[str, object], total: bool = True
-) -> dict[str | optional_key[str], object]:
-    d: dict[str | optional_key[str], object] = {}
+) -> dict[optional_key[str], object]:
+    d: dict[optional_key[str], object] = {}
     if not supports_Generics:
         raise SchemaError("Generic types are not supported")
     for k, v in type_hints.items():
         v_ = v
-        k_: str | optional_key[str] = k
+        k_ = optional_key(k, _optional=False)
         value_type = typing.get_origin(v)
         if supports_NotRequired and value_type in (Required, NotRequired):
             v_ = typing.get_args(v)[0]
@@ -320,6 +319,29 @@ def _c(s: object) -> str:
         return ret
 
 
+T = TypeVar("T")
+
+
+@overload
+def _canonize_key(key: str | optional_key[str]) -> optional_key[str]: ...
+
+
+@overload
+def _canonize_key(key: object) -> object: ...
+
+
+def _canonize_key(key: object) -> object:
+    if isinstance(key, str):
+        if len(key) > 0 and key[-1] == "?":
+            if not (len(key) > 2 and key[-2] == "\\"):
+                return optional_key(key[:-1])
+            else:
+                return optional_key(key[:-2] + "?", _optional=False)
+        else:
+            return optional_key(key, _optional=False)
+    return key
+
+
 def _wrong_type_message(
     obj: object,
     name: str,
@@ -395,22 +417,29 @@ K = TypeVar("K")
 class optional_key(Generic[K]):
     """
     Make a key in a Mapping schema optional. In the common case that the key
-      is a string, the same effect can be achieved by appending `?`.
+    is a string, the same effect can be achieved by appending `?`. If you
+    absolutely positively need a non-optional string key that ends in `?`
+    you can quote the `?` by preceding it with a backslash.
     """
 
     key: K
+    optional: bool
 
-    def __init__(self, key: K) -> None:
+    def __init__(self, key: K, _optional: bool = True) -> None:
         """
         :param key: the key to be made optional
+        :param _optional: if `False` create a mandatory key; this is normally
+          for internal use only
         """
         self.key = key
+        self.optional = _optional
 
     def __eq__(self, key: object) -> bool:
         if not isinstance(key, optional_key):
             return False
         k: object = key.key
-        return self.key == k
+        o: object = key.optional
+        return (self.key, key.optional) == (k, o)
 
     def __hash__(self) -> int:
         return hash(self.key)
@@ -1614,6 +1643,24 @@ class number(compiled_schema):
             return _wrong_type_message(obj, name, "number")
 
 
+class float_(compiled_schema):
+    """
+    Schema that only matches floats. Not ints.
+    """
+
+    def __validate__(
+        self,
+        obj: object,
+        name: str = "object",
+        strict: bool = True,
+        subs: Mapping[str, object] = {},
+    ) -> str:
+        if isinstance(obj, float):
+            return ""
+        else:
+            return _wrong_type_message(obj, name, "float_")
+
+
 class email(compiled_schema):
     """
     Checks if the object is a valid email address. This uses the package
@@ -2148,11 +2195,11 @@ class cond(wrapper):
 
 
 class _fields(compiled_schema):
-    d: dict[str | optional_key[str], compiled_schema]
+    d: dict[optional_key[str], compiled_schema]
 
     def __init__(
         self,
-        d: Mapping[str | optional_key[str], object],
+        d: Mapping[optional_key[str], object],
         _deferred_compiles: _mapping | None = None,
     ) -> None:
         self.d = {}
@@ -2167,9 +2214,14 @@ class _fields(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         for k, v in self.d.items():
-            name_ = f"{name}.{k}"
-            if not isinstance(k, optional_key) and not hasattr(obj, k):
-                return f"{name_} is missing"
+            name_ = f"{name}.{k.key}"
+            if not isinstance(k, optional_key):
+                if not hasattr(obj, k):
+                    return f"{name_} is missing"
+            elif not k.optional:
+                if not hasattr(obj, k.key):
+                    return f"{name_} is missing"
+
             if isinstance(k, optional_key):
                 k_ = k.key
             else:
@@ -2189,7 +2241,7 @@ class fields(wrapper):
     schemaN` respectively
     """
 
-    d: dict[str | optional_key[str], object]
+    d: dict[optional_key[str], object]
 
     def __init__(self, d: Mapping[str | optional_key[str], object]) -> None:
         """
@@ -2207,10 +2259,8 @@ class fields(wrapper):
                     f"key {repr(k)} in {repr(d)} is not an instance of"
                     " optional_key and not a string"
                 )
-            if isinstance(k, str) and k[-1] == "?":
-                self.d[optional_key(k[:-1])] = v
-            else:
-                self.d[k] = v
+            key_ = _canonize_key(k)
+            self.d[key_] = v
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _fields:
         return _fields(self.d, _deferred_compiles=_deferred_compiles)
@@ -2307,8 +2357,6 @@ class _type(compiled_schema):
         if math_numbers:
             if schema == float:
                 setattr(self, "__validate__", self.__validate_float__)
-            if schema == complex:
-                setattr(self, "__validate__", self.__validate_complex__)
         self.schema = schema
 
     def __validate__(
@@ -2341,19 +2389,6 @@ class _type(compiled_schema):
         else:
             return _wrong_type_message(obj, name, "float")
 
-    def __validate_complex__(
-        self,
-        obj: object,
-        name: str = "object",
-        strict: bool = True,
-        subs: Mapping[str, object] = {},
-    ) -> str:
-        # consider int, float as subtypes of complex
-        if isinstance(obj, (int, float, complex)):
-            return ""
-        else:
-            return _wrong_type_message(obj, name, "complex")
-
     def __str__(self) -> str:
         return self.schema.__name__
 
@@ -2512,13 +2547,13 @@ class _dict(compiled_schema):
         for k in schema:
             compiled_schema = _compile(schema[k], _deferred_compiles=_deferred_compiles)
             optional = True
-            if isinstance(k, optional_key):
-                key = k.key
-            elif isinstance(k, str) and len(k) > 0 and k[-1] == "?":
-                key = k[:-1]
+            key_ = _canonize_key(k)
+            if isinstance(key_, optional_key):
+                key = key_.key
+                optional = key_.optional
             else:
+                key = key_
                 optional = False
-                key = k
             c = _compile(key, _deferred_compiles=_deferred_compiles)
             if isinstance(c, _const):
                 if not optional:
@@ -2654,7 +2689,7 @@ class protocol(wrapper):
     which validate the corresponding fields in the object.
     """
 
-    type_dict: dict[str | optional_key[str], object]
+    type_dict: dict[optional_key[str], object]
     dict: bool
     __name__: str
 
@@ -2685,7 +2720,7 @@ class protocol(wrapper):
     ) -> compiled_schema:
         if not self.dict:
             return _set_name(
-                fields(self.type_dict),
+                _fields(self.type_dict),
                 self.__name__,
                 reason=True,
                 _deferred_compiles=_deferred_compiles,

{vtjson-2.1.9 → vtjson-2.2.1/src/vtjson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.9
+Version: 2.2.1
 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
@@ -130,4 +130,4 @@ class book_schema(TypedDict):
     year: Annotated[int, ge(1900)]
 ```
 
-For comprehensive documentation about `vtjson` see [https://www.cantate.be/vtjson](https://www.cantate.be/vtjson).
+For comprehensive documentation about `vtjson` see [https://www.cantate.be/vtjson](https://www.cantate.be/vtjson) (canonical reference) or [https://vtjson.readthedocs.io](https://vtjson.readthedocs.io).

{vtjson-2.1.9 → vtjson-2.2.1}/tests/test_vtjson.py

@@ -75,6 +75,7 @@ from vtjson import (
     email,
     fields,
     filter,
+    float_,
     ge,
     glob,
     gt,
@@ -303,6 +304,17 @@ class TestValidation(unittest.TestCase):
             object_ = {"a": 3}
             validate(schema, object_)
         show(mc)
+        schema = {r"a\?": str, "b": str}
+        with self.assertRaises(ValidationError) as mc:
+            object_ = {"b": "c"}
+            validate(schema, object_)
+        show(mc)
+        with self.assertRaises(ValidationError) as mc:
+            object_ = {"a": "c", "b": "d"}
+            validate(schema, object_)
+        show(mc)
+        object_ = {"a?": "c", "b": "d"}
+        validate(schema, object_)
 
         class fake_string:
             def __init__(self, s: str) -> None:
@@ -1872,7 +1884,7 @@ class TestValidation(unittest.TestCase):
         self.assertTrue("...}" in valid)
         self.assertTrue("TRUNCATED" in valid)
 
-    def test_int_float_complex(self) -> None:
+    def test_int_float(self) -> None:
         schema: object
         schema = int
         validate(schema, 1)
@@ -1885,10 +1897,11 @@ class TestValidation(unittest.TestCase):
         with self.assertRaises(ValidationError) as mc:
             validate(schema, 1.0 + 1.0j)
         show(mc)
-        schema = complex
-        validate(schema, 1)
+        schema = float_
+        with self.assertRaises(ValidationError) as mc:
+            validate(schema, 1)
+        show(mc)
         validate(schema, 1.0)
-        validate(schema, 1.0 + 1.0j)
 
     def test_float_equal(self) -> None:
         schema: object