thds.attrs-utils 1.6.20251107140602__py3-none-any.whl

thds/attrs_utils/__init__.py

@@ -0,0 +1,4 @@
+from thds.core import meta
+
+__version__ = meta.get_version(__name__)
+__commit__ = meta.read_metadata(__name__).git_commit

thds/attrs_utils/cattrs/__init__.py

@@ -0,0 +1,29 @@
+__all__ = [
+    "DEFAULT_RESTRICTED_CONVERSIONS",
+    "DEFAULT_JSON_CONVERTER",
+    "DEFAULT_STRUCTURE_HOOKS",
+    "DEFAULT_UNSTRUCTURE_HOOKS_JSON",
+    "PREJSON_UNSTRUCTURE_COLLECTION_OVERRIDES",
+    "DisallowedConversionError",
+    "default_converter",
+    "format_cattrs_classval_error",
+    "setup_converter",
+]
+
+from .converter import (
+    DEFAULT_RESTRICTED_CONVERSIONS,
+    DEFAULT_STRUCTURE_HOOKS,
+    DEFAULT_UNSTRUCTURE_HOOKS_JSON,
+    PREJSON_UNSTRUCTURE_COLLECTION_OVERRIDES,
+    default_converter,
+    setup_converter,
+)
+from .errors import DisallowedConversionError, format_cattrs_classval_error
+
+DEFAULT_JSON_CONVERTER = setup_converter(
+    default_converter(),
+    struct_hooks=DEFAULT_STRUCTURE_HOOKS,
+    unstruct_hooks=DEFAULT_UNSTRUCTURE_HOOKS_JSON,
+    deterministic=True,
+    strict_enums=False,
+)

thds/attrs_utils/cattrs/converter.py

