"typing" --- Suporte para dicas de tipo
***************************************

Novo na versão 3.5.

**Código-fonte:** Lib/typing.py

Nota:

  O tempo de execução do Python não força anotações de tipos de
  variáveis e funções. Elas podem ser usadas por ferramentas de
  terceiros como verificadores de tipo, IDEs, linters, etc.

======================================================================

This module provides runtime support for type hints. The most
fundamental support consists of the types "Any", "Union", "Callable",
"TypeVar", and "Generic". For a full specification, please see **PEP
484**. For a simplified introduction to type hints, see **PEP 483**.

A função abaixo recebe e retorna uma string e é anotada como a seguir:

   def greeting(name: str) -> str:
       return 'Hello ' + name

Na função "greeting", é esperado que o argumento "name" seja do tipo
"str" e o retorno do tipo "str". Subtipos são aceitos como argumentos.

Novos recursos são frequentemente adicionados ao módulo "typing". O
pacote typing_extensions provê suporte retroativo a estes novos
recursos em versões anteriores do Python.


PEPs Relevantes
===============

Since the initial introduction of type hints in **PEP 484** and **PEP
483**, a number of PEPs have modified and enhanced Python's framework
for type annotations. These include:

* **PEP 526**: Sintaxe para Anotações de Variável
     "Introduzindo" sintaxe para anotar variáveis fora de definições
     de funções e "ClassVar".

* **PEP 544**: Protocols: Structural subtyping (static duck typing)
     *Introduzindo* "Protocol" e o decorador "@runtime_checkable".

* **PEP 585**: Type Hinting Generics In Standard Collections
     *Introducing* "types.GenericAlias" and the ability to use
     standard library classes as generic types

* **PEP 586**: Tipos literais
     *Introducing* "Literal"

* **PEP 589**: TypedDict: Type Hints for Dictionaries with a Fixed Set
  of Keys
     *Introducing* "TypedDict"

* **PEP 591**: Adicionando um qualificador final para escrita
     *Introducing* "Final" and the "@final" decorator

* **PEP 593**: Flexible function and variable annotations
     *Introducing* "Annotated"


Apelidos de tipo
================

Um apelido de tipo é definido ao atribuir o tipo ao apelido. Nesse
exemplo, "Vector" e "list[float]" serão tratados como sinônimos
intercambiáveis:

   Vector = list[float]

   def scale(scalar: float, vector: Vector) -> Vector:
       return [scalar * num for num in vector]

   # typechecks; a list of floats qualifies as a Vector.
   new_vector = scale(2.0, [1.0, -4.2, 5.4])

Apelidos de tipo são úteis para simplificar assinaturas de tipo
complexas. Por exemplo:

   from collections.abc import Sequence

   ConnectionOptions = dict[str, str]
   Address = tuple[str, int]
   Server = tuple[Address, ConnectionOptions]

   def broadcast_message(message: str, servers: Sequence[Server]) -> None:
       ...

   # The static type checker will treat the previous type signature as
   # being exactly equivalent to this one.
   def broadcast_message(
           message: str,
           servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None:
       ...

Note que "None" como uma dica de tipo é um caso especial e é
substituído por "type(None)".


NewType
=======

Use the "NewType()" helper to create distinct types:

   from typing import NewType

   UserId = NewType('UserId', int)
   some_id = UserId(524313)

O verificador de tipo estático tratará o novo tipo como se fosse uma
subclasse do tipo original. Isso é útil para ajudar a encontrar erros
de lógica:

   def get_user_name(user_id: UserId) -> str:
       ...

   # typechecks
   user_a = get_user_name(UserId(42351))

   # does not typecheck; an int is not a UserId
   user_b = get_user_name(-1)

Você ainda pode executar todas as operações "int" em uma variável do
tipo "UserId", mas o resultado sempre será do tipo "int". Isso permite
que você passe um "UserId" em qualquer ocasião que "int" possa ser
esperado, mas previne que você acidentalmente crie um "UserId" de uma
forma inválida:

   # 'output' is of type 'int', not 'UserId'
   output = UserId(23413) + UserId(54341)

Note that these checks are enforced only by the static type checker.
At runtime, the statement "Derived = NewType('Derived', Base)" will
make "Derived" a callable that immediately returns whatever parameter
you pass it. That means the expression "Derived(some_value)" does not
create a new class or introduce any overhead beyond that of a regular
function call.

Mais precisamente, a expressão "some_value is Derived(some_value)" é
sempre verdadeira em tempo de execução.

This also means that it is not possible to create a subtype of
"Derived" since it is an identity function at runtime, not an actual
type:

   from typing import NewType

   UserId = NewType('UserId', int)

   # Fails at runtime and does not typecheck
   class AdminUserId(UserId): pass

However, it is possible to create a "NewType()" based on a 'derived'
"NewType":

   from typing import NewType

   UserId = NewType('UserId', int)

   ProUserId = NewType('ProUserId', UserId)

e a verificação de tipos para "ProUserId" funcionará como esperado.

Veja **PEP 484** para mais detalhes.

Nota:

  Relembre que o uso de um apelido de tipo declara que dois tipos
  serão *equivalentes* entre si. Efetuar "Alias = Original" irá fazer
  o verificador de tipo estático tratar "Alias" como sendo *exatamente
  equivalente* a "Original" em todos os casos. Isso é útil quando você
  deseja simplificar assinaturas de tipo complexas.Em contraste,
  "NewType" declara que um tipo será *subtipo* de outro. Efetuando
  "Derived = NewType('Derived', Original)" irá fazer o verificador de
  tipo estático tratar "Derived" como uma *subclasse* de "Original", o
  que significa que um valor do tipo "Original" não pode ser utilizado
  onde um valor do tipo "Derived" é esperado. Isso é útil quando você
  deseja evitar erros de lógica com custo mínimo de tempo de execução.

Novo na versão 3.5.2.


Callable
========

Frameworks que esperam funções de retorno com assinaturas específicas
podem ter seus tipos indicados usando "Callable[[Arg1Type, Arg2Type],
ReturnType]".

Por exemplo:

   from collections.abc import Callable

   def feeder(get_next_item: Callable[[], str]) -> None:
       # Body

   def async_query(on_success: Callable[[int], None],
                   on_error: Callable[[int, Exception], None]) -> None:
       # Body

   async def on_update(value: str) -> None:
       # Body
   callback: Callable[[str], Awaitable[None]] = on_update

É possível declarar o tipo de retorno de um chamável sem especificar a
assinatura da chamada, substituindo por reticências literais a lista
de argumentos na dica de tipo: "Callable[..., ReturnType]".


Genéricos
=========

Since type information about objects kept in containers cannot be
statically inferred in a generic way, abstract base classes have been
extended to support subscription to denote expected types for
container elements.

   from collections.abc import Mapping, Sequence

   def notify_by_email(employees: Sequence[Employee],
                       overrides: Mapping[str, str]) -> None: ...

Generics can be parameterized by using a factory available in typing
called "TypeVar".

   from collections.abc import Sequence
   from typing import TypeVar

   T = TypeVar('T')      # Declare type variable

   def first(l: Sequence[T]) -> T:   # Generic function
       return l[0]


