"__future__" --- Definições de instruções de future
***************************************************

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

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

Instruções do tipo "from __future__ import feature" são chamadas de
instruções future. Esses são casos especiais do compilador do Python
para permitir o uso de novos recursos do Python em módulos que contêm
a instrução future antes da versão em que o recurso se torna padrão.

Embora o compilador Python dê um significado especial adicional a
essas instruções future, elas ainda são executadas como qualquer outra
instrução de importação, o módulo "__future__" existe e é tratado pelo
sistema de importação da mesma forma que qualquer outro módulo Python.
Isso serve a três propósitos:

* Para evitar confundir as ferramentas existentes que analisam as
  instruções de importação e esperam encontrar os módulos  sendo
  importados.

* Para documentar quando as mudanças incompatíveis foram introduzidas,
  e quando elas serão --- ou foram --- obrigatórias. Esta é uma forma
  de documentação executável e pode ser inspecionada programaticamente
  através da importação "__future__" e examinando seus conteúdos.

* Para garantir que instruções future sejam executadas em versões
  anteriores a Python 2.1, pelo menos, processe exceções de tempo de
  execução (a importação de "__future__" falhará, porque não havia
  nenhum módulo desse nome antes de 2.1).


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

Nenhuma descrição de característica será excluída de "__future__".
Desde a sua introdução no Python 2.1, os seguintes recursos
encontraram o caminho para o idioma usando esse mecanismo:

+--------------------+---------------+----------------+-----------------------------------------------+
| característica     | opcional em   | obrigatório em | efeito                                        |
|====================|===============|================|===============================================|
| nested_scopes      | 2.1.0b1       | 2.2            | **PEP 227**: *Statically Nested Scopes*       |
+--------------------+---------------+----------------+-----------------------------------------------+
| generators         | 2.2.0a1       | 2.3            | **PEP 255**: *Simple Generators*              |
+--------------------+---------------+----------------+-----------------------------------------------+
| divisão            | 2.2.0a2       | 3.0            | **PEP 238**: *Changing the Division Operator* |
+--------------------+---------------+----------------+-----------------------------------------------+
| absolute_import    | 2.5.0a1       | 3.0            | **PEP 328**: *Imports: Multi-Line and         |
|                    |               |                | Absolute/Relative*                            |
+--------------------+---------------+----------------+-----------------------------------------------+
| with_statement     | 2.5.0a1       | 2.6            | **PEP 343**: *The "with" Statement*           |
+--------------------+---------------+----------------+-----------------------------------------------+
| print_function     | 2.6.0a2       | 3.0            | **PEP 3105**: *Make print a function*         |
+--------------------+---------------+----------------+-----------------------------------------------+
| unicode_literals   | 2.6.0a2       | 3.0            | **PEP 3112**: *Bytes literals in Python 3000* |
+--------------------+---------------+----------------+-----------------------------------------------+
| generator_stop     | 3.5.0b1       | 3.7            | **PEP 479**: *StopIteration handling inside   |
|                    |               |                | generators*                                   |
+--------------------+---------------+----------------+-----------------------------------------------+
| annotations        | 3.7.0b1       | Para ser feito | **PEP 563**: *Postponed evaluation of         |
|                    |               | [1]            | annotations*                                  |
+--------------------+---------------+----------------+-----------------------------------------------+

class __future__._Feature

   Cada instrução em "__future__.py" é da forma:

      FeatureName = _Feature(OptionalRelease, MandatoryRelease,
                             CompilerFlag)

   Onde, normalmente, *OptionalRelease* é inferior a
   *MandatoryRelease*, e ambos são tuplas de 5 entradas da mesma forma
   que "sys.version_info":

      (PY_MAJOR_VERSION, # the 2 in 2.1.0a3; an int
       PY_MINOR_VERSION, # the 1; an int
       PY_MICRO_VERSION, # the 0; an int
       PY_RELEASE_LEVEL, # "alpha", "beta", "candidate" or "final"; string
       PY_RELEASE_SERIAL # the 3; an int
      )

_Feature.getOptionalRelease()

   *OptionalRelease* registra o primeiro lançamento no qual o recurso
   foi aceito.

_Feature.getMandatoryRelease()

   No caso de um *MandatoryRelease* que ainda não ocorreu,
   *MandatoryRelease* prevê o lançamento em que o recurso se tornará
   parte da linguagem.

   Senão *MandatoryRelease* registra quando o recurso se tornou parte
   do idioma; Em versões em ou depois disso, os módulos não precisam
   mais de uma instrução future para usar o recurso em questão, mas
   podem continuar a usar essas importações.

   *MandatoryRelease* também pode ser "None", o que significa que uma
   característica planejada foi descartada ou que isso ainda não está
   decidido.

_Feature.compiler_flag

   *CompilerFlag* é o sinalizador (bitfield) que deve ser passado no
   quarto argumento para a função embutida "compile()" para habilitar
   o recurso no código compilado dinamicamente. Este sinalizador é
   armazenado no atributo "_Feature.compiler_flag" em instâncias de
   "_Feature".

[1] "from __future__ import annotations" foi programado anteriormente
    para se tornar obrigatório no Python 3.10, mas o Python Steering
    Council decidiu duas vezes adiar a mudança (anúncio para o Python
    3.10; anúncio para o Python 3.11). Nenhuma decisão final foi
    tomada ainda. Veja também **PEP 563** e **PEP 649**.

Ver também:

  Instruções future
     Como o compilador trata as importações de future.

  **PEP 236** - De volta ao __future__
     A proposta original para o mecanismo do __future__.