@@ -0,0 +1,182 @@
+import datetime
+import decimal
+import typing as ty
+from functools import partial
+from typing import Any, Callable, Sequence, Tuple, Type
+
+from cattr.converters import Converter, GenConverter
+
+from ..type_utils import is_literal_type, is_set_type, literal_base
+from . import errors
+
+T = ty.TypeVar("T")
+Struct = Callable[[Any, Type[T]], T]
+UnStruct = Callable[[Any], T]
+StructFactory = Callable[[Any], Struct[T]]
+
+
+PREJSON_UNSTRUCTURE_COLLECTION_OVERRIDES = {
+    ty.Set: list,
+    ty.FrozenSet: list,
+    ty.AbstractSet: list,
+    ty.MutableSet: list,
+    ty.Sequence: list,
+    ty.DefaultDict: dict,
+    ty.OrderedDict: dict,
+    ty.Mapping: dict,
+    ty.MutableMapping: dict,
+}
+
+
+# hooks
+
+
+def _date_from_isoformat(dt: ty.Union[str, datetime.date], t: Type[datetime.date]) -> datetime.date:
+    if isinstance(dt, datetime.datetime):  # check most specific type first
+        return dt.date()
+    if isinstance(dt, datetime.date):
+        return dt
+    return t.fromisoformat(str(dt))
+
+
+def _datetime_from_isoformat(
+    dt: ty.Union[str, datetime.date], t: Type[datetime.datetime]
+) -> datetime.datetime:
+    if isinstance(dt, datetime.datetime):
+        return dt
+    if isinstance(dt, datetime.date):
+        return datetime.datetime(dt.year, dt.month, dt.day)
+    return t.fromisoformat(str(dt))
+
+
+def unstructure_set(converter: Converter, items: ty.AbstractSet) -> ty.List:
+    sorted_items = sorted(items)
+    return list(map(converter.unstructure, sorted_items))
+
+
+def _structure_as(converter: Converter, actual_type: Type[T], obj: Any, _: Any) -> T:
+    return converter.structure(obj, actual_type)
+
+
+def structure_as(converter: Converter, actual_type: Type[T]) -> Struct[T]:
+    """Define a custom structuring function for cattrs which works by deferring to another type.
+    This is useful for some types which cattrs does not natively support, but which otherwise have implementations
+    using types that it *does* support; e.g. NewType(str) or a Union thereof"""
+    return partial(_structure_as, converter, actual_type)
+
+
+def _structure_literal_as_base_type(converter: Converter, type_: Type) -> Struct:
+    base_type = literal_base(type_)
+    return structure_as(converter, base_type)
+
+
+def structure_literal_as_base_type(converter: Converter) -> StructFactory:
+    return partial(_structure_literal_as_base_type, converter)
+
+
+def _structure_restricted_conversion(
+    allowed_types: Tuple[Type, ...], parse: Callable[[Any], T], value: Any, _: Type[T]
+) -> T:
+    if type(value) in allowed_types:
+        return parse(value)
+    raise errors.DisallowedConversionError(type(value), _)
+
+
+def structure_restricted_conversion(
+    allowed_types: Tuple[Type, ...], parse: Callable[[Any], T]
+) -> Struct[T]:
+    """This hook ensures that the more dubious behaviors of cattrs are forbidden; only values which can
+    be very unambiguously interpreted as the target type are allowed to be unstructured as such."""
+    return partial(_structure_restricted_conversion, allowed_types, parse)
+
+
+# default hooks
+
+DEFAULT_STRUCTURE_HOOKS: Sequence[Tuple[Type, Struct]] = (
+    (datetime.date, _date_from_isoformat),
+    (datetime.datetime, _datetime_from_isoformat),
+)
+DEFAULT_UNSTRUCTURE_HOOKS_JSON: Sequence[Tuple[Type, UnStruct]] = (
+    (datetime.date, datetime.date.isoformat),
+    (datetime.datetime, datetime.datetime.isoformat),
+    (decimal.Decimal, float),
+)
+DEFAULT_RESTRICTED_CONVERSIONS: Sequence[Tuple[Tuple[Type, ...], Type, UnStruct]] = (
+    ((int, str), str, str),
+    ((int, str, float, decimal.Decimal), float, float),
+    ((bool, str, int), int, int),
+    ((bool,), bool, bool),
+)
+
+
+# default converters
+
+
+def setup_converter(
+    converter: Converter,
+    struct_hooks: Sequence[Tuple[Type[T], Struct[T]]] = DEFAULT_STRUCTURE_HOOKS,
+    unstruct_hooks: Sequence[Tuple[Type[T], UnStruct[T]]] = (),
+    custom_structure_as: Sequence[Tuple[Type, Type]] = (),
+    restricted_conversions: Sequence[
+        Tuple[Tuple[Type, ...], Type[T], UnStruct[T]]
+    ] = DEFAULT_RESTRICTED_CONVERSIONS,
+    deterministic: bool = True,
+    strict_enums: bool = False,
+) -> Converter:
+    """Performs side effects on your converter, registering various hooks.
+
+    :param converter: the cattrs Converter to update
+    :param struct_hooks: custom structuring hooks as tuples of (type, callable(value, type) -> value)
+    :param unstruct_hooks: custom unstructuring hooks as tuples of (type, callable(value) -> value)
+    :param custom_structure_as: tuples of (type1, type2). When these are passed, the converter will
+      structure values into type1 using the pre-defined behavior for type2. Useful for specifying that
+      some complex type can really be treated in a simpler way (e.g. that a union over several string
+      literal enums can just be structured as a string).
+    :param restricted_conversions: tuples of ((in_type, ...), out_type, parser(value) -> out_type).
+      When an input is to be structured into the out_type, it will only be allowed to do so if its
+      concrete type is in the in_type tuple (strict inclusion, not `isinstance` check, to avoid confusion
+      e.g. from subtle subclass relations such as bool being a subclass of int). The default includes a
+      reasonable set of restrictions that are *not* by default respected by cattrs.
+    :param deterministic: when True, an attempt is made to produce deterministic output on unstructuring.
+      For example, sets will be sorted prior to being unstructured (but not after, since in general
+      unstructured values such as dicts may not be orderable). This requires all types contained within
+      sets in your data model to be orderable. Defaults to True.
+    :param strict_enums: when True, on unstructuring into a Literal type, an error will be raised when
+      the input value is not one of the expected values. This is the default behavior of cattrs as of
+      version 22. You may not wish to be so strict when accepting data from a source with potential data
+      quality issues, preferring perhaps to clean up any unexpected values after structuring, in which
+      case this should be False, the default value.
+    :return: the modified converter with hooks registered.
+    """
+    for target_type, struct in struct_hooks:
+        converter.register_structure_hook(target_type, struct)
+    for target_type, unstruct in unstruct_hooks:
+        converter.register_unstructure_hook(target_type, unstruct)
+    for input_types, target_type, parser in restricted_conversions:
+        converter.register_structure_hook(
+            target_type, structure_restricted_conversion(input_types, parser)
+        )
+    for actual_type, override_type in custom_structure_as:
+        converter.register_structure_hook(actual_type, structure_as(converter, override_type))
+    if deterministic:
+        converter.register_unstructure_hook_func(is_set_type, partial(unstructure_set, converter))
+    if not strict_enums:
+        converter.register_structure_hook_factory(
+            is_literal_type, structure_literal_as_base_type(converter)
+        )
+    return converter
+
+
+def default_converter(
+    *,
+    forbid_extra_keys: bool = True,
+    prefer_attrib_converters: bool = True,
+    unstruct_collection_overrides: ty.Mapping[
+        Type, Callable[[], ty.Collection]
+    ] = PREJSON_UNSTRUCTURE_COLLECTION_OVERRIDES,  # type: ignore [assignment]
+) -> Converter:
+    return GenConverter(
+        unstruct_collection_overrides=unstruct_collection_overrides,
+        prefer_attrib_converters=prefer_attrib_converters,
+        forbid_extra_keys=forbid_extra_keys,
+    )