Tipos genéricos definidos pelo usuário
======================================

Uma classe definida pelo usuário pode ser definica como uma classe
genérica.

   from typing import TypeVar, Generic
   from logging import Logger

   T = TypeVar('T')

   class LoggedVar(Generic[T]):
       def __init__(self, value: T, name: str, logger: Logger) -> None:
           self.name = name
           self.logger = logger
           self.value = value

       def set(self, new: T) -> None:
           self.log('Set ' + repr(self.value))
           self.value = new

       def get(self) -> T:
           self.log('Get ' + repr(self.value))
           return self.value

       def log(self, message: str) -> None:
           self.logger.info('%s: %s', self.name, message)

"Generic[T]" as a base class defines that the class "LoggedVar" takes
a single type parameter "T" . This also makes "T" valid as a type
within the class body.

The "Generic" base class defines "__class_getitem__()" so that
"LoggedVar[t]" is valid as a type:

   from collections.abc import Iterable

   def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:
       for var in vars:
           var.set(0)

Um tipo genérico pode ter qualquer número de tipos de variáveis. Todas
as variedades de "TypeVar" são permitidas como parâmetros para um tipo
genérico:

   from typing import TypeVar, Generic, Sequence

   T = TypeVar('T', contravariant=True)
   B = TypeVar('B', bound=Sequence[bytes], covariant=True)
   S = TypeVar('S', int, str)

   class WeirdTrio(Generic[T, B, S]):
       ...

Cada tipo dos argumentos para "Generic" devem ser distintos. Assim, os
seguintes exemplos são inválidos:

   from typing import TypeVar, Generic
   ...

   T = TypeVar('T')

   class Pair(Generic[T, T]):   # INVALID
       ...

You can use multiple inheritance with "Generic":

   from collections.abc import Sized
   from typing import TypeVar, Generic

   T = TypeVar('T')

   class LinkedList(Sized, Generic[T]):
       ...

When inheriting from generic classes, some type variables could be
fixed:

   from collections.abc import Mapping
   from typing import TypeVar

   T = TypeVar('T')

   class MyDict(Mapping[str, T]):
       ...

Neste caso "MyDict" possui um único parâmetro, "T".

Using a generic class without specifying type parameters assumes "Any"
for each position. In the following example, "MyIterable" is not
generic but implicitly inherits from "Iterable[Any]":

   from collections.abc import Iterable

   class MyIterable(Iterable): # Same as Iterable[Any]

User defined generic type aliases are also supported. Examples:

   from collections.abc import Iterable
   from typing import TypeVar, Union
   S = TypeVar('S')
   Response = Union[Iterable[S], int]

   # Return type here is same as Union[Iterable[str], int]
   def response(query: str) -> Response[str]:
       ...

   T = TypeVar('T', int, float, complex)
   Vec = Iterable[tuple[T, T]]

   def inproduct(v: Vec[T]) -> T: # Same as Iterable[tuple[T, T]]
       return sum(x*y for x, y in v)

Alterado na versão 3.7: "Generic" não possui mais uma metaclasse
personalizada.

A user-defined generic class can have ABCs as base classes without a
metaclass conflict. Generic metaclasses are not supported. The outcome
of parameterizing generics is cached, and most types in the typing
module are hashable and comparable for equality.


O tipo "Any"
============

Um tipo especial de tipo é "Any". Um verificador de tipo estático
tratará cada tipo como sendo compatível com "Any" e "Any" como sendo
compatível com todos os tipos.

Isso significa que é possível realizar qualquer operação ou chamada de
método sobre um valor do tipo "Any" e atribuí-lo a qualquer variável:

   from typing import Any

   a: Any = None
   a = []          # OK
   a = 2           # OK

   s: str = ''
   s = a           # OK

   def foo(item: Any) -> int:
       # Typechecks; 'item' could be any type,
       # and that type might have a 'bar' method
       item.bar()
       ...

Notice that no typechecking is performed when assigning a value of
type "Any" to a more precise type. For example, the static type
checker did not report an error when assigning "a" to "s" even though
"s" was declared to be of type "str" and receives an "int" value at
runtime!

Além disso, todas as funções sem um tipo de retorno ou tipos de
parâmetro terão como padrão implicitamente o uso de "Any":

   def legacy_parser(text):
       ...
       return data

   # A static type checker will treat the above
   # as having the same signature as:
   def legacy_parser(text: Any) -> Any:
       ...
       return data

Este comportamento permite que "Any" seja usado como uma *saída de
emergência* quando você precisar misturar código tipado dinamicamente
e estaticamente.

Compare o comportamento de "Any" com o comportamento de "object".
Semelhante a "Any", todo tipo é um subtipo de "object". No entanto, ao
contrário de "Any", o inverso não é verdadeiro: "object" *não* é um
subtipo de qualquer outro tipo.

Isso significa que quando o tipo de um valor é "object", um
verificador de tipo rejeitará quase todas as operações nele, e
atribuí-lo a uma variável (ou usá-la como valor de retorno) de um tipo
mais especializado é um tipo erro. Por exemplo:

   def hash_a(item: object) -> int:
       # Fails; an object does not have a 'magic' method.
       item.magic()
       ...

   def hash_b(item: Any) -> int:
       # Typechecks
       item.magic()
       ...

   # Typechecks, since ints and strs are subclasses of object
   hash_a(42)
   hash_a("foo")

   # Typechecks, since Any is compatible with all types
   hash_b(42)
   hash_b("foo")

Use "object" para indicar que um valor pode ser de qualquer tipo de
maneira segura. Use "Any" para indicar que um valor é tipado
dinamicamente.


Subtipagem nominal vs estrutural
================================

Inicialmente a **PEP 484** definiu o sistema de tipos estáticos do
Python como usando *subtipagem nominal*. Isto significa que uma classe
"A" é permitida onde uma classe "B" é esperada se e somente se "A" for
uma subclasse de "B".

Este requisito anteriormente também se aplicava a classes base
abstratas, como "Iterable". O problema com essa abordagem é que uma
classe teve que ser marcada explicitamente para suportá-los, o que não
é pythônico e diferente do que normalmente seria feito em código
Python de tipo dinamicamente idiomático. Por exemplo, isso está em
conformidade com **PEP 484**:

   from collections.abc import Sized, Iterable, Iterator

   class Bucket(Sized, Iterable[int]):
       ...
       def __len__(self) -> int: ...
       def __iter__(self) -> Iterator[int]: ...

**PEP 544** permite resolver este problema permitindo que os usuários
escrevam o código acima sem classes base explícitas na definição de
classe, permitindo que "Bucket" seja implicitamente considerado um
subtipo de "Sized" e "Iterable[int]" por verificador de tipo estático.
Isso é conhecido como *subtipagem estrutural* (ou tipagem pato
estática):

   from collections.abc import Iterator, Iterable

   class Bucket:  # Note: no base classes
       ...
       def __len__(self) -> int: ...
       def __iter__(self) -> Iterator[int]: ...

   def collect(items: Iterable[int]) -> int: ...
   result = collect(Bucket())  # Passes type check

