pip._vendor.typing_extensions Namespace Reference

Data Structures
class	_AnnotatedAlias
class	_AnyMeta
class	_ConcatenateForm
class	_ConcatenateGenericAlias
class	_DefaultMixin
class	_ExtensionsSpecialForm
class	_FinalForm
class	_Immutable
class	_LiteralForm
class	_LiteralGenericAlias
class	_NamedTupleMeta
class	_ProtocolMeta
class	_RequiredForm
class	_Sentinel
class	_SpecialForm
class	_TypedDictMeta
class	_TypeGuardForm
class	_TypeVarLikeMeta
class	_UnpackAlias
class	_UnpackForm
class	_UnpackSpecialForm
class	Annotated
class	Any
class	Buffer
class	NewType
class	ParamSpec
class	ParamSpecArgs
class	ParamSpecKwargs
class	Protocol
class	SupportsAbs
class	SupportsBytes
class	SupportsComplex
class	SupportsFloat
class	SupportsIndex
class	SupportsInt
class	SupportsRound
class	TypeAliasType
class	TypeVar
class	TypeVarTuple

Functions
	_check_generic (cls, parameters, elen=_marker)
	_should_collect_from_parameters (t)
	_collect_type_vars (types, typevar_types=None)
	final (f)
	IntVar (name)
	_flatten_literal_params (parameters)
	_value_and_type_iter (params)
	overload (func)
	get_overloads (func)
	_get_protocol_attrs (cls)
	_maybe_adjust_parameters (cls)
	_caller (depth=2)
	_allow_reckless_class_checks (depth=3)
	_no_init (self, *args, **kwargs)
	_proto_hook (cls, other)
	runtime_checkable (cls)
	_ensure_subclassable (mro_entries)
	TypedDict (__typename, __fields=_marker, *total=True, **kwargs)
	is_typeddict (tp)
	assert_type (__val, __typ)
	_strip_extras (t)
	get_type_hints (obj, globalns=None, localns=None, include_extras=False)
	get_origin (tp)
	get_args (tp)
	TypeAlias (self, parameters)
	_set_default (type_param, default)
	_set_module (typevarlike)
	_concatenate_getitem (self, parameters)
	Concatenate (self, parameters)
	TypeGuard (self, parameters)
	LiteralString (self, params)
	Self (self, params)
	Never (self, params)
	Required (self, parameters)
	NotRequired (self, parameters)
	_is_unpack (obj)
	Unpack (self, parameters)
T	reveal_type (T __obj)
Never	assert_never (Never __arg)
typing.Callable[[T], T]	dataclass_transform (*bool eq_default=True, bool order_default=False, bool kw_only_default=False, bool frozen_default=False, typing.Tuple[typing.Union[typing.Type[typing.Any], typing.Callable[..., typing.Any]],...] field_specifiers=(), **typing.Any kwargs)
_F	override (_F __arg)
typing.Callable[[_T], _T]	deprecated (str __msg, *typing.Optional[typing.Type[Warning]] category=DeprecationWarning, int stacklevel=1)
	_make_nmtuple (name, types, module, defaults=())
	_namedtuple_mro_entries (bases)
	NamedTuple (__typename, __fields=_marker, **kwargs)
	get_original_bases (__cls)
	_is_unionable (obj)
bool	is_protocol (type __tp)
typing.FrozenSet[str]	get_protocol_members (type __tp)

Variables
bool	PEP_560 = True
	GenericMeta = type
	_marker = _Sentinel()
	NoReturn = typing.NoReturn
	T = typing.TypeVar('T')
	KT = typing.TypeVar('KT')
	VT = typing.TypeVar('VT')
	T_co = typing.TypeVar('T_co', covariant=True)
	T_contra = typing.TypeVar('T_contra', contravariant=True)
	ClassVar = typing.ClassVar
	Final = typing.Final
	doc
	final = typing.final
	Literal = typing.Literal
	_overload_dummy = typing._overload_dummy
	overload = typing.overload
	get_overloads = typing.get_overloads
	clear_overloads = typing.clear_overloads
	_overload_registry
	Type = typing.Type
	Awaitable = typing.Awaitable
	Coroutine = typing.Coroutine
	AsyncIterable = typing.AsyncIterable
	AsyncIterator = typing.AsyncIterator
	Deque = typing.Deque
	ContextManager = typing.ContextManager
	AsyncContextManager = typing.AsyncContextManager
	DefaultDict = typing.DefaultDict
	OrderedDict = typing.OrderedDict
	Counter = typing.Counter
	ChainMap = typing.ChainMap
	AsyncGenerator = typing.AsyncGenerator
	Text = typing.Text
	TYPE_CHECKING = typing.TYPE_CHECKING
dict	_PROTO_ALLOWLIST
dict	_EXCLUDED_ATTRS
	Protocol = typing.Protocol
	_typing_Protocol = typing.Protocol
	_ProtocolMetaBase = type(_typing_Protocol)
	runtime_checkable = typing.runtime_checkable
	runtime = runtime_checkable
	SupportsInt = typing.SupportsInt
	SupportsFloat = typing.SupportsFloat
	SupportsComplex = typing.SupportsComplex
	SupportsBytes = typing.SupportsBytes
	SupportsIndex = typing.SupportsIndex
	SupportsAbs = typing.SupportsAbs
	SupportsRound = typing.SupportsRound
	TypedDict = typing.TypedDict
	_TypedDictMeta = typing._TypedDictMeta
	is_typeddict = typing.is_typeddict
str	_TAKES_MODULE = "module" in inspect.signature(typing._type_check).parameters
str	_fake_name = "Protocol"
	_TypedDict
tuple	_TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta)
	assert_type = typing.assert_type
	get_type_hints = typing.get_type_hints
	Annotated = typing.Annotated
	_AnnotatedAlias = typing._AnnotatedAlias
	get_origin = typing.get_origin
	get_args = typing.get_args
	_BaseGenericAlias = typing._GenericAlias
	_typing_GenericAlias = typing._GenericAlias
	TypeAlias = typing.TypeAlias
	ParamSpecArgs = typing.ParamSpecArgs
	ParamSpecKwargs = typing.ParamSpecKwargs
	Concatenate = typing.Concatenate
	_ConcatenateGenericAlias = typing._ConcatenateGenericAlias
	TypeGuard = typing.TypeGuard
	LiteralString = typing.LiteralString
	Self = typing.Self
	Never = typing.Never
	Required = typing.Required
	NotRequired = typing.NotRequired
str	_UNPACK_DOC
	Unpack = typing.Unpack
	reveal_type = typing.reveal_type
	assert_never = typing.assert_never
	dataclass_transform = typing.dataclass_transform
	override = typing.override
	_F = typing.TypeVar("_F", bound=typing.Callable[..., typing.Any])
	deprecated = typing.deprecated
	_T = typing.TypeVar("_T")
	_collect_type_vars
	_check_generic
	NamedTuple = typing.NamedTuple
	_prohibited_namedtuple_fields = typing._prohibited
	_special_namedtuple_fields = frozenset({'__module__', '__name__', '__annotations__'})
	_NamedTuple
str	_new_signature = '(typename, fields=None, /, **kwargs)'
	Buffer = collections.abc.Buffer
	get_original_bases = _types.get_original_bases
	NewType = typing.NewType
	TypeAliasType = typing.TypeAliasType
	is_protocol = typing.is_protocol
	get_protocol_members = typing.get_protocol_members
	AbstractSet = typing.AbstractSet
	AnyStr = typing.AnyStr
	BinaryIO = typing.BinaryIO
	Callable = typing.Callable
	Collection = typing.Collection
	Container = typing.Container
	Dict = typing.Dict
	ForwardRef = typing.ForwardRef
	FrozenSet = typing.FrozenSet
	Generator = typing.Generator
	Generic = typing.Generic
	Hashable = typing.Hashable
	IO = typing.IO
	ItemsView = typing.ItemsView
	Iterable = typing.Iterable
	Iterator = typing.Iterator
	KeysView = typing.KeysView
	List = typing.List
	Mapping = typing.Mapping
	MappingView = typing.MappingView
	Match = typing.Match
	MutableMapping = typing.MutableMapping
	MutableSequence = typing.MutableSequence
	MutableSet = typing.MutableSet
	Optional = typing.Optional
	Pattern = typing.Pattern
	Reversible = typing.Reversible
	Sequence = typing.Sequence
	Set = typing.Set
	Sized = typing.Sized
	TextIO = typing.TextIO
	Tuple = typing.Tuple
	Union = typing.Union
	ValuesView = typing.ValuesView
	cast = typing.cast
	no_type_check = typing.no_type_check
	no_type_check_decorator = typing.no_type_check_decorator
	_is_runtime_protocol

Function Documentation

_allow_reckless_class_checks()

_allow_reckless_class_checks (   depth = 3 )

protected

Allow instance and class checks for special stdlib modules.
The abc and functools modules indiscriminately call isinstance() and
issubclass() on the whole MRO of a user class, which may contain protocols.

Definition at line 590 of file typing_extensions.py.

    def _allow_reckless_class_checks(depth=3):
        """Allow instance and class checks for special stdlib modules.
        The abc and functools modules indiscriminately call isinstance() and
        issubclass() on the whole MRO of a user class, which may contain protocols.
        """
        return _caller(depth) in {'abc', 'functools', None}
 

References pip._vendor.typing_extensions._caller().

Referenced by _ProtocolMeta.__instancecheck__(), and _ProtocolMeta.__subclasscheck__().

Here is the call graph for this function:

Here is the caller graph for this function:

_caller()

_caller (   depth = 2 )

protected

Definition at line 578 of file typing_extensions.py.

def _caller(depth=2):
    try:
        return sys._getframe(depth).f_globals.get('__name__', '__main__')
    except (AttributeError, ValueError):  # For platforms without _getframe()
        return None
 
 
# The performance of runtime-checkable protocols is significantly improved on Python 3.12,
# so we backport the 3.12 version of Protocol to Python <=3.11

References i.

Referenced by ParamSpec.__init__(), TypeVarTuple.__init__(), NewType.__init__(), TypeAliasType.__init__(), pip._vendor.typing_extensions._allow_reckless_class_checks(), pip._vendor.typing_extensions._set_module(), pip._vendor.typing_extensions.NamedTuple(), and pip._vendor.typing_extensions.TypedDict().

Here is the caller graph for this function:

_check_generic()

_check_generic (   cls,   parameters,   elen = _marker  )

