Typing Inspect

Warnings

• breaking The API of `typing-inspect` is still considered experimental. While generally stable, breaking changes might occur in future versions. Users should consult the changelog for specific updates.
  Fix: Always pin the `typing-inspect` version in your `requirements.txt` or `pyproject.toml` to ensure consistent behavior across deployments.
• gotcha There exists another, distinct library named `typing-inspection` (used by Pydantic) which provides similar runtime typing introspection tools. Ensure you are importing from `typing_inspect` (underscore) for this library, not `typing_inspection` (hyphen).
  Fix: Double-check your `pip install` command (`pip install typing-inspect`) and import statements (`import typing_inspect` or `from typing_inspect import ...`) to ensure you are using the correct package.
• gotcha The `get_args` function, when called with `evaluate=True`, can be computationally expensive in terms of both time and memory. This option performs all type parameter substitutions.
  Fix: Avoid using `get_args(tp, evaluate=True)` in performance-critical paths unless strictly necessary. The default `evaluate=False` reports results as nested tuples and is generally more performant.
• gotcha `typing-inspect` is designed to work with the latest versions of the Python `typing` module and `typing-extensions`. Older or specific versions of these dependencies might lead to unexpected behavior or unsupported types.
  Fix: Ensure your project's `typing` and `typing-extensions` dependencies are up-to-date or meet the minimum versions specified by `typing-inspect` (currently `typing>=3.7.4` and `typing-extensions>=3.7.4`).

Install

• pip install typing-inspect Latest stable version

Imports

• is_generic_type

  from typing_inspect import is_generic_type

• get_args

  from typing_inspect import get_args

• get_origin

  from typing_inspect import get_origin

• is_union_type

  from typing_inspect import is_union_type

• is_optional_type

  from typing_inspect import is_optional_type

Quickstart

This quickstart demonstrates basic usage of `typing-inspect` to check for generic types, retrieve type arguments and origins, and identify optional types. It covers `is_generic_type`, `get_args`, `get_origin`, and `is_optional_type`.

from typing import List, Union, Optional, TypeVar
from typing_inspect import is_generic_type, get_args, get_origin, is_optional_type

T = TypeVar('T')

class MyGeneric(List[T]):
    pass

# Example 1: Check if a type is generic
assert is_generic_type(MyGeneric[int]) # This should be True
assert not is_generic_type(int) # This should be False

# Example 2: Get arguments of a type
args = get_args(List[str])
assert args == (str,)

union_type = Union[int, str]
union_args = get_args(union_type)
assert set(union_args) == {int, str}

# Example 3: Get the origin of a type
origin = get_origin(List[int])
assert origin is list

# Example 4: Check for optional types
assert is_optional_type(Optional[int])
assert not is_optional_type(int)

print("All quickstart assertions passed!")