Além disso, ao criar uma subclasse de uma classe especial "Protocol",
um usuário pode definir novos protocolos personalizados para
aproveitar ao máximo a subtipagem estrutural (veja exemplos abaixo).


Conteúdo do módulo
==================

The module defines the following classes, functions and decorators.

Nota:

  This module defines several types that are subclasses of pre-
  existing standard library classes which also extend "Generic" to
  support type variables inside "[]". These types became redundant in
  Python 3.9 when the corresponding pre-existing classes were enhanced
  to support "[]".The redundant types are deprecated as of Python 3.9
  but no deprecation warnings will be issued by the interpreter. It is
  expected that type checkers will flag the deprecated types when the
  checked program targets Python 3.9 or newer.The deprecated types
  will be removed from the "typing" module in the first Python version
  released 5 years after the release of Python 3.9.0. See details in
  **PEP 585**—*Type Hinting Generics In Standard Collections*.


Tipos primitivos especiais
--------------------------


Tipos especiais
~~~~~~~~~~~~~~~

These can be used as types in annotations and do not support "[]".

typing.Any

   Tipo especial que indica um tipo irrestrito.

   * Todos os tipos são compatíveis com "Any".

   * "Any" é compatível com todos os tipos.

typing.NoReturn

   Tipo especial indicando que uma função nunca retorna. Por exemplo:

      from typing import NoReturn

      def stop() -> NoReturn:
          raise RuntimeError('no way')

   Novo na versão 3.5.4.

   Novo na versão 3.6.2.


Formas especiais
~~~~~~~~~~~~~~~~

These can be used as types in annotations using "[]", each having a
unique syntax.

typing.Tuple

   Tuple type; "Tuple[X, Y]" is the type of a tuple of two items with
   the first item of type X and the second of type Y. The type of the
   empty tuple can be written as "Tuple[()]".

   Example: "Tuple[T1, T2]" is a tuple of two elements corresponding
   to type variables T1 and T2.  "Tuple[int, float, str]" is a tuple
   of an int, a float and a string.

   To specify a variable-length tuple of homogeneous type, use literal
   ellipsis, e.g. "Tuple[int, ...]". A plain "Tuple" is equivalent to
   "Tuple[Any, ...]", and in turn to "tuple".

   Obsoleto desde a versão 3.9: "builtins.tuple" now supports "[]".
   See **PEP 585** and Tipo Generic Alias.

typing.Union

   Union type; "Union[X, Y]" means either X or Y.

   To define a union, use e.g. "Union[int, str]".  Details:

   * Os argumentos devem ser tipos e deve haver pelo menos um.

   * As uniões de uniões são achatadas, por exemplo:

        Union[Union[int, str], float] == Union[int, str, float]

   * As uniões de um único argumento desaparecem, por exemplo:

        Union[int] == int  # The constructor actually returns int

   * Argumento redundantes são pulados, e.g.:

        Union[int, str, int] == Union[int, str]

   * Ao comparar uniões, a ordem de argumentos é ignorada. Por
     exemplo:

        Union[int, str] == Union[str, int]

   * You cannot subclass or instantiate a union.

   * Você não pode escrever "Union[X][Y]".

   * You can use "Optional[X]" as a shorthand for "Union[X, None]".

   Alterado na versão 3.7: Não remova subclasses explícitas de uniões
   em tempo de execução.

typing.Optional

   Tipo opcional.

   "Optional[X]" is equivalent to "Union[X, None]".

   Note que isso não é o mesmo conceito de um argumento opcional, que
   possui um valor por padrão. Um argumento opcional com padrão não
   requer o qualificador "Optional" em sua anotação de tipo só por ser
   opcional. Por exemplo:

      def foo(arg: int = 0) -> None:
          ...

   Por outro lado, se um valor explícito de "None" for permitido, o
   uso de "Optional" é apropriado, seja o argumento opcional ou não.
   Por exemplo:

      def foo(arg: Optional[int] = None) -> None:
          ...

typing.Callable

   Callable type; "Callable[[int], str]" is a function of (int) ->
   str.

   The subscription syntax must always be used with exactly two
   values: the argument list and the return type.  The argument list
   must be a list of types or an ellipsis; the return type must be a
   single type.

   There is no syntax to indicate optional or keyword arguments; such
   function types are rarely used as callback types. "Callable[...,
   ReturnType]" (literal ellipsis) can be used to type hint a callable
   taking any number of arguments and returning "ReturnType".  A plain
   "Callable" is equivalent to "Callable[..., Any]", and in turn to
   "collections.abc.Callable".

   Obsoleto desde a versão 3.9: "collections.abc.Callable" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Type(Generic[CT_co])

   A variable annotated with "C" may accept a value of type "C". In
   contrast, a variable annotated with "Type[C]" may accept values
   that are classes themselves -- specifically, it will accept the
   *class object* of "C". For example:

      a = 3         # Has type 'int'
      b = int       # Has type 'Type[int]'
      c = type(a)   # Also has type 'Type[int]'

   Note that "Type[C]" is covariant:

      class User: ...
      class BasicUser(User): ...
      class ProUser(User): ...
      class TeamUser(User): ...

      # Accepts User, BasicUser, ProUser, TeamUser, ...
      def make_new_user(user_class: Type[User]) -> User:
          # ...
          return user_class()

   The fact that "Type[C]" is covariant implies that all subclasses of
   "C" should implement the same constructor signature and class
   method signatures as "C". The type checker should flag violations
   of this, but should also allow constructor calls in subclasses that
   match the constructor calls in the indicated base class. How the
   type checker is required to handle this particular case may change
   in future revisions of **PEP 484**.

   The only legal parameters for "Type" are classes, "Any", type
   variables, and unions of any of these types. For example:

      def new_non_team_user(user_class: Type[Union[BasicUser, ProUser]]): ...

   "Type[Any]" is equivalent to "Type" which in turn is equivalent to
   "type", which is the root of Python's metaclass hierarchy.

   Novo na versão 3.5.2.

   Obsoleto desde a versão 3.9: "builtins.type" now supports "[]". See
   **PEP 585** and Tipo Generic Alias.

typing.Literal

   A type that can be used to indicate to type checkers that the
   corresponding variable or function parameter has a value equivalent
   to the provided literal (or one of several literals). For example:

      def validate_simple(data: Any) -> Literal[True]:  # always returns True
          ...

      MODE = Literal['r', 'rb', 'w', 'wb']
      def open_helper(file: str, mode: MODE) -> str:
          ...

      open_helper('/some/path', 'r')  # Passes type check
      open_helper('/other/path', 'typo')  # Error in type checker

   "Literal[...]" não é subclasse. Em tempo de execução, permite-se um
   valor arbitrário como argumento de tipo para "Literal[...]", mas
   verificadores de tipo podem impor restrições. Veja **PEP 586** para
   mais detalhes sobre tipos literais.

   Novo na versão 3.8.

   Alterado na versão 3.9.1: "Literal" agora remove parâmetros
   duplicados. Comparações de igualdade entre objetos "Literal" não
   dependem da ordem. Objetos "Literal" agora levantam uma exceção
   "TypeError" durante comparações de igualdade se um de seus
   parâmetros não for *hasheável*.