protected

Check correct count for parameters of a generic cls (internal helper).
This gives a nice error message in case of count mismatch.

Definition at line 147 of file typing_extensions.py.

def _check_generic(cls, parameters, elen=_marker):
    """Check correct count for parameters of a generic cls (internal helper).
    This gives a nice error message in case of count mismatch.
    """
    if not elen:
        raise TypeError(f"{cls} is not a generic class")
    if elen is _marker:
        if not hasattr(cls, "__parameters__") or not cls.__parameters__:
            raise TypeError(f"{cls} is not a generic class")
        elen = len(cls.__parameters__)
    alen = len(parameters)
    if alen != elen:
        if hasattr(cls, "__parameters__"):
            parameters = [p for p in cls.__parameters__ if not _is_unpack(p)]
            num_tv_tuples = sum(isinstance(p, TypeVarTuple) for p in parameters)
            if (num_tv_tuples > 0) and (alen >= elen - num_tv_tuples):
                return
        raise TypeError(f"Too {'many' if alen > elen else 'few'} parameters for {cls};"
                        f" actual {alen}, expected {elen}")
 
 

References pip._vendor.typing_extensions._is_unpack(), and i.

Here is the call graph for this function:

_collect_type_vars()

_collect_type_vars (   types,   typevar_types = None  )

protected

Collect all type variable contained in types in order of
first appearance (lexicographic order). For example::

    _collect_type_vars((T, List[S, T])) == (T, S)

Definition at line 181 of file typing_extensions.py.

def _collect_type_vars(types, typevar_types=None):
    """Collect all type variable contained in types in order of
    first appearance (lexicographic order). For example::
 
        _collect_type_vars((T, List[S, T])) == (T, S)
    """
    if typevar_types is None:
        typevar_types = typing.TypeVar
    tvars = []
    for t in types:
        if (
            isinstance(t, typevar_types) and
            t not in tvars and
            not _is_unpack(t)
        ):
            tvars.append(t)
        if _should_collect_from_parameters(t):
            tvars.extend([t for t in t.__parameters__ if t not in tvars])
    return tuple(tvars)
 
 

References pip._vendor.typing_extensions._is_unpack(), pip._vendor.typing_extensions._should_collect_from_parameters(), and i.

Here is the call graph for this function:

_concatenate_getitem()

_concatenate_getitem (   self,   parameters  )

protected

Definition at line 1775 of file typing_extensions.py.

def _concatenate_getitem(self, parameters):
    if parameters == ():
        raise TypeError("Cannot take a Concatenate of no types.")
    if not isinstance(parameters, tuple):
        parameters = (parameters,)
    if not isinstance(parameters[-1], ParamSpec):
        raise TypeError("The last parameter to Concatenate should be a "
                        "ParamSpec variable.")
    msg = "Concatenate[arg, ...]: each arg must be a type."
    parameters = tuple(typing._type_check(p, msg) for p in parameters)
    return _ConcatenateGenericAlias(self, parameters)
 
 
# 3.10+

References i.

Referenced by _ConcatenateForm.__getitem__(), and pip._vendor.typing_extensions.Concatenate().

Here is the caller graph for this function:

_ensure_subclassable()

_ensure_subclassable (   mro_entries )

protected

Definition at line 956 of file typing_extensions.py.

def _ensure_subclassable(mro_entries):
    def inner(func):
        if sys.implementation.name == "pypy" and sys.version_info < (3, 9):
            cls_dict = {
                "__call__": staticmethod(func),
                "__mro_entries__": staticmethod(mro_entries)
            }
            t = type(func.__name__, (), cls_dict)
            return functools.update_wrapper(t(), func)
        else:
            func.__mro_entries__ = mro_entries
            return func
    return inner
 
 

References i.

_flatten_literal_params()

_flatten_literal_params (   parameters )

protected

An internal helper for Literal creation: flatten Literals among parameters

Definition at line 324 of file typing_extensions.py.

    def _flatten_literal_params(parameters):
        """An internal helper for Literal creation: flatten Literals among parameters"""
        params = []
        for p in parameters:
            if isinstance(p, _LiteralGenericAlias):
                params.extend(p.__args__)
            else:
                params.append(p)
        return tuple(params)
 

References i.

Referenced by _LiteralForm.__getitem__().

Here is the caller graph for this function:

_get_protocol_attrs()

_get_protocol_attrs (   cls )

protected

Definition at line 526 of file typing_extensions.py.

def _get_protocol_attrs(cls):
    attrs = set()
    for base in cls.__mro__[:-1]:  # without object
        if base.__name__ in {'Protocol', 'Generic'}:
            continue
        annotations = getattr(base, '__annotations__', {})
        for attr in (*base.__dict__, *annotations):
            if (not attr.startswith('_abc_') and attr not in _EXCLUDED_ATTRS):
                attrs.add(attr)
    return attrs
 
 

References i.

Referenced by _ProtocolMeta.__init__(), and pip._vendor.typing_extensions.get_protocol_members().

Here is the caller graph for this function:

_is_unionable()

_is_unionable (   obj )

protected

Corresponds to is_unionable() in unionobject.c in CPython.

Definition at line 2867 of file typing_extensions.py.

    def _is_unionable(obj):
        """Corresponds to is_unionable() in unionobject.c in CPython."""
        return obj is None or isinstance(obj, (
            type,
            _types.GenericAlias,
            _types.UnionType,
            TypeAliasType,
        ))
 

References i.

Referenced by TypeAliasType.__or__(), and TypeAliasType.__ror__().

Here is the caller graph for this function:

_is_unpack()

_is_unpack (   obj )

protected

Definition at line 2175 of file typing_extensions.py.

    def _is_unpack(obj):
        return get_origin(obj) is Unpack
 

References pip._vendor.typing_extensions.get_origin, and i.

Referenced by pip._vendor.typing_extensions._check_generic(), and pip._vendor.typing_extensions._collect_type_vars().

Here is the caller graph for this function:

_make_nmtuple()

_make_nmtuple (   name,   types,   module,   defaults = ()  )

protected

Definition at line 2595 of file typing_extensions.py.

    def _make_nmtuple(name, types, module, defaults=()):
        fields = [n for n, t in types]
        annotations = {n: typing._type_check(t, f"field {n} annotation must be a type")
                       for n, t in types}
        nm_tpl = collections.namedtuple(name, fields,
                                        defaults=defaults, module=module)
        nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = annotations
        # The `_field_types` attribute was removed in 3.9;
        # in earlier versions, it is the same as the `__annotations__` attribute
        if sys.version_info < (3, 9):
            nm_tpl._field_types = annotations
        return nm_tpl
 

References i.

Referenced by _NamedTupleMeta.__new__(), and pip._vendor.typing_extensions.NamedTuple().

Here is the caller graph for this function:

_maybe_adjust_parameters()

_maybe_adjust_parameters (   cls )

protected

Helper function used in Protocol.__init_subclass__ and _TypedDictMeta.__new__.

The contents of this function are very similar
to logic found in typing.Generic.__init_subclass__
on the CPython main branch.

Definition at line 538 of file typing_extensions.py.

def _maybe_adjust_parameters(cls):
    """Helper function used in Protocol.__init_subclass__ and _TypedDictMeta.__new__.
 
    The contents of this function are very similar
    to logic found in typing.Generic.__init_subclass__
    on the CPython main branch.
    """
    tvars = []
    if '__orig_bases__' in cls.__dict__:
        tvars = _collect_type_vars(cls.__orig_bases__)
        # Look for Generic[T1, ..., Tn] or Protocol[T1, ..., Tn].
        # If found, tvars must be a subset of it.
        # If not found, tvars is it.
        # Also check for and reject plain Generic,
        # and reject multiple Generic[...] and/or Protocol[...].
        gvars = None
        for base in cls.__orig_bases__:
            if (isinstance(base, typing._GenericAlias) and
                    base.__origin__ in (typing.Generic, Protocol)):
                # for error messages
                the_base = base.__origin__.__name__
                if gvars is not None:
                    raise TypeError(
                        "Cannot inherit from Generic[...]"
                        " and/or Protocol[...] multiple types.")
                gvars = base.__parameters__
        if gvars is None:
            gvars = tvars
        else:
            tvarset = set(tvars)
            gvarset = set(gvars)
            if not tvarset <= gvarset:
                s_vars = ', '.join(str(t) for t in tvars if t not in gvarset)
                s_args = ', '.join(str(g) for g in gvars)
                raise TypeError(f"Some type variables ({s_vars}) are"
                                f" not listed in {the_base}[{s_args}]")
            tvars = gvars
    cls.__parameters__ = tuple(tvars)
 
 

References pip._vendor.typing_extensions._collect_type_vars, and i.

Referenced by Protocol.__init_subclass__().

Here is the caller graph for this function:

_namedtuple_mro_entries()

_namedtuple_mro_entries (   bases )

protected

Definition at line 2653 of file typing_extensions.py.

    def _namedtuple_mro_entries(bases):
        assert NamedTuple in bases
        return (_NamedTuple,)
 

_no_init()

_no_init (   self, *  args, **  kwargs  )

protected

Definition at line 597 of file typing_extensions.py.

    def _no_init(self, *args, **kwargs):
        if type(self)._is_protocol:
            raise TypeError('Protocols cannot be instantiated')
 

References i.

_proto_hook()

_proto_hook (   cls,   other  )

protected

Definition at line 716 of file typing_extensions.py.

    def _proto_hook(cls, other):
        if not cls.__dict__.get('_is_protocol', False):
            return NotImplemented
 
        for attr in cls.__protocol_attrs__:
            for base in other.__mro__:
                # Check if the members appears in the class dictionary...
                if attr in base.__dict__:
                    if base.__dict__[attr] is None:
                        return NotImplemented
                    break
 
                # ...or in annotations, if it is a sub-protocol.
                annotations = getattr(base, '__annotations__', {})
                if (
                    isinstance(annotations, collections.abc.Mapping)
                    and attr in annotations
                    and is_protocol(other)
                ):
                    break
            else:
                return NotImplemented
        return True
 

References i, and pip._vendor.typing_extensions.is_protocol.

_set_default()

_set_default (   type_param,   default  )

protected

Definition at line 1482 of file typing_extensions.py.

def _set_default(type_param, default):
    if isinstance(default, (tuple, list)):
        type_param.__default__ = tuple((typing._type_check(d, "Default must be a type")
                                        for d in default))
    elif default != _marker:
        type_param.__default__ = typing._type_check(default, "Default must be a type")
    else:
        type_param.__default__ = None
 
 