thds/attrs_utils/cattrs/errors.py

@@ -0,0 +1,46 @@
+from functools import singledispatch
+from typing import Callable, Optional, Type
+
+import cattrs
+import cattrs.errors
+import cattrs.v
+
+
+class DisallowedConversionError(TypeError):
+    """Raised when a value is not allowed to be converted to a certain type."""
+
+    def __init__(self, value_type: Type, target_type: Type):
+        super().__init__(value_type, target_type)
+        self.value_type = value_type
+        self.target_type = target_type
+
+    def __str__(self):
+        return f"Refusing to structure value of type {self.value_type} to type {self.target_type}"
+
+
+@singledispatch
+def format_cattrs_exception(exc: BaseException, type_: Optional[Type]) -> str:
+    """Default formatter for cattrs exceptions. Extensible via `singledispatch` to handle other exception types."""
+    return cattrs.v.format_exception(exc, type_)
+
+
+@format_cattrs_exception.register(DisallowedConversionError)
+def _format_disallowed_conversion_error(exc: DisallowedConversionError, type_: Optional[Type]) -> str:
+    """Override cattrs' default exception formatting for our more strict approach to type conversion.
+    Cattrs is extremely lax - e.g. `None` is permitted for `str` (structures to `"None"`) or `bool`
+    (structures to `False`), which we prevent with custom hooks and signal with a custom exception."""
+    return f"invalid value for type, expected {exc.target_type.__name__}, got {exc.value_type.__name__}"
+
+
+@format_cattrs_exception.register(cattrs.errors.ClassValidationError)
+def format_cattrs_classval_error(
+    exc: cattrs.errors.ClassValidationError,
+    format_exception: Callable[[BaseException, Optional[Type]], str] = format_cattrs_exception,
+) -> str:
+    """Format a cattrs ClassValError into a human-readable string."""
+
+    sep = "\n  "
+    return (
+        f"{exc.message}:{sep}"
+        f"{sep.join(reversed(cattrs.transform_error(exc, format_exception=format_exception)))}"
+    )

thds/attrs_utils/defaults.py

@@ -0,0 +1,31 @@
+import typing as ty
+
+import attrs
+from attr._make import Factory  # cannot import the actual class via attrs
+
+
+def has_value_default(default: ty.Any) -> bool:
+    if isinstance(default, Factory):
+        # a takes_self Factory requires an instance to create the default; therefore
+        # there is no single, known default value to extract
+        return not default.takes_self
+    return default is not attrs.NOTHING
+
+
+def extract_factory_default(default: ty.Any) -> ty.Any:
+    if isinstance(default, Factory):
+        assert not default.takes_self
+        return default.factory()
+
+    return default
+
+
+def attrs_value_defaults(attrs_cls: ty.Type) -> ty.Dict[str, ty.Any]:
+    """Returns a dictionary populated only by attribute names and their default values -
+    and only for attributes which _have_ simple default values.
+    """
+    return {
+        name: extract_factory_default(field.default)
+        for name, field in attrs.fields_dict(attrs_cls).items()
+        if has_value_default(field.default)
+    }

thds/attrs_utils/docs.py