typing.ClassVar

   Uma construção especial de tipagem para marcar variáveis de classe.

   Como introduzido na **PEP 526**, uma variável cuja anotação de tipo
   tem um invólucro ClassVar indica que um dado atributo deve ser
   usado como uma variável de classe, e que ele não deve ser definido
   em instâncias dessa classe. Modo de usar:

      class Starship:
          stats: ClassVar[dict[str, int]] = {} # class variable
          damage: int = 10                     # instance variable

   "ClassVar" aceita apenas tipos e não pode ser subscrita
   posteriormente.

   "ClassVar" não é uma classe, e não deve ser usada com
   "isinstance()" ou "issubclass()". "ClassVar" não muda com o
   comportamento do Python em tempo de execução, mas pode ser usada
   por verificadores de tipos de terceiros. Por exemplo, um
   verificador de tipos pode sinalizar que o seguinte código é errado:

      enterprise_d = Starship(3000)
      enterprise_d.stats = {} # Error, setting class variable on instance
      Starship.stats = {}     # This is OK

   Novo na versão 3.5.3.

typing.Final

   A special typing construct to indicate to type checkers that a name
   cannot be re-assigned or overridden in a subclass. For example:

      MAX_SIZE: Final = 9000
      MAX_SIZE += 1  # Error reported by type checker

      class Connection:
          TIMEOUT: Final[int] = 10

      class FastConnector(Connection):
          TIMEOUT = 1  # Error reported by type checker

   Não há verificação em tempo de execução dessas propriedades. Veja
   **PEP 591** para mais detalhes.

   Novo na versão 3.8.

