dycw-utilities 0.163.1__py3-none-any.whl → 0.164.1__py3-none-any.whl

{dycw_utilities-0.163.1.dist-info → dycw_utilities-0.164.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.163.1
+Version: 0.164.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.163.1.dist-info → dycw_utilities-0.164.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=H6bv_6LaATx2o2hoGm4VlmfBe0l3DJHbz7hkL80krDQ,60
+utilities/__init__.py,sha256=MvCrVmUm07-n3CLSgsov6yvmEZo6n9Jy9H_ppTFtrsI,60
 utilities/aeventkit.py,sha256=ddoleSwW9zdc2tjX5Ge0pMKtYwV_JMxhHYOxnWX2AGM,12609
 utilities/altair.py,sha256=92E2lCdyHY4Zb-vCw6rEJIsWdKipuu-Tu2ab1ufUfAk,9079
 utilities/asyncio.py,sha256=PUedzQ5deqlSECQ33sam9cRzI9TnygHz3FdOqWJWPTM,15288
@@ -11,12 +11,12 @@ utilities/contextlib.py,sha256=m2D5bwvtCZLJcJ3IwVqyErYODuwJ1gLrT2UfATAQl-w,7435
 utilities/contextvars.py,sha256=J8OhC7jqozAGYOCe2KUWysbPXNGe5JYz3HfaY_mIs08,883
 utilities/cryptography.py,sha256=5PFrzsNUGHay91dFgYnDKwYprXxahrBqztmUqViRzBk,956
 utilities/cvxpy.py,sha256=Rv1-fD-XYerosCavRF8Pohop2DBkU3AlFaGTfD8AEAA,13776
-utilities/dataclasses.py,sha256=wGfQtopYZCwvUxNxLOlVNFlhK8Q0_aQbKJ0rWfT-fEc,32482
+utilities/dataclasses.py,sha256=xbU3QN1GFy7RC6hIJRZIeUZm7YRlodrgEWmahWG6k2g,32465
 utilities/enum.py,sha256=5l6pwZD1cjSlVW4ss-zBPspWvrbrYrdtJWcg6f5_J5w,5781
 utilities/errors.py,sha256=mFlDGSM0LI1jZ1pbqwLAH3ttLZ2JVIxyZLojw8tGVZU,1479
 utilities/fastapi.py,sha256=TqyKvBjiMS594sXPjrz-KRTLMb3l3D3rZ1zAYV7GfOk,1454
 utilities/fpdf2.py,sha256=dSiYz0FJTD2sQuxpxqFWwwIe2-p6Y7oTB9Tv0Jajit0,1866
-utilities/functions.py,sha256=RNVAoLeT_sl-gXaBv2VI_U_EB-d-nSVosYR4gTeeojE,28261
+utilities/functions.py,sha256=82qCAaPIB0JmZ5wsQurA3MTYl7fh8LHcoBFkxPs7Zeg,21478
 utilities/functools.py,sha256=I00ru2gQPakZw2SHVeKIKXfTv741655s6HI0lUoE0D4,1552
 utilities/getpass.py,sha256=DfN5UgMAtFCqS3dSfFHUfqIMZX2shXvwphOz_6J6f6A,103
 utilities/gzip.py,sha256=fkGP3KdsBfXlstodT4wtlp-PwNyUsogpbDCVVVGdsm4,781
@@ -26,27 +26,27 @@ utilities/hypothesis.py,sha256=eoFAFnM2SdvzH6DWD5oCs8cH57LsEEXsRy8vMZDW6i8,44874
 utilities/importlib.py,sha256=mV1xT_O_zt_GnZZ36tl3xOmMaN_3jErDWY54fX39F6Y,429
 utilities/inflect.py,sha256=v7YkOWSu8NAmVghPcf4F3YBZQoJCS47_DLf9jbfWIs0,581
 utilities/ipython.py,sha256=V2oMYHvEKvlNBzxDXdLvKi48oUq2SclRg5xasjaXStw,763
-utilities/iterables.py,sha256=fM7s5072m9ram33zMk4nYQpOSxW8Zt6_XX2GCD5BMY0,43013
+utilities/iterables.py,sha256=8_dljtugLjxL8GCO_udMoH5uldvxdAmsN6aZ3EdnAiA,42564
 utilities/json.py,sha256=-WcGtSsCr9Y42wHZzAMnfvU6ihAfVftylFfRUORaDFo,2102
 utilities/jupyter.py,sha256=ft5JA7fBxXKzP-L9W8f2-wbF0QeYc_2uLQNFDVk4Z-M,2917
 utilities/libcst.py,sha256=TKgKN4bNmtBNEE-TUfhTyd1BrTncfsl_7tTuhpesGYY,5585
 utilities/lightweight_charts.py,sha256=YM3ojBvJxuCSUBu_KrhFBmaMCvRPvupKC3qkm-UVZq4,2751
-utilities/logging.py,sha256=uJ-hhtkrx4xnLUzZmE1soV4O8wQzNPUB1f_YJJe6I30,18089
+utilities/logging.py,sha256=W3d8Vby0mmqGWvTNlGtcfrmORDTt7abCuqjkIyCPIg8,18914
 utilities/math.py,sha256=cevB-YyEYAzJTWtkAr7qeeu-hbxorDI3gMznXlmNQkw,26897
 utilities/memory_profiler.py,sha256=XzN56jDCa5aqXS_DxEjb_K4L6aIWh_5zyKi6OhcIxw0,853
 utilities/modules.py,sha256=iuvLluJya-hvl1Q25-Jk3dLgx2Es3ck4SjJiEkAlVTs,3195
 utilities/more_itertools.py,sha256=syfIPhQF_WS-YiicdGe2h5F1G-Ld12Q2XsVduL2hA40,10908
 utilities/numpy.py,sha256=Xn23sA2ZbVNqwUYEgNJD3XBYH6IbCri_WkHSNhg3NkY,26122
-utilities/operator.py,sha256=nhxn5q6CFNzUm1wpTwWPCu9JGCqVHSlaJf0o1-efoII,3616
+utilities/operator.py,sha256=C3NylZWGTVWRpwYHOPVhaLgRhw0DfpS4_XQ8KfPhBLQ,3613
 utilities/optuna.py,sha256=C-fhWYiXHVPo1l8QctYkFJ4DyhbSrGorzP1dJb_qvd8,1933
-utilities/orjson.py,sha256=pOCsldgiuxTFQJQAxh6vzEZnkDGuOCx_Nn1t5ziNFhY,41970
+utilities/orjson.py,sha256=rII_rINPcH9X0CfL_WeFjwHgKNkKAF-TVS5rnpLHjzc,41998
 utilities/os.py,sha256=8TjFLVWlGhhEpzZ0X_vNAyhYntjeVL5WTwaQcdTaNVw,3934
 utilities/parse.py,sha256=JcJn5yXKhIWXBCwgBdPsyu7Hvcuw6kyEdqvaebCaI9k,17951
 utilities/pathlib.py,sha256=qGuU8XPmdgGpy8tOMUgelfXx3kxI8h9IaV3TI_06QGE,8428
 utilities/pickle.py,sha256=MBT2xZCsv0pH868IXLGKnlcqNx2IRVKYNpRcqiQQqxw,653
 utilities/platform.py,sha256=pTn7gw6N4T6LdKrf0virwarof_mze9WtoQlrGMzhGVI,2798
-utilities/polars.py,sha256=T-7GZtiw_LBhm3na0jyb8PBpgKGpszZ4zCbJhgc4w2M,79781
-utilities/polars_ols.py,sha256=Uc9V5kvlWZ5cU93lKZ-cfAKdVFFw81tqwLW9PxtUvMs,5618
+utilities/polars.py,sha256=oV63oc7qI100dHoZUu8rfnr5-bEd7iY0O79iEFtDmj4,79772
+utilities/polars_ols.py,sha256=LNTFNLPuYW7fcAHymlbnams_DhitToblYvib3mhKbwI,5615
 utilities/postgres.py,sha256=ynCTTaF-bVEOSW-KEAR-dlLh_hYjeVVjm__-4pEU8Zk,12269
 utilities/pottery.py,sha256=ggMN72Y7wx7Js8VN6eyNyodpm8TIYqZHGghkDPXIVWk,3949
 utilities/pqdm.py,sha256=idv2seRVP2f6NeSfpeEnT5A-tQezaHZKDyeu16g2-0E,3091
@@ -57,14 +57,14 @@ utilities/pytest.py,sha256=M-Om6b3hpF9W_bEB7UFY2IzBCubSxzVQleGrgRXHtxY,7741
 utilities/pytest_regressions.py,sha256=ocjHTtfOeiGfQAKIei8pKNd61sxN9dawrJJ9gPt2wzA,4097
 utilities/random.py,sha256=hZlH4gnAtoaofWswuJYjcygejrY8db4CzP-z_adO2Mo,4165
 utilities/re.py,sha256=S4h-DLL6ScMPqjboZ_uQ1BVTJajrqV06r_81D--_HCE,4573
-utilities/redis.py,sha256=BT4QGNgaoIg5sXK8CN8mX0weCzLtcyD7rgf9fSbXfm8,30471
+utilities/redis.py,sha256=f16zuOabP_rFDFtan7x1S-d8KOjBK93pS8OEyp7T9Is,30156
 utilities/reprlib.py,sha256=ssYTcBW-TeRh3fhCJv57sopTZHF5FrPyyUg9yp5XBlo,3953
 utilities/scipy.py,sha256=wZJM7fEgBAkLSYYvSmsg5ac-QuwAI0BGqHVetw1_Hb0,947
 utilities/sentinel.py,sha256=A_p5jX2K0Yc5XBfoYHyBLqHsEWzE1ByOdDuzzA2pZnE,1434
 utilities/shelve.py,sha256=4OzjQI6kGuUbJciqf535rwnao-_IBv66gsT6tRGiUt0,759
 utilities/slack_sdk.py,sha256=76-DYtcGiUhEvl-voMamc5OjfF7Y7nCq54Bys1arqzw,2233
 utilities/socket.py,sha256=K77vfREvzoVTrpYKo6MZakol0EYu2q1sWJnnZqL0So0,118
-utilities/sqlalchemy.py,sha256=xAVU92MTphMx2xAdYZpQX5xGnAACI5UvJIPG95infjE,36395
+utilities/sqlalchemy.py,sha256=gCd7rBn7mDt1ZepxMtW4j0QSUo-zwCC3VvzH8P0LcZI,36411
 utilities/sqlalchemy_polars.py,sha256=JCGhB37raSR7fqeWV5dTsciRTMVzIdVT9YSqKT0piT0,13370
 utilities/statsmodels.py,sha256=koyiBHvpMcSiBfh99wFUfSggLNx7cuAw3rwyfAhoKpQ,3410
 utilities/string.py,sha256=shmBK87zZwzGyixuNuXCiUbqzfeZ9xlrFwz6JTaRvDk,582
@@ -76,7 +76,7 @@ utilities/timer.py,sha256=oXfTii6ymu57niP0BDGZjFD55LEHi2a19kqZKiTgaFQ,2588
 utilities/traceback.py,sha256=b1nSvlyrGmI1MyZLkkoLVET3DQBSGt9qqIlAAQbyjEw,9629
 utilities/typed_settings.py,sha256=SFWqS3lAzV7IfNRwqFcTk0YynTcQ7BmrcW2mr_KUnos,4466
 utilities/types.py,sha256=oeH-hEC3-67Eja4nLz-Nj9WvK6Z9-3T1zobO_XJpuVg,18735
-utilities/typing.py,sha256=7ZgCNZwA6oaiwpSJIS9Rj3i3MbRBYHMqbC3jMe5KiNg,13992
+utilities/typing.py,sha256=vPqxHE2G5_dbDEgWAyAaTSDbUQE0pmihIj0vdXogbRU,24185
 utilities/tzdata.py,sha256=fgNVj66yUbCSI_-vrRVzSD3gtf-L_8IEJEPjP_Jel5Y,266
 utilities/tzlocal.py,sha256=KyCXEgCTjqGFx-389JdTuhMRUaT06U1RCMdWoED-qro,728
 utilities/uuid.py,sha256=nQZs6tFX4mqtc2Ku3KqjloYCqwpTKeTj8eKwQwh3FQI,1572
@@ -88,8 +88,8 @@ utilities/zoneinfo.py,sha256=tdIScrTB2-B-LH0ukb1HUXKooLknOfJNwHk10MuMYvA,3619
 utilities/pytest_plugins/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
 utilities/pytest_plugins/pytest_randomly.py,sha256=B1qYVlExGOxTywq2r1SMi5o7btHLk2PNdY_b1p98dkE,409
 utilities/pytest_plugins/pytest_regressions.py,sha256=9v8kAXDM2ycIXJBimoiF4EgrwbUvxTycFWJiGR_GHhM,1466
-dycw_utilities-0.163.1.dist-info/METADATA,sha256=eaPtQYq94LvYpZRiDAsg5g8fVHJ2XV2QuJSEGnwaF2g,1696
-dycw_utilities-0.163.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.163.1.dist-info/entry_points.txt,sha256=BOD_SoDxwsfJYOLxhrSXhHP_T7iw-HXI9f2WVkzYxvQ,135
-dycw_utilities-0.163.1.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.163.1.dist-info/RECORD,,
+dycw_utilities-0.164.1.dist-info/METADATA,sha256=4-ckCdR3FFMcVm2AWHdzIEhR72r_NvE6YImrElaIkRY,1696
+dycw_utilities-0.164.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.164.1.dist-info/entry_points.txt,sha256=BOD_SoDxwsfJYOLxhrSXhHP_T7iw-HXI9f2WVkzYxvQ,135
+dycw_utilities-0.164.1.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.164.1.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.163.1"
+__version__ = "0.164.1"

utilities/dataclasses.py

@@ -6,11 +6,7 @@ from dataclasses import MISSING, dataclass, field, fields, replace
 from typing import TYPE_CHECKING, Any, Literal, assert_never, overload, override
 
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import (
-    get_class_name,
-    is_dataclass_class,
-    is_dataclass_instance,
-)
+from utilities.functions import get_class_name
 from utilities.iterables import (
     OneStrEmptyError,
     OneStrNonUniqueError,
@@ -35,7 +31,7 @@ from utilities.text import (
     split_key_value_pairs,
 )
 from utilities.types import MaybeType, SupportsLT
-from utilities.typing import get_type_hints
+from utilities.typing import get_type_hints, is_dataclass_class, is_dataclass_instance
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Iterator

utilities/functions.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from collections.abc import Callable, Iterable, Iterator, Sequence
-from dataclasses import asdict, dataclass, is_dataclass
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import asdict, dataclass
 from functools import _lru_cache_wrapper, cached_property, partial, reduce, wraps
 from inspect import getattr_static
 from pathlib import Path
@@ -20,17 +20,10 @@ from whenever import Date, PlainDateTime, Time, TimeDelta, ZonedDateTime
 
 from utilities.reprlib import get_repr, get_repr_and_class
 from utilities.sentinel import Sentinel, is_sentinel, sentinel
-from utilities.types import (
-    Dataclass,
-    Number,
-    StrMapping,
-    SupportsRichComparison,
-    TupleOrStrMapping,
-    TypeLike,
-)
+from utilities.types import Dataclass, Number, SupportsRichComparison, TypeLike
 
 if TYPE_CHECKING:
-    from collections.abc import Container, Hashable, Sized
+    from collections.abc import Container
 
 
 def apply_decorators[F1: Callable, F2: Callable](
@@ -230,25 +223,6 @@ class EnsureFloatError(Exception):
 ##
 
 
-def ensure_hashable(obj: Any, /) -> Hashable:
-    """Ensure an object is hashable."""
-    if is_hashable(obj):
-        return obj
-    raise EnsureHashableError(obj=obj)
-
-
-@dataclass(kw_only=True, slots=True)
-class EnsureHashableError(Exception):
-    obj: Any
-
-    @override
-    def __str__(self) -> str:
-        return _make_error_msg(self.obj, "hashable")
-
-
-##
-
-
 @overload
 def ensure_int(obj: Any, /, *, nullable: bool) -> int | None: ...
 @overload
@@ -405,44 +379,6 @@ class EnsurePlainDateTimeError(Exception):
 ##
 
 
-def ensure_sized(obj: Any, /) -> Sized:
-    """Ensure an object is sized."""
-    if is_sized(obj):
-        return obj
-    raise EnsureSizedError(obj=obj)
-
-
-@dataclass(kw_only=True, slots=True)
-class EnsureSizedError(Exception):
-    obj: Any
-
-    @override
-    def __str__(self) -> str:
-        return _make_error_msg(self.obj, "sized")
-
-
-##
-
-
-def ensure_sized_not_str(obj: Any, /) -> Sized:
-    """Ensure an object is sized, but not a string."""
-    if is_sized_not_str(obj):
-        return obj
-    raise EnsureSizedNotStrError(obj=obj)
-
-
-@dataclass(kw_only=True, slots=True)
-class EnsureSizedNotStrError(Exception):
-    obj: Any
-
-    @override
-    def __str__(self) -> str:
-        return _make_error_msg(self.obj, "sized and not a string")
-
-
-##
-
-
 @overload
 def ensure_str(obj: Any, /, *, nullable: bool) -> str | None: ...
 @overload
@@ -633,67 +569,7 @@ def identity[T](obj: T, /) -> T:
 ##
 
 
-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_hashable(obj: Any, /) -> TypeGuard[Hashable]:
-    """Check if an object is hashable."""
-    try:
-        _ = hash(obj)
-    except TypeError:
-        return False
-    return True
-
-
-##
-
-
-@overload
-def is_iterable_of[T](obj: Any, cls: type[T], /) -> TypeGuard[Iterable[T]]: ...
-@overload
-def is_iterable_of[T1](
-    obj: Any, cls: tuple[type[T1]], /
-) -> TypeGuard[Iterable[T1]]: ...
-@overload
-def is_iterable_of[T1, T2](
-    obj: Any, cls: tuple[type[T1], type[T2]], /
-) -> TypeGuard[Iterable[T1 | T2]]: ...
-@overload
-def is_iterable_of[T1, T2, T3](
-    obj: Any, cls: tuple[type[T1], type[T2], type[T3]], /
-) -> 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]], /
-) -> 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]], /
-) -> TypeGuard[Iterable[T1 | T2 | T3 | T4 | T5]]: ...
-@overload
-def is_iterable_of[T](obj: Any, cls: TypeLike[T], /) -> TypeGuard[Iterable[T]]: ...
-def is_iterable_of[T](obj: Any, cls: TypeLike[T], /) -> TypeGuard[Iterable[T]]:
-    """Check if an object is a iterable of tuple or string mappings."""
-    return isinstance(obj, Iterable) and all(map(make_isinstance(cls), obj))
-
-
-##
-
-
-def is_none(obj: Any, /) -> bool:
+def is_none(obj: Any, /) -> TypeGuard[None]:
     """Check if an object is `None`."""
     return obj is None
 