@@ -0,0 +1,75 @@
+"""Utils for collecting structured documentation from class docstrings"""
+
+import inspect
+from collections import ChainMap
+from itertools import chain
+from typing import Callable, Dict, List, Literal, Optional, Set, Type
+
+from docstring_parser import Docstring, DocstringMeta, DocstringParam, Style, parse
+
+from .type_utils import bases
+
+DocCombineSpec = Literal["first", "join"]
+
+
+def get_record_class_fields(cls: Type) -> Set[str]:
+    """Get the names of the attributes of a class"""
+
+    if not inspect.isclass(cls):
+        raise ValueError("Input should be a class")
+
+    return set(inspect.signature(cls).parameters.keys())
+
+
+def record_class_docs(
+    cls: Type,
+    filter_bases: Optional[Callable[[Type], bool]] = None,
+    style: Style = Style.AUTO,
+    combine_docs: DocCombineSpec = "first",
+    join_sep: str = "\n\n",
+    require_complete: bool = False,
+) -> Docstring:
+    base_clss = [c for c in bases(cls, filter_bases) if c is not object]
+
+    docs = [parse(c.__doc__, style=style) for c in base_clss if c.__doc__]
+    params = dict(ChainMap(*({param.arg_name: param for param in doc.params} for doc in docs)))
+
+    if require_complete:
+        missing = get_record_class_fields(cls) - set(params.keys())
+        if missing:
+            raise ValueError(f"Missing docstring params for {cls.__name__}: {missing}")
+
+    if combine_docs == "first":
+        short_description = next((doc.short_description for doc in docs if doc.short_description), None)
+        long_description = next((doc.long_description for doc in docs if doc.long_description), None)
+    else:
+        short_description = join_sep.join(
+            doc.short_description for doc in reversed(docs) if doc.short_description
+        )
+        long_description = join_sep.join(
+            doc.long_description for doc in reversed(docs) if doc.long_description
+        )
+
+    combined_meta: Dict[Type[DocstringMeta], List[DocstringMeta]] = {
+        DocstringParam: list(params.values())
+    }
+    for doc in docs:
+        metas: Dict[Type[DocstringMeta], List[DocstringMeta]] = {}
+        for meta in doc.meta:
+            meta_type = type(meta)
+            if meta_type not in combined_meta:
+                metas.setdefault(meta_type, []).append(meta)
+        for meta_type, meta_list in metas.items():
+            combined_meta[meta_type] = meta_list
+
+    style_: Optional[Style] = next((doc.style for doc in docs if doc.style), None)
+    combined_doc = Docstring(style_)
+    combined_doc.short_description = short_description
+    combined_doc.long_description = long_description
+    combined_doc.meta = list(chain.from_iterable(combined_meta.values()))
+
+    bad_params = {param.arg_name for param in combined_doc.params if not param.description}
+    if bad_params:
+        raise ValueError(f"Parameters {bad_params} have no description")
+
+    return combined_doc

thds/attrs_utils/empty.py

