vtjson 2.2.6__tar.gz → 2.2.7__tar.gz

{vtjson-2.2.6/src/vtjson.egg-info → vtjson-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtjson
-Version: 2.2.6
+Version: 2.2.7
 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

{vtjson-2.2.6 → vtjson-2.2.7}/src/vtjson/vtjson.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import datetime
+import functools
+import inspect
 import ipaddress
 import math
 import pathlib
@@ -10,7 +12,7 @@ import types
 import typing
 import urllib.parse
 import warnings
-from collections.abc import Sequence, Set, Sized
+from collections.abc import Iterable, Sequence, Set, Sized
 from dataclasses import dataclass
 from typing import (
     Any,
@@ -204,7 +206,7 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.2.6"
+__version__ = "2.2.7"
 
 
 @dataclass
@@ -248,14 +250,79 @@ skip_first = Apply(skip_first=True)
 _dns_resolver: dns.resolver.Resolver | None = None
 
 
-def _generic_name(origin: type, args: tuple[object, ...]) -> str:
-    def to_name(c: object) -> str:
-        if hasattr(c, "__name__"):
-            return str(c.__name__)
+def _to_name(s: object) -> str:
+    if hasattr(s, "__name__"):
+        return str(s.__name__)
+    else:
+        if isinstance(s, str):
+            return repr(s)
+        elif s == Ellipsis:
+            return "..."
         else:
-            return str(c)
+            return str(s)
+
+
+def _generic_name(origin: type, args: tuple[object, ...]) -> str:
+    return _to_name(origin) + "[" + ",".join([_to_name(arg) for arg in args]) + "]"
+
+
+def _make_name(
+    type: type,
+    args: tuple[object, ...],
+    kw: dict[str, object],
+    defaults: dict[str, object] = {},
+) -> str:
+    arg_list = []
+    for a in args:
+        arg_list.append(_to_name(a))
+    for k, v in kw.items():
+        if k not in defaults or v != defaults[k]:
+            arg_list.append(f"{k}={_to_name(v)}")
+    if len(arg_list) == 0:
+        return _to_name(type)
+    else:
+        return f"{_to_name(type)}({','.join(arg_list)})"
+
+
+C = TypeVar("C")
+
+
+def _set__name__(c: type[C]) -> type[C]:
+    defaults = {}
+    a = inspect.getfullargspec(c.__init__)
+    a_defaults: tuple[object, ...] = ()
+    if a.defaults is not None:
+        a_defaults = a.defaults
+
+    if a is None or a.args is None:
+        raise Exception(f"Could not get signature of {c.__name__}")
+    start = len(a.args) - len(a_defaults)
+    for i in range(start, len(a.args)):
+        defaults[a.args[i]] = a_defaults[i - start]
+    __init__org = c.__init__
+
+    @functools.wraps(c.__init__)
+    def __init__wrapper(self: C, *args: object, **kw: object) -> None:
+        setattr(
+            self, "__name__", _make_name(self.__class__, args, kw, defaults=defaults)
+        )
+        return __init__org(self, *args, **kw)
+
+    @functools.wraps(c.__str__)
+    def __str__(self: C) -> str:
+        assert hasattr(self, "__name__")
+        return str(self.__name__)
+
+    @functools.wraps(c.__repr__)
+    def __repr__(self: C) -> str:
+        assert hasattr(self, "__name__")
+        return str(self.__name__)
 
-    return to_name(origin) + "[" + ",".join([to_name(arg) for arg in args]) + "]"
+    setattr(c, "__init__", __init__wrapper)
+    setattr(c, "__str__", __str__)
+    setattr(c, "__repr__", __repr__)
+
+    return c
 
 
 def _get_type_hints(schema: object) -> dict[str, object]:
@@ -414,6 +481,7 @@ def make_type(
 K = TypeVar("K")
 
 
+@_set__name__
 class optional_key(Generic[K]):
     """
     Make a key in a Mapping schema optional. In the common case that the key
@@ -424,6 +492,7 @@ class optional_key(Generic[K]):
 
     key: K
     optional: bool
+    __name__: str
 
     def __init__(self, key: K, _optional: bool = True) -> None:
         """
@@ -445,6 +514,13 @@ class optional_key(Generic[K]):
         return hash(self.key)
 
 
+#    def __str__(self) -> str:
+#        return self.__name__
+#
+#    def __repr__(self) -> str:
+#        return self.__name__
+
+
 StringKeyType = TypeVar("StringKeyType", bound=Union[str, optional_key[str]])
 
 
@@ -823,6 +899,7 @@ class set_name(wrapper):
         )
 
 
+@_set__name__
 class regex(compiled_schema):
     """
     This matches the strings which match the given pattern.
@@ -857,10 +934,6 @@ class regex(compiled_schema):
             if not isinstance(name, str):
                 raise SchemaError(f"The regex name {_c(name)} is not a string")
             self.__name__ = name
-        else:
-            _flags = "" if flags == 0 else f", flags={flags}"
-            _fullmatch = "" if fullmatch else ", fullmatch=False"
-            self.__name__ = f"regex({repr(regex)}{_fullmatch}{_flags})"
 
         try:
             self.pattern = re.compile(regex, flags)
@@ -878,7 +951,9 @@ class regex(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a string"
+            )
         try:
             if self.fullmatch and self.pattern.fullmatch(obj):
                 return ""
@@ -889,6 +964,7 @@ class regex(compiled_schema):
         return _wrong_type_message(obj, name, self.__name__)
 
 
+@_set__name__
 class glob(compiled_schema):
     """
     Unix style filename matching. This is implemented using
@@ -910,9 +986,7 @@ class glob(compiled_schema):
 
         self.pattern = pattern
 
-        if name is None:
-            self.__name__ = f"glob({repr(pattern)})"
-        else:
+        if name is not None:
             self.__name__ = name
 
         try:
@@ -931,7 +1005,9 @@ class glob(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a string"
+            )
         try:
             if pathlib.PurePath(obj).match(self.pattern):
                 return ""
@@ -941,6 +1017,7 @@ class glob(compiled_schema):
             return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
+@_set__name__
 class magic(compiled_schema):
     """
     Checks if a buffer (for example a string or a byte array) has the given
@@ -966,9 +1043,7 @@ class magic(compiled_schema):
 
         self.mime_type = mime_type
 
-        if name is None:
-            self.__name__ = f"magic({repr(mime_type)})"
-        else:
+        if name is not None:
             self.__name__ = name
 
     def __validate__(
@@ -979,7 +1054,12 @@ class magic(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, (str, bytes)):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj,
+                name,
+                self.__name__,
+                explanation=f"{_c(obj)} is not a string nor bytes",
+            )
         try:
             objmime_type = magic_.from_buffer(obj, mime=True)
         except Exception as e:
@@ -994,6 +1074,7 @@ class magic(compiled_schema):
         return ""
 
 
+@_set__name__
 class div(compiled_schema):
     """
     This matches the integers `x` such that `(x - remainder) % divisor` == 0.
@@ -1024,13 +1105,7 @@ class div(compiled_schema):
         self.divisor = divisor
         self.remainder = remainder
 
-        if name is None:
-            _divisor = str(divisor)
-            _remainder = ""
-            if remainder != 0:
-                _remainder = "," + str(remainder)
-            self.__name__ = f"div({_divisor+_remainder})"
-        else:
+        if name is not None:
             self.__name__ = name
 
     def __validate__(
@@ -1041,13 +1116,16 @@ class div(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, int):
-            return _wrong_type_message(obj, name, "int")
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not an integer"
+            )
         elif (obj - self.remainder) % self.divisor == 0:
             return ""
         else:
             return _wrong_type_message(obj, name, self.__name__)
 
 
+@_set__name__
 class close_to(compiled_schema):
     """
     This matches the real numbers that are close to `x` in the sense of
@@ -1087,9 +1165,6 @@ class close_to(compiled_schema):
                 )
             self.kw["abs_tol"] = abs_tol
 
-        kwl = [str(x)] + [f"{k}={v}" for (k, v) in self.kw.items()]
-        kwl_ = ",".join(kwl)
-        self.__name__ = f"close_to({kwl_})"
         self.x = x
 
     def __validate__(
@@ -1100,19 +1175,23 @@ class close_to(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, (float, int)):
-            return _wrong_type_message(obj, name, "number")
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not an integer"
+            )
         elif math.isclose(obj, self.x, **self.kw):
             return ""
         else:
             return _wrong_type_message(obj, name, self.__name__)
 
 
+@_set__name__
 class gt(compiled_schema):
     """
     This checks if `object > lb`.
     """
 
     lb: comparable
+    __name__: str
 
     def __init__(self, lb: comparable) -> None:
         """
@@ -1148,12 +1227,14 @@ class gt(compiled_schema):
             return f"{self.message(name, obj)}: {str(e)}"
 
 
+@_set__name__
 class ge(compiled_schema):
     """
     This checks if `object >= lb`.
     """
 
     lb: comparable
+    __name__: str
 
     def __init__(self, lb: comparable) -> None:
         """
@@ -1189,12 +1270,14 @@ class ge(compiled_schema):
             return f"{self.message(name, obj)}: {str(e)}"
 
 
+@_set__name__
 class lt(compiled_schema):
     """
     This checks if `object < ub`.
     """
 
     ub: comparable
+    __name__: str
 
     def __init__(self, ub: comparable) -> None:
         """
@@ -1230,12 +1313,14 @@ class lt(compiled_schema):
             return f"{self.message(name, obj)}: {str(e)}"
 
 
+@_set__name__
 class le(compiled_schema):
     """
     This checks if `object <= ub`.
     """
 
     ub: comparable
+    __name__: str
 
     def __init__(self, ub: comparable) -> None:
         """
@@ -1271,6 +1356,7 @@ class le(compiled_schema):
             return f"{self.message(name, obj)}: {str(e)}"
 
 
+@_set__name__
 class interval(compiled_schema):
     """
     This checks if `lb <= object <= ub`, provided the comparisons make sense.
@@ -1278,6 +1364,7 @@ class interval(compiled_schema):
 
     lb_s: str
     ub_s: str
+    __name__: str
 
     def __init__(
         self,
@@ -1346,6 +1433,7 @@ class interval(compiled_schema):
             setattr(self, "__validate__", anything().__validate__)
 
 
+@_set__name__
 class size(compiled_schema):
     """
     Matches the objects (which support `len()` such as strings or lists) whose
@@ -1353,6 +1441,7 @@ class size(compiled_schema):
     """
 
     interval_: interval
+    __name__: str
 
     def __init__(self, lb: int, ub: int | types.EllipsisType | None = None) -> None:
         """
@@ -1625,11 +1714,14 @@ def validate(
 # Some predefined schemas
 
 
+@_set__name__
 class number(compiled_schema):
     """
     A deprecated alias for `float`.
     """
 
+    __name__: str
+
     def __init__(self) -> None:
         warnings.warn(
             "The schema 'number' is deprecated. Use 'float' instead.",
@@ -1646,14 +1738,20 @@ class number(compiled_schema):
         if isinstance(obj, (int, float)):
             return ""
         else:
-            return _wrong_type_message(obj, name, "number")
+            return _wrong_type_message(obj, name, self.__name__)
 
 
+@_set__name__
 class float_(compiled_schema):
     """
     Schema that only matches floats. Not ints.
     """
 
+    __name__: str
+
+    def __init__(self) -> None:
+        pass
+
     def __validate__(
         self,
         obj: object,
@@ -1664,9 +1762,10 @@ class float_(compiled_schema):
         if isinstance(obj, float):
             return ""
         else:
-            return _wrong_type_message(obj, name, "float_")
+            return _wrong_type_message(obj, name, self.__name__)
 
 
+@_set__name__
 class email(compiled_schema):
     """
     Checks if the object is a valid email address. This uses the package
@@ -1675,6 +1774,7 @@ class email(compiled_schema):
     """
 
     kw: dict[str, Any]
+    __name__: str
 
     def __init__(self, **kw: Any) -> None:
         """
@@ -1695,14 +1795,17 @@ class email(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, "email", f"{_c(obj)} is not a string")
+            return _wrong_type_message(
+                obj, name, self.__name__, f"{_c(obj)} is not a string"
+            )
         try:
             email_validator.validate_email(obj, **self.kw)
             return ""
         except Exception as e:
-            return _wrong_type_message(obj, name, "email", str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
+@_set__name__
 class ip_address(compiled_schema):
     """
     Matches ip addresses of the specified version which can be 4, 6 or None.
@@ -1719,10 +1822,7 @@ class ip_address(compiled_schema):
         """
         if version is not None and version not in (4, 6):
             raise SchemaError("version is not 4 or 6")
-        if version is None:
-            self.__name__ = "ip_address"
-        else:
-            self.__name__ = f"ip_address(version={version})"
+
         if version == 4:
             self.method = ipaddress.IPv4Address
         elif version == 6:
@@ -1738,7 +1838,12 @@ class ip_address(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, (int, str, bytes)):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj,
+                name,
+                self.__name__,
+                explanation=f"{_c(obj)} is not a string, an int or bytes",
+            )
         try:
             self.method(obj)
         except ValueError as e:
@@ -1746,6 +1851,7 @@ class ip_address(compiled_schema):
         return ""
 
 
+@_set__name__
 class regex_pattern(compiled_schema):
     """
     Matches valid regular expression patterns
@@ -1754,7 +1860,7 @@ class regex_pattern(compiled_schema):
     __name__: str
 
     def __init__(self) -> None:
-        self.__name__ = "regex_pattern"
+        pass
 
     def __validate__(
         self,
@@ -1764,7 +1870,9 @@ class regex_pattern(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a string"
+            )
         try:
             re.compile(obj)
         except re.error as e:
@@ -1772,11 +1880,60 @@ class regex_pattern(compiled_schema):
         return ""
 
 
+@_set__name__
+class unique(compiled_schema):
+    """
+    Matches containers whose entries do not repeat. We first attempt to convert the
+    object to a set and check its size. If this does not work then we check the
+    entries of the object one by one (this is a quadratic algorithm).
+    """
+
+    __name__: str
+
+    def __init__(self) -> None:
+        pass
+
+    def __validate__(
+        self,
+        obj: object,
+        name: str = "object",
+        strict: bool = True,
+        subs: Mapping[str, object] = {},
+    ) -> str:
+        if not isinstance(obj, Iterable):
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not iterable"
+            )
+        try:
+            if isinstance(obj, Sized):
+                if len(set(obj)) == len(obj):
+                    return ""
+        except Exception:
+            pass
+        try:
+            object_list = []
+            for o in obj:
+                if o in object_list:
+                    return _wrong_type_message(
+                        obj, name, self.__name__, explanation=f"{_c(o)} is repeated"
+                    )
+                object_list.append(o)
+        except Exception as e:
+            return _wrong_type_message(obj, name, self.__name__, explanation=str(e))
+        return ""
+
+
+@_set__name__
 class url(compiled_schema):
     """
     Matches valid urls.
     """
 
+    __name__: str
+
+    def __init__(self) -> None:
+        pass
+
     def __validate__(
         self,
         obj: object,
@@ -1785,13 +1942,16 @@ class url(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, "url")
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a string"
+            )
         result = urllib.parse.urlparse(obj)
         if all([result.scheme, result.netloc]):
             return ""
-        return _wrong_type_message(obj, name, "url")
+        return _wrong_type_message(obj, name, self.__name__)
 
 
+@_set__name__
 class date_time(compiled_schema):
     """
     Without argument this represents an ISO 8601 date-time. The `format`
@@ -1806,10 +1966,6 @@ class date_time(compiled_schema):
         :param format: format string for `strftime`
         """
         self.format = format
-        if format is not None:
-            self.__name__ = f"date_time({repr(format)})"
-        else:
-            self.__name__ = "date_time"
 
     def __validate__(
         self,
@@ -1819,7 +1975,9 @@ class date_time(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a string"
+            )
         if self.format is not None:
             try:
                 datetime.datetime.strptime(obj, self.format)
@@ -1833,11 +1991,17 @@ class date_time(compiled_schema):
         return ""
 
 
+@_set__name__
 class date(compiled_schema):
     """
     Matches an ISO 8601 date.
     """
 
+    __name__: str
+
+    def __init__(self) -> None:
+        pass
+
     def __validate__(
         self,
         obj: object,
@@ -1846,19 +2010,27 @@ class date(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, "date")
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a string"
+            )
         try:
             datetime.date.fromisoformat(obj)
         except Exception as e:
-            return _wrong_type_message(obj, name, "date", str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
         return ""
 
 
+@_set__name__
 class time(compiled_schema):
     """
     Matches an ISO 8601 time.
     """
 
+    __name__: str
+
+    def __init__(self) -> None:
+        pass
+
     def __validate__(
         self,
         obj: object,
@@ -1867,19 +2039,27 @@ class time(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, "date")
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a string"
+            )
         try:
             datetime.time.fromisoformat(obj)
         except Exception as e:
-            return _wrong_type_message(obj, name, "time", str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
         return ""
 
 
+@_set__name__
 class nothing(compiled_schema):
     """
     Matches nothing.
     """
 
+    __name__: str
+
+    def __init__(self) -> None:
+        pass
+
     def __validate__(
         self,
         obj: object,
@@ -1887,14 +2067,20 @@ class nothing(compiled_schema):
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        return _wrong_type_message(obj, name, "nothing")
+        return _wrong_type_message(obj, name, self.__name__)
 
 
+@_set__name__
 class anything(compiled_schema):
     """
     Matchess anything.
     """
 
+    __name__: str
+
+    def __init__(self) -> None:
+        pass
+
     def __validate__(
         self,
         obj: object,
@@ -1905,6 +2091,7 @@ class anything(compiled_schema):
         return ""
 
 
+@_set__name__
 class domain_name(compiled_schema):
     """
     Checks if the object is a valid domain name.
@@ -1923,16 +2110,6 @@ class domain_name(compiled_schema):
         self.re_ascii = re.compile(r"[\x00-\x7F]*")
         self.ascii_only = ascii_only
         self.resolve = resolve
-        arg_string = ""
-        if not ascii_only:
-            arg_string += ", ascii_only=False"
-        if resolve:
-            arg_string += ", resolve=True"
-        if arg_string != "":
-            arg_string = arg_string[2:]
-        self.__name__ = (
-            "domain_name" if not arg_string else f"domain_name({arg_string})"
-        )
 
     def __validate__(
         self,
@@ -1942,7 +2119,9 @@ class domain_name(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, str):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a string"
+            )
         if self.ascii_only:
             if not self.re_ascii.fullmatch(obj):
                 return _wrong_type_message(
@@ -1961,6 +2140,7 @@ class domain_name(compiled_schema):
         return ""
 
 
+@_set__name__
 class at_least_one_of(compiled_schema):
     """
     This represents a dictionary with a least one key among a collection of
@@ -1975,8 +2155,6 @@ class at_least_one_of(compiled_schema):
         :param args: a collection of keys
         """
         self.args = args
-        args_s = [repr(a) for a in args]
-        self.__name__ = f"{self.__class__.__name__}({','.join(args_s)})"
 
     def __validate__(
         self,
@@ -1986,7 +2164,9 @@ class at_least_one_of(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, Mapping):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a Mapping"
+            )
         try:
             if any([a in obj for a in self.args]):
                 return ""
@@ -1996,6 +2176,7 @@ class at_least_one_of(compiled_schema):
             return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
+@_set__name__
 class at_most_one_of(compiled_schema):
     """
     This represents an dictionary with at most one key among a collection of
@@ -2010,8 +2191,6 @@ class at_most_one_of(compiled_schema):
         :param args: a collection of keys
         """
         self.args = args
-        args_s = [repr(a) for a in args]
-        self.__name__ = f"{self.__class__.__name__}({','.join(args_s)})"
 
     def __validate__(
         self,
@@ -2021,7 +2200,9 @@ class at_most_one_of(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, Mapping):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a Mapping"
+            )
         try:
             if sum([a in obj for a in self.args]) <= 1:
                 return ""
@@ -2031,6 +2212,7 @@ class at_most_one_of(compiled_schema):
             return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
+@_set__name__
 class one_of(compiled_schema):
     """
     This represents a dictionary with exactly one key among a collection of
@@ -2045,8 +2227,6 @@ class one_of(compiled_schema):
         :param args: a collection of keys
         """
         self.args = args
-        args_s = [repr(a) for a in args]
-        self.__name__ = f"{self.__class__.__name__}({','.join(args_s)})"
 
     def __validate__(
         self,
@@ -2056,7 +2236,9 @@ class one_of(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, Mapping):
-            return _wrong_type_message(obj, name, self.__name__)
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a Mapping"
+            )
         try:
             if sum([a in obj for a in self.args]) == 1:
                 return ""
@@ -2066,6 +2248,7 @@ class one_of(compiled_schema):
             return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
+@_set__name__
 class keys(compiled_schema):
     """
     This represents a dictionary containing all the keys in a collection of
@@ -2073,6 +2256,7 @@ class keys(compiled_schema):
     """
 
     args: tuple[object, ...]
+    __name__: str
 
     def __init__(self, *args: object) -> None:
         """
@@ -2088,7 +2272,9 @@ class keys(compiled_schema):
         subs: Mapping[str, object] = {},
     ) -> str:
         if not isinstance(obj, Mapping):
-            return _wrong_type_message(obj, name, "Mapping")  # TODO: __name__
+            return _wrong_type_message(
+                obj, name, self.__name__, explanation=f"{_c(obj)} is not a Mapping"
+            )
         for k in self.args:
             if k not in obj:
                 return f"{name}[{repr(k)}] is missing"
@@ -2268,6 +2454,7 @@ class _fields(compiled_schema):
         return ""
 
 
+@_set__name__
 class fields(wrapper, Generic[StringKeyType]):
     """
     `d` is a dictionary `{"field1": schema1, ...}`.
@@ -2277,6 +2464,7 @@ class fields(wrapper, Generic[StringKeyType]):
     """
 
     d: Mapping[StringKeyType, object]
+    __name__: str
 
     def __init__(self, d: Mapping[StringKeyType, object]) -> None:
         """

{vtjson-2.2.6 → vtjson-2.2.7/src/vtjson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtjson
-Version: 2.2.6
+Version: 2.2.7
 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

{vtjson-2.2.6 → vtjson-2.2.7}/tests/test_vtjson.py

@@ -104,6 +104,7 @@ from vtjson import (
     strict,
     time,
     union,
+    unique,
     url,
     validate,
 )
@@ -111,7 +112,7 @@ from vtjson import (
 
 def show(mc: Any) -> None:
     exception = mc.exception
-    print(f"{exception.__class__.__name__}: {str(mc.exception)}")
+    print(f"{exception.__class__.__name__}: {str(mc.exception)}", flush=True)
 
 
 class TestValidation(unittest.TestCase):
@@ -212,6 +213,10 @@ class TestValidation(unittest.TestCase):
             object_ = "hello.doc"
             validate(schema, object_)
         show(mc)
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
         with self.assertRaises(SchemaError) as mc_:
             schema = glob({})  # type: ignore
         show(mc_)
@@ -404,6 +409,10 @@ class TestValidation(unittest.TestCase):
         schema = close_to(1.0)
         validate(schema, 1.0)
 
+        with self.assertRaises(ValidationError) as mc:
+            validate(schema, "1.0")
+        show(mc)
+
         with self.assertRaises(ValidationError) as mc:
             validate(schema, 1.1)
         show(mc)
@@ -423,6 +432,10 @@ class TestValidation(unittest.TestCase):
         validate(schema, object_)
         object_ = {"cat": None}
         validate(schema, object_)
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
         with self.assertRaises(ValidationError) as mc:
             object_ = {"cat": None, "dog": None}
             validate(schema, object_)
@@ -474,6 +487,10 @@ class TestValidation(unittest.TestCase):
         schema = keys("a", "b")
         object_ = {"a": 1, "b": 2}
         validate(schema, object_)
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
         with self.assertRaises(ValidationError) as mc:
             object_ = {"a": 1}
             validate(schema, object_)
@@ -761,6 +778,11 @@ class TestValidation(unittest.TestCase):
     def test_date_time(self) -> None:
         schema: object
         object_: object
+        with self.assertRaises(ValidationError) as mc:
+            schema = date_time
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
         with self.assertRaises(ValidationError) as mc:
             schema = date_time
             object_ = "2000-30-30"
@@ -796,6 +818,10 @@ class TestValidation(unittest.TestCase):
         object_ = "2023-10-10"
         validate(schema, object_)
 
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
         with self.assertRaises(ValidationError) as mc:
             object_ = "2023-10-10T01:01:01"
             validate(schema, object_)
@@ -808,6 +834,10 @@ class TestValidation(unittest.TestCase):
         object_ = "01:01:01"
         validate(schema, object_)
 
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
         with self.assertRaises(ValidationError) as mc:
             object_ = "2023-10-10T01:01:01"
             validate(schema, object_)
@@ -1386,6 +1416,12 @@ class TestValidation(unittest.TestCase):
             compile(schema)
         show(cm_)
 
+        ip_address = regex(r"(?:[\d]+\.){3}(?:[\d]+)")
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(ip_address, object_)
+        show(mc)
+
         ip_address = regex(r"(?:[\d]+\.){3}(?:[\d]+)", name="ip_address")
         with self.assertRaises(ValidationError) as mc:
             object_ = 123
@@ -1788,6 +1824,11 @@ class TestValidation(unittest.TestCase):
         object_ = {"url": "https://user:pass@google.com?search=chatgpt"}
         validate(schema, object_)
 
+        with self.assertRaises(ValidationError) as mc:
+            object_ = {"url": 123}
+            validate(schema, object_)
+        show(mc)
+
         with self.assertRaises(ValidationError) as mc:
             object_ = {"url": "google.com"}
             validate(schema, object_)
@@ -1800,6 +1841,10 @@ class TestValidation(unittest.TestCase):
         object_ = "www.example.com"
         validate(schema, object_)
 
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
         with self.assertRaises(ValidationError) as mc:
             object_ = "www.éxample.com"
             validate(schema, object_)
@@ -1849,6 +1894,10 @@ class TestValidation(unittest.TestCase):
         schema: object
         object_: object
         schema = regex_pattern
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
         with self.assertRaises(ValidationError) as mc:
             object_ = "(("
             validate(schema, object_)
@@ -1856,6 +1905,26 @@ class TestValidation(unittest.TestCase):
         object_ = ".*"
         validate(schema, object_)
 
+    def test_unique(self) -> None:
+        schema = unique
+        object_: object
+        with self.assertRaises(ValidationError) as mc:
+            object_ = 123
+            validate(schema, object_)
+        show(mc)
+        with self.assertRaises(ValidationError) as mc:
+            object_ = [1, 2, 3, 2]
+            validate(schema, object_)
+        show(mc)
+        with self.assertRaises(ValidationError) as mc:
+            object_ = [[1], [2], [3], [2]]
+            validate(schema, object_)
+        show(mc)
+        object_ = [1, 2, 3]
+        validate(schema, object_)
+        object_ = [[1], [2], [3]]
+        validate(schema, object_)
+
     def test_truncation(self) -> None:
         schema: object
         object_: object
@@ -2380,6 +2449,131 @@ class TestValidation(unittest.TestCase):
                 validate(protocol(dummy2), u(""))
             show(mc)
 
+    def test_name(self) -> None:
+        schema: object
+
+        schema = regex("abc", name="cba")
+        self.assertEqual(schema.__name__, "cba")
+        schema = regex("abc")
+        self.assertEqual(schema.__name__, "regex('abc')")
+        schema = regex("abc", fullmatch=False)
+        self.assertEqual(schema.__name__, "regex('abc',fullmatch=False)")
+        schema = regex("abc", fullmatch=True)
+        self.assertEqual(schema.__name__, "regex('abc')")
+        schema = regex("abc", fullmatch=False, flags=re.ASCII | re.MULTILINE)
+        self.assertEqual(
+            schema.__name__, "regex('abc',fullmatch=False,flags=re.ASCII|re.MULTILINE)"
+        )
+        schema = regex("abc", fullmatch=False, flags=0)
+        self.assertEqual(schema.__name__, "regex('abc',fullmatch=False)")
+
+        schema = glob("*.txt", "text_file")
+        self.assertEqual(schema.__name__, "text_file")
+        schema = glob("*.txt")
+        self.assertEqual(schema.__name__, "glob('*.txt')")
+
+        schema = div(2, name="even")
+        self.assertEqual(schema.__name__, "even")
+        schema = div(2)
+        self.assertEqual(schema.__name__, "div(2)")
+        schema = div(2, 1)
+        self.assertEqual(schema.__name__, "div(2,1)")
+
+        schema = close_to(0.75)
+        self.assertEqual(schema.__name__, "close_to(0.75)")
+
+        schema = email
+        self.assertEqual(schema.__name__, "email")
+
+        schema = ip_address
+        self.assertEqual(schema.__name__, "ip_address")
+        schema = ip_address(version=4)
+        self.assertEqual(schema.__name__, "ip_address(version=4)")
+
+        schema = regex_pattern
+        self.assertEqual(schema.__name__, "regex_pattern")
+
+        schema = url
+        self.assertEqual(schema.__name__, "url")
+
+        schema = domain_name
+        self.assertEqual(schema.__name__, "domain_name")
+        schema = domain_name(ascii_only=False)
+        self.assertEqual(schema.__name__, "domain_name(ascii_only=False)")
+        schema = domain_name(ascii_only=False, resolve=True)
+        self.assertEqual(schema.__name__, "domain_name(ascii_only=False,resolve=True)")
+
+        schema = date_time
+        self.assertEqual(schema.__name__, "date_time")
+        schema = date_time("%Y^%m^%d")
+        self.assertEqual(schema.__name__, "date_time('%Y^%m^%d')")
+
+        schema = date
+        self.assertEqual(schema.__name__, "date")
+
+        schema = time
+        self.assertEqual(schema.__name__, "time")
+
+        schema = nothing
+        self.assertEqual(schema.__name__, "nothing")
+
+        schema = anything
+        self.assertEqual(schema.__name__, "anything")
+
+        schema = float_
+        self.assertEqual(schema.__name__, "float_")
+
+        schema = one_of("a", "b", 1)
+        self.assertEqual(schema.__name__, "one_of('a','b',1)")
+
+        schema = at_least_one_of("a", "b", 1)
+        self.assertEqual(schema.__name__, "at_least_one_of('a','b',1)")
+
+        schema = at_most_one_of("a", "b", 1)
+        self.assertEqual(schema.__name__, "at_most_one_of('a','b',1)")
+
+        schema = keys("a", "b", 1)
+        self.assertEqual(schema.__name__, "keys('a','b',1)")
+
+        schema = interval(1, 10)
+        self.assertEqual(schema.__name__, "interval(1,10)")
+        schema = interval(1, ...)
+        self.assertEqual(schema.__name__, "interval(1,...)")
+        schema = interval(..., 10)
+        self.assertEqual(schema.__name__, "interval(...,10)")
+        schema = interval(..., 10, strict_ub=True)
+        self.assertEqual(schema.__name__, "interval(...,10,strict_ub=True)")
+
+        schema = gt(10)
+        self.assertEqual(schema.__name__, "gt(10)")
+
+        schema = ge(10)
+        self.assertEqual(schema.__name__, "ge(10)")
+
+        schema = lt(10)
+        self.assertEqual(schema.__name__, "lt(10)")
+
+        schema = le(10)
+        self.assertEqual(schema.__name__, "le(10)")
+
+        schema = size(1)
+        self.assertEqual(schema.__name__, "size(1)")
+        schema = size(1, 10)
+        self.assertEqual(schema.__name__, "size(1,10)")
+
+        schema = fields({"a": "b"})
+        self.assertEqual(schema.__name__, "fields({'a': 'b'})")
+        schema = fields({optional_key("a"): "b"})
+        self.assertEqual(schema.__name__, "fields({optional_key('a'): 'b'})")
+
+        schema = magic("application/html", name="html")
+        self.assertEqual(schema.__name__, "html")
+        schema = magic("application/html")
+        self.assertEqual(schema.__name__, "magic('application/html')")
+
+        schema = unique
+        self.assertEqual(schema.__name__, "unique")
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)