vtjson 2.1.8__py3-none-any.whl → 2.2.0__py3-none-any.whl

vtjson/vtjson.py

@@ -12,7 +12,18 @@ import urllib.parse
 import warnings
 from collections.abc import Sequence, Set, Sized
 from dataclasses import dataclass
-from typing import Any, Callable, Container, Mapping, Type, TypeVar, Union, cast
+from typing import (
+    Any,
+    Callable,
+    Container,
+    Generic,
+    Mapping,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
 
 try:
     from typing import Literal
@@ -75,26 +86,89 @@ import dns.resolver
 import email_validator
 import idna
 
-T = TypeVar("T")
 
+def safe_cast(schema: Type[T], obj: Any) -> T:
+    """
+    Validates the given object against the given schema and changes its type
+    accordingly.
+
+    :param schema: the given schema
+    :param obj: the object to be validated
+    :return: the validated object with its type changed
+
+    :raises ValidationError: exception thrown when the object does not
+      validate; the exception message contains an explanation about what went
+      wrong
+
+    :raises SchemaError: exception thrown when the schema definition is found
+      to contain an error
+    """
 
-def safe_cast(t: Type[T], object_: Any) -> T:
-    validate(t, object_)
-    return cast(T, object_)
+    validate(schema, obj)
+    return cast(T, obj)
 
 
 class compiled_schema:
+    """
+    The result of compiling a schema. A :py:class:`compiled_schema` is
+    produced by the factory function :py:func:`vtjson.compile`.
+    """
+
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str,
         strict: bool,
         subs: Mapping[str, object],
     ) -> str:
+        """
+        Validates the given object against the given schema.
+
+        :param schema: the given schema
+        :param obj: the object to be validated
+        :param name: common name for the object to be validated; used in
+          non-validation messages
+        :param strict: indicates whether or not the object being validated is
+          allowed to have keys/entries which are not in the schema
+        :param subs: a dictionary whose keys are labels and whose values are
+          substitution schemas for schemas with those labels
+        :return: an empty string if validation succeeds; otherwise an
+          explanation about what went wrong
+        """
+
         return ""
 
 
