vtjson 2.2.5__py3-none-any.whl → 2.2.7__py3-none-any.whl

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.5"
+__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")
 
-    return to_name(origin) + "[" + ",".join([to_name(arg) for arg in args]) + "]"
+
+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__)
+
+    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,11 +1851,89 @@ class ip_address(compiled_schema):
         return ""
 
 
+@_set__name__
+class regex_pattern(compiled_schema):
+    """
+    Matches valid regular expression patterns
+    """
+
+    __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, str):
+            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:
+            return _wrong_type_message(obj, name, self.__name__, explanation=str(e))
+        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,
@@ -1759,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`
@@ -1780,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,
@@ -1793,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)
@@ -1807,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,
@@ -1820,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,
@@ -1841,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,
@@ -1861,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,
@@ -1879,6 +2091,7 @@ class anything(compiled_schema):
         return ""
 
 
+@_set__name__
 class domain_name(compiled_schema):
     """
     Checks if the object is a valid domain name.
@@ -1897,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,
@@ -1916,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(
@@ -1935,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
@@ -1949,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,
@@ -1960,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 ""
@@ -1970,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
@@ -1984,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,
@@ -1995,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 ""
@@ -2005,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
@@ -2019,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,
@@ -2030,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 ""
@@ -2040,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
@@ -2047,6 +2256,7 @@ class keys(compiled_schema):
     """
 
     args: tuple[object, ...]
+    __name__: str
 
     def __init__(self, *args: object) -> None:
         """
@@ -2062,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"
@@ -2242,6 +2454,7 @@ class _fields(compiled_schema):
         return ""
 
 
+@_set__name__
 class fields(wrapper, Generic[StringKeyType]):
     """
     `d` is a dictionary `{"field1": schema1, ...}`.
@@ -2251,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.5.dist-info → vtjson-2.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtjson
-Version: 2.2.5
+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.7.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=AZOYnkjYeefa6agUiU7FUl7_fk8tUAxGBsqc6a1Hee0,91671
+vtjson-2.2.7.dist-info/licenses/AUTHORS,sha256=qmxaXxaIO-YPNHJAZ0dcCrnPCs1x9ocbtMksiy4i80M,21
+vtjson-2.2.7.dist-info/licenses/LICENSE,sha256=n7xW-zX8xBLHzCdqWIMRuMzBD_ACLcNCwio0LEkKt1o,1077
+vtjson-2.2.7.dist-info/METADATA,sha256=Rvm5_Z2otxfFfcf8StFHpZAIOuNmqXu-GQNFflf7MRs,3980
+vtjson-2.2.7.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+vtjson-2.2.7.dist-info/top_level.txt,sha256=9DlSF3l63igcvnYPcj117F2hzOW4Nx0N-JBoW3jjBZM,7
+vtjson-2.2.7.dist-info/RECORD,,

{vtjson-2.2.5.dist-info → vtjson-2.2.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

vtjson-2.2.5.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=AQIoyST4Qfpc6apLbIg4plWEh-z0VlvbAjr03JVr924,87109
-vtjson-2.2.5.dist-info/licenses/AUTHORS,sha256=qmxaXxaIO-YPNHJAZ0dcCrnPCs1x9ocbtMksiy4i80M,21
-vtjson-2.2.5.dist-info/licenses/LICENSE,sha256=n7xW-zX8xBLHzCdqWIMRuMzBD_ACLcNCwio0LEkKt1o,1077
-vtjson-2.2.5.dist-info/METADATA,sha256=4TSessIW50S0gojL08Xhj8k6kze022XbfQrMrIIWUE0,3980
-vtjson-2.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vtjson-2.2.5.dist-info/top_level.txt,sha256=9DlSF3l63igcvnYPcj117F2hzOW4Nx0N-JBoW3jjBZM,7
-vtjson-2.2.5.dist-info/RECORD,,