typing.Annotated

   A type, introduced in **PEP 593** ("Flexible function and variable
   annotations"), to decorate existing types with context-specific
   metadata (possibly multiple pieces of it, as "Annotated" is
   variadic). Specifically, a type "T" can be annotated with metadata
   "x" via the typehint "Annotated[T, x]". This metadata can be used
   for either static analysis or at runtime. If a library (or tool)
   encounters a typehint "Annotated[T, x]" and has no special logic
   for metadata "x", it should ignore it and simply treat the type as
   "T". Unlike the "no_type_check" functionality that currently exists
   in the "typing" module which completely disables typechecking
   annotations on a function or a class, the "Annotated" type allows
   for both static typechecking of "T" (which can safely ignore "x")
   together with runtime access to "x" within a specific application.

   Ultimately, the responsibility of how to interpret the annotations
   (if at all) is the responsibility of the tool or library
   encountering the "Annotated" type. A tool or library encountering
   an "Annotated" type can scan through the annotations to determine
   if they are of interest (e.g., using "isinstance()").

   When a tool or a library does not support annotations or encounters
   an unknown annotation it should just ignore it and treat annotated
   type as the underlying type.

   It's up to the tool consuming the annotations to decide whether the
   client is allowed to have several annotations on one type and how
   to merge those annotations.

   Since the "Annotated" type allows you to put several annotations of
   the same (or different) type(s) on any node, the tools or libraries
   consuming those annotations are in charge of dealing with potential
   duplicates. For example, if you are doing value range analysis you
   might allow this:

      T1 = Annotated[int, ValueRange(-10, 5)]
      T2 = Annotated[T1, ValueRange(-20, 3)]

   Passing "include_extras=True" to "get_type_hints()" lets one access
   the extra annotations at runtime.

   Os detalhes da sintaxe:

   * O primeiro argumento de "Annotated" deve ser um tipo válido

   * Multiple type annotations are supported ("Annotated" supports
     variadic arguments):

        Annotated[int, ValueRange(3, 10), ctype("char")]

   * "Annotated" must be called with at least two arguments (
     "Annotated[int]" is not valid)

   * The order of the annotations is preserved and matters for
     equality checks:

        Annotated[int, ValueRange(3, 10), ctype("char")] != Annotated[
            int, ctype("char"), ValueRange(3, 10)
        ]

   * Nested "Annotated" types are flattened, with metadata ordered
     starting with the innermost annotation:

        Annotated[Annotated[int, ValueRange(3, 10)], ctype("char")] == Annotated[
            int, ValueRange(3, 10), ctype("char")
        ]

   * Duplicated annotations are not removed:

        Annotated[int, ValueRange(3, 10)] != Annotated[
            int, ValueRange(3, 10), ValueRange(3, 10)
        ]

   * "Annotated" can be used with nested and generic aliases:

        T = TypeVar('T')
        Vec = Annotated[list[tuple[T, T]], MaxLen(10)]
        V = Vec[int]

        V == Annotated[list[tuple[int, int]], MaxLen(10)]

   Novo na versão 3.9.


Construindo tipos genéricos
~~~~~~~~~~~~~~~~~~~~~~~~~~~

These are not used in annotations. They are building blocks for
creating generic types.

class typing.Generic

   Classe base abstrata para tipos genéricos

   A generic type is typically declared by inheriting from an
   instantiation of this class with one or more type variables. For
   example, a generic mapping type might be defined as:

      class Mapping(Generic[KT, VT]):
          def __getitem__(self, key: KT) -> VT:
              ...
              # Etc.

   Esta classe pode ser utilizada como segue:

      X = TypeVar('X')
      Y = TypeVar('Y')

      def lookup_name(mapping: Mapping[X, Y], key: X, default: Y) -> Y:
          try:
              return mapping[key]
          except KeyError:
              return default

class typing.TypeVar

   Tipo variável.

   Uso:

      T = TypeVar('T')  # Can be anything
      S = TypeVar('S', bound=str)  # Can be any subtype of str
      A = TypeVar('A', str, bytes)  # Must be exactly str or bytes

   Type variables exist primarily for the benefit of static type
   checkers.  They serve as the parameters for generic types as well
   as for generic function definitions.  See "Generic" for more
   information on generic types.  Generic functions work as follows:

      def repeat(x: T, n: int) -> Sequence[T]:
          """Return a list containing n references to x."""
          return [x]*n


      def print_capitalized(x: S) -> S:
          """Print x capitalized, and return x."""
          print(x.capitalize())
          return x


      def concatenate(x: A, y: A) -> A:
          """Add two strings or bytes objects together."""
          return x + y

   Observe que tipos variáveis podem ser *delimitados*, *restritos*,
   nenhum dos dois, mas não podem ser *ambos*.

   Constrained type variables and bound type variables have different
   semantics in several important ways. Using a *constrained* type
   variable means that the "TypeVar" can only ever be solved as being
   exactly one of the constraints given:

      a = concatenate('one', 'two')  # Ok, variable 'a' has type 'str'
      b = concatenate(StringSubclass('one'), StringSubclass('two'))  # Inferred type of variable 'b' is 'str',
                                                                     # despite 'StringSubclass' being passed in
      c = concatenate('one', b'two')  # error: type variable 'A' can be either 'str' or 'bytes' in a function call, but not both

   Using a *bound* type variable, however, means that the "TypeVar"
   will be solved using the most specific type possible:

      print_capitalized('a string')  # Ok, output has type 'str'

      class StringSubclass(str):
          pass

      print_capitalized(StringSubclass('another string'))  # Ok, output has type 'StringSubclass'
      print_capitalized(45)  # error: int is not a subtype of str

   Type variables can be bound to concrete types, abstract types (ABCs
   or protocols), and even unions of types:

      U = TypeVar('U', bound=str|bytes)  # Can be any subtype of the union str|bytes
      V = TypeVar('V', bound=SupportsAbs)  # Can be anything with an __abs__ method

   Bound type variables are particularly useful for annotating
   "classmethods" that serve as alternative constructors. In the
   following example (© Raymond Hettinger), the type variable "C" is
   bound to the "Circle" class through the use of a forward reference.
   Using this type variable to annotate the "with_circumference"
   classmethod, rather than hardcoding the return type as "Circle",
   means that a type checker can correctly infer the return type even
   if the method is called on a subclass:

      import math

      C = TypeVar('C', bound='Circle')

      class Circle:
          """An abstract circle"""

          def __init__(self, radius: float) -> None:
              self.radius = radius

          # Use a type variable to show that the return type
          # will always be an instance of whatever ``cls`` is
          @classmethod
          def with_circumference(cls: type[C], circumference: float) -> C:
              """Create a circle with the specified circumference"""
              radius = circumference / (math.pi * 2)
              return cls(radius)


      class Tire(Circle):
          """A specialised circle (made out of rubber)"""

          MATERIAL = 'rubber'


      c = Circle.with_circumference(3)  # Ok, variable 'c' has type 'Circle'
      t = Tire.with_circumference(4)  # Ok, variable 't' has type 'Tire' (not 'Circle')

   At runtime, "isinstance(x, T)" will raise "TypeError".  In general,
   "isinstance()" and "issubclass()" should not be used with types.

   Type variables may be marked covariant or contravariant by passing
   "covariant=True" or "contravariant=True".  See **PEP 484** for more
   details.  By default, type variables are invariant.

typing.AnyStr

   "AnyStr" is a "constrained type variable" defined as "AnyStr =
   TypeVar('AnyStr', str, bytes)".

   It is meant to be used for functions that may accept any kind of
   string without allowing different kinds of strings to mix. For
   example:

      def concat(a: AnyStr, b: AnyStr) -> AnyStr:
          return a + b

      concat(u"foo", u"bar")  # Ok, output has type 'unicode'
      concat(b"foo", b"bar")  # Ok, output has type 'bytes'
      concat(u"foo", b"bar")  # Error, cannot mix unicode and bytes

class typing.Protocol(Generic)

   Base class for protocol classes. Protocol classes are defined like
   this:

      class Proto(Protocol):
          def meth(self) -> int:
              ...

   Essas classes são usadas principalmente com verificadores de tipo
   estático que reconhecem a subtipagem estrutural (tipagem pato
   estática). Por exemplo:

      class C:
          def meth(self) -> int:
              return 0

      def func(x: Proto) -> int:
          return x.meth()

      func(C())  # Passes static type check

   See **PEP 544** for details. Protocol classes decorated with
   "runtime_checkable()" (described later) act as simple-minded
   runtime protocols that check only the presence of given attributes,
   ignoring their type signatures.

   Classes de protocolo podem ser genéricas. Por exemplo:

      class GenProto(Protocol[T]):
          def meth(self) -> T:
              ...

   Novo na versão 3.8.

@typing.runtime_checkable

   Marca uma classe de protocolo como um protocolo de tempo de
   execução.

   Esse protocolo pode ser usado com "isinstance()" e "issubclass()".
   Isso levanta "TypeError" quando aplicado a uma classe não-
   protocolo.  Isso permite uma verificação estrutural simples, muito
   semelhante a "pôneis de um truque só" em "collections.abc", como
   "Iterable". Por exemplo:

      @runtime_checkable
      class Closable(Protocol):
          def close(self): ...

      assert isinstance(open('/some/file'), Closable)

   Nota:

     "runtime_checkable()" will check only the presence of the
     required methods, not their type signatures! For example,
     "builtins.complex" implements "__float__()", therefore it passes
     an "issubclass()" check against "SupportsFloat". However, the
     "complex.__float__" method exists only to raise a "TypeError"
     with a more informative message.

   Novo na versão 3.8.


Outras diretivas especiais
~~~~~~~~~~~~~~~~~~~~~~~~~~

These are not used in annotations. They are building blocks for
declaring types.

class typing.NamedTuple

   Versão tipada de "collections.namedtuple()".

   Uso:

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

   Isso equivale a:

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

   Para dar um valor padrão a um campo, você pode atribuir um valor a
   ele no corpo da classe:

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

      employee = Employee('Guido')
      assert employee.id == 3

   Campos com valor padrão devem vir depois de quaisquer campos sem
   valor padrão.

   A classe resultante tem um atributo extra "__annotations__" que
   fornece um dicionário que mapeia os nomes de campos para os tipos
   de campos. (Os nomes de campos estão no atributo "_fields" e os
   valores padrões estão no atributo "_field_defaults", e ambos fazem
   parte da API de "namedtuple()".)

   Subclasses de "NamedTuple" também podem ter strings de documentação
   e métodos:

      class Employee(NamedTuple):
          """Represents an employee."""
          name: str
          id: int = 3

          def __repr__(self) -> str:
              return f'<Employee {self.name}, id={self.id}>'

   Uso retrocompatível:

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

   Alterado na versão 3.6: Adiciona suporte à sintaxe de anotação de
   variáveis da **PEP 526**.

   Alterado na versão 3.6.1: Adiciona suporte a valores padrões,
   métodos, e docstrings.

   Alterado na versão 3.8: Os atributos "_field_types" e
   "__annotations__" agora são dicionários regulares em vez de
   instâncias de "OrderedDict".

   Alterado na versão 3.9: Remove o atributo "_field_types" em favor
   do atributo mais padronizado "__annotations__" que tem as mesmas
   informações.

typing.NewType(name, tp)

   A helper function to indicate a distinct type to a typechecker, see
   NewType. At runtime it returns a function that returns its
   argument. Usage:

      UserId = NewType('UserId', int)
      first_user = UserId(1)

   Novo na versão 3.5.2.

class typing.TypedDict(dict)

   Uma construção especial para adicionar dicas de tipo a um
   dicionário. Em tempo de execução, é um simples "dict".

   "TypedDict" declara um tipo dicionário que espera que todas as suas
   instâncias tenham um determinado conjunto de chaves, onde cada
   chave está associada a um valor de um tipo consistente. Essa
   expectativa não é verificada em tempo de execução, mas é imposta
   apenas por verificadores de tipos. Modo de usar:

      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')

   To allow using this feature with older versions of Python that do
   not support **PEP 526**, "TypedDict" supports two additional
   equivalent syntactic forms:

   * Utilizando um literal "dict" como segundo argumento:

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

   * Using keyword arguments:

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

   The functional syntax should also be used when any of the keys are
   not valid identifiers, for example because they are keywords or
   contain hyphens. Example:

      # raises SyntaxError
      class Point2D(TypedDict):
          in: int  # 'in' is a keyword
          x-y: int  # name with hyphens

      # OK, functional syntax
      Point2D = TypedDict('Point2D', {'in': int, 'x-y': int})

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

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

      # Alternative syntax
      Point2D = TypedDict('Point2D', {'x': int, 'y': int}, total=False)

   Isso significa que um "TypedDict" "Point2D"  pode ter qualquer uma
   de suas chaves omitidas. Espera-se que um verificador de tipos
   apenas permita os literais "False" ou "True" como valores do
   argumento "total". "True" é o padrão, e todos os itens definidos no
   corpo da classe tornam-se obrigatórios.

   É possível que um tipo "TypedDict" herde de um ou mais tipos
   "TypedDict" usando a sintaxe baseada em classes. Modo de usar:

      class Point3D(Point2D):
          z: int

   "Point3D" tem três itens: "x", "y" e "z". Equivale a esta
   definição:

      class Point3D(TypedDict):
          x: int
          y: int
          z: int

   A "TypedDict" cannot inherit from a non-"TypedDict" class, notably
   including "Generic". For example:

      class X(TypedDict):
          x: int

      class Y(TypedDict):
          y: int

      class Z(object): pass  # A non-TypedDict class

      class XY(X, Y): pass  # OK

      class XZ(X, Z): pass  # raises TypeError

      T = TypeVar('T')
      class XT(X, Generic[T]): pass  # raises TypeError

   A "TypedDict" can be introspected via "__annotations__",
   "__total__", "__required_keys__", and "__optional_keys__".

   __total__

      "Point2D.__total__" gives the value of the "total" argument.
      Example:

         >>> from typing import TypedDict
         >>> class Point2D(TypedDict): pass
         >>> Point2D.__total__
         True
         >>> class Point2D(TypedDict, total=False): pass
         >>> Point2D.__total__
         False
         >>> class Point3D(Point2D): pass
         >>> Point3D.__total__
         True

   __required_keys__

   __optional_keys__

      "Point2D.__required_keys__" and "Point2D.__optional_keys__"
      return "frozenset" objects containing required and non-required
      keys, respectively. Currently the only way to declare both
      required and non-required keys in the same "TypedDict" is mixed
      inheritance, declaring a "TypedDict" with one value for the
      "total" argument and then inheriting it from another "TypedDict"
      with a different value for "total". Usage:

         >>> class Point2D(TypedDict, total=False):
         ...     x: int
         ...     y: int
         ...
         >>> class Point3D(Point2D):
         ...     z: int
         ...
         >>> Point3D.__required_keys__ == frozenset({'z'})
         True
         >>> Point3D.__optional_keys__ == frozenset({'x', 'y'})
         True

   Consulte **PEP 589** para obter mais exemplos e regras detalhadas
   sobre o uso de "TypedDict".

   Novo na versão 3.8.


Generic concrete collections
----------------------------


Corresponding to built-in types
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class typing.Dict(dict, MutableMapping[KT, VT])

   A generic version of "dict". Useful for annotating return types. To
   annotate arguments it is preferred to use an abstract collection
   type such as "Mapping".

   This type can be used as follows:

      def count_words(text: str) -> Dict[str, int]:
          ...

   Obsoleto desde a versão 3.9: "builtins.dict" now supports "[]". See
   **PEP 585** and Tipo Generic Alias.

class typing.List(list, MutableSequence[T])

   Generic version of "list". Useful for annotating return types. To
   annotate arguments it is preferred to use an abstract collection
   type such as "Sequence" or "Iterable".

   This type may be used as follows:

      T = TypeVar('T', int, float)

      def vec2(x: T, y: T) -> List[T]:
          return [x, y]

      def keep_positives(vector: Sequence[T]) -> List[T]:
          return [item for item in vector if item > 0]

   Obsoleto desde a versão 3.9: "builtins.list" now supports "[]". See
   **PEP 585** and Tipo Generic Alias.

class typing.Set(set, MutableSet[T])

   A generic version of "builtins.set". Useful for annotating return
   types. To annotate arguments it is preferred to use an abstract
   collection type such as "AbstractSet".

   Obsoleto desde a versão 3.9: "builtins.set" now supports "[]". See
   **PEP 585** and Tipo Generic Alias.

class typing.FrozenSet(frozenset, AbstractSet[T_co])

   A generic version of "builtins.frozenset".

   Obsoleto desde a versão 3.9: "builtins.frozenset" now supports
   "[]". See **PEP 585** and Tipo Generic Alias.

Nota:

  "Tuple" is a special form.


Corresponding to types in "collections"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class typing.DefaultDict(collections.defaultdict, MutableMapping[KT, VT])

   A generic version of "collections.defaultdict".

   Novo na versão 3.5.2.

   Obsoleto desde a versão 3.9: "collections.defaultdict" now supports
   "[]". See **PEP 585** and Tipo Generic Alias.

class typing.OrderedDict(collections.OrderedDict, MutableMapping[KT, VT])

   A generic version of "collections.OrderedDict".

   Novo na versão 3.7.2.

   Obsoleto desde a versão 3.9: "collections.OrderedDict" now supports
   "[]". See **PEP 585** and Tipo Generic Alias.

class typing.ChainMap(collections.ChainMap, MutableMapping[KT, VT])

   A generic version of "collections.ChainMap".

   Novo na versão 3.5.4.

   Novo na versão 3.6.1.

   Obsoleto desde a versão 3.9: "collections.ChainMap" now supports
   "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Counter(collections.Counter, Dict[T, int])

   A generic version of "collections.Counter".

   Novo na versão 3.5.4.

   Novo na versão 3.6.1.

   Obsoleto desde a versão 3.9: "collections.Counter" now supports
   "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Deque(deque, MutableSequence[T])

   A generic version of "collections.deque".

   Novo na versão 3.5.4.

   Novo na versão 3.6.1.

   Obsoleto desde a versão 3.9: "collections.deque" now supports "[]".
   See **PEP 585** and Tipo Generic Alias.


Other concrete types
~~~~~~~~~~~~~~~~~~~~

class typing.IO
class typing.TextIO
class typing.BinaryIO

   O tipo genérico "IO[AnyStr]" e suas subclasses "TextIO(IO[str])" e
   "BinaryIO(IO[bytes])" representam os tipos de fluxos de E/S, como
   os retornados por "open()".

   Deprecated since version 3.8, will be removed in version 3.12:
   These types are also in the "typing.io" namespace, which was never
   supported by type checkers and will be removed.

class typing.Pattern
class typing.Match

   These type aliases correspond to the return types from
   "re.compile()" and "re.match()".  These types (and the
   corresponding functions) are generic in "AnyStr" and can be made
   specific by writing "Pattern[str]", "Pattern[bytes]", "Match[str]",
   or "Match[bytes]".

   Deprecated since version 3.8, will be removed in version 3.12:
   These types are also in the "typing.re" namespace, which was never
   supported by type checkers and will be removed.

   Obsoleto desde a versão 3.9: Classes "Pattern" e "Match" de "re"
   agora suporte "[]". Consulte **PEP 585** e Tipo Generic Alias.

class typing.Text

   "Text" is an alias for "str". It is provided to supply a forward
   compatible path for Python 2 code: in Python 2, "Text" is an alias
   for "unicode".

   Use "Text" para indicar que um valor deve conter uma string unicode
   de forma compatível com Python 2 e Python 3:

      def add_unicode_checkmark(text: Text) -> Text:
          return text + u' \u2713'

   Novo na versão 3.5.2.


Classes Bases Abstratas
-----------------------


Corresponding to collections in "collections.abc"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class typing.AbstractSet(Sized, Collection[T_co])

   A generic version of "collections.abc.Set".

   Obsoleto desde a versão 3.9: "collections.abc.Set" now supports
   "[]". See **PEP 585** and Tipo Generic Alias.

class typing.ByteString(Sequence[int])

   A generic version of "collections.abc.ByteString".

   Este tipo representa os tipos "bytes", "bytearray" e "memoryview"
   de sequências de bytes.

   As a shorthand for this type, "bytes" can be used to annotate
   arguments of any of the types mentioned above.

   Obsoleto desde a versão 3.9: "collections.abc.ByteString" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Collection(Sized, Iterable[T_co], Container[T_co])

   A generic version of "collections.abc.Collection"

   Novo na versão 3.6.0.

   Obsoleto desde a versão 3.9: "collections.abc.Collection" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Container(Generic[T_co])

   A generic version of "collections.abc.Container".

   Obsoleto desde a versão 3.9: "collections.abc.Container" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.ItemsView(MappingView, Generic[KT_co, VT_co])

   A generic version of "collections.abc.ItemsView".

   Obsoleto desde a versão 3.9: "collections.abc.ItemsView" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.KeysView(MappingView[KT_co], AbstractSet[KT_co])

   A generic version of "collections.abc.KeysView".

   Obsoleto desde a versão 3.9: "collections.abc.KeysView" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Mapping(Sized, Collection[KT], Generic[VT_co])

   A generic version of "collections.abc.Mapping". This type can be
   used as follows:

      def get_position_in_index(word_list: Mapping[str, int], word: str) -> int:
          return word_list[word]

   Obsoleto desde a versão 3.9: "collections.abc.Mapping" now supports
   "[]". See **PEP 585** and Tipo Generic Alias.

class typing.MappingView(Sized, Iterable[T_co])

   A generic version of "collections.abc.MappingView".

   Obsoleto desde a versão 3.9: "collections.abc.MappingView" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.MutableMapping(Mapping[KT, VT])

   A generic version of "collections.abc.MutableMapping".

   Obsoleto desde a versão 3.9: "collections.abc.MutableMapping" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.MutableSequence(Sequence[T])

   A generic version of "collections.abc.MutableSequence".

   Obsoleto desde a versão 3.9: "collections.abc.MutableSequence" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.MutableSet(AbstractSet[T])

   A generic version of "collections.abc.MutableSet".

   Obsoleto desde a versão 3.9: "collections.abc.MutableSet" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Sequence(Reversible[T_co], Collection[T_co])

   A generic version of "collections.abc.Sequence".

   Obsoleto desde a versão 3.9: "collections.abc.Sequence" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.ValuesView(MappingView[VT_co])

   A generic version of "collections.abc.ValuesView".

   Obsoleto desde a versão 3.9: "collections.abc.ValuesView" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.


Corresponding to other types in "collections.abc"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class typing.Iterable(Generic[T_co])

   A generic version of "collections.abc.Iterable".

   Obsoleto desde a versão 3.9: "collections.abc.Iterable" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Iterator(Iterable[T_co])

   A generic version of "collections.abc.Iterator".

   Obsoleto desde a versão 3.9: "collections.abc.Iterator" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Generator(Iterator[T_co], Generic[T_co, T_contra, V_co])

   A generator can be annotated by the generic type
   "Generator[YieldType, SendType, ReturnType]". For example:

      def echo_round() -> Generator[int, float, str]:
          sent = yield 0
          while sent >= 0:
              sent = yield round(sent)
          return 'Done'

   Note that unlike many other generics in the typing module, the
   "SendType" of "Generator" behaves contravariantly, not covariantly
   or invariantly.

   If your generator will only yield values, set the "SendType" and
   "ReturnType" to "None":

      def infinite_stream(start: int) -> Generator[int, None, None]:
          while True:
              yield start
              start += 1

   Alternatively, annotate your generator as having a return type of
   either "Iterable[YieldType]" or "Iterator[YieldType]":

      def infinite_stream(start: int) -> Iterator[int]:
          while True:
              yield start
              start += 1

   Obsoleto desde a versão 3.9: "collections.abc.Generator" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Hashable

   An alias to "collections.abc.Hashable".

class typing.Reversible(Iterable[T_co])

   A generic version of "collections.abc.Reversible".

   Obsoleto desde a versão 3.9: "collections.abc.Reversible" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Sized

   An alias to "collections.abc.Sized".


Asynchronous programming
~~~~~~~~~~~~~~~~~~~~~~~~

class typing.Coroutine(Awaitable[V_co], Generic[T_co, T_contra, V_co])

   A generic version of "collections.abc.Coroutine". The variance and
   order of type variables correspond to those of "Generator", for
   example:

      from collections.abc import Coroutine
      c: Coroutine[list[str], str, int]  # Some coroutine defined elsewhere
      x = c.send('hi')                   # Inferred type of 'x' is list[str]
      async def bar() -> None:
          y = await c                    # Inferred type of 'y' is int

   Novo na versão 3.5.3.

   Obsoleto desde a versão 3.9: "collections.abc.Coroutine" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra])

   An async generator can be annotated by the generic type
   "AsyncGenerator[YieldType, SendType]". For example:

      async def echo_round() -> AsyncGenerator[int, float]:
          sent = yield 0
          while sent >= 0.0:
              rounded = await round(sent)
              sent = yield rounded

   Unlike normal generators, async generators cannot return a value,
   so there is no "ReturnType" type parameter. As with "Generator",
   the "SendType" behaves contravariantly.

   If your generator will only yield values, set the "SendType" to
   "None":

      async def infinite_stream(start: int) -> AsyncGenerator[int, None]:
          while True:
              yield start
              start = await increment(start)

   Alternatively, annotate your generator as having a return type of
   either "AsyncIterable[YieldType]" or "AsyncIterator[YieldType]":

      async def infinite_stream(start: int) -> AsyncIterator[int]:
          while True:
              yield start
              start = await increment(start)

   Novo na versão 3.6.1.

   Obsoleto desde a versão 3.9: "collections.abc.AsyncGenerator" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.AsyncIterable(Generic[T_co])

   Uma versão genérica de "collections.abc.AsyncIterable".

   Novo na versão 3.5.2.

   Obsoleto desde a versão 3.9: "collections.abc.AsyncIterable" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.AsyncIterator(AsyncIterable[T_co])

   A generic version of "collections.abc.AsyncIterator".

   Novo na versão 3.5.2.

   Obsoleto desde a versão 3.9: "collections.abc.AsyncIterator" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.Awaitable(Generic[T_co])

   A generic version of "collections.abc.Awaitable".

   Novo na versão 3.5.2.

   Obsoleto desde a versão 3.9: "collections.abc.Awaitable" now
   supports "[]". See **PEP 585** and Tipo Generic Alias.