References i.

Referenced by ParamSpec.__new__(), TypeVar.__new__(), and TypeVarTuple.__new__().

Here is the caller graph for this function:

_set_module()

_set_module (   typevarlike )

protected

Definition at line 1492 of file typing_extensions.py.

def _set_module(typevarlike):
    # for pickling:
    def_mod = _caller(depth=3)
    if def_mod != 'typing_extensions':
        typevarlike.__module__ = def_mod
 
 

References pip._vendor.typing_extensions._caller(), and i.

Referenced by ParamSpec.__new__(), TypeVar.__new__(), and TypeVarTuple.__new__().

Here is the call graph for this function:

Here is the caller graph for this function:

_should_collect_from_parameters()

_should_collect_from_parameters (   t )

protected

Definition at line 169 of file typing_extensions.py.

    def _should_collect_from_parameters(t):
        return isinstance(
            t, (typing._GenericAlias, _types.GenericAlias, _types.UnionType)
        )

References i.

Referenced by pip._vendor.typing_extensions._collect_type_vars().

Here is the caller graph for this function:

_strip_extras()

_strip_extras (   t )

protected

Strips Annotated, Required and NotRequired from a given type.

Definition at line 1209 of file typing_extensions.py.

    def _strip_extras(t):
        """Strips Annotated, Required and NotRequired from a given type."""
        if isinstance(t, _AnnotatedAlias):
            return _strip_extras(t.__origin__)
        if hasattr(t, "__origin__") and t.__origin__ in (Required, NotRequired):
            return _strip_extras(t.__args__[0])
        if isinstance(t, typing._GenericAlias):
            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
            if stripped_args == t.__args__:
                return t
            return t.copy_with(stripped_args)
        if hasattr(_types, "GenericAlias") and isinstance(t, _types.GenericAlias):
            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
            if stripped_args == t.__args__:
                return t
            return _types.GenericAlias(t.__origin__, stripped_args)
        if hasattr(_types, "UnionType") and isinstance(t, _types.UnionType):
            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
            if stripped_args == t.__args__:
                return t
            return functools.reduce(operator.or_, stripped_args)
 
        return t
 

References pip._vendor.typing_extensions._strip_extras(), and i.

Referenced by pip._vendor.typing_extensions._strip_extras(), and pip._vendor.typing_extensions.get_type_hints().

Here is the call graph for this function:

Here is the caller graph for this function:

_value_and_type_iter()

_value_and_type_iter (   params )

protected

Definition at line 334 of file typing_extensions.py.

    def _value_and_type_iter(params):
        for p in params:
            yield p, type(p)
 

Referenced by _LiteralGenericAlias.__eq__(), _LiteralForm.__getitem__(), and _LiteralGenericAlias.__hash__().

Here is the caller graph for this function:

assert_never()

Never assert_never

(

Never

__arg

)

Assert to the type checker that a line of code is unreachable.

Example::

    def int_or_str(arg: int | str) -> None:
        match arg:
            case int():
                print("It's an int")
            case str():
                print("It's a str")
            case _:
                assert_never(arg)

If a type checker finds that a call to assert_never() is
reachable, it will emit an error.

At runtime, this throws an exception when called.

Definition at line 2333 of file typing_extensions.py.

    def assert_never(__arg: Never) -> Never:
        """Assert to the type checker that a line of code is unreachable.
 
        Example::
 
            def int_or_str(arg: int | str) -> None:
                match arg:
                    case int():
                        print("It's an int")
                    case str():
                        print("It's a str")
                    case _:
                        assert_never(arg)
 
        If a type checker finds that a call to assert_never() is
        reachable, it will emit an error.
 
        At runtime, this throws an exception when called.
 
        """
        raise AssertionError("Expected code to be unreachable")
 
 

References i.

assert_type()

assert_type	(		__val,
			__typ
	)

Assert (to the type checker) that the value is of the given type.

When the type checker encounters a call to assert_type(), it
emits an error if the value is not of the specified type::

    def greet(name: str) -> None:
        assert_type(name, str)  # ok
        assert_type(name, int)  # type checker error

At runtime this returns the first argument unchanged and otherwise
does nothing.

Definition at line 1189 of file typing_extensions.py.

    def assert_type(__val, __typ):
        """Assert (to the type checker) that the value is of the given type.
 
        When the type checker encounters a call to assert_type(), it
        emits an error if the value is not of the specified type::
 
            def greet(name: str) -> None:
                assert_type(name, str)  # ok
                assert_type(name, int)  # type checker error
 
        At runtime this returns the first argument unchanged and otherwise
        does nothing.
        """
        return __val
 
 

References i.

Concatenate()

Concatenate	(		self,
			parameters
	)

Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
higher order function which adds, removes or transforms parameters of a
callable.

For example::

   Callable[Concatenate[int, P], int]

See PEP 612 for detailed information.