@@ -0,0 +1,146 @@
+import datetime
+import enum
+import inspect
+import typing as ty
+import uuid
+import warnings
+from functools import partial
+
+import attr
+
+from . import recursion, type_recursion, type_utils
+from .registry import Registry
+from .type_recursion import Constructor
+
+T = ty.TypeVar("T")
+
+
+def const(value: T) -> Constructor[T]:
+    return lambda: value
+
+
+def empty_optional(empty_gen, type_: ty.Type[T]) -> Constructor[ty.Optional[T]]:
+    return const(None)
+
+
+def _construct_record(
+    type_: ty.Type[T],
+    signature: inspect.Signature,
+    defaults: ty.Mapping[str, Constructor[ty.Any]],
+    *args: ty.Any,
+    **kwargs: ty.Any,
+) -> T:
+    bound = signature.bind_partial(*args, **kwargs)
+    defaults_ = {k: v() for k, v in defaults.items() if k not in bound.arguments}
+    bound.arguments.update(defaults_)
+    return type_(*bound.args, **bound.kwargs)
+
+
+def _record_constructor(
+    type_: ty.Type[T], defaults: ty.Mapping[str, Constructor[ty.Any]]
+) -> Constructor[T]:
+    signature = inspect.signature(type_)
+    f = partial(
+        _construct_record, type_, signature, defaults
+    )  # using partial application to allow picklability
+    try:
+        repl_signature = inspect.Signature(
+            [
+                (
+                    inspect.Parameter(
+                        p.name, p.kind, default=defaults[p.name](), annotation=p.annotation
+                    )
+                    if p.name in defaults
+                    else p
+                )
+                for p in signature.parameters.values()
+            ],
+            return_annotation=signature.return_annotation,
+        )
+    except Exception as e:
+        warnings.warn(
+            f"Couldn't generate signature for {type_} with new defaults {defaults}; using original signature for documenation: {e}"
+        )
+        repl_signature = signature
+    f.__signature__ = repl_signature  # type: ignore[attr-defined]
+    # ^ allows tab completion in REPLs
+    return f
+
+
+def empty_attrs(empty_gen, type_: ty.Type[attr.AttrsInstance]) -> Constructor[attr.AttrsInstance]:
+    fields = attr.fields(type_)
+    defaults = {f.name: empty_gen(f.type) for f in fields if f.default is attr.NOTHING}
+    # keep the original defaults and default factories
+    return _record_constructor(type_, defaults)
+
+
+def empty_namedtuple(empty_gen, type_: ty.Type[ty.NamedTuple]) -> Constructor[ty.NamedTuple]:
+    defaults = {
+        name: empty_gen(t)
+        for name, t in type_.__annotations__.items()
+        if name not in type_._field_defaults
+    }
+    # keep the original defaults
+    return _record_constructor(type_, defaults)
+
+
+def empty_collection(empty_gen, type_: ty.Type[ty.Collection]) -> Constructor[ty.Collection]:
+    return type_utils.concrete_constructor(type_)
+
+
+def empty_literal(empty_gen, type_: ty.Type[T]) -> Constructor[T]:
+    return const(ty.get_args(type_)[0])
+
+
+def empty_enum(empty_gen, type_: ty.Type[enum.Enum]) -> Constructor[enum.Enum]:
+    return const(next(iter(type_)))
+
+
+def empty_union(empty_gen, type_: ty.Type[T]) -> Constructor[T]:
+    return empty_gen(ty.get_args(type_)[0])  # construct the first type in the union
+
+
+def _construct_tuple(
+    type_: ty.Callable[..., ty.Tuple], defaults: ty.Sequence[Constructor[ty.Any]], *args: ty.Any
+) -> ty.Tuple:
+    return type_([*args, *(f() for f in defaults[len(args) :])])
+
+
+def empty_tuple(empty_gen, type_: ty.Type[ty.Tuple]) -> Constructor[ty.Tuple]:
+    args = ty.get_args(type_)
+    base = type_utils.concrete_constructor(type_)
+    defaults = [empty_gen(arg) for arg in args]
+    return partial(_construct_tuple, base, defaults)  # using partial application to allow picklability
+
+
+unknown_type: "recursion.RecF[ty.Type, [], Constructor]" = recursion.value_error(
+    "Don't know how to generate an 'empty' value for type {!r}; "
+    "use {__name__}.empty_gen.register to register an empty generator",
+    TypeError,
+)
+
+REGISTRY: Registry[ty.Type, Constructor] = Registry(
+    [
+        (type(None), const(None)),
+        *[(type_, type_) for type_ in [int, bool, float, str, bytes, bytearray]],
+        (datetime.date, const(datetime.date.min)),
+        (datetime.datetime, const(datetime.datetime.min)),
+        (uuid.UUID, uuid.uuid4),
+    ]
+)
+
+empty_gen: "type_recursion.ConstructorFactory[[]]" = type_recursion.ConstructorFactory(
+    REGISTRY,
+    cached=True,
+    attrs=empty_attrs,
+    namedtuple=empty_namedtuple,
+    literal=empty_literal,
+    enum=empty_enum,
+    optional=empty_optional,
+    union=empty_union,
+    tuple=empty_tuple,
+    variadic_tuple=empty_collection,
+    mapping=empty_collection,
+    collection=empty_collection,
+    otherwise=unknown_type,
+)

thds/attrs_utils/isinstance/__init__.py

@@ -0,0 +1,4 @@
+"""Interface for creating a callable from a data type, which accepts a value and validates that the
+value is an instance of the type, recursively and respecting generic type parameters"""
+
+from .check import instancecheck, isinstance  # noqa: F401

thds/attrs_utils/isinstance/check.py