Context manager types
~~~~~~~~~~~~~~~~~~~~~

class typing.ContextManager(Generic[T_co])

   Uma versão genérica de "contextlib.AbstractContextManager".

   Novo na versão 3.5.4.

   Novo na versão 3.6.0.

   Obsoleto desde a versão 3.9: "contextlib.AbstractContextManager"
   now supports "[]". See **PEP 585** and Tipo Generic Alias.

class typing.AsyncContextManager(Generic[T_co])

   A generic version of "contextlib.AbstractAsyncContextManager".

   Novo na versão 3.5.4.

   Novo na versão 3.6.2.

   Obsoleto desde a versão 3.9:
   "contextlib.AbstractAsyncContextManager" now supports "[]". See
   **PEP 585** and Tipo Generic Alias.


Protocolos
----------

Esses protocolos são decorados com "runtime_checkable()".

class typing.SupportsAbs

   Um ABC com um método abstrato "__abs__" que é covariante em seu
   tipo de retorno.

class typing.SupportsBytes

   Um ABC com um método abstrato "__bytes__".

class typing.SupportsComplex

   Um ABC com um método abstrato "__complex__".

class typing.SupportsFloat

   Um ABC com um método abstrato "__float__".

class typing.SupportsIndex

   Um ABC com um método abstrato "__index__".

   Novo na versão 3.8.