Definition at line 1795 of file typing_extensions.py.

    def Concatenate(self, parameters):
        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
        higher order function which adds, removes or transforms parameters of a
        callable.
 
        For example::
 
           Callable[Concatenate[int, P], int]
 
        See PEP 612 for detailed information.
        """
        return _concatenate_getitem(self, parameters)
# 3.7-8

References pip._vendor.typing_extensions._concatenate_getitem().

Here is the call graph for this function:

dataclass_transform()

typing.Callable[[T], T] dataclass_transform	(	*bool	eq_default = True,
		bool	order_default = False,
		bool	kw_only_default = False,
		bool	frozen_default = False,
		typing.Tuple[ typing.Union[typing.Type[typing.Any], typing.Callable[..., typing.Any]], ... ]	field_specifiers = (),
		**typing.Any	kwargs
	)

Decorator that marks a function, class, or metaclass as providing
dataclass-like behavior.

Example:

    from pip._vendor.typing_extensions import dataclass_transform

    _T = TypeVar("_T")

    # Used on a decorator function
    @dataclass_transform()
    def create_model(cls: type[_T]) -> type[_T]:
        ...
        return cls

    @create_model
    class CustomerModel:
        id: int
        name: str

    # Used on a base class
    @dataclass_transform()
    class ModelBase: ...

    class CustomerModel(ModelBase):
        id: int
        name: str

    # Used on a metaclass
    @dataclass_transform()
    class ModelMeta(type): ...

    class ModelBase(metaclass=ModelMeta): ...

    class CustomerModel(ModelBase):
        id: int
        name: str

Each of the ``CustomerModel`` classes defined in this example will now
behave similarly to a dataclass created with the ``@dataclasses.dataclass``
decorator. For example, the type checker will synthesize an ``__init__``
method.

The arguments to this decorator can be used to customize this behavior:
- ``eq_default`` indicates whether the ``eq`` parameter is assumed to be
  True or False if it is omitted by the caller.
- ``order_default`` indicates whether the ``order`` parameter is
  assumed to be True or False if it is omitted by the caller.
- ``kw_only_default`` indicates whether the ``kw_only`` parameter is
  assumed to be True or False if it is omitted by the caller.
- ``frozen_default`` indicates whether the ``frozen`` parameter is
  assumed to be True or False if it is omitted by the caller.
- ``field_specifiers`` specifies a static list of supported classes
  or functions that describe fields, similar to ``dataclasses.field()``.

At runtime, this decorator records its arguments in the
``__dataclass_transform__`` attribute on the decorated object.

See PEP 681 for details.

Definition at line 2360 of file typing_extensions.py.

    ) -> typing.Callable[[T], T]:
        """Decorator that marks a function, class, or metaclass as providing
        dataclass-like behavior.
 
        Example:
 
            from pip._vendor.typing_extensions import dataclass_transform
 
            _T = TypeVar("_T")
 
            # Used on a decorator function
            @dataclass_transform()
            def create_model(cls: type[_T]) -> type[_T]:
                ...
                return cls
 
            @create_model
            class CustomerModel:
                id: int
                name: str
 
            # Used on a base class
            @dataclass_transform()
            class ModelBase: ...
 
            class CustomerModel(ModelBase):
                id: int
                name: str
 
            # Used on a metaclass
            @dataclass_transform()
            class ModelMeta(type): ...
 
            class ModelBase(metaclass=ModelMeta): ...
 
            class CustomerModel(ModelBase):
                id: int
                name: str
 
        Each of the ``CustomerModel`` classes defined in this example will now
        behave similarly to a dataclass created with the ``@dataclasses.dataclass``
        decorator. For example, the type checker will synthesize an ``__init__``
        method.
 
        The arguments to this decorator can be used to customize this behavior:
        - ``eq_default`` indicates whether the ``eq`` parameter is assumed to be
          True or False if it is omitted by the caller.
        - ``order_default`` indicates whether the ``order`` parameter is
          assumed to be True or False if it is omitted by the caller.
        - ``kw_only_default`` indicates whether the ``kw_only`` parameter is
          assumed to be True or False if it is omitted by the caller.
        - ``frozen_default`` indicates whether the ``frozen`` parameter is
          assumed to be True or False if it is omitted by the caller.
        - ``field_specifiers`` specifies a static list of supported classes
          or functions that describe fields, similar to ``dataclasses.field()``.
 
        At runtime, this decorator records its arguments in the
        ``__dataclass_transform__`` attribute on the decorated object.
 
        See PEP 681 for details.
 
        """
        def decorator(cls_or_fn):
            cls_or_fn.__dataclass_transform__ = {
                "eq_default": eq_default,
                "order_default": order_default,
                "kw_only_default": kw_only_default,
                "frozen_default": frozen_default,
                "field_specifiers": field_specifiers,
                "kwargs": kwargs,
            }
            return cls_or_fn
        return decorator
 
 

References i.

deprecated()

typing.Callable[[_T], _T] deprecated	(	str	__msg,
		*typing.Optional[typing.Type[Warning]]	category = DeprecationWarning,
		int	stacklevel = 1
	)

Indicate that a class, function or overload is deprecated.

Usage:

    @deprecated("Use B instead")
    class A:
        pass

    @deprecated("Use g instead")
    def f():
        pass

    @overload
    @deprecated("int support is deprecated")
    def g(x: int) -> int: ...
    @overload
    def g(x: str) -> int: ...

When this decorator is applied to an object, the type checker
will generate a diagnostic on usage of the deprecated object.

The warning specified by ``category`` will be emitted on use
of deprecated objects. For functions, that happens on calls;
for classes, on instantiation. If the ``category`` is ``None``,
no warning is emitted. The ``stacklevel`` determines where the
warning is emitted. If it is ``1`` (the default), the warning
is emitted at the direct caller of the deprecated object; if it
is higher, it is emitted further up the stack.

The decorator sets the ``__deprecated__``
attribute on the decorated object to the deprecation message
passed to the decorator. If applied to an overload, the decorator
must be after the ``@overload`` decorator for the attribute to
exist on the overload as returned by ``get_overloads()``.

See PEP 702 for details.

Definition at line 2492 of file typing_extensions.py.

    ) -> typing.Callable[[_T], _T]:
        """Indicate that a class, function or overload is deprecated.
 
        Usage:
 
            @deprecated("Use B instead")
            class A:
                pass
 
            @deprecated("Use g instead")
            def f():
                pass
 
            @overload
            @deprecated("int support is deprecated")
            def g(x: int) -> int: ...
            @overload
            def g(x: str) -> int: ...
 
        When this decorator is applied to an object, the type checker
        will generate a diagnostic on usage of the deprecated object.
 
        The warning specified by ``category`` will be emitted on use
        of deprecated objects. For functions, that happens on calls;
        for classes, on instantiation. If the ``category`` is ``None``,
        no warning is emitted. The ``stacklevel`` determines where the
        warning is emitted. If it is ``1`` (the default), the warning
        is emitted at the direct caller of the deprecated object; if it
        is higher, it is emitted further up the stack.
 
        The decorator sets the ``__deprecated__``
        attribute on the decorated object to the deprecation message
        passed to the decorator. If applied to an overload, the decorator
        must be after the ``@overload`` decorator for the attribute to
        exist on the overload as returned by ``get_overloads()``.
 
        See PEP 702 for details.
 
        """
        def decorator(__arg: _T) -> _T:
            if category is None:
                __arg.__deprecated__ = __msg
                return __arg
            elif isinstance(__arg, type):
                original_new = __arg.__new__
                has_init = __arg.__init__ is not object.__init__
 
                @functools.wraps(original_new)
                def __new__(cls, *args, **kwargs):
                    warnings.warn(__msg, category=category, stacklevel=stacklevel + 1)
                    if original_new is not object.__new__:
                        return original_new(cls, *args, **kwargs)
                    # Mirrors a similar check in object.__new__.
                    elif not has_init and (args or kwargs):
                        raise TypeError(f"{cls.__name__}() takes no arguments")
                    else:
                        return original_new(cls)
 
                __arg.__new__ = staticmethod(__new__)
                __arg.__deprecated__ = __new__.__deprecated__ = __msg
                return __arg
            elif callable(__arg):
                @functools.wraps(__arg)
                def wrapper(*args, **kwargs):
                    warnings.warn(__msg, category=category, stacklevel=stacklevel + 1)
                    return __arg(*args, **kwargs)
 
                __arg.__deprecated__ = wrapper.__deprecated__ = __msg
                return wrapper
            else:
                raise TypeError(
                    "@deprecated decorator with non-None category must be applied to "
                    f"a class or callable, not {__arg!r}"
                )
 
        return decorator
 
 
# We have to do some monkey patching to deal with the dual nature of
# Unpack/TypeVarTuple:
# - We want Unpack to be a kind of TypeVar so it gets accepted in
#   Generic[Unpack[Ts]]
# - We want it to *not* be treated as a TypeVar for the purposes of
#   counting generic parameters, so that when we subscript a generic,
#   the runtime doesn't try to substitute the Unpack with the subscripted type.

References i.

final()

final

(

f

)

This decorator can be used to indicate to type checkers that
the decorated method cannot be overridden, and decorated class
cannot be subclassed. For example:

    class Base:
        @final
        def done(self) -> None:
            ...
    class Sub(Base):
        def done(self) -> None:  # Error reported by type checker
            ...
    @final
    class Leaf:
        ...
    class Other(Leaf):  # Error reported by type checker
        ...

There is no runtime checking of these properties. The decorator
sets the ``__final__`` attribute to ``True`` on the decorated object
to allow runtime introspection.

Definition at line 284 of file typing_extensions.py.

    def final(f):
        """This decorator can be used to indicate to type checkers that
        the decorated method cannot be overridden, and decorated class
        cannot be subclassed. For example:
 
            class Base:
                @final
                def done(self) -> None:
                    ...
            class Sub(Base):
                def done(self) -> None:  # Error reported by type checker
                    ...
            @final
            class Leaf:
                ...
            class Other(Leaf):  # Error reported by type checker
                ...
 
        There is no runtime checking of these properties. The decorator
        sets the ``__final__`` attribute to ``True`` on the decorated object
        to allow runtime introspection.
        """
        try:
            f.__final__ = True
        except (AttributeError, TypeError):
            # Skip the attribute silently if it is not writable.
            # AttributeError happens if the object has __slots__ or a
            # read-only property, TypeError if it's a builtin class.
            pass
        return f
 
 

References i.

get_args()

get_args

(

tp

)

Get type arguments with all substitutions performed.

For unions, basic simplifications used by Union constructor are performed.
Examples::
    get_args(Dict[str, int]) == (str, int)
    get_args(int) == ()
    get_args(Union[int, Union[T, int], str][int]) == (int, str)
    get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
    get_args(Callable[[], T][int]) == ([], int)

Definition at line 1424 of file typing_extensions.py.

    def get_args(tp):
        """Get type arguments with all substitutions performed.
 
        For unions, basic simplifications used by Union constructor are performed.
        Examples::
            get_args(Dict[str, int]) == (str, int)
            get_args(int) == ()
            get_args(Union[int, Union[T, int], str][int]) == (int, str)
            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
            get_args(Callable[[], T][int]) == ([], int)
        """
        if isinstance(tp, _AnnotatedAlias):
            return (tp.__origin__,) + tp.__metadata__
        if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias)):
            if getattr(tp, "_special", False):
                return ()
            res = tp.__args__
            if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis:
                res = (list(res[:-1]), res[-1])
            return res
        return ()
 
 
# 3.10+

References pip._vendor.typing_extensions.get_origin, and i.

get_origin()

get_origin

(

tp

)

Get the unsubscripted version of a type.

This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
and Annotated. Return None for unsupported types. Examples::

    get_origin(Literal[42]) is Literal
    get_origin(int) is None
    get_origin(ClassVar[int]) is ClassVar
    get_origin(Generic) is Generic
    get_origin(Generic[T]) is Generic
    get_origin(Union[T, int]) is Union
    get_origin(List[Tuple[T, T]][int]) == list
    get_origin(P.args) is P

Definition at line 1400 of file typing_extensions.py.

    def get_origin(tp):
        """Get the unsubscripted version of a type.
 
        This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
        and Annotated. Return None for unsupported types. Examples::
 
            get_origin(Literal[42]) is Literal
            get_origin(int) is None
            get_origin(ClassVar[int]) is ClassVar
            get_origin(Generic) is Generic
            get_origin(Generic[T]) is Generic
            get_origin(Union[T, int]) is Union
            get_origin(List[Tuple[T, T]][int]) == list
            get_origin(P.args) is P
        """
        if isinstance(tp, _AnnotatedAlias):
            return Annotated
        if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias, _BaseGenericAlias,
                           ParamSpecArgs, ParamSpecKwargs)):
            return tp.__origin__
        if tp is typing.Generic:
            return typing.Generic
        return None
 

References i.

get_original_bases()

get_original_bases

(

__cls

)

Return the class's "original" bases prior to modification by `__mro_entries__`.

Examples::

    from typing import TypeVar, Generic
    from pip._vendor.typing_extensions import NamedTuple, TypedDict

    T = TypeVar("T")
    class Foo(Generic[T]): ...
    class Bar(Foo[int], float): ...
    class Baz(list[str]): ...
    Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
    Spam = TypedDict("Spam", {"a": int, "b": str})

    assert get_original_bases(Bar) == (Foo[int], float)
    assert get_original_bases(Baz) == (list[str],)
    assert get_original_bases(Eggs) == (NamedTuple,)
    assert get_original_bases(Spam) == (TypedDict,)
    assert get_original_bases(int) == (object,)

Definition at line 2767 of file typing_extensions.py.

    def get_original_bases(__cls):
        """Return the class's "original" bases prior to modification by `__mro_entries__`.
 
        Examples::
 
            from typing import TypeVar, Generic
            from pip._vendor.typing_extensions import NamedTuple, TypedDict
 
            T = TypeVar("T")
            class Foo(Generic[T]): ...
            class Bar(Foo[int], float): ...
            class Baz(list[str]): ...
            Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
            Spam = TypedDict("Spam", {"a": int, "b": str})
 
            assert get_original_bases(Bar) == (Foo[int], float)
            assert get_original_bases(Baz) == (list[str],)
            assert get_original_bases(Eggs) == (NamedTuple,)
            assert get_original_bases(Spam) == (TypedDict,)
            assert get_original_bases(int) == (object,)
        """
        try:
            return __cls.__orig_bases__
        except AttributeError:
            try:
                return __cls.__bases__
            except AttributeError:
                raise TypeError(
                    f'Expected an instance of type, not {type(__cls).__name__!r}'
                ) from None
 
 
# NewType is a class on Python 3.10+, making it pickleable
# The error message for subclassing instances of NewType was improved on 3.11+

References i.

get_overloads()

get_overloads

(

func

)

Return all defined overloads for *func* as a sequence.

Definition at line 447 of file typing_extensions.py.

    def get_overloads(func):
        """Return all defined overloads for *func* as a sequence."""
        # classmethod and staticmethod
        f = getattr(func, "__func__", func)
        if f.__module__ not in _overload_registry:
            return []
        mod_dict = _overload_registry[f.__module__]
        if f.__qualname__ not in mod_dict:
            return []
        return list(mod_dict[f.__qualname__].values())
 

References i.

get_protocol_members()

typing.FrozenSet[str] get_protocol_members

(

type

__tp

)

Return the set of members defined in a Protocol.

Example::

    >>> from typing_extensions import Protocol, get_protocol_members
    >>> class P(Protocol):
    ...     def a(self) -> str: ...
    ...     b: int
    >>> get_protocol_members(P)
    frozenset({'a', 'b'})

Raise a TypeError for arguments that are not Protocols.

Definition at line 3011 of file typing_extensions.py.

    def get_protocol_members(__tp: type) -> typing.FrozenSet[str]:
        """Return the set of members defined in a Protocol.
 
        Example::
 
            >>> from typing_extensions import Protocol, get_protocol_members
            >>> class P(Protocol):
            ...     def a(self) -> str: ...
            ...     b: int
            >>> get_protocol_members(P)
            frozenset({'a', 'b'})
 
        Raise a TypeError for arguments that are not Protocols.
        """
        if not is_protocol(__tp):
            raise TypeError(f'{__tp!r} is not a Protocol')
        if hasattr(__tp, '__protocol_attrs__'):
            return frozenset(__tp.__protocol_attrs__)
        return frozenset(_get_protocol_attrs(__tp))
 
 
# Aliases for items that have always been in typing.
# Explicitly assign these (rather than using `from typing import *` at the top),
# so that we get a CI error if one of these is deleted from typing.py
# in a future version of Python

References pip._vendor.typing_extensions._get_protocol_attrs(), i, and pip._vendor.typing_extensions.is_protocol.

Here is the call graph for this function:

get_type_hints()

get_type_hints	(		obj,
			globalns = None,
			localns = None,
			include_extras = False
	)

Return type hints for an object.

This is often the same as obj.__annotations__, but it handles
forward references encoded as string literals, adds Optional[t] if a
default value equal to None is set and recursively replaces all
'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'
(unless 'include_extras=True').

The argument may be a module, class, method, or function. The annotations
are returned as a dictionary. For classes, annotations include also
inherited members.

TypeError is raised if the argument is not of a type that can contain
annotations, and an empty dictionary is returned if no annotations are
present.

BEWARE -- the behavior of globalns and localns is counterintuitive
(unless you are familiar with how eval() and exec() work).  The
search order is locals first, then globals.

- If no dict arguments are passed, an attempt is made to use the
  globals from obj (or the respective module's globals for classes),
  and these are also used as the locals.  If the object does not appear
  to have globals, an empty dictionary is used.

- If one dict argument is passed, it is used for both globals and
  locals.

- If two dict arguments are passed, they specify globals and
  locals, respectively.

Definition at line 1233 of file typing_extensions.py.

    def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
        """Return type hints for an object.
 
        This is often the same as obj.__annotations__, but it handles
        forward references encoded as string literals, adds Optional[t] if a
        default value equal to None is set and recursively replaces all
        'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'
        (unless 'include_extras=True').
 
        The argument may be a module, class, method, or function. The annotations
        are returned as a dictionary. For classes, annotations include also
        inherited members.
 
        TypeError is raised if the argument is not of a type that can contain
        annotations, and an empty dictionary is returned if no annotations are
        present.
 
        BEWARE -- the behavior of globalns and localns is counterintuitive
        (unless you are familiar with how eval() and exec() work).  The
        search order is locals first, then globals.
 
        - If no dict arguments are passed, an attempt is made to use the
          globals from obj (or the respective module's globals for classes),
          and these are also used as the locals.  If the object does not appear
          to have globals, an empty dictionary is used.
 
        - If one dict argument is passed, it is used for both globals and
          locals.
 
        - If two dict arguments are passed, they specify globals and
          locals, respectively.
        """
        if hasattr(typing, "Annotated"):
            hint = typing.get_type_hints(
                obj, globalns=globalns, localns=localns, include_extras=True
            )
        else:
            hint = typing.get_type_hints(obj, globalns=globalns, localns=localns)
        if include_extras:
            return hint
        return {k: _strip_extras(t) for k, t in hint.items()}
 
 
# Python 3.9+ has PEP 593 (Annotated)

References pip._vendor.typing_extensions._strip_extras(), and i.

Here is the call graph for this function:

IntVar()

IntVar

(

name

)

Definition at line 316 of file typing_extensions.py.

def IntVar(name):
    return typing.TypeVar(name)
 
 
# A Literal bug was fixed in 3.11.0, 3.10.1 and 3.9.8

References i.

is_protocol()

bool is_protocol

(

type

__tp

)

Return True if the given type is a Protocol.

Example::

    >>> from typing_extensions import Protocol, is_protocol
    >>> class P(Protocol):
    ...     def a(self) -> str: ...
    ...     b: int
    >>> is_protocol(P)
    True
    >>> is_protocol(int)
    False

Definition at line 2990 of file typing_extensions.py.

    def is_protocol(__tp: type) -> bool:
        """Return True if the given type is a Protocol.
 
        Example::
 
            >>> from typing_extensions import Protocol, is_protocol
            >>> class P(Protocol):
            ...     def a(self) -> str: ...
            ...     b: int
            >>> is_protocol(P)
            True
            >>> is_protocol(int)
            False
        """
        return (
            isinstance(__tp, type)
            and getattr(__tp, '_is_protocol', False)
            and __tp is not Protocol
            and __tp is not getattr(typing, "Protocol", object())
        )
 

References i.

is_typeddict()

is_typeddict

(

tp

)

Check if an annotation is a TypedDict class

For example::
    class Film(TypedDict):
        title: str
        year: int

    is_typeddict(Film)  # => True
    is_typeddict(Union[list, str])  # => False

Definition at line 1168 of file typing_extensions.py.

    def is_typeddict(tp):
        """Check if an annotation is a TypedDict class
 
        For example::
            class Film(TypedDict):
                title: str
                year: int
 
            is_typeddict(Film)  # => True
            is_typeddict(Union[list, str])  # => False
        """
        # On 3.8, this would otherwise return True
        if hasattr(typing, "TypedDict") and tp is typing.TypedDict:
            return False
        return isinstance(tp, _TYPEDDICT_TYPES)
 
 

References i.

LiteralString()

LiteralString	(		self,
			params
	)

Represents an arbitrary literal string.

Example::

  from pip._vendor.typing_extensions import LiteralString

  def query(sql: LiteralString) -> ...:
      ...

  query("SELECT * FROM table")  # ok
  query(f"SELECT * FROM {input()}")  # not ok

See PEP 675 for details.

Definition at line 1979 of file typing_extensions.py.

    def LiteralString(self, params):
        """Represents an arbitrary literal string.
 
        Example::
 
          from pip._vendor.typing_extensions import LiteralString
 
          def query(sql: LiteralString) -> ...:
              ...
 
          query("SELECT * FROM table")  # ok
          query(f"SELECT * FROM {input()}")  # not ok
 
        See PEP 675 for details.
 
        """
        raise TypeError(f"{self} is not subscriptable")
 
 

References i.

NamedTuple()

NamedTuple	(		__typename,
			__fields = _marker,
		**	kwargs
	)

Typed version of namedtuple.

Usage::

    class Employee(NamedTuple):
        name: str
        id: int

This is equivalent to::

    Employee = collections.namedtuple('Employee', ['name', 'id'])

The resulting class has an extra __annotations__ attribute, giving a
dict that maps field names to types.  (The field names are also in
the _fields attribute, which is part of the namedtuple API.)
An alternative equivalent functional syntax is also accepted::

    Employee = NamedTuple('Employee', [('name', str), ('id', int)])

Definition at line 2658 of file typing_extensions.py.

    def NamedTuple(__typename, __fields=_marker, **kwargs):
        """Typed version of namedtuple.
 
        Usage::
 
            class Employee(NamedTuple):
                name: str
                id: int
 
        This is equivalent to::
 
            Employee = collections.namedtuple('Employee', ['name', 'id'])
 
        The resulting class has an extra __annotations__ attribute, giving a
        dict that maps field names to types.  (The field names are also in
        the _fields attribute, which is part of the namedtuple API.)
        An alternative equivalent functional syntax is also accepted::
 
            Employee = NamedTuple('Employee', [('name', str), ('id', int)])
        """
        if __fields is _marker:
            if kwargs:
                deprecated_thing = "Creating NamedTuple classes using keyword arguments"
                deprecation_msg = (
                    "{name} is deprecated and will be disallowed in Python {remove}. "
                    "Use the class-based or functional syntax instead."
                )
            else:
                deprecated_thing = "Failing to pass a value for the 'fields' parameter"
                example = f"`{__typename} = NamedTuple({__typename!r}, [])`"
                deprecation_msg = (
                    "{name} is deprecated and will be disallowed in Python {remove}. "
                    "To create a NamedTuple class with 0 fields "
                    "using the functional syntax, "
                    "pass an empty list, e.g. "
                ) + example + "."
        elif __fields is None:
            if kwargs:
                raise TypeError(
                    "Cannot pass `None` as the 'fields' parameter "
                    "and also specify fields using keyword arguments"
                )
            else:
                deprecated_thing = "Passing `None` as the 'fields' parameter"
                example = f"`{__typename} = NamedTuple({__typename!r}, [])`"
                deprecation_msg = (
                    "{name} is deprecated and will be disallowed in Python {remove}. "
                    "To create a NamedTuple class with 0 fields "
                    "using the functional syntax, "
                    "pass an empty list, e.g. "
                ) + example + "."
        elif kwargs:
            raise TypeError("Either list of fields or keywords"
                            " can be provided to NamedTuple, not both")
        if __fields is _marker or __fields is None:
            warnings.warn(
                deprecation_msg.format(name=deprecated_thing, remove="3.15"),
                DeprecationWarning,
                stacklevel=2,
            )
            __fields = kwargs.items()
        nt = _make_nmtuple(__typename, __fields, module=_caller())
        nt.__orig_bases__ = (NamedTuple,)
        return nt
 

References pip._vendor.typing_extensions._caller(), pip._vendor.typing_extensions._make_nmtuple(), and i.

Here is the call graph for this function:

Never()

Never	(		self,
			params
	)

The bottom type, a type that has no members.

This can be used to define a function that should never be
called, or a function that never returns::

    from pip._vendor.typing_extensions import Never

    def never_call_me(arg: Never) -> None:
        pass

    def int_or_str(arg: int | str) -> None:
        never_call_me(arg)  # type checker error
        match arg:
            case int():
                print("It's an int")
            case str():
                print("It's a str")
            case _:
                never_call_me(arg)  # ok, arg is of type Never

Definition at line 2023 of file typing_extensions.py.

    def Never(self, params):
        """The bottom type, a type that has no members.
 
        This can be used to define a function that should never be
        called, or a function that never returns::
 
            from pip._vendor.typing_extensions import Never
 
            def never_call_me(arg: Never) -> None:
                pass
 
            def int_or_str(arg: int | str) -> None:
                never_call_me(arg)  # type checker error
                match arg:
                    case int():
                        print("It's an int")
                    case str():
                        print("It's a str")
                    case _:
                        never_call_me(arg)  # ok, arg is of type Never
 
        """
 
        raise TypeError(f"{self} is not subscriptable")
 
 

References i.

NotRequired()

NotRequired	(		self,
			parameters
	)

A special typing construct to mark a key of a TypedDict as
potentially missing. For example:

    class Movie(TypedDict):
        title: str
        year: NotRequired[int]

    m = Movie(
        title='The Matrix',  # typechecker error if key is omitted
        year=1999,
    )

Definition at line 2074 of file typing_extensions.py.

    def NotRequired(self, parameters):
        """A special typing construct to mark a key of a TypedDict as
        potentially missing. For example:
 
            class Movie(TypedDict):
                title: str
                year: NotRequired[int]
 
            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )
        """
        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
        return typing._GenericAlias(self, (item,))
 

References i.

overload()

overload

(

func

)

Decorator for overloaded functions/methods.

In a stub file, place two or more stub definitions for the same
function in a row, each decorated with @overload.  For example:

@overload
def utf8(value: None) -> None: ...
@overload
def utf8(value: bytes) -> bytes: ...
@overload
def utf8(value: str) -> bytes: ...

In a non-stub file (i.e. a regular .py file), do the same but
follow it with an implementation.  The implementation should *not*
be decorated with @overload.  For example:

@overload
def utf8(value: None) -> None: ...
@overload
def utf8(value: bytes) -> bytes: ...
@overload
def utf8(value: str) -> bytes: ...
def utf8(value):
    # implementation goes here

The overloads for a function can be retrieved at runtime using the
get_overloads() function.

Definition at line 407 of file typing_extensions.py.

    def overload(func):
        """Decorator for overloaded functions/methods.
 
        In a stub file, place two or more stub definitions for the same
        function in a row, each decorated with @overload.  For example:
 
        @overload
        def utf8(value: None) -> None: ...
        @overload
        def utf8(value: bytes) -> bytes: ...
        @overload
        def utf8(value: str) -> bytes: ...
 
        In a non-stub file (i.e. a regular .py file), do the same but
        follow it with an implementation.  The implementation should *not*
        be decorated with @overload.  For example:
 
        @overload
        def utf8(value: None) -> None: ...
        @overload
        def utf8(value: bytes) -> bytes: ...
        @overload
        def utf8(value: str) -> bytes: ...
        def utf8(value):
            # implementation goes here
 
        The overloads for a function can be retrieved at runtime using the
        get_overloads() function.
        """
        # classmethod and staticmethod
        f = getattr(func, "__func__", func)
        try:
            _overload_registry[f.__module__][f.__qualname__][
                f.__code__.co_firstlineno
            ] = func
        except AttributeError:
            # Not a normal function; ignore.
            pass
        return _overload_dummy
 

References i.

override()

_F override

(

_F

__arg

)

Indicate that a method is intended to override a method in a base class.

Usage:

    class Base:
        def method(self) -> None: ...
            pass

    class Child(Base):
        @override
        def method(self) -> None:
            super().method()

When this decorator is applied to a method, the type checker will
validate that it overrides a method with the same name on a base class.
This helps prevent bugs that may occur when a base class is changed
without an equivalent change to a child class.

There is no runtime checking of these properties. The decorator
sets the ``__override__`` attribute to ``True`` on the decorated object
to allow runtime introspection.

See PEP 698 for details.

Definition at line 2451 of file typing_extensions.py.

    def override(__arg: _F) -> _F:
        """Indicate that a method is intended to override a method in a base class.
 
        Usage:
 
            class Base:
                def method(self) -> None: ...
                    pass
 
            class Child(Base):
                @override
                def method(self) -> None:
                    super().method()
 
        When this decorator is applied to a method, the type checker will
        validate that it overrides a method with the same name on a base class.
        This helps prevent bugs that may occur when a base class is changed
        without an equivalent change to a child class.
 
        There is no runtime checking of these properties. The decorator
        sets the ``__override__`` attribute to ``True`` on the decorated object
        to allow runtime introspection.
 
        See PEP 698 for details.
 
        """
        try:
            __arg.__override__ = True
        except (AttributeError, TypeError):
            # Skip the attribute silently if it is not writable.
            # AttributeError happens if the object has __slots__ or a
            # read-only property, TypeError if it's a builtin class.
            pass
        return __arg
 
 

References i.

Required()

Required	(		self,
			parameters
	)

A special typing construct to mark a key of a total=False TypedDict
as required. For example:

    class Movie(TypedDict, total=False):
        title: Required[str]
        year: int

    m = Movie(
        title='The Matrix',  # typechecker error if key is omitted
        year=1999,
    )

There is no runtime checking that a required key is actually provided
when instantiating a related TypedDict.

Definition at line 2054 of file typing_extensions.py.

    def Required(self, parameters):
        """A special typing construct to mark a key of a total=False TypedDict
        as required. For example:
 
            class Movie(TypedDict, total=False):
                title: Required[str]
                year: int
 
            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )
 
        There is no runtime checking that a required key is actually provided
        when instantiating a related TypedDict.
        """
        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
        return typing._GenericAlias(self, (item,))
 

References i.

reveal_type()

T reveal_type

(

T

__obj

)

Reveal the inferred type of a variable.

When a static type checker encounters a call to ``reveal_type()``,
it will emit the inferred type of the argument::

    x: int = 1
    reveal_type(x)

Running a static type checker (e.g., ``mypy``) on this example
will produce output similar to 'Revealed type is "builtins.int"'.

At runtime, the function prints the runtime type of the
argument and returns it unchanged.

Definition at line 2310 of file typing_extensions.py.

    def reveal_type(__obj: T) -> T:
        """Reveal the inferred type of a variable.
 
        When a static type checker encounters a call to ``reveal_type()``,
        it will emit the inferred type of the argument::
 
            x: int = 1
            reveal_type(x)
 
        Running a static type checker (e.g., ``mypy``) on this example
        will produce output similar to 'Revealed type is "builtins.int"'.
 
        At runtime, the function prints the runtime type of the
        argument and returns it unchanged.
 
        """
        print(f"Runtime type is {type(__obj).__name__!r}", file=sys.stderr)
        return __obj
 
 

References i.

runtime_checkable()

runtime_checkable

(

cls

)

Mark a protocol class as a runtime protocol, so that it
can be used with isinstance() and issubclass(). Raise TypeError
if applied to a non-protocol class.

This allows a simple-minded structural check very similar to the
one-offs in collections.abc such as Hashable.

Definition at line 857 of file typing_extensions.py.

    def runtime_checkable(cls):
        """Mark a protocol class as a runtime protocol, so that it
        can be used with isinstance() and issubclass(). Raise TypeError
        if applied to a non-protocol class.
 
        This allows a simple-minded structural check very similar to the
        one-offs in collections.abc such as Hashable.
        """
        if not (
            (isinstance(cls, _ProtocolMeta) or issubclass(cls, typing.Generic))
            and getattr(cls, "_is_protocol", False)
        ):
            raise TypeError('@runtime_checkable can be only applied to protocol classes,'
                            f' got {cls!r}')
        cls._is_runtime_protocol = True
        return cls
 
 
# Exists for backwards compatibility.

References i.

Self()

Self	(		self,
			params
	)

Used to spell the type of "self" in classes.

Example::

  from typing import Self

  class ReturnsSelf:
      def parse(self, data: bytes) -> Self:
          ...
          return self

Definition at line 2002 of file typing_extensions.py.

    def Self(self, params):
        """Used to spell the type of "self" in classes.
 
        Example::
 
          from typing import Self
 
          class ReturnsSelf:
              def parse(self, data: bytes) -> Self:
                  ...
                  return self
 
        """
 
        raise TypeError(f"{self} is not subscriptable")
 
 

References i.

TypeAlias()

TypeAlias	(		self,
			parameters
	)

Special marker indicating that an assignment should
be recognized as a proper type alias definition by type
checkers.

For example::

    Predicate: TypeAlias = Callable[..., bool]

It's invalid when used anywhere except as in the example above.

Definition at line 1453 of file typing_extensions.py.

    def TypeAlias(self, parameters):
        """Special marker indicating that an assignment should
        be recognized as a proper type alias definition by type
        checkers.
 
        For example::
 
            Predicate: TypeAlias = Callable[..., bool]
 
        It's invalid when used anywhere except as in the example above.
        """
        raise TypeError(f"{self} is not subscriptable")
# 3.7-3.8

TypedDict()

TypedDict	(		__typename,
			__fields = _marker,
		*	total = True,
		**	kwargs
	)

A simple typed namespace. At runtime it is equivalent to a plain dict.

TypedDict creates a dictionary type such that a type checker will expect all
instances to have a certain set of keys, where each key is
associated with a value of a consistent type. This expectation
is not checked at runtime.

Usage::

    class Point2D(TypedDict):
        x: int
        y: int
        label: str

    a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
    b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check

    assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')

The type info can be accessed via the Point2D.__annotations__ dict, and
the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
TypedDict supports an additional equivalent form::

    Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})

By default, all keys must be present in a TypedDict. It is possible
to override this by specifying totality::

    class Point2D(TypedDict, total=False):
        x: int
        y: int

This means that a Point2D TypedDict can have any of the keys omitted. A type
checker is only expected to support a literal False or True as the value of
the total argument. True is the default, and makes all items defined in the
class body be required.

The Required and NotRequired special forms can also be used to mark
individual keys as being required or not required::

    class Point2D(TypedDict):
        x: int  # the "x" key must always be present (Required is the default)
        y: NotRequired[int]  # the "y" key can be omitted

See PEP 655 for more details on Required and NotRequired.

Definition at line 1080 of file typing_extensions.py.

    def TypedDict(__typename, __fields=_marker, *, total=True, **kwargs):
        """A simple typed namespace. At runtime it is equivalent to a plain dict.
 
        TypedDict creates a dictionary type such that a type checker will expect all
        instances to have a certain set of keys, where each key is
        associated with a value of a consistent type. This expectation
        is not checked at runtime.
 
        Usage::
 
            class Point2D(TypedDict):
                x: int
                y: int
                label: str
 
            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
            b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check
 
            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
 
        The type info can be accessed via the Point2D.__annotations__ dict, and
        the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
        TypedDict supports an additional equivalent form::
 
            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
 
        By default, all keys must be present in a TypedDict. It is possible
        to override this by specifying totality::
 
            class Point2D(TypedDict, total=False):
                x: int
                y: int
 
        This means that a Point2D TypedDict can have any of the keys omitted. A type
        checker is only expected to support a literal False or True as the value of
        the total argument. True is the default, and makes all items defined in the
        class body be required.
 
        The Required and NotRequired special forms can also be used to mark
        individual keys as being required or not required::
 
            class Point2D(TypedDict):
                x: int  # the "x" key must always be present (Required is the default)
                y: NotRequired[int]  # the "y" key can be omitted
 
        See PEP 655 for more details on Required and NotRequired.
        """
        if __fields is _marker or __fields is None:
            if __fields is _marker:
                deprecated_thing = "Failing to pass a value for the 'fields' parameter"
            else:
                deprecated_thing = "Passing `None` as the 'fields' parameter"
 
            example = f"`{__typename} = TypedDict({__typename!r}, {{}})`"
            deprecation_msg = (
                f"{deprecated_thing} is deprecated and will be disallowed in "
                "Python 3.15. To create a TypedDict class with 0 fields "
                "using the functional syntax, pass an empty dictionary, e.g. "
            ) + example + "."
            warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2)
            __fields = kwargs
        elif kwargs:
            raise TypeError("TypedDict takes either a dict or keyword arguments,"
                            " but not both")
        if kwargs:
            warnings.warn(
                "The kwargs-based syntax for TypedDict definitions is deprecated "
                "in Python 3.11, will be removed in Python 3.13, and may not be "
                "understood by third-party type checkers.",
                DeprecationWarning,
                stacklevel=2,
            )
 
        ns = {'__annotations__': dict(__fields)}
        module = _caller()
        if module is not None:
            # Setting correct module is necessary to make typed dict classes pickleable.
            ns['__module__'] = module
 
        td = _TypedDictMeta(__typename, (), ns, total=total)
        td.__orig_bases__ = (TypedDict,)
        return td
 

References pip._vendor.typing_extensions._caller(), and i.

Here is the call graph for this function:

TypeGuard()

TypeGuard	(		self,
			parameters
	)

Special typing form used to annotate the return type of a user-defined
type guard function.  ``TypeGuard`` only accepts a single type argument.
At runtime, functions marked this way should return a boolean.

``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
type checkers to determine a more precise type of an expression within a
program's code flow.  Usually type narrowing is done by analyzing
conditional code flow and applying the narrowing to a block of code.  The
conditional expression here is sometimes referred to as a "type guard".

Sometimes it would be convenient to use a user-defined boolean function
as a type guard.  Such a function should use ``TypeGuard[...]`` as its
return type to alert static type checkers to this intention.

Using  ``-> TypeGuard`` tells the static type checker that for a given
function:

1. The return value is a boolean.
2. If the return value is ``True``, the type of its argument
is the type inside ``TypeGuard``.

For example::

    def is_str(val: Union[str, float]):
        # "isinstance" type guard
        if isinstance(val, str):
            # Type of ``val`` is narrowed to ``str``
            ...
        else:
            # Else, type of ``val`` is narrowed to ``float``.
            ...

Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
form of ``TypeA`` (it can even be a wider form) and this may lead to
type-unsafe results.  The main reason is to allow for things like
narrowing ``List[object]`` to ``List[str]`` even though the latter is not
a subtype of the former, since ``List`` is invariant.  The responsibility of
writing type-safe type guards is left to the user.

``TypeGuard`` also works with type variables.  For more information, see
PEP 647 (User-Defined Type Guards).

Definition at line 1832 of file typing_extensions.py.

    def TypeGuard(self, parameters):
        """Special typing form used to annotate the return type of a user-defined
        type guard function.  ``TypeGuard`` only accepts a single type argument.
        At runtime, functions marked this way should return a boolean.
 
        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
        type checkers to determine a more precise type of an expression within a
        program's code flow.  Usually type narrowing is done by analyzing
        conditional code flow and applying the narrowing to a block of code.  The
        conditional expression here is sometimes referred to as a "type guard".
 
        Sometimes it would be convenient to use a user-defined boolean function
        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
        return type to alert static type checkers to this intention.
 
        Using  ``-> TypeGuard`` tells the static type checker that for a given
        function:
 
        1. The return value is a boolean.
        2. If the return value is ``True``, the type of its argument
        is the type inside ``TypeGuard``.
 
        For example::
 
            def is_str(val: Union[str, float]):
                # "isinstance" type guard
                if isinstance(val, str):
                    # Type of ``val`` is narrowed to ``str``
                    ...
                else:
                    # Else, type of ``val`` is narrowed to ``float``.
                    ...
 
        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
        form of ``TypeA`` (it can even be a wider form) and this may lead to
        type-unsafe results.  The main reason is to allow for things like
        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
        a subtype of the former, since ``List`` is invariant.  The responsibility of
        writing type-safe type guards is left to the user.
 
        ``TypeGuard`` also works with type variables.  For more information, see
        PEP 647 (User-Defined Type Guards).
        """
        item = typing._type_check(parameters, f'{self} accepts only a single type.')
        return typing._GenericAlias(self, (item,))
# 3.7-3.8

References i.

Unpack()

Unpack	(		self,
			parameters
	)

Definition at line 2188 of file typing_extensions.py.

    def Unpack(self, parameters):
        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
        return _UnpackAlias(self, (item,))
 

References i.

Variable Documentation

_AnnotatedAlias

_AnnotatedAlias = typing._AnnotatedAlias

protected

Definition at line 1281 of file typing_extensions.py.

_BaseGenericAlias

_BaseGenericAlias = typing._GenericAlias

protected

Definition at line 1393 of file typing_extensions.py.

_check_generic

_check_generic

protected

Definition at line 2584 of file typing_extensions.py.

Referenced by Protocol.__class_getitem__().

_collect_type_vars

_collect_type_vars

protected

Definition at line 2583 of file typing_extensions.py.

Referenced by pip._vendor.typing_extensions._maybe_adjust_parameters().

_ConcatenateGenericAlias

_ConcatenateGenericAlias = typing._ConcatenateGenericAlias

protected

Definition at line 1791 of file typing_extensions.py.

_EXCLUDED_ATTRS

_EXCLUDED_ATTRS

protected

Initial value:

=  {
    "__abstractmethods__", "__annotations__", "__weakref__", "_is_protocol",
    "_is_runtime_protocol", "__dict__", "__slots__", "__parameters__",
    "__orig_bases__", "__module__", "_MutableMapping__marker", "__doc__",
    "__subclasshook__", "__orig_class__", "__init__", "__new__",
    "__protocol_attrs__", "__callable_proto_members_only__",
}

Definition at line 503 of file typing_extensions.py.

_F

_F = typing.TypeVar("_F", bound=typing.Callable[..., typing.Any])

protected

Definition at line 2449 of file typing_extensions.py.

_fake_name

str _fake_name = "Protocol"

protected

Definition at line 990 of file typing_extensions.py.

_is_runtime_protocol

_is_runtime_protocol

protected

Definition at line 871 of file typing_extensions.py.

_marker

_marker = _Sentinel()

protected

Definition at line 144 of file typing_extensions.py.

_NamedTuple

_NamedTuple

protected

Definition at line 2651 of file typing_extensions.py.

_new_signature

str _new_signature = '(typename, fields=None, /, **kwargs)'

protected

Definition at line 2727 of file typing_extensions.py.

_overload_dummy

_overload_dummy = typing._overload_dummy

protected

Definition at line 394 of file typing_extensions.py.

_overload_registry

_overload_registry

protected

Initial value:

=  collections.defaultdict(
        functools.partial(collections.defaultdict, dict)
    )

Definition at line 403 of file typing_extensions.py.

_prohibited_namedtuple_fields

_prohibited_namedtuple_fields = typing._prohibited

protected

Definition at line 2608 of file typing_extensions.py.

_PROTO_ALLOWLIST

dict _PROTO_ALLOWLIST

protected

Initial value:

=  {
    'collections.abc': [
        'Callable', 'Awaitable', 'Iterable', 'Iterator', 'AsyncIterable',
        'Hashable', 'Sized', 'Container', 'Collection', 'Reversible', 'Buffer',
    ],
    'contextlib': ['AbstractContextManager', 'AbstractAsyncContextManager'],
    'typing_extensions': ['Buffer'],
}

Definition at line 493 of file typing_extensions.py.

_ProtocolMetaBase

_ProtocolMetaBase = type(_typing_Protocol)

protected

Definition at line 606 of file typing_extensions.py.

_special_namedtuple_fields

_special_namedtuple_fields = frozenset({'__module__', '__name__', '__annotations__'})

protected

Definition at line 2609 of file typing_extensions.py.

_T

_T = typing.TypeVar("_T")

protected

Definition at line 2490 of file typing_extensions.py.

_TAKES_MODULE

str _TAKES_MODULE = "module" in inspect.signature(typing._type_check).parameters

protected

Definition at line 987 of file typing_extensions.py.

_TypedDict

_TypedDict

protected

Definition at line 1077 of file typing_extensions.py.

_TYPEDDICT_TYPES

tuple _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta)

protected

Definition at line 1164 of file typing_extensions.py.

_TypedDictMeta

_TypedDictMeta = typing._TypedDictMeta

protected

Definition at line 983 of file typing_extensions.py.

_typing_GenericAlias

_typing_GenericAlias = typing._GenericAlias

protected

Definition at line 1398 of file typing_extensions.py.

_typing_Protocol

_typing_Protocol = typing.Protocol

protected

Definition at line 605 of file typing_extensions.py.

_UNPACK_DOC

str _UNPACK_DOC

protected

Definition at line 2130 of file typing_extensions.py.

AbstractSet

AbstractSet = typing.AbstractSet

Definition at line 3036 of file typing_extensions.py.

Annotated

Annotated = typing.Annotated

Definition at line 1278 of file typing_extensions.py.

AnyStr

AnyStr = typing.AnyStr

Definition at line 3037 of file typing_extensions.py.

assert_never

assert_never = typing.assert_never

Definition at line 2331 of file typing_extensions.py.

assert_type

assert_type = typing.assert_type

Definition at line 1186 of file typing_extensions.py.

AsyncContextManager

AsyncContextManager = typing.AsyncContextManager

Definition at line 476 of file typing_extensions.py.

AsyncGenerator

AsyncGenerator = typing.AsyncGenerator

Definition at line 488 of file typing_extensions.py.

AsyncIterable

AsyncIterable = typing.AsyncIterable

Definition at line 472 of file typing_extensions.py.

AsyncIterator

AsyncIterator = typing.AsyncIterator

Definition at line 473 of file typing_extensions.py.

Awaitable

Awaitable = typing.Awaitable

Definition at line 470 of file typing_extensions.py.

BinaryIO

BinaryIO = typing.BinaryIO

Definition at line 3038 of file typing_extensions.py.

Buffer

Buffer = collections.abc.Buffer

Definition at line 2735 of file typing_extensions.py.

Callable

Callable = typing.Callable

Definition at line 3039 of file typing_extensions.py.

cast

cast = typing.cast

Definition at line 3070 of file typing_extensions.py.

ChainMap

ChainMap = typing.ChainMap

Definition at line 487 of file typing_extensions.py.

ClassVar

ClassVar = typing.ClassVar

Definition at line 243 of file typing_extensions.py.

clear_overloads

clear_overloads

(

)

= typing.clear_overloads

Clear all overloads in the registry.

Definition at line 400 of file typing_extensions.py.

Collection

Collection = typing.Collection

Definition at line 3040 of file typing_extensions.py.

Concatenate

Concatenate = typing.Concatenate

Definition at line 1790 of file typing_extensions.py.

Container

Container = typing.Container

Definition at line 3041 of file typing_extensions.py.

ContextManager

ContextManager = typing.ContextManager

Definition at line 475 of file typing_extensions.py.

Coroutine

Coroutine = typing.Coroutine

Definition at line 471 of file typing_extensions.py.

Counter

Counter = typing.Counter

Definition at line 486 of file typing_extensions.py.

dataclass_transform

dataclass_transform = typing.dataclass_transform

Definition at line 2358 of file typing_extensions.py.

DefaultDict

DefaultDict = typing.DefaultDict

Definition at line 477 of file typing_extensions.py.

deprecated

deprecated = typing.deprecated

Definition at line 2488 of file typing_extensions.py.

Deque

Deque = typing.Deque

Definition at line 474 of file typing_extensions.py.

Dict

Dict = typing.Dict

Definition at line 3042 of file typing_extensions.py.

doc

doc

Definition at line 264 of file typing_extensions.py.

Final

Final = typing.Final

Definition at line 254 of file typing_extensions.py.

final

final = typing.final

Definition at line 279 of file typing_extensions.py.

ForwardRef

ForwardRef = typing.ForwardRef

Definition at line 3043 of file typing_extensions.py.

FrozenSet

FrozenSet = typing.FrozenSet

Definition at line 3044 of file typing_extensions.py.

Generator

Generator = typing.Generator

Definition at line 3045 of file typing_extensions.py.

Generic

Generic = typing.Generic

Definition at line 3046 of file typing_extensions.py.

GenericMeta

GenericMeta = type

Definition at line 133 of file typing_extensions.py.

get_args

get_args = typing.get_args

Definition at line 1386 of file typing_extensions.py.

Referenced by _TypedDictMeta.__new__().

get_origin

get_origin = typing.get_origin

Definition at line 1385 of file typing_extensions.py.

Referenced by Annotated.__class_getitem__(), _TypedDictMeta.__new__(), pip._vendor.typing_extensions._is_unpack(), and pip._vendor.typing_extensions.get_args().

get_original_bases

get_original_bases = _types.get_original_bases

Definition at line 2765 of file typing_extensions.py.

get_overloads

get_overloads = typing.get_overloads

Definition at line 399 of file typing_extensions.py.

get_protocol_members

get_protocol_members = typing.get_protocol_members

Definition at line 2988 of file typing_extensions.py.

get_type_hints

get_type_hints = typing.get_type_hints

Definition at line 1206 of file typing_extensions.py.

Hashable

Hashable = typing.Hashable

Definition at line 3047 of file typing_extensions.py.

IO

IO = typing.IO

Definition at line 3048 of file typing_extensions.py.

is_protocol

is_protocol = typing.is_protocol

Definition at line 2987 of file typing_extensions.py.

Referenced by _ProtocolMeta.__new__(), pip._vendor.typing_extensions._proto_hook(), and pip._vendor.typing_extensions.get_protocol_members().

is_typeddict

is_typeddict = typing.is_typeddict

Definition at line 984 of file typing_extensions.py.

ItemsView

ItemsView = typing.ItemsView

Definition at line 3049 of file typing_extensions.py.

Iterable

Iterable = typing.Iterable

Definition at line 3050 of file typing_extensions.py.

Iterator

Iterator = typing.Iterator

Definition at line 3051 of file typing_extensions.py.

KeysView

KeysView = typing.KeysView

Definition at line 3052 of file typing_extensions.py.

KT

KT = typing.TypeVar('KT')

Definition at line 207 of file typing_extensions.py.

List

List = typing.List

Definition at line 3053 of file typing_extensions.py.

Literal

Literal = typing.Literal

Definition at line 322 of file typing_extensions.py.

LiteralString

LiteralString = typing.LiteralString

Definition at line 1976 of file typing_extensions.py.

Mapping

Mapping = typing.Mapping

Definition at line 3054 of file typing_extensions.py.

MappingView

MappingView = typing.MappingView

Definition at line 3055 of file typing_extensions.py.

Match

Match = typing.Match

Definition at line 3056 of file typing_extensions.py.

MutableMapping

MutableMapping = typing.MutableMapping

Definition at line 3057 of file typing_extensions.py.

MutableSequence

MutableSequence = typing.MutableSequence

Definition at line 3058 of file typing_extensions.py.

MutableSet

MutableSet = typing.MutableSet

Definition at line 3059 of file typing_extensions.py.

NamedTuple

NamedTuple = typing.NamedTuple

Definition at line 2593 of file typing_extensions.py.

Never

Never = typing.Never

Definition at line 2020 of file typing_extensions.py.

NewType

NewType = typing.NewType

Definition at line 2802 of file typing_extensions.py.

no_type_check

no_type_check = typing.no_type_check

Definition at line 3071 of file typing_extensions.py.

no_type_check_decorator

no_type_check_decorator = typing.no_type_check_decorator

Definition at line 3072 of file typing_extensions.py.

NoReturn

NoReturn = typing.NoReturn

Definition at line 202 of file typing_extensions.py.

NotRequired

NotRequired = typing.NotRequired

Definition at line 2051 of file typing_extensions.py.

Optional

Optional = typing.Optional

Definition at line 3060 of file typing_extensions.py.

OrderedDict

OrderedDict = typing.OrderedDict

Definition at line 481 of file typing_extensions.py.

overload

overload = typing.overload

Definition at line 398 of file typing_extensions.py.

override

override = typing.override

Definition at line 2447 of file typing_extensions.py.

ParamSpecArgs

ParamSpecArgs = typing.ParamSpecArgs

Definition at line 1542 of file typing_extensions.py.

ParamSpecKwargs

ParamSpecKwargs = typing.ParamSpecKwargs

Definition at line 1543 of file typing_extensions.py.

Pattern

Pattern = typing.Pattern

Definition at line 3061 of file typing_extensions.py.

PEP_560

bool PEP_560 = True

Definition at line 132 of file typing_extensions.py.

Protocol

Protocol = typing.Protocol

Definition at line 588 of file typing_extensions.py.

Required

Required = typing.Required

Definition at line 2050 of file typing_extensions.py.

reveal_type

reveal_type = typing.reveal_type

Definition at line 2308 of file typing_extensions.py.

Reversible

Reversible = typing.Reversible

Definition at line 3062 of file typing_extensions.py.

runtime

runtime = runtime_checkable

Definition at line 876 of file typing_extensions.py.

runtime_checkable

runtime_checkable = typing.runtime_checkable

Definition at line 855 of file typing_extensions.py.

Self

Self = typing.Self

Definition at line 1999 of file typing_extensions.py.

Sequence

Sequence = typing.Sequence

Definition at line 3063 of file typing_extensions.py.

Set

Set = typing.Set

Definition at line 3064 of file typing_extensions.py.

Sized

Sized = typing.Sized

Definition at line 3065 of file typing_extensions.py.

SupportsAbs

SupportsAbs = typing.SupportsAbs

Definition at line 886 of file typing_extensions.py.

SupportsBytes

SupportsBytes = typing.SupportsBytes

Definition at line 884 of file typing_extensions.py.

SupportsComplex

SupportsComplex = typing.SupportsComplex

Definition at line 883 of file typing_extensions.py.

SupportsFloat

SupportsFloat = typing.SupportsFloat

Definition at line 882 of file typing_extensions.py.

SupportsIndex

SupportsIndex = typing.SupportsIndex

Definition at line 885 of file typing_extensions.py.

SupportsInt

SupportsInt = typing.SupportsInt

Definition at line 881 of file typing_extensions.py.

SupportsRound

SupportsRound = typing.SupportsRound

Definition at line 887 of file typing_extensions.py.

T

T = typing.TypeVar('T')

Definition at line 206 of file typing_extensions.py.

T_co

T_co = typing.TypeVar('T_co', covariant=True)

Definition at line 209 of file typing_extensions.py.

T_contra

T_contra = typing.TypeVar('T_contra', contravariant=True)

Definition at line 210 of file typing_extensions.py.

Text

Text = typing.Text

Definition at line 489 of file typing_extensions.py.

TextIO

TextIO = typing.TextIO

Definition at line 3066 of file typing_extensions.py.

Tuple

Tuple = typing.Tuple

Definition at line 3067 of file typing_extensions.py.

Type

Type = typing.Type

Definition at line 464 of file typing_extensions.py.

TYPE_CHECKING

TYPE_CHECKING = typing.TYPE_CHECKING

Definition at line 490 of file typing_extensions.py.

TypeAlias

TypeAlias = typing.TypeAlias

Definition at line 1449 of file typing_extensions.py.

TypeAliasType

TypeAliasType = typing.TypeAliasType

Definition at line 2865 of file typing_extensions.py.

TypedDict

TypedDict = typing.TypedDict

Definition at line 982 of file typing_extensions.py.

TypeGuard

TypeGuard = typing.TypeGuard

Definition at line 1828 of file typing_extensions.py.

Union

Union = typing.Union

Definition at line 3068 of file typing_extensions.py.

Unpack

Unpack = typing.Unpack

Definition at line 2173 of file typing_extensions.py.

ValuesView

ValuesView = typing.ValuesView

Definition at line 3069 of file typing_extensions.py.

VT

VT = typing.TypeVar('VT')

Definition at line 208 of file typing_extensions.py.