+class wrapper:
+    """
+    Base class for schemas that refer to other schemas.
+
+    Handling such schemas is somewhat delicate since `vtjson` allows them to
+    be recursive.
+    """
+
+    def __compile__(
+        self, _deferred_compiles: _mapping | None = None
+    ) -> compiled_schema:
+        """
+        Compiles a schema.
+
+        :param _deferred_compiles: an opaque data structure used for handling
+          recursive schemas; it should be passed unmodifed to any internal
+          invocations of :py:func:`vtjson._compile` or
+          :py:meth:`vtjson.wrapper.__compile__`
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
+        return anything()
+
+
 class comparable(Protocol):
+    """
+    Base class for objects that are comparable with each other.
+    """
+
     def __eq__(self, x: Any) -> bool: ...
 
     def __lt__(self, x: Any) -> bool: ...
@@ -114,18 +188,39 @@ except Exception:
 
 
 class ValidationError(Exception):
+    """
+    Raised if validation fails. The associated message explains what went
+    wrong.
+    """
+
     pass
 
 
 class SchemaError(Exception):
+    """
+    Raised if a schema contains an error.
+    """
+
     pass
 
 
-__version__ = "2.1.8"
+__version__ = "2.2.0"
 
 
 @dataclass
 class Apply:
+    """
+    Modifies the treatement of the previous arguments in an `Annotated` schema.
+
+    :param skip_first: if `True` do not use the first argument (the Python
+      type annotation) in an `Annotated` construct for validation because this
+      is already covered by the other arguments
+    :param name:  apply the corresponding :py:class:`vtjson.set_name` command
+      to the previous arguments
+    :param labels: apply the corresponding :py:class:`vtjson.set_label`
+      command  to the previous arguments
+    """
+
     skip_first: bool | None = None
     name: str | None = None
     labels: Sequence[str] | None = None
@@ -177,13 +272,13 @@ def _get_type_hints(schema: object) -> dict[str, object]:
 
 def _to_dict(
     type_hints: Mapping[str, object], total: bool = True
-) -> dict[object, object]:
-    d: dict[object, 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 = 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]
@@ -224,15 +319,38 @@ 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(
-    object_: object,
+    obj: object,
     name: str,
     type_name: str,
     explanation: str | None = None,
     skip_value: bool = False,
 ) -> str:
     if not skip_value:
-        message = f"{name} (value:{_c(object_)}) is not of type '{type_name}'"
+        message = f"{name} (value:{_c(obj)}) is not of type '{type_name}'"
     else:
         message = f"{name} is not of type '{type_name}'"
     if explanation is not None:
@@ -246,9 +364,9 @@ class _validate_meta(type):
     __subs__: Mapping[str, object]
     __dbg__: bool
 
-    def __instancecheck__(cls, object_: object) -> bool:
+    def __instancecheck__(cls, obj: object) -> bool:
         valid = _validate(
-            cls.__schema__, object_, "object", strict=cls.__strict__, subs=cls.__subs__
+            cls.__schema__, obj, "object", strict=cls.__strict__, subs=cls.__subs__
         )
         if cls.__dbg__ and valid != "":
             print(f"DEBUG: {valid}")
@@ -262,6 +380,20 @@ def make_type(
     debug: bool = False,
     subs: Mapping[str, object] = {},
 ) -> _validate_meta:
+    """
+    Transforms a schema into a genuine Python type.
+
+    :param schema: the given schema
+    :param name: sets the `__name__` attribute of the type; if it is not
+      supplied then `vtjson` makes an educated guess
+    :param strict: indicates whether or not the object being validated is
+      allowed to have keys/entries which are not in the schema
+    :param debug: print feedback on the console if validation fails
+    :param subs: a dictionary whose keys are labels and whose values are
+      substitution schemas for schemas with those labels
+    :raises SchemaError: exception thrown when the schema definition is found
+      to contain an error
+    """
     if name is None:
         if hasattr(schema, "__name__"):
             name = schema.__name__
@@ -279,16 +411,35 @@ def make_type(
     )
 
 
-class optional_key:
-    key: object
+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 `?`. 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: object) -> 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
-        return self.key == key.key
+        k: object = key.key
+        o: object = key.optional
+        return (self.key, key.optional) == (k, o)
 
     def __hash__(self) -> int:
         return hash(self.key)
@@ -308,14 +459,14 @@ class _union(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         messages = []
         for schema in self.schemas:
-            message = schema.__validate__(object_, name=name, strict=strict, subs=subs)
+            message = schema.__validate__(obj, name=name, strict=strict, subs=subs)
             if message == "":
                 return ""
             else:
@@ -323,10 +474,18 @@ class _union(compiled_schema):
         return " and ".join(messages)
 
 
-class union:
+class union(wrapper):
+    """
+    An object matches the schema `union(schema1, ..., schemaN)` if it matches
+    one of the schemas `schema1, ..., schemaN`.
+    """
+
     schemas: tuple[object, ...]
 
     def __init__(self, *schemas: object) -> None:
+        """
+        :param schemas: collection of schemas, one of which should match
+        """
         self.schemas = schemas
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _union:
@@ -347,22 +506,30 @@ class _intersect(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         for schema in self.schemas:
-            message = schema.__validate__(object_, name=name, strict=strict, subs=subs)
+            message = schema.__validate__(obj, name=name, strict=strict, subs=subs)
             if message != "":
                 return message
         return ""
 
 
-class intersect:
+class intersect(wrapper):
+    """
+    An object matches the schema `intersect(schema1, ..., schemaN)` if it
+    matches all the schemas `schema1, ..., schemaN`.
+    """
+
     schemas: tuple[object, ...]
 
     def __init__(self, *schemas: object) -> None:
+        """
+        :param schemas: collection of schemas, all of which should match
+        """
         self.schemas = schemas
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _intersect:
@@ -379,22 +546,30 @@ class _complement(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        message = self.schema.__validate__(object_, name=name, strict=strict, subs=subs)
+        message = self.schema.__validate__(obj, name=name, strict=strict, subs=subs)
         if message != "":
             return ""
         else:
             return f"{name} does not match the complemented schema"
 
 
-class complement:
+class complement(wrapper):
+    """
+    An object matches the schema `complement(schema)` if it does not match
+    `schema`.
+    """
+
     schema: object
 
     def __init__(self, schema: object) -> None:
+        """
+        :param schema: the schema that should not be matched
+        """
         self.schema = schema
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _complement:
@@ -411,18 +586,27 @@ class _lax(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        return self.schema.__validate__(object_, name=name, strict=False, subs=subs)
+        return self.schema.__validate__(obj, name=name, strict=False, subs=subs)
+
 
+class lax(wrapper):
+    """
+    An object matches the schema `lax(schema)` if it matches `schema` when
+    validated with `strict=False`.
+    """
 
-class lax:
     schema: object
 
     def __init__(self, schema: object) -> None:
+        """
+        :param schema: schema that should be validated against with
+          `strict=False`
+        """
         self.schema = schema
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _lax:
@@ -439,16 +623,25 @@ class _strict(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        return self.schema.__validate__(object_, name=name, strict=True, subs=subs)
+        return self.schema.__validate__(obj, name=name, strict=True, subs=subs)
 
 
-class strict:
+class strict(wrapper):
+    """
+    An object matches the schema `strict(schema)` if it matches `schema` when
+    validated with `strict=True`.
+    """
+
     def __init__(self, schema: object) -> None:
+        """
+        :param schema: schema that should be validated against with
+          `strict=True`
+        """
         self.schema = schema
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _strict:
@@ -473,7 +666,7 @@ class _set_label(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
@@ -492,17 +685,31 @@ class _set_label(compiled_schema):
             # known at schema creation time.
             #
             # But the user can always pre-compile subs[key].
-            return _validate(subs[key], object_, name=name, strict=True, subs=subs)
+            return _validate(subs[key], obj, name=name, strict=True, subs=subs)
         else:
-            return self.schema.__validate__(object_, name=name, strict=True, subs=subs)
+            return self.schema.__validate__(obj, name=name, strict=True, subs=subs)
+
 
+class set_label(wrapper):
+    """
+    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`.
+    """
 
-class set_label:
     schema: object
     labels: set[str]
     debug: bool
 
     def __init__(self, schema: object, *labels: str, debug: bool = False) -> None:
+        """
+        :param schema: the schema that will be labeled
+        :param labels: labels that will be attached to the schema
+        :param debug:  it `True` print a message on the console if the schema
+          was changed via substitution
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         self.schema = schema
         for L in labels:
             if not isinstance(L, str):
@@ -519,19 +726,28 @@ class set_label:
 
 
 class quote(compiled_schema):
+    """
+    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
 
     def __init__(self, schema: object) -> None:
+        """
+        :param schema: the schema to be quoted
+        """
         self.schema = _const(schema, strict_eq=True)
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        return self.schema.__validate__(object_, name=name, strict=strict, subs=subs)
+        return self.schema.__validate__(obj, name=name, strict=strict, subs=subs)
 
 
 class _set_name(compiled_schema):
@@ -552,28 +768,40 @@ class _set_name(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        message = self.schema.__validate__(object_, name=name, strict=strict, subs=subs)
+        message = self.schema.__validate__(obj, name=name, strict=strict, subs=subs)
         if message != "":
             if not self.reason:
-                return _wrong_type_message(object_, name, self.__name__)
+                return _wrong_type_message(obj, name, self.__name__)
             else:
                 return _wrong_type_message(
-                    object_, name, self.__name__, explanation=message, skip_value=True
+                    obj, name, self.__name__, explanation=message, skip_value=True
                 )
         return ""
 
 
-class set_name:
+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.
+    """
+
     reason: bool
     schema: object
     name: str
 
     def __init__(self, schema: object, name: str, reason: bool = False) -> None:
+        """
+        :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
+        """
         if not isinstance(name, str):
             raise SchemaError(f"The name {_c(name)} is not a string")
         self.schema = schema
@@ -590,6 +818,10 @@ class set_name:
 
 
 class regex(compiled_schema):
+    """
+    This matches the strings which match the given pattern.
+    """
+
     regex: str
     fullmatch: bool
     __name__: str
@@ -602,6 +834,17 @@ class regex(compiled_schema):
         fullmatch: bool = True,
         flags: int = 0,
     ) -> None:
+        """
+        :param regex: the regular expression pattern
+        :param name: common name for the pattern that will be used in
+          non-validation messages
+        :param fullmatch: indicates whether or not the full string should be
+          matched
+        :param flags: the flags argument used when invoking `re.compile`
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         self.regex = regex
         self.fullmatch = fullmatch
         if name is not None:
@@ -623,28 +866,42 @@ class regex(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, str):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, str):
+            return _wrong_type_message(obj, name, self.__name__)
         try:
-            if self.fullmatch and self.pattern.fullmatch(object_):
+            if self.fullmatch and self.pattern.fullmatch(obj):
                 return ""
-            elif not self.fullmatch and self.pattern.match(object_):
+            elif not self.fullmatch and self.pattern.match(obj):
                 return ""
         except Exception:
             pass
-        return _wrong_type_message(object_, name, self.__name__)
+        return _wrong_type_message(obj, name, self.__name__)
 
 
 class glob(compiled_schema):
+    """
+    Unix style filename matching. This is implemented using
+    `pathlib.PurePath().match()`.
+    """
+
     pattern: str
     __name__: str
 
     def __init__(self, pattern: str, name: str | None = None) -> None:
+        """
+        :param pattern: the wild card pattern to match
+        :param name: common name for the pattern that will be used in
+          non-validation messages
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
+
         self.pattern = pattern
 
         if name is None:
@@ -662,27 +919,39 @@ class glob(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, str):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, str):
+            return _wrong_type_message(obj, name, self.__name__)
         try:
-            if pathlib.PurePath(object_).match(self.pattern):
+            if pathlib.PurePath(obj).match(self.pattern):
                 return ""
             else:
-                return _wrong_type_message(object_, name, self.__name__)
+                return _wrong_type_message(obj, name, self.__name__)
         except Exception as e:
-            return _wrong_type_message(object_, name, self.__name__, str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
 class magic(compiled_schema):
+    """
+    Checks if a buffer (for example a string or a byte array) has the given
+    mime type. This is implemented using the `python-magic` package.
+    """
+
     mime_type: str
     __name__: str
 
     def __init__(self, mime_type: str, name: str | None = None) -> None:
+        """
+        :param mime_type: the mime type
+        :param name: common name to refer to this mime type
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         if not HAS_MAGIC:
             raise SchemaError("Failed to load python-magic")
 
@@ -698,28 +967,32 @@ class magic(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, (str, bytes)):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, (str, bytes)):
+            return _wrong_type_message(obj, name, self.__name__)
         try:
-            object_mime_type = magic_.from_buffer(object_, mime=True)
+            objmime_type = magic_.from_buffer(obj, mime=True)
         except Exception as e:
-            return _wrong_type_message(object_, name, self.__name__, str(e))
-        if object_mime_type != self.mime_type:
+            return _wrong_type_message(obj, name, self.__name__, str(e))
+        if objmime_type != self.mime_type:
             return _wrong_type_message(
-                object_,
+                obj,
                 name,
                 self.__name__,
-                f"{repr(object_mime_type)} is different from {repr(self.mime_type)}",
+                f"{repr(objmime_type)} is different from {repr(self.mime_type)}",
             )
         return ""
 
 
 class div(compiled_schema):
+    """
+    This matches the integers `x` such that `(x - remainder) % divisor` == 0.
+    """
+
     divisor: int
     remainder: int
     __name__: str
@@ -727,6 +1000,15 @@ class div(compiled_schema):
     def __init__(
         self, divisor: int, remainder: int = 0, name: str | None = None
     ) -> None:
+        """
+        :param divisor: the divisor
+        :param remainder: the remainer
+        :param name: common name (e.g. `even` or `odd`) that will be used in
+          non-validation messages
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         if not isinstance(divisor, int):
             raise SchemaError(f"The divisor {repr(divisor)} is not an integer")
         if divisor == 0:
@@ -747,20 +1029,25 @@ class div(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, int):
-            return _wrong_type_message(object_, name, "int")
-        elif (object_ - self.remainder) % self.divisor == 0:
+        if not isinstance(obj, int):
+            return _wrong_type_message(obj, name, "int")
+        elif (obj - self.remainder) % self.divisor == 0:
             return ""
         else:
-            return _wrong_type_message(object_, name, self.__name__)
+            return _wrong_type_message(obj, name, self.__name__)
 
 
 class close_to(compiled_schema):
+    """
+    This matches the real numbers that are close to `x` in the sense of
+    `math.isclose`.
+    """
+
     kw: dict[str, float]
     x: int | float
     __name__: str
@@ -771,6 +1058,13 @@ class close_to(compiled_schema):
         rel_tol: int | float | None = None,
         abs_tol: int | float | None = None,
     ) -> None:
+        """
+        :param rel_tol: the maximal allowed relative deviation
+        :param abs_tol: the maximal allowed absolute deviation
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         self.kw = {}
         if not isinstance(x, (int, float)):
             raise SchemaError(f"{repr(x)} is not a number")
@@ -794,23 +1088,33 @@ class close_to(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, (float, int)):
-            return _wrong_type_message(object_, name, "number")
-        elif math.isclose(object_, self.x, **self.kw):
+        if not isinstance(obj, (float, int)):
+            return _wrong_type_message(obj, name, "number")
+        elif math.isclose(obj, self.x, **self.kw):
             return ""
         else:
-            return _wrong_type_message(object_, name, self.__name__)
+            return _wrong_type_message(obj, name, self.__name__)
 
 
 class gt(compiled_schema):
+    """
+    This checks if `object > lb`.
+    """
+
     lb: comparable
 
     def __init__(self, lb: comparable) -> None:
+        """
+        :param lb: the strict lower bound
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         try:
             lb <= lb
         except Exception:
@@ -819,29 +1123,39 @@ class gt(compiled_schema):
             ) from None
         self.lb = lb
 
-    def message(self, name: str, object_: object) -> str:
-        return f"{name} (value:{_c(object_)}) is not strictly greater than {self.lb}"
+    def message(self, name: str, obj: object) -> str:
+        return f"{name} (value:{_c(obj)}) is not strictly greater than {self.lb}"
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         try:
-            if self.lb < object_:
+            if self.lb < obj:
                 return ""
             else:
-                return self.message(name, object_)
+                return self.message(name, obj)
         except Exception as e:
-            return f"{self.message(name, object_)}: {str(e)}"
+            return f"{self.message(name, obj)}: {str(e)}"
 
 
 class ge(compiled_schema):
+    """
+    This checks if `object >= lb`.
+    """
+
     lb: comparable
 
     def __init__(self, lb: comparable) -> None:
+        """
+        :param lb: the lower bound
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         try:
             lb <= lb
         except Exception:
@@ -850,29 +1164,39 @@ class ge(compiled_schema):
             ) from None
         self.lb = lb
 
-    def message(self, name: str, object_: object) -> str:
-        return f"{name} (value:{_c(object_)}) is not greater than or equal to {self.lb}"
+    def message(self, name: str, obj: object) -> str:
+        return f"{name} (value:{_c(obj)}) is not greater than or equal to {self.lb}"
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         try:
-            if self.lb <= object_:
+            if self.lb <= obj:
                 return ""
             else:
-                return self.message(name, object_)
+                return self.message(name, obj)
         except Exception as e:
-            return f"{self.message(name, object_)}: {str(e)}"
+            return f"{self.message(name, obj)}: {str(e)}"
 
 
 class lt(compiled_schema):
+    """
+    This checks if `object < ub`.
+    """
+
     ub: comparable
 
     def __init__(self, ub: comparable) -> None:
+        """
+        :param ub: the strict upper bound
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         try:
             ub <= ub
         except Exception:
@@ -881,29 +1205,39 @@ class lt(compiled_schema):
             ) from None
         self.ub = ub
 
-    def message(self, name: str, object_: object) -> str:
-        return f"{name} (value:{_c(object_)}) is not strictly less than {self.ub}"
+    def message(self, name: str, obj: object) -> str:
+        return f"{name} (value:{_c(obj)}) is not strictly less than {self.ub}"
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         try:
-            if self.ub > object_:
+            if self.ub > obj:
                 return ""
             else:
-                return self.message(name, object_)
+                return self.message(name, obj)
         except Exception as e:
-            return f"{self.message(name, object_)}: {str(e)}"
+            return f"{self.message(name, obj)}: {str(e)}"
 
 
 class le(compiled_schema):
+    """
+    This checks if `object <= ub`.
+    """
+
     ub: comparable
 
     def __init__(self, ub: comparable) -> None:
+        """
+        :param ub: the upper bound
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         try:
             ub <= ub
         except Exception:
@@ -912,26 +1246,30 @@ class le(compiled_schema):
             ) from None
         self.ub = ub
 
-    def message(self, name: str, object_: object) -> str:
-        return f"{name} (value:{_c(object_)}) is not less than or equal to {self.ub}"
+    def message(self, name: str, obj: object) -> str:
+        return f"{name} (value:{_c(obj)}) is not less than or equal to {self.ub}"
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         try:
-            if self.ub >= object_:
+            if self.ub >= obj:
                 return ""
             else:
-                return self.message(name, object_)
+                return self.message(name, obj)
         except Exception as e:
-            return f"{self.message(name, object_)}: {str(e)}"
+            return f"{self.message(name, obj)}: {str(e)}"
 
 
 class interval(compiled_schema):
+    """
+    This checks if `lb <= object <= ub`, provided the comparisons make sense.
+    """
+
     lb_s: str
     ub_s: str
 
@@ -942,7 +1280,15 @@ class interval(compiled_schema):
         strict_lb: bool = False,
         strict_ub: bool = False,
     ) -> None:
-
+        """
+        :param lb: lower bound; ... (ellipsis) means no lower bound
+        :param ub: upper bound; ... (ellipsis) means no upper bound
+        :param strict_lb: if True use a strict lower bound
+        :param strict_ub: if True use a strict upper bound
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         self.lb_s = "..." if lb == ... else repr(lb)
         self.ub_s = "..." if ub == ... else repr(ub)
 
@@ -995,9 +1341,22 @@ class interval(compiled_schema):
 
 
 class size(compiled_schema):
+    """
+    Matches the objects (which support `len()` such as strings or lists) whose
+    length is in the interval `[lb, ub]`.
+    """
+
     interval_: interval
 
     def __init__(self, lb: int, ub: int | types.EllipsisType | None = None) -> None:
+        """
+        :param lb: the lower bound for the length
+        :param ub: the upper bound for the length; ... (ellipsis) means that
+          there is no upper bound; `None` means `lb==ub`
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         if ub is None:
             ub = lb
         if not isinstance(lb, int):
@@ -1021,15 +1380,15 @@ class size(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, Sized):
-            return f"{name} (value:{_c(object_)}) has no len()"
+        if not isinstance(obj, Sized):
+            return f"{name} (value:{_c(obj)}) has no len()"
 
-        L = len(object_)
+        L = len(obj)
 
         return self.interval_.__validate__(L, f"len({name})", strict, subs)
 
@@ -1044,7 +1403,7 @@ class _deferred(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
@@ -1052,7 +1411,7 @@ class _deferred(compiled_schema):
         if self.key not in self.collection:
             raise ValidationError(f"{name}: key {self.key} is unknown")
         return self.collection[self.key].__validate__(
-            object_, name=name, strict=strict, subs=subs
+            obj, name=name, strict=strict, subs=subs
         )
 
 
@@ -1092,12 +1451,32 @@ class _validate_schema(compiled_schema):
 
 
 def compile(schema: object) -> compiled_schema:
+    """
+    Compiles a schema. Internally invokes :py:func:`vtjson._compile`.
+
+    :param schema: the schema that should be compiled
+
+    :raises SchemaError: exception thrown when the schema definition is found
+      to contain an error
+    """
     return _compile(schema, _deferred_compiles=None)
 
 
 def _compile(
     schema: object, _deferred_compiles: _mapping | None = None
 ) -> compiled_schema:
+    """
+    Compiles a schema.
+
+    :param schema: the schema that should be compiled
+    :param _deferred_compiles: an opaque data structure used for handling
+      recursive schemas; it should be passed unmodifed to any internal
+      invocations of :py:func:`vtjson._compile` or
+      :py:meth:`vtjson.wrapper.__compile__`
+
+    :raises SchemaError: exception thrown when the schema definition is found
+      to contain an error
+    """
     if _deferred_compiles is None:
         _deferred_compiles = _mapping()
     # avoid infinite loop in case of a recursive schema
@@ -1123,7 +1502,7 @@ def _compile(
             ) from None
     elif hasattr(schema, "__validate__"):
         ret = _validate_schema(schema)
-    elif hasattr(schema, "__compile__"):
+    elif isinstance(schema, wrapper):
         ret = schema.__compile__(_deferred_compiles=_deferred_compiles)
     elif isinstance(schema, compiled_schema):
         ret = schema
@@ -1194,24 +1573,41 @@ def _compile(
 
 def _validate(
     schema: object,
-    object_: object,
+    obj: object,
     name: str = "object",
     strict: bool = True,
     subs: Mapping[str, object] = {},
 ) -> str:
-    return compile(schema).__validate__(object_, name=name, strict=strict, subs=subs)
+    return compile(schema).__validate__(obj, name=name, strict=strict, subs=subs)
 
 
 def validate(
     schema: object,
-    object_: object,
+    obj: object,
     name: str = "object",
     strict: bool = True,
     subs: Mapping[str, object] = {},
 ) -> None:
+    """
+    Validates the given object against the given schema.
+
+    :param schema: the given schema
+    :param obj: the object to be validated
+    :param name: common name for the object to be validated; used in
+      non-validation messages
+    :param strict: indicates whether or not the object being validated is
+      allowed to have keys/entries which are not in the schema
+    :param subs: a dictionary whose keys are labels and whose values are
+      substitution schemas for schemas with those labels
+    :raises ValidationError: exception thrown when the object does not
+      validate; the exception message contains an explanation about what went
+      wrong
+    :raises SchemaError: exception thrown when the schema definition is found
+      to contain an error
+    """
     message = _validate(
         schema,
-        object_,
+        obj,
         name=name,
         strict=strict,
         subs=subs,
@@ -1224,7 +1620,10 @@ def validate(
 
 
 class number(compiled_schema):
-    # functionally equivalent to float
+    """
+    A deprecated alias for `float`.
+    """
+
     def __init__(self) -> None:
         warnings.warn(
             "The schema 'number' is deprecated. Use 'float' instead.",
@@ -1233,21 +1632,49 @@ class number(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
+        name: str = "object",
+        strict: bool = True,
+        subs: Mapping[str, object] = {},
+    ) -> str:
+        if isinstance(obj, (int, float)):
+            return ""
+        else:
+            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(object_, (int, float)):
+        if isinstance(obj, float):
             return ""
         else:
-            return _wrong_type_message(object_, name, "number")
+            return _wrong_type_message(obj, name, "float_")
 
 
 class email(compiled_schema):
+    """
+    Checks if the object is a valid email address. This uses the package
+    `email_validator`. The `email` schema accepts the same options as
+    `validate_email` in loc. cit.
+    """
+
     kw: dict[str, Any]
 
     def __init__(self, **kw: Any) -> None:
+        """
+        :param kw: optional keyword arguments to be forwarded to
+          `email_validator.validate_email`
+        """
         self.kw = kw
         if "dns_resolver" not in kw:
             self.kw["dns_resolver"] = _get_dns_resolver()
@@ -1256,28 +1683,34 @@ class email(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, str):
-            return _wrong_type_message(
-                object_, name, "email", f"{_c(object_)} is not a string"
-            )
+        if not isinstance(obj, str):
+            return _wrong_type_message(obj, name, "email", f"{_c(obj)} is not a string")
         try:
-            email_validator.validate_email(object_, **self.kw)
+            email_validator.validate_email(obj, **self.kw)
             return ""
         except Exception as e:
-            return _wrong_type_message(object_, name, "email", str(e))
+            return _wrong_type_message(obj, name, "email", str(e))
 
 
 class ip_address(compiled_schema):
+    """
+    Matches ip addresses of the specified version which can be 4, 6 or None.
+    """
 
     __name__: str
     method: Callable[[Any], Any]
 
-    def __init__(self, version: Literal[4, 6] | None = None) -> None:
+    def __init__(self, version: Literal[4, 6, None] = None) -> None:
+        """
+        :param version: the version of the ip protocol
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         if version is not None and version not in (4, 6):
             raise SchemaError("version is not 4 or 6")
         if version is None:
@@ -1293,41 +1726,53 @@ class ip_address(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, (int, str, bytes)):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, (int, str, bytes)):
+            return _wrong_type_message(obj, name, self.__name__)
         try:
-            self.method(object_)
+            self.method(obj)
         except ValueError as e:
-            return _wrong_type_message(object_, name, self.__name__, explanation=str(e))
+            return _wrong_type_message(obj, name, self.__name__, explanation=str(e))
         return ""
 
 
 class url(compiled_schema):
+    """
+    Matches valid urls.
+    """
+
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, str):
-            return _wrong_type_message(object_, name, "url")
-        result = urllib.parse.urlparse(object_)
+        if not isinstance(obj, str):
+            return _wrong_type_message(obj, name, "url")
+        result = urllib.parse.urlparse(obj)
         if all([result.scheme, result.netloc]):
             return ""
-        return _wrong_type_message(object_, name, "url")
+        return _wrong_type_message(obj, name, "url")
 
 
 class date_time(compiled_schema):
+    """
+    Without argument this represents an ISO 8601 date-time. The `format`
+    argument represents a format string for `strftime`.
+    """
+
     format: str | None
     __name__: str
 
     def __init__(self, format: str | None = None) -> None:
+        """
+        :param format: format string for `strftime`
+        """
         self.format = format
         if format is not None:
             self.__name__ = f"date_time({repr(format)})"
@@ -1336,75 +1781,91 @@ class date_time(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, str):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, str):
+            return _wrong_type_message(obj, name, self.__name__)
         if self.format is not None:
             try:
-                datetime.datetime.strptime(object_, self.format)
+                datetime.datetime.strptime(obj, self.format)
             except Exception as e:
-                return _wrong_type_message(object_, name, self.__name__, str(e))
+                return _wrong_type_message(obj, name, self.__name__, str(e))
         else:
             try:
-                datetime.datetime.fromisoformat(object_)
+                datetime.datetime.fromisoformat(obj)
             except Exception as e:
-                return _wrong_type_message(object_, name, self.__name__, str(e))
+                return _wrong_type_message(obj, name, self.__name__, str(e))
         return ""
 
 
 class date(compiled_schema):
+    """
+    Matches an ISO 8601 date.
+    """
+
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, str):
-            return _wrong_type_message(object_, name, "date")
+        if not isinstance(obj, str):
+            return _wrong_type_message(obj, name, "date")
         try:
-            datetime.date.fromisoformat(object_)
+            datetime.date.fromisoformat(obj)
         except Exception as e:
-            return _wrong_type_message(object_, name, "date", str(e))
+            return _wrong_type_message(obj, name, "date", str(e))
         return ""
 
 
 class time(compiled_schema):
+    """
+    Matches an ISO 8601 time.
+    """
+
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, str):
-            return _wrong_type_message(object_, name, "date")
+        if not isinstance(obj, str):
+            return _wrong_type_message(obj, name, "date")
         try:
-            datetime.time.fromisoformat(object_)
+            datetime.time.fromisoformat(obj)
         except Exception as e:
-            return _wrong_type_message(object_, name, "time", str(e))
+            return _wrong_type_message(obj, name, "time", str(e))
         return ""
 
 
 class nothing(compiled_schema):
+    """
+    Matches nothing.
+    """
+
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        return _wrong_type_message(object_, name, "nothing")
+        return _wrong_type_message(obj, name, "nothing")
 
 
 class anything(compiled_schema):
+    """
+    Matchess anything.
+    """
+
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
@@ -1413,12 +1874,20 @@ class anything(compiled_schema):
 
 
 class domain_name(compiled_schema):
+    """
+    Checks if the object is a valid domain name.
+    """
+
     re_asci: re.Pattern[str]
     ascii_only: bool
     resolve: bool
     __name__: str
 
     def __init__(self, ascii_only: bool = True, resolve: bool = False) -> None:
+        """
+        :param ascii_only: if `False` then allow IDNA domain names
+        :param resolve: if `True` check if the domain names resolves
+        """
         self.re_ascii = re.compile(r"[\x00-\x7F]*")
         self.ascii_only = ascii_only
         self.resolve = resolve
@@ -1435,129 +1904,161 @@ class domain_name(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, str):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, str):
+            return _wrong_type_message(obj, name, self.__name__)
         if self.ascii_only:
-            if not self.re_ascii.fullmatch(object_):
+            if not self.re_ascii.fullmatch(obj):
                 return _wrong_type_message(
-                    object_, name, self.__name__, "Non-ascii characters"
+                    obj, name, self.__name__, "Non-ascii characters"
                 )
         try:
-            idna.encode(object_, uts46=False)
+            idna.encode(obj, uts46=False)
         except idna.core.IDNAError as e:
-            return _wrong_type_message(object_, name, self.__name__, str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
 
         if self.resolve:
             try:
-                _get_dns_resolver().resolve(object_)
+                _get_dns_resolver().resolve(obj)
             except Exception as e:
-                return _wrong_type_message(object_, name, self.__name__, str(e))
+                return _wrong_type_message(obj, name, self.__name__, str(e))
         return ""
 
 
 class at_least_one_of(compiled_schema):
+    """
+    This represents a dictionary with a least one key among a collection of
+    keys.
+    """
+
     args: tuple[object, ...]
     __name__: str
 
     def __init__(self, *args: object) -> None:
+        """
+        :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,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, Mapping):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, Mapping):
+            return _wrong_type_message(obj, name, self.__name__)
         try:
-            if any([a in object_ for a in self.args]):
+            if any([a in obj for a in self.args]):
                 return ""
             else:
-                return _wrong_type_message(object_, name, self.__name__)
+                return _wrong_type_message(obj, name, self.__name__)
         except Exception as e:
-            return _wrong_type_message(object_, name, self.__name__, str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
 class at_most_one_of(compiled_schema):
+    """
+    This represents an dictionary with at most one key among a collection of
+    keys.
+    """
+
     args: tuple[object, ...]
     __name__: str
 
     def __init__(self, *args: object) -> None:
+        """
+        :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,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, Mapping):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, Mapping):
+            return _wrong_type_message(obj, name, self.__name__)
         try:
-            if sum([a in object_ for a in self.args]) <= 1:
+            if sum([a in obj for a in self.args]) <= 1:
                 return ""
             else:
-                return _wrong_type_message(object_, name, self.__name__)
+                return _wrong_type_message(obj, name, self.__name__)
         except Exception as e:
-            return _wrong_type_message(object_, name, self.__name__, str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
 class one_of(compiled_schema):
+    """
+    This represents a dictionary with exactly one key among a collection of
+    keys.
+    """
+
     args: tuple[object, ...]
     __name__: str
 
     def __init__(self, *args: object) -> None:
+        """
+        :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,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, Mapping):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, Mapping):
+            return _wrong_type_message(obj, name, self.__name__)
         try:
-            if sum([a in object_ for a in self.args]) == 1:
+            if sum([a in obj for a in self.args]) == 1:
                 return ""
             else:
-                return _wrong_type_message(object_, name, self.__name__)
+                return _wrong_type_message(obj, name, self.__name__)
         except Exception as e:
-            return _wrong_type_message(object_, name, self.__name__, str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
 
 
 class keys(compiled_schema):
+    """
+    This represents a dictionary containing all the keys in a collection of
+    keys
+    """
+
     args: tuple[object, ...]
 
     def __init__(self, *args: object) -> None:
+        """
+        :param args: a collection of keys
+        """
         self.args = args
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, Mapping):
-            return _wrong_type_message(object_, name, "Mapping")  # TODO: __name__
+        if not isinstance(obj, Mapping):
+            return _wrong_type_message(obj, name, "Mapping")  # TODO: __name__
         for k in self.args:
-            if k not in object_:
+            if k not in obj:
                 return f"{name}[{repr(k)}] is missing"
         return ""
 
@@ -1585,26 +2086,29 @@ class _ifthen(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if (
-            self.if_schema.__validate__(object_, name=name, strict=strict, subs=subs)
-            == ""
-        ):
+        if self.if_schema.__validate__(obj, name=name, strict=strict, subs=subs) == "":
             return self.then_schema.__validate__(
-                object_, name=name, strict=strict, subs=subs
+                obj, name=name, strict=strict, subs=subs
             )
         elif self.else_schema is not None:
             return self.else_schema.__validate__(
-                object_, name=name, strict=strict, subs=subs
+                obj, name=name, strict=strict, subs=subs
             )
         return ""
 
 
-class ifthen:
+class ifthen(wrapper):
+    """
+    If the object matches the `if_schema` then it should also match the
+    `then_schema`. If the object does not match the `if_schema` then it should
+    match the `else_schema`, if present.
+    """
+
     if_schema: object
     then_schema: object
     else_schema: object | None
@@ -1615,6 +2119,11 @@ class ifthen:
         then_schema: object,
         else_schema: object | None = None,
     ) -> None:
+        """
+        :param if_schema: the `if_schema`
+        :param then_schema: the `then_schema`
+        :param else_schema: the `else_schema`
+        """
         self.if_schema = if_schema
         self.then_schema = then_schema
         self.else_schema = else_schema
@@ -1647,21 +2156,35 @@ class _cond(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         for c in self.conditions:
-            if c[0].__validate__(object_, name=name, strict=strict, subs=subs) == "":
-                return c[1].__validate__(object_, name=name, strict=strict, subs=subs)
+            if c[0].__validate__(obj, name=name, strict=strict, subs=subs) == "":
+                return c[1].__validate__(obj, name=name, strict=strict, subs=subs)
         return ""
 
 
-class cond:
+class cond(wrapper):
+    """
+    An object is successively validated against `if_schema1`, `if_schema2`,
+    ... until a validation succeeds. When this happens the object should match
+    the corresponding `then_schema`. If no `if_schema` succeeds then the
+    object is considered to have been validated. If one sets `if_schemaN`
+    equal to `anything` then this serves as a catch all.
+    """
+
     args: tuple[tuple[object, object], ...]
 
     def __init__(self, *args: tuple[object, object]) -> None:
+        """
+        :param args: list of tuples pairing `if_schemas` with `then_schemas`
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         for c in args:
             if not isinstance(c, tuple) or len(c) != 2:
                 raise SchemaError(f"{repr(c)} is not a tuple of length two")
@@ -1672,10 +2195,12 @@ class cond:
 
 
 class _fields(compiled_schema):
-    d: dict[str, compiled_schema]
+    d: dict[str | optional_key[str], compiled_schema]
 
     def __init__(
-        self, d: Mapping[str, object], _deferred_compiles: _mapping | None = None
+        self,
+        d: Mapping[optional_key[str], object],
+        _deferred_compiles: _mapping | None = None,
     ) -> None:
         self.d = {}
         for k, v in d.items():
@@ -1683,31 +2208,59 @@ class _fields(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         for k, v in self.d.items():
             name_ = f"{name}.{k}"
-            if not hasattr(object_, k):
-                return f"{name_} is missing"
+            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:
+                k_ = k
             ret = self.d[k].__validate__(
-                getattr(object_, k), name=name_, strict=strict, subs=subs
+                getattr(obj, k_), name=name_, strict=strict, subs=subs
             )
             if ret != "":
                 return ret
         return ""
 
 
-class fields:
-    def __init__(self, d: object) -> None:
+class fields(wrapper):
+    """
+    Matches Python objects with attributes `field1, field2, ..., fieldN` whose
+    corresponding values should validate against `schema1, schema2, ...,
+    schemaN` respectively
+    """
+
+    d: dict[optional_key[str], object]
+
+    def __init__(self, d: Mapping[str | optional_key[str], 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 in d:
-            if not isinstance(k, str):
-                raise SchemaError(f"key {repr(k)} in {repr(d)} is not a string")
-        self.d = d
+        for k, v in d.items():
+            if not isinstance(k, str) and not isinstance(k, optional_key):
+                raise SchemaError(
+                    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
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _fields:
         return _fields(self.d, _deferred_compiles=_deferred_compiles)
@@ -1739,25 +2292,28 @@ class _filter(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         try:
-            object_ = self.filter(object_)
+            obj = self.filter(obj)
         except Exception as e:
             return (
                 f"Applying {self.filter_name} to {name} "
-                f"(value: {_c(object_)}) failed: {str(e)}"
+                f"(value: {_c(obj)}) failed: {str(e)}"
             )
         name = f"{self.filter_name}({name})"
-        return self.schema.__validate__(
-            object_, name="object", strict=strict, subs=subs
-        )
+        return self.schema.__validate__(obj, name="object", strict=strict, subs=subs)
+
 
+class filter(wrapper):
+    """
+    Applies `callable` to the object and validates the result with `schema`.
+    If the callable throws an exception then validation fails.
+    """
 
-class filter:
     filter: Callable[[Any], object]
     schema: object
     filter_name: str | None
@@ -1768,6 +2324,15 @@ class filter:
         schema: object,
         filter_name: str | None = None,
     ) -> None:
+        """
+        :param filter: the filter to apply to the object
+        :param schema: the schema used for validation once the filter has been
+          applied
+        :param filter_name: common name to refer to the filter
+
+        :raises SchemaError: exception thrown when the schema definition is
+          found to contain an error
+        """
         if filter_name is not None and not isinstance(filter_name, str):
             raise SchemaError("The filter name is not a string")
         if not callable(filter):
@@ -1792,22 +2357,20 @@ 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__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         try:
-            if self.schema == float and isinstance(object_, int):
+            if self.schema == float and isinstance(obj, int):
                 return ""
-            if not isinstance(object_, self.schema):
-                return _wrong_type_message(object_, name, self.schema.__name__)
+            if not isinstance(obj, self.schema):
+                return _wrong_type_message(obj, name, self.schema.__name__)
             else:
                 return ""
         except Exception as e:
@@ -1815,29 +2378,16 @@ class _type(compiled_schema):
 
     def __validate_float__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         # consider int as a subtype of float
-        if isinstance(object_, (int, float)):
-            return ""
-        else:
-            return _wrong_type_message(object_, name, "float")
-
-    def __validate_complex__(
-        self,
-        object_: object,
-        name: str = "object",
-        strict: bool = True,
-        subs: Mapping[str, object] = {},
-    ) -> str:
-        # consider int, float as subtypes of complex
-        if isinstance(object_, (int, float, complex)):
+        if isinstance(obj, (int, float)):
             return ""
         else:
-            return _wrong_type_message(object_, name, "complex")
+            return _wrong_type_message(obj, name, "float")
 
     def __str__(self) -> str:
         return self.schema.__name__
@@ -1871,15 +2421,15 @@ class _sequence(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, self.type_schema.__name__)
+        if not isinstance(obj, self.type_schema):
+            return _wrong_type_message(obj, name, self.type_schema.__name__)
         ls = len(self.schema)
-        lo = len(object_)
+        lo = len(obj)
         if strict:
             if lo > ls:
                 return f"{name}[{ls}] is not in the schema"
@@ -1887,32 +2437,32 @@ class _sequence(compiled_schema):
             return f"{name}[{lo}] is missing"
         for i in range(ls):
             name_ = f"{name}[{i}]"
-            ret = self.schema[i].__validate__(object_[i], name_, strict, subs)
+            ret = self.schema[i].__validate__(obj[i], name_, strict, subs)
             if ret != "":
                 return ret
         return ""
 
     def __validate_ellipsis__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, self.type_schema.__name__)
+        if not isinstance(obj, self.type_schema):
+            return _wrong_type_message(obj, name, self.type_schema.__name__)
         ls = len(self.schema)
-        lo = len(object_)
+        lo = len(obj)
         if ls > lo:
             return f"{name}[{lo}] is missing"
         for i in range(ls):
             name_ = f"{name}[{i}]"
-            ret = self.schema[i].__validate__(object_[i], name_, strict, subs)
+            ret = self.schema[i].__validate__(obj[i], name_, strict, subs)
             if ret != "":
                 return ret
         for i in range(ls, lo):
             name_ = f"{name}[{i}]"
-            ret = self.fill.__validate__(object_[i], name_, strict, subs)
+            ret = self.fill.__validate__(obj[i], name_, strict, subs)
             if ret != "":
                 return ret
         return ""
@@ -1929,18 +2479,18 @@ class _const(compiled_schema):
         if isinstance(schema, float) and not strict_eq:
             setattr(self, "__validate__", close_to(schema).__validate__)
 
-    def message(self, name: str, object_: object) -> str:
-        return f"{name} (value:{_c(object_)}) is not equal to {repr(self.schema)}"
+    def message(self, name: str, obj: object) -> str:
+        return f"{name} (value:{_c(obj)}) is not equal to {repr(self.schema)}"
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if object_ != self.schema:
-            return self.message(name, object_)
+        if obj != self.schema:
+            return self.message(name, obj)
         return ""
 
     def __str__(self) -> str:
@@ -1960,18 +2510,18 @@ class _callable(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
         try:
-            if self.schema(object_):
+            if self.schema(obj):
                 return ""
             else:
-                return _wrong_type_message(object_, name, self.__name__)
+                return _wrong_type_message(obj, name, self.__name__)
         except Exception as e:
-            return _wrong_type_message(object_, name, self.__name__, str(e))
+            return _wrong_type_message(obj, name, self.__name__, str(e))
 
     def __str__(self) -> str:
         return str(self.schema)
@@ -1997,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:
@@ -2016,25 +2566,25 @@ class _dict(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, self.type_schema.__name__)
+        if not isinstance(obj, self.type_schema):
+            return _wrong_type_message(obj, name, self.type_schema.__name__)
 
         for k in self.min_keys:
-            if k not in object_:
+            if k not in obj:
                 name_ = f"{name}[{repr(k)}]"
                 return f"{name_} is missing"
 
-        for k in object_:
+        for k in obj:
             vals = []
             name_ = f"{name}[{repr(k)}]"
             if k in self.const_keys:
                 val = self.schema[k].__validate__(
-                    object_[k], name=name_, strict=strict, subs=subs
+                    obj[k], name=name_, strict=strict, subs=subs
                 )
                 if val == "":
                     continue
@@ -2044,7 +2594,7 @@ class _dict(compiled_schema):
             for kk in self.other_keys:
                 if kk.__validate__(k, name="key", strict=strict, subs=subs) == "":
                     val = self.schema[kk].__validate__(
-                        object_[k], name=name_, strict=strict, subs=subs
+                        obj[k], name=name_, strict=strict, subs=subs
                     )
                     if val == "":
                         break
@@ -2085,27 +2635,27 @@ class _set(compiled_schema):
 
     def __validate_empty_set__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, self.type_schema.__name__)
-        if len(object_) != 0:
-            return f"{name} (value:{_c(object_)}) is not empty"
+        if not isinstance(obj, self.type_schema):
+            return _wrong_type_message(obj, name, self.type_schema.__name__)
+        if len(obj) != 0:
+            return f"{name} (value:{_c(obj)}) is not empty"
         return ""
 
     def __validate_singleton__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, set):
-            return _wrong_type_message(object_, name, self.type_schema.__name__)
-        for i, o in enumerate(object_):
+        if not isinstance(obj, set):
+            return _wrong_type_message(obj, name, self.type_schema.__name__)
+        for i, o in enumerate(obj):
             name_ = f"{name}{{{i}}}"
             v = self.schema.__validate__(o, name=name_, strict=True, subs=subs)
             if v != "":
@@ -2114,14 +2664,14 @@ class _set(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
-        if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, self.type_schema.__name__)
-        for i, o in enumerate(object_):
+        if not isinstance(obj, self.type_schema):
+            return _wrong_type_message(obj, name, self.type_schema.__name__)
+        for i, o in enumerate(obj):
             name_ = f"{name}{{{i}}}"
             v = self.schema.__validate__(o, name=name_, strict=True, subs=subs)
             if v != "":
@@ -2132,12 +2682,26 @@ class _set(compiled_schema):
         return str(self.schema_)
 
 
-class protocol:
-    type_dict: dict[object, object]
+class protocol(wrapper):
+    """
+    An object matches the schema `protocol(schema, dict=False)` if `schema` is
+    a class (or class like object) and its fields are annotated with schemas
+    which validate the corresponding fields in the object.
+    """
+
+    type_dict: dict[optional_key[str], object]
     dict: bool
     __name__: str
 
     def __init__(self, schema: object, dict: bool = False):
+        """
+        :param schema: a type annotated class (or class like object such as
+          Protocol or TypedDict) serving as prototype
+        :param dict: if `True` parse the object as a `dict`
+
+        :raises SchemaError: exception thrown when the schema does not support
+          type_hints
+        """
         if not isinstance(dict, bool):
             raise SchemaError("bool flag is not a bool")
         type_hints = _get_type_hints(schema)
@@ -2156,7 +2720,7 @@ class protocol:
     ) -> 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,
@@ -2225,16 +2789,16 @@ class _Mapping(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
 
-        if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, self.__name__)
+        if not isinstance(obj, self.type_schema):
+            return _wrong_type_message(obj, name, self.__name__)
 
-        for k, v in object_.items():
+        for k, v in obj.items():
             _name = f"{name}[{repr(k)}]"
             message = self.key.__validate__(k, name=str(k), strict=strict, subs=subs)
             if message != "":
@@ -2265,17 +2829,17 @@ class _Container(compiled_schema):
 
     def __validate__(
         self,
-        object_: object,
+        obj: object,
         name: str = "object",
         strict: bool = True,
         subs: Mapping[str, object] = {},
     ) -> str:
 
-        if not isinstance(object_, self.type_schema):
-            return _wrong_type_message(object_, name, self.type_schema.__name__)
+        if not isinstance(obj, self.type_schema):
+            return _wrong_type_message(obj, name, self.type_schema.__name__)
 
         try:
-            for i, o in enumerate(object_):
+            for i, o in enumerate(obj):
                 _name = f"{name}[{i}]"
                 message = self.schema.__validate__(
                     o, name=_name, strict=strict, subs=subs
@@ -2283,7 +2847,7 @@ class _Container(compiled_schema):
                 if message != "":
                     return message
         except Exception as e:
-            return _wrong_type_message(object_, name, self.__name__, explanation=str(e))
+            return _wrong_type_message(obj, name, self.__name__, explanation=str(e))
 
         return ""