class typing.SupportsInt

   Um ABC com um método abstrato "__int__".

class typing.SupportsRound

   Uma ABC com um método abstrato "__round__" que é covariante em seu
   tipo de retorno.


Funções e decoradores
---------------------

typing.cast(typ, val)

   Converta um valor em um tipo.

   Isso retorna o valor inalterado. Para o verificador de tipos, isso
   indica que o valor de retorno tem o tipo designado, mas em tempo de
   execução não verificamos nada intencionalmente (queremos que isso
   seja o mais rápido possível).

@typing.overload

   The "@overload" decorator allows describing functions and methods
   that support multiple different combinations of argument types. A
   series of "@overload"-decorated definitions must be followed by
   exactly one non-"@overload"-decorated definition (for the same
   function/method). The "@overload"-decorated definitions are for the
   benefit of the type checker only, since they will be overwritten by
   the non-"@overload"-decorated definition, while the latter is used
   at runtime but should be ignored by a type checker.  At runtime,
   calling a "@overload"-decorated function directly will raise
   "NotImplementedError". An example of overload that gives a more
   precise type than can be expressed using a union or a type
   variable:

      @overload
      def process(response: None) -> None:
          ...
      @overload
      def process(response: int) -> tuple[int, str]:
          ...
      @overload
      def process(response: bytes) -> str:
          ...
      def process(response):
          <actual implementation>

   See **PEP 484** for details and comparison with other typing
   semantics.

