dycw-utilities 0.129.10__py3-none-any.whl → 0.175.17__py3-none-any.whl

utilities/typing.py

@@ -1,21 +1,25 @@
 from __future__ import annotations
 
 import datetime as dt
-from collections.abc import Mapping, Sequence
-from dataclasses import dataclass
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from dataclasses import dataclass, is_dataclass
+from functools import partial
 from itertools import chain
 from pathlib import Path
+from re import search
 from types import NoneType, UnionType
 from typing import (
     Any,
+    ForwardRef,
     Literal,
     NamedTuple,
+    NotRequired,
     Optional,  # pyright: ignore[reportDeprecated]
-    Self,
     TypeAliasType,
     TypeGuard,
-    TypeVar,
     Union,  # pyright: ignore[reportDeprecated]
+    _TypedDictMeta,  # pyright: ignore[reportAttributeAccessIssue]
+    cast,
     get_origin,
     overload,
     override,
@@ -25,27 +29,26 @@ from typing import get_type_hints as _get_type_hints
 from uuid import UUID
 from warnings import warn
 
+import whenever
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
 from utilities.iterables import unique_everseen
 from utilities.sentinel import Sentinel
-from utilities.types import StrMapping
-
-_T = TypeVar("_T")
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_T4 = TypeVar("_T4")
-_T5 = TypeVar("_T5")
-
-
-##
-
-
-def contains_self(obj: Any, /) -> bool:
-    """Check if an annotation contains `Self`."""
-    return (obj is Self) or any(map(contains_self, get_args(obj)))
-
-
-##
+from utilities.types import (
+    Dataclass,
+    StrMapping,
+    StrStrMapping,
+    TupleOrStrMapping,
+    TypeLike,
+)
 
 
 def get_args(obj: Any, /, *, optional_drop_none: bool = False) -> tuple[Any, ...]:
@@ -61,6 +64,18 @@ def get_args(obj: Any, /, *, optional_drop_none: bool = False) -> tuple[Any, ...
 ##
 
 
+def get_forward_ref_args(obj: Any, /) -> StrStrMapping:
+    """Get the forward args."""
+    return {
+        k: v.__forward_arg__
+        for k, v in obj.__annotations__.items()
+        if isinstance(v, ForwardRef)
+    }
+
+
+##
+
+
 def get_literal_elements(obj: Any, /) -> list[Any]:
     """Get the elements of a literal annotation."""
     return _get_literal_elements_inner(obj)
@@ -132,21 +147,44 @@ def get_type_hints(
     warn_name_errors: bool = False,
 ) -> dict[str, Any]:
     """Get the type hints of an object."""
-    result: dict[str, Any] = obj.__annotations__
-    _ = {Literal, Path, Sentinel, StrMapping, UUID, dt}
+    _ = {
+        Date,
+        DateDelta,
+        DateTimeDelta,
+        Literal,
+        Path,
+        PlainDateTime,
+        Sentinel,
+        StrMapping,
+        Time,
+        TimeDelta,
+        UUID,
+        ZonedDateTime,
+        whenever.Date,
+        whenever.DateDelta,
+        whenever.DateTimeDelta,
+        whenever.PlainDateTime,
+        whenever.Time,
+        whenever.TimeDelta,
+        whenever.ZonedDateTime,
+    }
     globalns_use = globals() | ({} if globalns is None else dict(globalns))
     localns_use = {} if localns is None else dict(localns)
+    result: dict[str, Any] = obj.__annotations__
+    result = result | dict(get_forward_ref_args(obj))
     try:
-        hints = _get_type_hints(obj, globalns=globalns_use, localns=localns_use)
+        hints = _get_type_hints(
+            obj, globalns=globalns_use, localns=localns_use, include_extras=True
+        )
     except NameError as error:
         if warn_name_errors:
             warn(f"Error getting type hints for {obj!r}; {error}", stacklevel=2)
     else:
-        result.update({
+        result = result | {
             key: value
             for key, value in hints.items()
             if (key not in result) or isinstance(result[key], str)
-        })
+        }
     return result
 
 
@@ -159,12 +197,9 @@ def get_union_type_classes(obj: Any, /) -> tuple[type[Any], ...]:
         raise _GetUnionTypeClassesUnionTypeError(obj=obj)
     types_: Sequence[type[Any]] = []
     for arg in get_args(obj):
-        if isinstance(arg, type):
-            types_.append(arg)
-        elif is_union_type(arg):
-            types_.extend(get_union_type_classes(arg))
-        else:
+        if not isinstance(arg, type):
             raise _GetUnionTypeClassesInternalTypeError(obj=obj, inner=arg)
+        types_.append(arg)
     return tuple(types_)
 
 
@@ -194,6 +229,22 @@ class _GetUnionTypeClassesInternalTypeError(GetUnionTypeClassesError):
 ##
 
 
+def is_dataclass_class(obj: Any, /) -> TypeGuard[type[Dataclass]]:
+    """Check if an object is a dataclass."""
+    return isinstance(obj, type) and is_dataclass(obj)
+
+
+##
+
+
+def is_dataclass_instance(obj: Any, /) -> TypeGuard[Dataclass]:
+    """Check if an object is an instance of a dataclass."""
+    return (not isinstance(obj, type)) and is_dataclass(obj)
+
+
+##
+
+
 def is_dict_type(obj: Any, /) -> bool:
     """Check if an object is a dict type annotation."""
     return _is_annotation_of_type(obj, dict)
@@ -211,49 +262,175 @@ def is_frozenset_type(obj: Any, /) -> bool:
 
 
 @overload
-def is_instance_gen(obj: Any, type_: type[_T], /) -> TypeGuard[_T]: ...
+def is_instance_gen[T](
+    obj: Any,
+    type_: type[T],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[T]: ...
 @overload
-def is_instance_gen(obj: Any, type_: tuple[_T1], /) -> TypeGuard[_T1]: ...
+def is_instance_gen[T1](
+    obj: Any,
+    type_: tuple[T1],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[T1]: ...
 @overload
-def is_instance_gen(obj: Any, type_: tuple[_T1, _T2], /) -> TypeGuard[_T1 | _T2]: ...
+def is_instance_gen[T1, T2](
+    obj: Any,
+    type_: tuple[T1, T2],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[T1 | T2]: ...
 @overload
-def is_instance_gen(
-    obj: Any, type_: tuple[_T1, _T2, _T3], /
-) -> TypeGuard[_T1 | _T2 | _T3]: ...
+def is_instance_gen[T1, T2, T3](
+    obj: Any,
+    type_: tuple[T1, T2, T3],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[T1 | T2 | T3]: ...
 @overload
-def is_instance_gen(
-    obj: Any, type_: tuple[_T1, _T2, _T3, _T4], /
-) -> TypeGuard[_T1 | _T2 | _T3 | _T4]: ...
+def is_instance_gen[T1, T2, T3, T4](
+    obj: Any,
+    type_: tuple[T1, T2, T3, T4],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[T1 | T2 | T3 | T4]: ...
 @overload
-def is_instance_gen(
-    obj: Any, type_: tuple[_T1, _T2, _T3, _T4, _T5], /
-) -> TypeGuard[_T1 | _T2 | _T3 | _T4 | _T5]: ...
+def is_instance_gen[T1, T2, T3, T4, T5](
+    obj: Any,
+    type_: tuple[T1, T2, T3, T4, T5],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[T1 | T2 | T3 | T4 | T5]: ...
 @overload
-def is_instance_gen(obj: Any, type_: Any, /) -> bool: ...
-def is_instance_gen(obj: Any, type_: Any, /) -> bool:
+def is_instance_gen(
+    obj: Any,
+    type_: Any,
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> bool: ...
+def is_instance_gen(
+    obj: Any,
+    type_: Any,
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> bool:
     """Check if an instance relationship holds, except bool<int."""
     # parent
     if isinstance(type_, tuple):
-        return any(is_instance_gen(obj, t) for t in type_)
+        return any(
+            is_instance_gen(
+                obj,
+                t,
+                globalns=globalns,
+                localns=localns,
+                warn_name_errors=warn_name_errors,
+            )
+            for t in type_
+        )
     if is_literal_type(type_):
         return obj in get_args(type_)
     if is_union_type(type_):
-        return any(is_instance_gen(obj, t) for t in get_args(type_))
+        return any(
+            is_instance_gen(
+                obj,
+                t,
+                globalns=globalns,
+                localns=localns,
+                warn_name_errors=warn_name_errors,
+            )
+            for t in get_args(type_)
+        )
     # tuple vs tuple
     if isinstance(obj, tuple) and is_tuple_type(type_):
         type_args = get_args(type_)
         return (len(obj) == len(type_args)) and all(
-            is_instance_gen(o, t) for o, t in zip(obj, type_args, strict=True)
+            is_instance_gen(
+                o,
+                t,
+                globalns=globalns,
+                localns=localns,
+                warn_name_errors=warn_name_errors,
+            )
+            for o, t in zip(obj, type_args, strict=True)
         )
     if isinstance(obj, tuple) is not is_tuple_type(type_):
         return False
     # basic
+    if isinstance(type_, _TypedDictMeta):
+        return _is_instance_typed_dict(
+            obj,
+            type_,
+            globalns=globalns,
+            localns=localns,
+            warn_name_errors=warn_name_errors,
+        )
     if isinstance(type_, type):
         return any(_is_instance_gen_type(obj, t) for t in get_type_classes(type_))
     raise IsInstanceGenError(obj=obj, type_=type_)
 
 
-def _is_instance_gen_type(obj: Any, type_: type[_T], /) -> TypeGuard[_T]:
+def _is_instance_typed_dict[T: _TypedDictMeta](
+    obj: Any,
+    type_: type[T],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[T]:
+    if not isinstance(obj, dict):
+        return False
+    if not all(isinstance(k, str) for k in obj):
+        return False
+    obj = cast("dict[str, Any]", obj)
+    hints = get_type_hints(
+        type_, globalns=globalns, localns=localns, warn_name_errors=warn_name_errors
+    )
+    optional = {
+        k for k, v in type_.__annotations__.items() if is_not_required_annotation(v)
+    }
+    required = {k: v for k, v in hints.items() if k not in optional}
+    if not set(obj).issuperset(required):
+        return False
+    return all(
+        is_instance_gen(
+            obj[k],
+            required[k],
+            globalns=globalns,
+            localns=localns,
+            warn_name_errors=warn_name_errors,
+        )
+        for k in required
+    )
+
+
+def _is_instance_gen_type[T](obj: Any, type_: type[T], /) -> TypeGuard[T]:
     return (
         isinstance(obj, type_)
         and not (
@@ -282,6 +459,101 @@ class IsInstanceGenError(Exception):
 ##
 
 
+@overload
+def is_iterable_of[T](
+    obj: Any,
+    cls: type[T],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Iterable[T]]: ...
+@overload
+def is_iterable_of[T1](
+    obj: Any,
+    cls: tuple[type[T1]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Iterable[T1]]: ...
+@overload
+def is_iterable_of[T1, T2](
+    obj: Any,
+    cls: tuple[type[T1], type[T2]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Iterable[T1 | T2]]: ...
+@overload
+def is_iterable_of[T1, T2, T3](
+    obj: Any,
+    cls: tuple[type[T1], type[T2], type[T3]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Iterable[T1 | T2 | T3]]: ...
+@overload
+def is_iterable_of[T1, T2, T3, T4](
+    obj: Any,
+    cls: tuple[type[T1], type[T2], type[T3], type[T4]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Iterable[T1 | T2 | T3 | T4]]: ...
+@overload
+def is_iterable_of[T1, T2, T3, T4, T5](
+    obj: Any,
+    cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Iterable[T1 | T2 | T3 | T4 | T5]]: ...
+@overload
+def is_iterable_of[T](
+    obj: Any,
+    cls: TypeLike[T],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Iterable[T]]: ...
+def is_iterable_of[T](
+    obj: Any,
+    cls: TypeLike[T],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Iterable[T]]:
+    """Check if an object is a iterable of tuple or string mappings."""
+    return isinstance(obj, Iterable) and all(
+        is_instance_gen(
+            o,
+            cls,
+            globalns=globalns,
+            localns=localns,
+            warn_name_errors=warn_name_errors,
+        )
+        for o in obj
+    )
+
+
+##
+
+
 def is_list_type(obj: Any, /) -> bool:
     """Check if an object is a list type annotation."""
     return _is_annotation_of_type(obj, list)
@@ -328,6 +600,30 @@ def _is_namedtuple_core(obj: Any, /) -> bool:
 ##
 
 
+def is_not_required_annotation(obj: Any) -> bool:
+    """Check if an annotation is not required."""
+    if is_not_required_type(obj):
+        return True
+    match obj:
+        case str() as text:
+            return bool(search("NotRequired", text))
+        case ForwardRef() as fr:
+            return is_not_required_annotation(fr.__forward_arg__)
+        case _:
+            return False
+
+
+##
+
+
+def is_not_required_type(obj: Any, /) -> bool:
+    """Check if an object is a not-required type annotation."""
+    return (obj is NotRequired) or _is_annotation_of_type(obj, NotRequired)
+
+
+##
+
+
 def is_optional_type(obj: Any, /) -> bool:
     """Check if an object is an optional type annotation."""
     is_optional = _is_annotation_of_type(obj, Optional)  # pyright: ignore[reportDeprecated]
@@ -339,6 +635,104 @@ def is_optional_type(obj: Any, /) -> bool:
 ##
 
 
+@overload
+def is_sequence_of[T](
+    obj: Any,
+    cls: type[T],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Sequence[T]]: ...
+@overload
+def is_sequence_of[T1](
+    obj: Any,
+    cls: tuple[type[T1]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Sequence[T1]]: ...
+@overload
+def is_sequence_of[T1, T2](
+    obj: Any,
+    cls: tuple[type[T1], type[T2]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Sequence[T1 | T2]]: ...
+@overload
+def is_sequence_of[T1, T2, T3](
+    obj: Any,
+    cls: tuple[type[T1], type[T2], type[T3]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Sequence[T1 | T2 | T3]]: ...
+@overload
+def is_sequence_of[T1, T2, T3, T4](
+    obj: Any,
+    cls: tuple[type[T1], type[T2], type[T3], type[T4]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Sequence[T1 | T2 | T3 | T4]]: ...
+@overload
+def is_sequence_of[T1, T2, T3, T4, T5](
+    obj: Any,
+    cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Sequence[T1 | T2 | T3 | T4 | T5]]: ...
+@overload
+def is_sequence_of[T](
+    obj: Any,
+    cls: TypeLike[T],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Sequence[T]]: ...
+def is_sequence_of[T](
+    obj: Any,
+    cls: TypeLike[T],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    warn_name_errors: bool = False,
+) -> TypeGuard[Sequence[T]]:
+    """Check if an object is a sequence of tuple or string mappings."""
+    return isinstance(obj, Sequence) and is_iterable_of(
+        obj, cls, globalns=globalns, localns=localns, warn_name_errors=warn_name_errors
+    )
+
+
+##
+
+
+def is_sequence_of_tuple_or_str_mapping(
+    obj: Any, /
+) -> TypeGuard[Sequence[TupleOrStrMapping]]:
+    """Check if an object is a sequence of tuple or string mappings."""
+    return isinstance(obj, Sequence) and all(map(is_tuple_or_str_mapping, obj))
+
+
+##
+
+
 def is_sequence_type(obj: Any, /) -> bool:
     """Check if an object is a sequence type annotation."""
     return _is_annotation_of_type(obj, Sequence)
@@ -355,30 +749,36 @@ def is_set_type(obj: Any, /) -> bool:
 ##
 
 
+def is_string_mapping(obj: Any, /) -> TypeGuard[StrMapping]:
+    """Check if an object is a string mapping."""
+    return isinstance(obj, Mapping) and is_iterable_of(obj, str)
+
+
+##
+
+
 @overload
-def is_subclass_gen(cls: type[Any], parent: type[_T], /) -> TypeGuard[type[_T]]: ...
+def is_subclass_gen[T](cls: type[Any], parent: type[T], /) -> TypeGuard[type[T]]: ...
 @overload
-def is_subclass_gen(
-    cls: type[Any], parent: tuple[type[_T1]], /
-) -> TypeGuard[type[_T1]]: ...
+def is_subclass_gen[T1](
+    cls: type[Any], parent: tuple[type[T1]], /
+) -> TypeGuard[type[T1]]: ...
 @overload
-def is_subclass_gen(
-    cls: type[Any], parent: tuple[type[_T1], type[_T2]], /
-) -> TypeGuard[type[_T1 | _T2]]: ...
+def is_subclass_gen[T1, T2](
+    cls: type[Any], parent: tuple[type[T1], type[T2]], /
+) -> TypeGuard[type[T1 | T2]]: ...
 @overload
-def is_subclass_gen(
-    cls: type[Any], parent: tuple[type[_T1], type[_T2], type[_T3]], /
-) -> TypeGuard[type[_T1 | _T2 | _T3]]: ...
+def is_subclass_gen[T1, T2, T3](
+    cls: type[Any], parent: tuple[type[T1], type[T2], type[T3]], /
+) -> TypeGuard[type[T1 | T2 | T3]]: ...
 @overload
-def is_subclass_gen(
-    cls: type[Any], parent: tuple[type[_T1], type[_T2], type[_T3], type[_T4]], /
-) -> TypeGuard[type[_T1 | _T2 | _T3 | _T4]]: ...
+def is_subclass_gen[T1, T2, T3, T4](
+    cls: type[Any], parent: tuple[type[T1], type[T2], type[T3], type[T4]], /
+) -> TypeGuard[type[T1 | T2 | T3 | T4]]: ...
 @overload
-def is_subclass_gen(
-    cls: type[Any],
-    parent: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]],
-    /,
-) -> TypeGuard[type[_T1 | _T2 | _T3 | _T4 | _T5]]: ...
+def is_subclass_gen[T1, T2, T3, T4, T5](
+    cls: type[Any], parent: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]], /
+) -> TypeGuard[type[T1 | T2 | T3 | T4 | T5]]: ...
 @overload
 def is_subclass_gen(cls: Any, parent: Any, /) -> bool: ...
 def is_subclass_gen(cls: Any, parent: Any, /) -> bool:
@@ -414,7 +814,7 @@ def is_subclass_gen(cls: Any, parent: Any, /) -> bool:
     raise IsSubclassGenError(cls=cls)
 
 
-def _is_subclass_gen_type(cls: type[Any], parent: type[_T], /) -> TypeGuard[type[_T]]:
+def _is_subclass_gen_type[T](cls: type[Any], parent: type[T], /) -> TypeGuard[type[T]]:
     return (
         issubclass(cls, parent)
         and not (
@@ -442,6 +842,22 @@ class IsSubclassGenError(Exception):
 ##
 
 
+def is_tuple(obj: Any, /) -> TypeGuard[tuple[Any, ...]]:
+    """Check if an object is a tuple."""
+    return isinstance(obj, tuple)
+
+
+##
+
+
+def is_tuple_or_str_mapping(obj: Any, /) -> TypeGuard[TupleOrStrMapping]:
+    """Check if an object is a tuple or string mapping."""
+    return is_tuple(obj) or is_string_mapping(obj)
+
+
+##
+
+
 def is_tuple_type(obj: Any, /) -> bool:
     """Check if an object is a tuple type annotation."""
     return _is_annotation_of_type(obj, tuple)
@@ -466,28 +882,72 @@ def _is_annotation_of_type(obj: Any, origin: Any, /) -> bool:
     )
 
 
+##
+
+
+@overload
+def make_isinstance[T](cls: type[T], /) -> Callable[[Any], TypeGuard[T]]: ...
+@overload
+def make_isinstance[T1](cls: tuple[type[T1]], /) -> Callable[[Any], TypeGuard[T1]]: ...
+@overload
+def make_isinstance[T1, T2](
+    cls: tuple[type[T1], type[T2]], /
+) -> Callable[[Any], TypeGuard[T1 | T2]]: ...
+@overload
+def make_isinstance[T1, T2, T3](
+    cls: tuple[type[T1], type[T2], type[T3]], /
+) -> Callable[[Any], TypeGuard[T1 | T2 | T3]]: ...
+@overload
+def make_isinstance[T1, T2, T3, T4](
+    cls: tuple[type[T1], type[T2], type[T3], type[T4]], /
+) -> Callable[[Any], TypeGuard[T1 | T2 | T3 | T4]]: ...
+@overload
+def make_isinstance[T1, T2, T3, T4, T5](
+    cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]], /
+) -> Callable[[Any], TypeGuard[T1 | T2 | T3 | T4 | T5]]: ...
+@overload
+def make_isinstance[T](cls: TypeLike[T], /) -> Callable[[Any], TypeGuard[T]]: ...
+def make_isinstance[T](cls: TypeLike[T], /) -> Callable[[Any], TypeGuard[T]]:
+    """Make a curried `isinstance` function."""
+    return partial(_make_instance_core, cls=cls)
+
+
+def _make_instance_core[T](obj: Any, /, *, cls: TypeLike[T]) -> TypeGuard[T]:
+    return is_instance_gen(obj, cls)
+
+
 __all__ = [
     "GetTypeClassesError",
     "GetUnionTypeClassesError",
     "IsInstanceGenError",
     "IsSubclassGenError",
-    "contains_self",
     "get_literal_elements",
     "get_type_classes",
     "get_type_hints",
     "get_union_type_classes",
+    "is_dataclass_class",
+    "is_dataclass_instance",
     "is_dict_type",
     "is_frozenset_type",
     "is_instance_gen",
+    "is_iterable_of",
     "is_list_type",
     "is_literal_type",
     "is_mapping_type",
     "is_namedtuple_class",
     "is_namedtuple_instance",
+    "is_not_required_annotation",
+    "is_not_required_type",
     "is_optional_type",
+    "is_sequence_of",
+    "is_sequence_of_tuple_or_str_mapping",
     "is_sequence_type",
     "is_set_type",
+    "is_string_mapping",
     "is_subclass_gen",
+    "is_tuple",
+    "is_tuple_or_str_mapping",
     "is_tuple_type",
     "is_union_type",
+    "make_isinstance",
 ]