@@ -0,0 +1,107 @@
+from typing import Any, NamedTuple, Type, cast, get_args, get_origin
+
+import attrs
+
+from .. import recursion, type_utils
+from ..type_recursion import TypeRecursion
+from . import util
+from .registry import ISINSTANCE_REGISTRY
+from .util import Check
+
+_UNKNOWN_TYPE = (
+    "Don't know how to check for instances of {!r}; use "
+    f"{__name__}.instancecheck.register to register an instance check"
+)
+
+unknown_type: "recursion.RecF[Type, [], Check]" = recursion.value_error(_UNKNOWN_TYPE, TypeError)
+
+
+def simple_isinstance(instancecheck, type_: Type):
+    return util.simple_isinstance(type_)
+
+
+def check_literal(instancecheck, type_: Type):
+    return util.check_in_values(get_args(type_))
+
+
+def check_attrs(instancecheck, type_: Type[attrs.AttrsInstance]):
+    # this _should_ typecheck according to my understanding of attrs.AttrsInstance but it is not
+    fields = attrs.fields(type_)  # type: ignore [misc]
+    names = tuple(f.name for f in fields)
+    types = (f.type for f in fields)
+    return util.check_attrs(
+        util.simple_isinstance(type_),
+        names,
+        *map(instancecheck, types),
+    )
+
+
+def check_namedtuple(instancecheck, type_: Type[NamedTuple]):
+    field_types = tuple(type_.__annotations__[name] for name in type_._fields)
+    return util.check_typed_tuple(util.simple_isinstance(type_), *map(instancecheck, field_types))
+
+
+def check_mapping(instancecheck, type_: Type):
+    args = get_args(type_)
+    if len(args) != 2:
+        return unknown_type(instancecheck, type_)
+    kt, vt = args
+    k_check = instancecheck(kt)
+    v_check = instancecheck(vt)
+    org = cast(Type, get_origin(type_))
+    return util.check_mapping(util.simple_isinstance(org), k_check, v_check)
+
+
+def check_tuple(instancecheck, type_: Type):
+    org = cast(Type, get_origin(type_))
+    args = get_args(type_)
+    return util.check_typed_tuple(util.simple_isinstance(org), *map(instancecheck, args))
+
+
+def check_variadic_tuple(instancecheck, type_: Type):
+    org = cast(Type, get_origin(type_))
+    args = get_args(type_)
+    v_check = instancecheck(args[0])
+    return util.check_collection(util.simple_isinstance(org), v_check)
+
+
+def check_collection(instancecheck, type_: Type):
+    args = get_args(type_)
+    if len(args) != 1:
+        return unknown_type(instancecheck, type_)
+    org = cast(Type, get_origin(type_))
+    v_check = instancecheck(args[0])
+    return util.check_collection(util.simple_isinstance(org), v_check)
+
+
+def check_union(instancecheck, type_: Type):
+    return util.check_any(*map(instancecheck, get_args(type_)))
+
+
+def check_any(instancecheck, type_: Type):
+    if isinstance(type_, type):
+        # simple concrete type
+        return util.simple_isinstance(type_)
+    return unknown_type(instancecheck, type_)
+
+
+instancecheck: "TypeRecursion[[], Check]" = TypeRecursion(
+    ISINSTANCE_REGISTRY,
+    # just use isinstance on builtins - don't want to check bytes/str as collections for instance.
+    # also an optimization to put this check first since these are the most common types.
+    first=(type_utils.is_builtin_type, simple_isinstance),
+    literal=check_literal,
+    enum=simple_isinstance,
+    attrs=check_attrs,
+    namedtuple=check_namedtuple,
+    union=check_union,
+    mapping=check_mapping,
+    collection=check_collection,
+    tuple=check_tuple,
+    variadic_tuple=check_variadic_tuple,
+    otherwise=check_any,
+)
+
+
+def isinstance(obj: Any, type_: Type) -> bool:
+    return instancecheck(type_)(obj)

thds/attrs_utils/isinstance/registry.py

@@ -0,0 +1,13 @@
+from typing import Any, Type
+
+from ..registry import Registry
+from .util import Check
+
+
+def true(value: Any) -> bool:
+    return True
+
+
+ISINSTANCE_REGISTRY: Registry[Type, Check] = Registry(
+    {Any: true, object: true}  # type: ignore [dict-item]
+)