@@ -709,126 +585,6 @@ def is_not_none(obj: Any, /) -> bool:
 ##
 
 
-@overload
-def is_sequence_of[T](obj: Any, cls: type[T], /) -> TypeGuard[Sequence[T]]: ...
-@overload
-def is_sequence_of[T1](
-    obj: Any, cls: tuple[type[T1]], /
-) -> TypeGuard[Sequence[T1]]: ...
-@overload
-def is_sequence_of[T1, T2](
-    obj: Any, cls: tuple[type[T1], type[T2]], /
-) -> TypeGuard[Sequence[T1 | T2]]: ...
-@overload
-def is_sequence_of[T1, T2, T3](
-    obj: Any, cls: tuple[type[T1], type[T2], type[T3]], /
-) -> 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]], /
-) -> 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]], /
-) -> TypeGuard[Sequence[T1 | T2 | T3 | T4 | T5]]: ...
-@overload
-def is_sequence_of[T](obj: Any, cls: TypeLike[T], /) -> TypeGuard[Sequence[T]]: ...
-def is_sequence_of[T](obj: Any, cls: TypeLike[T], /) -> 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)
-
-
-##
-
-
-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_sized(obj: Any, /) -> TypeGuard[Sized]:
-    """Check if an object is sized."""
-    try:
-        _ = len(obj)
-    except TypeError:
-        return False
-    return True
-
-
-##
-
-
-def is_sized_not_str(obj: Any, /) -> TypeGuard[Sized]:
-    """Check if an object is sized, but not a string."""
-    return is_sized(obj) and not isinstance(obj, str)
-
-
-##
-
-
-def is_string_mapping(obj: Any, /) -> TypeGuard[StrMapping]:
-    """Check if an object is a string mapping."""
-    return isinstance(obj, dict) and is_iterable_of(obj, str)
-
-
-##
-
-
-def is_tuple(obj: Any, /) -> TypeGuard[tuple[Any, ...]]:
-    """Check if an object is a tuple or string mapping."""
-    return make_isinstance(tuple)(obj)
-
-
-##
-
-
-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)
-
-
-##
-
-
-@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 isinstance(obj, cls)
-
-
-##
-
-
 def map_object[T](
     func: Callable[[Any], Any], obj: T, /, *, before: Callable[[Any], Any] | None = None
 ) -> T:
@@ -1000,15 +756,12 @@ __all__ = [
     "EnsureClassError",
     "EnsureDateError",
     "EnsureFloatError",
-    "EnsureHashableError",
     "EnsureIntError",
     "EnsureMemberError",
     "EnsureNotNoneError",
     "EnsureNumberError",
     "EnsurePathError",
     "EnsurePlainDateTimeError",
-    "EnsureSizedError",
-    "EnsureSizedNotStrError",
     "EnsureStrError",
     "EnsureTimeDeltaError",
     "EnsureTimeError",
@@ -1021,15 +774,12 @@ __all__ = [
     "ensure_class",
     "ensure_date",
     "ensure_float",
-    "ensure_hashable",
     "ensure_int",
     "ensure_member",
     "ensure_not_none",
     "ensure_number",
     "ensure_path",
     "ensure_plain_date_time",
-    "ensure_sized",
-    "ensure_sized_not_str",
     "ensure_str",
     "ensure_time",
     "ensure_time_delta",
@@ -1040,19 +790,8 @@ __all__ = [
     "get_func_name",
     "get_func_qualname",
     "identity",
-    "is_dataclass_class",
-    "is_dataclass_instance",
-    "is_hashable",
-    "is_iterable_of",
     "is_none",
     "is_not_none",
-    "is_sequence_of_tuple_or_str_mapping",
-    "is_sized",
-    "is_sized_not_str",
-    "is_string_mapping",
-    "is_tuple",
-    "is_tuple_or_str_mapping",
-    "make_isinstance",
     "map_object",
     "max_nullable",
     "min_nullable",

utilities/iterables.py

@@ -31,7 +31,6 @@ from typing import (
 )
 
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import ensure_hashable, ensure_str
 from utilities.math import (
     _CheckIntegerEqualError,
     _CheckIntegerEqualOrApproxError,
@@ -236,8 +235,7 @@ def check_iterables_equal(left: Iterable[Any], right: Iterable[Any], /) -> None:
             if lv != rv:
                 errors.append((i, lv, rv))
     except ValueError as error:
-        msg = ensure_str(one(error.args))
-        match msg:
+        match one(error.args):
             case "zip() argument 2 is longer than argument 1":
                 state = "right_longer"
             case "zip() argument 2 is shorter than argument 1":
@@ -695,18 +693,6 @@ def chunked[T](iterable: Iterable[T], n: int, /) -> Iterator[Sequence[T]]:
 ##
 
 
-def ensure_hashables(
-    *args: Any, **kwargs: Any
-) -> tuple[list[Hashable], dict[str, Hashable]]:
-    """Ensure a set of positional & keyword arguments are all hashable."""
-    hash_args = list(map(ensure_hashable, args))
-    hash_kwargs = {k: ensure_hashable(v) for k, v in kwargs.items()}
-    return hash_args, hash_kwargs
-
-
-##
-
-
 def ensure_iterable(obj: Any, /) -> Iterable[Any]:
     """Ensure an object is iterable."""
     if is_iterable(obj):
@@ -1480,7 +1466,6 @@ __all__ = [
     "check_unique_modulo_case",
     "chunked",
     "cmp_nullable",
-    "ensure_hashables",
     "ensure_iterable",
     "ensure_iterable_not_str",
     "enumerate_with_edge",

utilities/logging.py

@@ -8,6 +8,7 @@ from logging import (
     Formatter,
     Handler,
     Logger,
+    LoggerAdapter,
     LogRecord,
     StreamHandler,
     basicConfig,
@@ -22,6 +23,7 @@ from socket import gethostname
 from typing import (
     TYPE_CHECKING,
     Any,
+    Concatenate,
     Literal,
     NotRequired,
     Self,
@@ -53,7 +55,7 @@ from utilities.whenever import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Mapping
+    from collections.abc import Callable, Iterable, Mapping, MutableMapping
     from datetime import time
     from logging import _FilterType
 
@@ -63,6 +65,7 @@ if TYPE_CHECKING:
         MaybeCallablePathLike,
         MaybeIterable,
         PathLike,
+        StrMapping,
     )
 
 
@@ -75,6 +78,35 @@ _DEFAULT_WHEN: _When = "D"
 ##
 
 
+def add_adapter[**P](
+    logger: Logger,
+    process: Callable[Concatenate[str, P], str],
+    /,
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> LoggerAdapter:
+    """Add an adapter to a logger."""
+
+    class CustomAdapter(LoggerAdapter):
+        @override
+        def process(
+            self, msg: str, kwargs: MutableMapping[str, Any]
+        ) -> tuple[str, MutableMapping[str, Any]]:
+            extra = cast("_ArgsAndKwargs", self.extra)
+            new_msg = process(msg, *extra["args"], **extra["kwargs"])
+            return new_msg, kwargs
+
+    return CustomAdapter(logger, extra=_ArgsAndKwargs(args=args, kwargs=kwargs))
+
+
+class _ArgsAndKwargs(TypedDict):
+    args: tuple[Any, ...]
+    kwargs: StrMapping
+
+
+##
+
+
 def add_filters(handler: Handler, /, *filters: _FilterType) -> None:
     """Add a set of filters to a handler."""
     for filter_i in filters:
@@ -589,6 +621,7 @@ def to_logger(logger: LoggerLike | None = None, /) -> Logger:
 __all__ = [
     "GetLoggingLevelNumberError",
     "SizeAndTimeRotatingFileHandler",
+    "add_adapter",
     "add_filters",
     "basic_config",
     "get_format_str",

utilities/operator.py

@@ -6,9 +6,9 @@ from dataclasses import asdict, dataclass
 from typing import TYPE_CHECKING, Any, cast, override
 
 import utilities.math
-from utilities.functions import is_dataclass_instance
 from utilities.iterables import SortIterableError, sort_iterable
 from utilities.reprlib import get_repr
+from utilities.typing import is_dataclass_instance
 
 if TYPE_CHECKING:
     from utilities.types import Dataclass, Number

utilities/orjson.py

@@ -38,7 +38,7 @@ from whenever import (
 
 from utilities.concurrent import concurrent_map
 from utilities.dataclasses import dataclass_to_dict
-from utilities.functions import ensure_class, is_string_mapping
+from utilities.functions import ensure_class
 from utilities.gzip import read_binary
 from utilities.iterables import (
     OneEmptyError,
@@ -51,6 +51,7 @@ from utilities.json import write_formatted_json
 from utilities.logging import get_logging_level_number
 from utilities.math import MAX_INT64, MIN_INT64
 from utilities.types import Dataclass, LogLevel, MaybeIterable, PathLike, StrMapping
+from utilities.typing import is_string_mapping
 from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.version import Version, parse_version
 from utilities.whenever import (

utilities/polars.py

@@ -56,12 +56,7 @@ from whenever import DateDelta, DateTimeDelta, PlainDateTime, TimeDelta, ZonedDa
 import utilities.math
 from utilities.dataclasses import yield_fields
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import (
-    get_class_name,
-    is_dataclass_class,
-    is_dataclass_instance,
-    make_isinstance,
-)
+from utilities.functions import get_class_name
 from utilities.gzip import read_binary
 from utilities.iterables import (
     CheckIterablesEqualError,
@@ -91,11 +86,14 @@ from utilities.reprlib import get_repr
 from utilities.types import MaybeStr, Number, PathLike, WeekDay
 from utilities.typing import (
     get_args,
+    is_dataclass_class,
+    is_dataclass_instance,
     is_frozenset_type,
     is_list_type,
     is_literal_type,
     is_optional_type,
     is_set_type,
+    make_isinstance,
 )
 from utilities.warnings import suppress_warnings
 from utilities.whenever import (

utilities/polars_ols.py

@@ -6,8 +6,8 @@ from polars import Expr, Series, struct
 from polars_ols import RollingKwargs, compute_rolling_least_squares
 
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import is_sequence_of
 from utilities.polars import concat_series, ensure_expr_or_series
+from utilities.typing import is_sequence_of
 
 if TYPE_CHECKING:
     from polars._typing import IntoExprColumn

utilities/redis.py

@@ -26,6 +26,7 @@ from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_int, identity
 from utilities.iterables import always_iterable, one
 from utilities.os import is_pytest
+from utilities.typing import is_instance_gen
 from utilities.whenever import MILLISECOND, SECOND, to_milliseconds, to_seconds
 
 if TYPE_CHECKING:
@@ -788,17 +789,7 @@ async def _subscribe_core[T](
 def _is_message(
     message: Any, /, *, channels: Collection[bytes]
 ) -> TypeGuard[_RedisMessage]:
-    return (
-        isinstance(message, Mapping)
-        and ("type" in message)
-        and (message["type"] in {"subscribe", "psubscribe", "message", "pmessage"})
-        and ("pattern" in message)
-        and ((message["pattern"] is None) or isinstance(message["pattern"], str))
-        and ("channel" in message)
-        and (message["channel"] in channels)
-        and ("data" in message)
-        and isinstance(message["data"], bytes)
-    )
+    return is_instance_gen(message, _RedisMessage) and (message["channel"] in channels)
 
 
 def _handle_message[T](

utilities/sqlalchemy.py

@@ -66,15 +66,7 @@ from sqlalchemy.orm.exc import UnmappedClassError
 from sqlalchemy.pool import NullPool, Pool
 
 from utilities.asyncio import timeout_td
-from utilities.functions import (
-    ensure_str,
-    get_class_name,
-    is_sequence_of_tuple_or_str_mapping,
-    is_string_mapping,
-    is_tuple,
-    is_tuple_or_str_mapping,
-    yield_object_attributes,
-)
+from utilities.functions import ensure_str, get_class_name, yield_object_attributes
 from utilities.iterables import (
     CheckLengthError,
     CheckSubSetError,
@@ -97,6 +89,12 @@ from utilities.types import (
     StrMapping,
     TupleOrStrMapping,
 )
+from utilities.typing import (
+    is_sequence_of_tuple_or_str_mapping,
+    is_string_mapping,
+    is_tuple,
+    is_tuple_or_str_mapping,
+)
 
 if TYPE_CHECKING:
     from enum import Enum, StrEnum

utilities/typing.py

@@ -1,19 +1,23 @@
 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 types import NoneType, UnionType
 from typing import (
     Any,
+    ForwardRef,
     Literal,
     NamedTuple,
     Optional,  # pyright: ignore[reportDeprecated]
     TypeAliasType,
     TypeGuard,
     Union,  # pyright: ignore[reportDeprecated]
+    _TypedDictMeta,  # pyright: ignore[reportAttributeAccessIssue]
+    cast,
     get_origin,
     overload,
     override,
@@ -36,7 +40,7 @@ from whenever import (
 
 from utilities.iterables import unique_everseen
 from utilities.sentinel import Sentinel
-from utilities.types import StrMapping
+from utilities.types import Dataclass, StrMapping, TupleOrStrMapping, TypeLike
 
 
 def get_args(obj: Any, /, *, optional_drop_none: bool = False) -> tuple[Any, ...]:
@@ -147,6 +151,10 @@ def get_type_hints(
     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 = {
+        k: v.__forward_arg__ if isinstance(v, ForwardRef) else v
+        for k, v in result.items()
+    }
     try:
         hints = _get_type_hints(obj, globalns=globalns_use, localns=localns_use)
     except NameError as error:
@@ -202,6 +210,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)
@@ -219,50 +243,170 @@ def is_frozenset_type(obj: Any, /) -> bool:
 
 
 @overload
-def is_instance_gen[T](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[T1](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[T1, T2](
-    obj: Any, type_: tuple[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[T1, T2, T3](
-    obj: Any, type_: tuple[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[T1, T2, T3, T4](
-    obj: Any, type_: tuple[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[T1, T2, T3, T4, T5](
-    obj: Any, type_: tuple[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_)  # skipif-ci-and-not-windows
+        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_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
+    )
+    if not set(obj).issuperset(hints):
+        return False
+    return all(
+        is_instance_gen(
+            obj[k],
+            hints[k],
+            globalns=globalns,
+            localns=localns,
+            warn_name_errors=warn_name_errors,
+        )
+        for k in hints
+    )
+
+
 def _is_instance_gen_type[T](obj: Any, type_: type[T], /) -> TypeGuard[T]:
     return (
         isinstance(obj, type_)
@@ -292,6 +436,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)
@@ -349,6 +588,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)
@@ -365,6 +702,14 @@ 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[T](cls: type[Any], parent: type[T], /) -> TypeGuard[type[T]]: ...
 @overload
@@ -450,6 +795,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)
@@ -474,6 +835,40 @@ 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",
@@ -483,18 +878,27 @@ __all__ = [
     "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_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",
 ]