@typing.final

   A decorator to indicate to type checkers that the decorated method
   cannot be overridden, and the 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
          ...

   Não há verificação em tempo de execução dessas propriedades. Veja
   **PEP 591** para mais detalhes.

   Novo na versão 3.8.

@typing.no_type_check

   Decorador para indicar que anotações não são dicas de tipo.

   This works as class or function *decorator*.  With a class, it
   applies recursively to all methods defined in that class (but not
   to methods defined in its superclasses or subclasses).

   This mutates the function(s) in place.

@typing.no_type_check_decorator

   Decorador para dar a outro decorador o efeito "no_type_check()".

   Isso envolve o decorador com algo que envolve a função decorada em
   "no_type_check()".

@typing.type_check_only

   Decorator to mark a class or function to be unavailable at runtime.

   Este decorador em si não está disponível em tempo de execução. Seu
   objetivo principal é marcar classes definidas em arquivos de tipo
   stub se uma implementação retornar uma instância de uma classe
   privada:

      @type_check_only
      class Response:  # private or not available at runtime
          code: int
          def get_header(self, name: str) -> str: ...

      def fetch_response() -> Response: ...

   Observe que retornar instâncias de classes privadas não é
   recomendado. Normalmente, é preferível tornar essas classes
   públicas.


Auxiliares de introspecção
--------------------------

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

   Retorna um dicionário contendo dicas de tipo para uma função,
   método, módulo ou objeto classe.

   This is often the same as "obj.__annotations__". In addition,
   forward references encoded as string literals are handled by
   evaluating them in "globals" and "locals" namespaces. If necessary,
   "Optional[t]" is added for function and method annotations if a
   default value equal to "None" is set. For a class "C", return a
   dictionary constructed by merging all the "__annotations__" along
   "C.__mro__" in reverse order.

   The function recursively replaces all "Annotated[T, ...]" with "T",
   unless "include_extras" is set to "True" (see "Annotated" for more
   information). For example:

      class Student(NamedTuple):
          name: Annotated[str, 'some marker']

      get_type_hints(Student) == {'name': str}
      get_type_hints(Student, include_extras=False) == {'name': str}
      get_type_hints(Student, include_extras=True) == {
          'name': Annotated[str, 'some marker']
      }

   Alterado na versão 3.9: Added "include_extras" parameter as part of
   **PEP 593**.

typing.get_args(tp)

typing.get_origin(tp)

   Provide basic introspection for generic types and special typing
   forms.

   For a typing object of the form "X[Y, Z, ...]" these functions
   return "X" and "(Y, Z, ...)". If "X" is a generic alias for a
   builtin or "collections" class, it gets normalized to the original
   class. If "X" is a "Union" or "Literal" contained in another
   generic type, the order of "(Y, Z, ...)" may be different from the
   order of the original arguments "[Y, Z, ...]" due to type caching.
   For unsupported objects return "None" and "()" correspondingly.
   Examples:

      assert get_origin(Dict[str, int]) is dict
      assert get_args(Dict[int, str]) == (int, str)

      assert get_origin(Union[int, str]) is Union
      assert get_args(Union[int, str]) == (int, str)

   Novo na versão 3.8.

class typing.ForwardRef

   A class used for internal typing representation of string forward
   references. For example, "List["SomeClass"]" is implicitly
   transformed into "List[ForwardRef("SomeClass")]".  This class
   should not be instantiated by a user, but may be used by
   introspection tools.

   Nota:

     Tipos genéricos da **PEP 585** como "list["SomeClass"]" não serão
     transformados implicitamente em "list[ForwardRef("SomeClass")]"
     e, portanto, não serão resolvidos automaticamente para
     "list[SomeClass]".

   Novo na versão 3.7.4.


Constante
---------

typing.TYPE_CHECKING

   A special constant that is assumed to be "True" by 3rd party static
   type checkers. It is "False" at runtime. Usage:

      if TYPE_CHECKING:
          import expensive_mod

      def fun(arg: 'expensive_mod.SomeType') -> None:
          local_var: expensive_mod.AnotherType = other_fun()

   A primeira anotação de tipo deve ser colocada entre aspas,
   tornando-a uma "referência futura", para esconder do interpretador
   a referência ao módulo "expensive_mod". As anotações de tipos em
   variáveis locais não são avaliadas, então a segunda anotação não
   precisa ser colocada entre aspas.

   Nota:

     Se "from __future__ import annotations" for usado, anotações não
     serão avaliadas no momento de definição de funções. Em vez disso,
     elas são armazenadas como string em "__annotations__". Isso torna
     desnecessário o uso de aspas em anotações (consulte **PEP 563**).

   Novo na versão 3.5.2.
