typechecked 0.11.1

Supported Typing Constructs

• Basic types: int, str, float, bool, etc.

• Generic types: Set, Mapping, Sequence, Iterable, Callable, Collection

• Specific types: list, dict, OrderedDict, frozenset, tuple, etc.

• Generic aliases: list[int], dict[str, float], etc.

• Tuple types: Tuple, tuple, Tuple[int, …], Tuple[int, str], etc

• Union types: Union, Optional, |, etc.

• Final types: Final

• TypeVar

• NewType types: NewType

• Annotated types: Annotated

• Literal types: Literal

• Typed dictionaries: TypedDict, NotRequired, Required, ReadOnly, total, extras

• Runtime Protocols: Protocol

• Nested generics: List[Dict[str, Union[int, str]]], etc.

• User-defined classes and dataclasses

• Nested combinations of the above

It especially shines in scenarios where data structures are deeply nested immutable structures (lists, tuples, dicts, sets, frozensets) containing various combinations of types that need to be validated at runtime because it caches type information for objects for improved performance on repeated checks and subtree validations to avoid redundant checks.

If you check a subcontainer (e.g., a tuple within a MappingProxyType within a frozenset), it will cache the results of each subtree so that if the same subtree is encountered again, it can skip re-validating that subtree.

This library can be used in data processing pipelines, ETL processes, or any scenario where data integrity and type correctness are paramount.

It also provides deep immutability checking for deep immutable types via the typechecked.immutable submodule to validate data structures that should not be modified after creation. This is useful for ensuring that certain data structures remain unchanged throughout their lifecycle, preventing accidental mutations that could lead to bugs or data corruption. It checks not just the top-level container, but also all nested containers and their contents to ensure complete immutability.

It provides a base class Immutable that can be inherited by user-defined classes to label them as immutable and have their instances marked as immutable during type checking.

It can check TypedDict definitions against any Mapping type at runtime, allowing for validation of dictionary-like structures against TypedDict schemas.

Installation

You can install TypeChecked via pip:

pip install typechecked

It has few external dependencies and relies on the Python standard library except for the use of typing-extensions to allow older Python versions to use newer typing features when available.

Usage

from typechecked import isinstance_of_typehint

MyDataStructure = dict[str, list[int]]

data = {"numbers": [1, 2, 3]}
if isinstance_of_typehint(data, MyDataStructure):
    print("Data is valid")
else:
    print("Data is invalid")

Contributing

This project is open to contributions! If you find a bug or have a feature request, please open an issue on GitHub. Pull requests are also welcome.

python bootstrap.py