"importlib" --- A implementação de "import"
*******************************************

Novo na versão 3.1.

**Código-fonte:** Lib/importlib/__init__.py

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


Introdução
==========

The purpose of the "importlib" package is two-fold. One is to provide
the implementation of the "import" statement (and thus, by extension,
the "__import__()" function) in Python source code. This provides an
implementation of "import" which is portable to any Python
interpreter. This also provides an implementation which is easier to
comprehend than one implemented in a programming language other than
Python.

Dois, os componentes para implementar "import" são expostos neste
pacote, tornando mais fácil para os usuários criarem seus próprios
objetos personalizados (conhecidos genericamente como *importador*)
para participar do processo de importação.

Ver também:

  A instrução import
     A referência da linguagem para a instrução "import".

  Especificação dos pacotes
     Especificação original dos pacotes. Algumas semânticas mudaram
     desde a redação deste documento (por exemplo, redirecionamento
     baseado em "None" em "sys.modules").

  A função "__import__()"
     A instrução "import" é um açúcar sintático para esta função.

  **PEP 235**
     Importação em plataformas que diferenciam maiúsculo de minúsculo

  **PEP 263**
     Definindo codificações do código-fonte do Python

  **PEP 302**
     Novos ganchos de importação

  **PEP 328**
     Importações: Multilinha e Absoluto/Relativo

  **PEP 366**
     Importações relativas explícitas do módulo principal

  **PEP 420**
     Pacotes de espaço de nomes implícitos

  **PEP 451**
     Um tipo de ModuleSpec para o sistema de importação

  **PEP 488**
     Eliminação de arquivos PYO

  **PEP 489**
     Inicialização de módulo extensão multifase

  **PEP 552**
     pycs determinísticos

  **PEP 3120**
     Usando UTF-8 como fonte padrão de codificação

  **PEP 3147**
     Diretórios de repositório de PYC


Funções
=======

importlib.__import__(name, globals=None, locals=None, fromlist=(), level=0)

   Uma implementação da função embutida "__import__()".

   Nota:

     A importação programática de módulos deve usar "import_module()"
     em vez desta função.

importlib.import_module(name, package=None)

   Importa um módulo. O argumento *name* especifica qual módulo
   importar em termos absolutos ou relativos (por exemplo, "pkg.mod"
   ou "..mod"). Se o nome for especificado em termos relativos, então
   o argumento *package* deve ser definido como o nome do pacote que
   atuará como âncora para resolver o nome do pacote (por exemplo,
   "import_module('..mod', 'pkg.subpkg')" importará "pkg.mod").

   A função "import_module()" atua como um wrapper simplificador em
   torno de "importlib.__import__()". Isso significa que toda a
   semântica da função é derivada de "importlib.__import__()". A
   diferença mais importante entre essas duas funções é que
   "import_module()" retorna o pacote ou módulo especificado (por
   exemplo, "pkg.mod"), enquanto "__import__()" retorna o pacote ou
   módulo de nível superior (por exemplo, "pkg").

   Se você estiver importando dinamicamente um módulo que foi criado
   desde que o interpretador iniciou a execução (por exemplo, criou um
   arquivo fonte Python), você pode precisar chamar
   "invalidate_caches()" para que o novo módulo seja notado pelo
   sistema de importação.

   Alterado na versão 3.3: Os pacotes pai são importados
   automaticamente.

importlib.find_loader(name, path=None)

   Find the loader for a module, optionally within the specified
   *path*. If the module is in "sys.modules", then
   "sys.modules[name].__loader__" is returned (unless the loader would
   be "None" or is not set, in which case "ValueError" is raised).
   Otherwise a search using "sys.meta_path" is done. "None" is
   returned if no loader is found.

   A dotted name does not have its parents implicitly imported as that
   requires loading them and that may not be desired. To properly
   import a submodule you will need to import all parent packages of
   the submodule and use the correct argument to *path*.

   Novo na versão 3.3.

   Alterado na versão 3.4: If "__loader__" is not set, raise
   "ValueError", just like when the attribute is set to "None".

   Obsoleto desde a versão 3.4: Use "importlib.util.find_spec()".

importlib.invalidate_caches()

   Invalida os caches internos dos localizadores armazenados em
   "sys.meta_path". Se um localizador implementar
   "invalidate_caches()" então ele será chamado para realizar a
   invalidação. Esta função deve ser chamada se algum módulo for
   criado/instalado enquanto seu programa estiver em execução para
   garantir que todos os localizadores notarão a existência do novo
   módulo.

   Novo na versão 3.3.

importlib.reload(module)

   Recarrega um *module* importado anteriormente. O argumento deve ser
   um objeto módulo, portanto deve ter sido importado com êxito antes.
   Isso é útil se você editou o arquivo fonte do módulo usando um
   editor externo e deseja experimentar a nova versão sem sair do
   interpretador Python. O valor de retorno é o objeto módulo (que
   pode ser diferente se a reimportação fizer com que um objeto
   diferente seja colocado em "sys.modules").

   Quando "reload()" é executado:

   * O código do módulo Python é recompilado e o código em nível de
     módulo é reexecutado, definindo um novo conjunto de objetos que
     são vinculados a nomes no dicionário do módulo reutilizando o
     *carregador* que originalmente carregou o módulo. A função "init"
     dos módulos de extensão não é chamada uma segunda vez.

   * Tal como acontece com todos os outros objetos em Python, os
     objetos antigos só são recuperados depois que suas contagens de
     referências caem para zero.

   * Os nomes no espaço de nomes do módulo são atualizados para
     apontar para quaisquer objetos novos ou alterados.

   * Outras referências aos objetos antigos (como nomes externos ao
     módulo) não são religadas para se referir aos novos objetos e
     devem ser atualizadas em cada espaço de nomes onde ocorrem, se
     isso for desejado.

   Existem várias outras ressalvas:

   Quando um módulo é recarregado, seu dicionário (contendo as
   variáveis globais do módulo) é retido. As redefinições de nomes vão
   substituir as definições antigas, portanto isso geralmente não é um
   problema. Se a nova versão de um módulo não definir um nome
   definido pela versão antiga, a definição antiga permanecerá. Este
   recurso pode ser usado para vantagem do módulo se ele mantiver uma
   tabela global ou cache de objetos -- com uma instrução "try" ele
   pode testar a presença da tabela e pular sua inicialização se
   desejar:

      try:
          cache
      except NameError:
          cache = {}

   Geralmente não é muito útil recarregar módulos embutidos ou
   carregados dinamicamente. Recarregar "sys", "__main__", "builtins"
   e outros módulos principais não é recomendado. Em muitos casos, os
   módulos de extensão não são projetados para serem inicializados
   mais de uma vez e podem falhar de maneiras arbitrárias quando
   recarregados.

   Se um módulo importa objetos de outro módulo usando "from" ...
   "import" ..., chamar "reload()" para o outro módulo não redefine os
   objetos importados dele -- uma maneira de contornar isso é executar
   novamente a instrução "from", outra é usar "import" e nomes
   qualificados (*module.name*).

   Se um módulo instancia instâncias de uma classe, recarregar o
   módulo que define a classe não afeta as definições de método das
   instâncias -- elas continuam a usar a definição de classe antiga. O
   mesmo se aplica às classes derivadas.

   Novo na versão 3.4.

   Alterado na versão 3.7: "ModuleNotFoundError" é levantada quando o
   módulo que está sendo recarregado não possui um "ModuleSpec".


"importlib.abc" -- classes base abstratas relacionadas a importação
===================================================================

**Código-fonte:** Lib/importlib/abc.py

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

O módulo "importlib.abc" contém todas as principais classes base
abstratas usadas por "import". Algumas subclasses das classes base
abstratas principais também são fornecidas para ajudar na
implementação dss ABCs principais.

Hierarquia de ABC:

   object
    +-- Finder (deprecated)
    +-- MetaPathFinder
    +-- PathEntryFinder
    +-- Loader
         +-- ResourceLoader --------+
         +-- InspectLoader          |
              +-- ExecutionLoader --+
                                    +-- FileLoader
                                    +-- SourceLoader

class importlib.abc.Finder

   An abstract base class representing a *finder*.

   Obsoleto desde a versão 3.3: Use "MetaPathFinder" or
   "PathEntryFinder" instead.

   abstractmethod find_module(fullname, path=None)

      An abstract method for finding a *loader* for the specified
      module.  Originally specified in **PEP 302**, this method was
      meant for use in "sys.meta_path" and in the path-based import
      subsystem.

      Alterado na versão 3.4: Returns "None" when called instead of
      raising "NotImplementedError".

      Obsoleto desde a versão 3.10: Implement
      "MetaPathFinder.find_spec()" or "PathEntryFinder.find_spec()"
      instead.

class importlib.abc.MetaPathFinder

   Uma classe base abstrata que representa um *localizador de
   metacaminho*.

   Novo na versão 3.3.

   Alterado na versão 3.10: No longer a subclass of "Finder".

   find_spec(fullname, path, target=None)

      Um método abstrato para encontrar um *spec* para o módulo
      especificado. Se esta for uma importação de nível superior,
      *path* será "None". Caso contrário, esta é uma busca por um
      subpacote ou módulo e *path* será o valor de "__path__" do
      pacote pai. Se uma especificação não puder ser encontrada,
      "None" será retornado. Quando passado, "target" é um objeto de
      módulo que o localizador pode usar para fazer uma estimativa
      mais informada sobre qual especificação retornar.
      "importlib.util.spec_from_loader()" pode ser útil para
      implementar "MetaPathFinders" concretos.

      Novo na versão 3.4.

   find_module(fullname, path)

      A legacy method for finding a *loader* for the specified module.
      If this is a top-level import, *path* will be "None". Otherwise,
      this is a search for a subpackage or module and *path* will be
      the value of "__path__" from the parent package. If a loader
      cannot be found, "None" is returned.

      If "find_spec()" is defined, backwards-compatible functionality
      is provided.

      Alterado na versão 3.4: Returns "None" when called instead of
      raising "NotImplementedError". Can use "find_spec()" to provide
      functionality.

      Obsoleto desde a versão 3.4: Use "find_spec()" instead.

   invalidate_caches()

      Um método opcional que, quando chamado, deve invalidar qualquer
      cache interno usado pelo localizador. Usado por
      "importlib.invalidate_caches()" ao invalidar os caches de todos
      os localizadores em "sys.meta_path".

      Alterado na versão 3.4: Returns "None" when called instead of
      "NotImplemented".

class importlib.abc.PathEntryFinder

   Uma classe base abstrata que representa um *localizador de entrada
   de caminho*. Embora tenha algumas semelhanças com "MetaPathFinder",
   "PathEntryFinder" deve ser usado apenas dentro do subsistema de
   importação baseado em caminho fornecido por
   "importlib.machinery.PathFinder".

   Novo na versão 3.3.

   Alterado na versão 3.10: No longer a subclass of "Finder".

   find_spec(fullname, target=None)

      Um método abstrato para encontrar um *spec* para o módulo
      especificado. O localizador irá procurar pelo módulo apenas
      dentro do *entrada de caminho* ao qual ele está atribuído. Se um
      spec não puder ser encontrado, "None" será retornado. Quando
      passado, "target" é um objeto de módulo que o localizador pode
      usar para fazer uma estimativa mais informada sobre qual spec
      retornar. "importlib.util.spec_from_loader()" pode ser útil para
      implementar "PathEntryFinders" concretos.

      Novo na versão 3.4.

   find_loader(fullname)

      A legacy method for finding a *loader* for the specified module.
      Returns a 2-tuple of "(loader, portion)" where "portion" is a
      sequence of file system locations contributing to part of a
      namespace package. The loader may be "None" while specifying
      "portion" to signify the contribution of the file system
      locations to a namespace package. An empty list can be used for
      "portion" to signify the loader is not part of a namespace
      package. If "loader" is "None" and "portion" is the empty list
      then no loader or location for a namespace package were found
      (i.e. failure to find anything for the module).

      If "find_spec()" is defined then backwards-compatible
      functionality is provided.

      Alterado na versão 3.4: Returns "(None, [])" instead of raising
      "NotImplementedError". Uses "find_spec()" when available to
      provide functionality.

      Obsoleto desde a versão 3.4: Use "find_spec()" instead.

   find_module(fullname)

      A concrete implementation of "Finder.find_module()" which is
      equivalent to "self.find_loader(fullname)[0]".

      Obsoleto desde a versão 3.4: Use "find_spec()" instead.

   invalidate_caches()

      Um método opcional que, quando chamado, deve invalidar qualquer
      cache interno usado pelo localizador. Usado por
      "importlib.machinery.PathFinder.invalidate_caches()" ao
      invalidar os caches de todos os localizadores em cache.

class importlib.abc.Loader

   Uma classe base abstrata para um *carregador*. Veja **PEP 302**
   para a definição exata de um carregador.

   Loaders that wish to support resource reading should implement a
   "get_resource_reader(fullname)" method as specified by
   "importlib.abc.ResourceReader".

   Alterado na versão 3.7: Introduced the optional
   "get_resource_reader()" method.

   create_module(spec)

      Um método que retorna o objeto do módulo a ser usado ao importar
      um módulo. Este método pode retornar "None", indicando que a
      semântica padrão de criação do módulo deve ocorrer.

      Novo na versão 3.4.

      Alterado na versão 3.5: Starting in Python 3.6, this method will
      not be optional when "exec_module()" is defined.

   exec_module(module)

      An abstract method that executes the module in its own namespace
      when a module is imported or reloaded.  The module should
      already be initialized when "exec_module()" is called. When this
      method exists, "create_module()" must be defined.

      Novo na versão 3.4.

      Alterado na versão 3.6: "create_module()" precisa ser definida.

   load_module(fullname)

      A legacy method for loading a module. If the module cannot be
      loaded, "ImportError" is raised, otherwise the loaded module is
      returned.

      If the requested module already exists in "sys.modules", that
      module should be used and reloaded. Otherwise the loader should
      create a new module and insert it into "sys.modules" before any
      loading begins, to prevent recursion from the import. If the
      loader inserted a module and the load fails, it must be removed
      by the loader from "sys.modules"; modules already in
      "sys.modules" before the loader began execution should be left
      alone (see "importlib.util.module_for_loader()").

      The loader should set several attributes on the module. (Note
      that some of these attributes can change when a module is
      reloaded):

      * "__name__"
           O nome do módulo.

      * "__file__"
           The path to where the module data is stored (not set for
           built-in modules).

      * "__cached__"
           The path to where a compiled version of the module
           is/should be stored (not set when the attribute would be
           inappropriate).

      * "__path__"
           A list of strings specifying the search path within a
           package. This attribute is not set on modules.

      * "__package__"
           The fully qualified name of the package under which the
           module was loaded as a submodule (or the empty string for
           top-level modules). For packages, it is the same as
           "__name__".  The "importlib.util.module_for_loader()"
           decorator can handle the details for "__package__".

      * "__loader__"
           The loader used to load the module. The
           "importlib.util.module_for_loader()" decorator can handle
           the details for "__package__".

      Quando "exec_module()" está disponível, então a funcionalidade
      compatível com versões anteriores é fornecida.

      Alterado na versão 3.4: Raise "ImportError" when called instead
      of "NotImplementedError". Functionality provided when
      "exec_module()" is available.

      Obsoleto desde a versão 3.4: The recommended API for loading a
      module is "exec_module()" (and "create_module()").  Loaders
      should implement it instead of load_module().  The import
      machinery takes care of all the other responsibilities of
      load_module() when exec_module() is implemented.

   module_repr(module)

      A legacy method which when implemented calculates and returns
      the given module's repr, as a string. The module type's default
      repr() will use the result of this method as appropriate.

      Novo na versão 3.3.

      Alterado na versão 3.4: Made optional instead of an
      abstractmethod.

      Obsoleto desde a versão 3.4: The import machinery now takes care
      of this automatically.

class importlib.abc.ResourceReader

   *Substituída por TraversableResources*

   Uma *classe base abstrata* para fornecer a capacidade de ler
   *recursos*.

   Da perspectiva deste ABC, um *recurso* é um artefato binário que é
   enviado dentro de um pacote. Normalmente isso é algo como um
   arquivo de dados que fica próximo ao arquivo "__init__.py" do
   pacote. O objetivo desta classe é ajudar a abstrair o acesso a tais
   arquivos de dados para que não importe se o pacote e seu(s)
   arquivo(s) de dados estão armazenados em um arquivo, por exemplo,
   zip versus no sistema de arquivos.

   Para qualquer um dos métodos desta classe, espera-se que o
   argumento *resource* seja um *objeto caminho ou similar* que
   representa conceitualmente apenas um nome de arquivo. Isso
   significa que nenhum caminho de subdiretório deve ser incluído no
   argumento *resource*. Isso ocorre porque a localização do pacote
   para o qual o leitor se destina, atua como o "diretório". Portanto,
   a metáfora para diretórios e nomes de arquivos são pacotes e
   recursos, respectivamente. É também por isso que se espera que as
   instâncias dessa classe se correlacionem diretamente a um pacote
   específico (em vez de representar potencialmente vários pacotes ou
   um módulo).

   Carregadores que desejam oferecer suporte à leitura de recursos
   devem fornecer um método chamado
   "get_resource_reader(nomecompleto)" que retorna um objeto
   implementando esta interface ABC. Se o módulo especificado por
   nomecompleto não for um pacote, este método deve retornar "None".
   Um objeto compatível com este ABC só deve ser retornado quando o
   módulo especificado for um pacote.

   Novo na versão 3.7.

   abstractmethod open_resource(resource)

      Retorna um *objeto arquivo ou similar* aberto para leitura
      binária de *resource*.

      Se o recurso não puder ser encontrado, "FileNotFoundError" é
      levantada.

   abstractmethod resource_path(resource)

      Retorna o caminho do sistema de arquivos para *resource*.

      Se o recurso não existir concretamente no sistema de arquivos,
      levanta "FileNotFoundError".

   abstractmethod is_resource(name)

      Retorna "True" se o *name* nomeado for considerado um recurso.
      "FileNotFoundError" é levantada se *name* não existir.

   abstractmethod contents()

      Retorna um *iterável* de strings sobre o conteúdo do pacote.
      Observe que não é necessário que todos os nomes retornados pelo
      iterador sejam recursos reais, por exemplo, é aceitável retornar
      nomes para os quais "is_resource()" seria falso.

      Permitir que nomes que não são recursos sejam retornados é
      permitir situações em que a forma como um pacote e seus recursos
      são armazenados é conhecida a priori e os nomes que não são
      recursos seriam úteis. Por exemplo, o retorno de nomes de
      subdiretórios é permitido para que, quando se souber que o
      pacote e os recursos estão armazenados no sistema de arquivos,
      esses nomes de subdiretórios possam ser usados diretamente.

      O método abstrato retorna um iterável sem itens.

class importlib.abc.ResourceLoader

   Uma classe base abstrata para um *carregador* que implementa o
   protocolo opcional **PEP 302** para carregar recursos arbitrários
   do back-end de armazenamento.

   Obsoleto desde a versão 3.7: This ABC is deprecated in favour of
   supporting resource loading through "importlib.abc.ResourceReader".

   abstractmethod get_data(path)

      Um método abstrato para retornar os bytes dos dados localizados
      em *path*. Carregadores que possuem um backend de armazenamento
      arquivo ou similar que permite o armazenamento de dados
      arbitrários podem implementar esse método abstrato para fornecer
      acesso direto aos dados armazenados. "OSError" deve ser
      levantada se o *path* não puder ser encontrado. Espera-se que o
      *path* seja construído usando o atributo "__file__" de um módulo
      ou um item de "__path__" de um pacote.

      Alterado na versão 3.4: Levanta "OSError" em vez de
      "NotImplementedError".

class importlib.abc.InspectLoader

   Uma classe base abstrata para um *carregador* que implementa o
   protocolo opcional da **PEP 302** para carregadores que inspecionam
   módulos.

   get_code(fullname)

      Retorna o objeto de código para um módulo, ou "None" se o módulo
      não tiver um objeto código (como seria o caso, por exemplo, para
      um módulo embutido). Levanta um "ImportError" se o carregador
      não conseguir encontrar o módulo solicitado.

      Nota:

        Embora o método tenha uma implementação padrão, sugere-se que
        ele seja substituído, se possível, para desempenho.

      Alterado na versão 3.4: Não é mais abstrato e uma implementação
      concreta é fornecida.

   abstractmethod get_source(fullname)

      Um método abstrato para retornar a fonte de um módulo. Ele é
      retornado como uma string de texto usando *novas linhas
      universais*, traduzindo todos os separadores de linha
      reconhecidos em caracteres "'\n'". Retorna "None" se nenhuma
      fonte estiver disponível (por exemplo, um módulo embutido).
      Levanta "ImportError" se o carregador não puder encontrar o
      módulo especificado.

      Alterado na versão 3.4: Levanta "ImportError" em vez de
      "NotImplementedError".

   is_package(fullname)

      Um método opcional para retornar um valor verdadeiro se o módulo
      for um pacote, um valor falso caso contrário. "ImportError" é
      levantada se o *carregador* não puder encontrar o módulo.

      Alterado na versão 3.4: Levanta "ImportError" em vez de
      "NotImplementedError".

   static source_to_code(data, path='<string>')

      Cria um objeto código a partir de código-fonte Python

      O argumento *data* pode ser qualquer coisa a qual a função
      "compile()" tenha suporte (por exemplo, string ou bytes). O
      argumento *path* deve ser o "caminho" de onde o código-fonte se
      originou, o que pode ser um conceito abstrato (por exemplo,
      local em um arquivo zip).

      Com o objeto de código subsequente, é possível executá-lo em um
      módulo executando "exec(code, module.__dict__)".

      Novo na versão 3.4.

      Alterado na versão 3.5: O método foi tornado estático.

   exec_module(module)

      Implementação de "Loader.exec_module()".

      Novo na versão 3.4.

   load_module(fullname)

      Implementação de "Loader.load_module()".

      Obsoleto desde a versão 3.4: use "exec_module()".

class importlib.abc.ExecutionLoader

   Uma classe base abstrata que herda de "InspectLoader" que, quando
   implementada, ajuda um módulo a ser executado como um script. A ABC
   representa um protocolo opcional da **PEP 302**.

   abstractmethod get_filename(fullname)

      Um método abstrato que deve retornar o valor de "__file__" para
      o módulo especificado. Se nenhum caminho estiver disponível,
      "ImportError" é levantada.

      Se o código-fonte estiver disponível, o método deverá retornar o
      caminho para o arquivo fonte, independentemente de um bytecode
      ter sido usado para carregar o módulo.

      Alterado na versão 3.4: Levanta "ImportError" em vez de
      "NotImplementedError".

class importlib.abc.FileLoader(fullname, path)

   Uma classe base abstrata que herda de "ResourceLoader" e
   "ExecutionLoader", fornecendo implementações concretas de
   "ResourceLoader.get_data()" e "ExecutionLoader.get_filename()".

   O argumento *fullname* é um nome totalmente resolvido do módulo que
   o carregador deve manipular. O argumento *path* é o caminho para o
   arquivo do módulo.

   Novo na versão 3.3.

   name

      O nome do módulo que o carregador pode manipular.

   path

      Caminho para o arquivo do módulo

   load_module(fullname)

      Chama "load_module()" do super.

      Obsoleto desde a versão 3.4: Use "Loader.exec_module()"

   abstractmethod get_filename(fullname)

      Retorna "path".

   abstractmethod get_data(path)

      Lê *caminho* como um arquivo binário e retorna os bytes dele.

class importlib.abc.SourceLoader

   Uma classe base abstrata para implementar o carregamento de arquivo
   fonte (e opcionalmente bytecode). A classe herda de
   "ResourceLoader" e "ExecutionLoader", exigindo a implementação de:

   * "ResourceLoader.get_data()"

   * "ExecutionLoader.get_filename()"
        Deve retornar apenas o caminho para o arquivo fonte; o
        carregamento sem fonte não é suportado.

   Os métodos abstratos definidos por esta classe são para adicionar
   suporte opcional ao arquivo bytecode. Não implementar esses métodos
   opcionais (ou fazer com que eles levantem "NotImplementedError")
   faz com que o carregador funcione apenas com código-fonte.
   Implementar os métodos permite que o carregador funcione com
   arquivos de código-fonte *e* bytecode; ele não permite carregamento
   *sem fonte* onde apenas o bytecode é fornecido. Arquivos de
   bytecode são uma otimização para acelerar o carregamento removendo
   a etapa de análise do compilador do Python e, portanto, nenhuma API
   específica de bytecode é exposta.

   path_stats(path)

      Método abstrato opcional que retorna um "dict" contendo
      metadados sobre o caminho especificado. As chaves de dicionário
      suportadas são:

      * "'mtime'" (obrigatório): um número inteiro ou de ponto
        flutuante que representa o tempo de modificação do código-
        fonte;

      * "'size'" (opcional): o tamanho em bytes do código-fonte.

      Quaisquer outras chaves no dicionário são ignoradas, para
      permitir extensões futuras. Se o caminho não puder ser
      manipulado, "OSError" é levantada.

      Novo na versão 3.3.

      Alterado na versão 3.4: Levanta "OSError" em vez de
      "NotImplementedError".

   path_mtime(path)

      Método abstrato opcional que retorna o horário de modificação do
      caminho especificado.

      Obsoleto desde a versão 3.3: Este método foi descontinuado em
      favor de "path_stats()". Você não precisa implementá-lo, mas ele
      ainda está disponível para fins de compatibilidade. Levanta
      "OSError" se o caminho não puder ser manipulado.

      Alterado na versão 3.4: Levanta "OSError" em vez de
      "NotImplementedError".

   set_data(path, data)

      Método abstrato opcional que grava os bytes especificados em um
      caminho de arquivo. Quaisquer diretórios intermediários que não
      existam devem ser criados automaticamente.

      When writing to the path fails because the path is read-only
      ("errno.EACCES"/"PermissionError"), do not propagate the
      exception.

      Alterado na versão 3.4: Não mais levanta "NotImplementedError"
      quando chamado.

   get_code(fullname)

      Implementação concreta de "InspectLoader.get_code()".

   exec_module(module)

      Implementação concreta de "Loader.exec_module()".

      Novo na versão 3.4.

   load_module(fullname)

      Implementação concreta de "Loader.load_module()".

      Obsoleto desde a versão 3.4: Use "exec_module()".

   get_source(fullname)

      Implementação concreta de "InspectLoader.get_source()".

   is_package(fullname)

      Implementação concreta de "InspectLoader.is_package()". Um
      módulo é determinado como um pacote se seu caminho de arquivo
      (conforme fornecido por "ExecutionLoader.get_filename()") for um
      arquivo chamado "__init__" quando a extensão do arquivo for
      removida **e** o nome do módulo em si não terminar em
      "__init__".

class importlib.abc.Traversable

   Um objeto com um subconjunto de métodos de "pathlib.Path" adequados
   para percorrer diretórios e abrir arquivos.

   Para uma representação do objeto no sistema de arquivos, use
   "importlib.resources.as_file()".

   Novo na versão 3.9.

   abstractmethod name()

      The base name of this object without any parent references.

   abstractmethod iterdir()

      Produz objetos Traversable em self.

   abstractmethod is_dir()

      Retorna True se self for um diretório.

   abstractmethod is_file()

      Retorna True se self for um arquivo.

   abstractmethod joinpath(child)

      Retorna o filho Traversable em self.

   abstractmethod __truediv__(child)

      Retorna o filho Traversable em self.

   abstractmethod open(mode='r', *args, **kwargs)

      *mode* pode ser 'r' ou 'rb' para abrir como texto ou binário.
      Retorna um manipulador adequado para leitura (o mesmo que
      "pathlib.Path.open").

      Ao abrir como texto, aceita parâmetros de codificação como os
      aceitos por "io.TextIOWrapper".

   read_bytes()

      Lê o conteúdo de self como bytes.

   read_text(encoding=None)

      Lê o conteúdo de self como texto.

   Note: In Python 3.11 and later, this class is found in
   "importlib.resources.abc".

class importlib.abc.TraversableResources

   An abstract base class for resource readers capable of serving the
   "files" interface. Subclasses ResourceReader and provides concrete
   implementations of the ResourceReader's abstract methods.
   Therefore, any loader supplying TraversableResources also supplies
   ResourceReader.

   Espera-se que os carregadores que desejam oferecer suporte à
   leitura de recursos implementem essa interface.

   Novo na versão 3.9.

   Note: In Python 3.11 and later, this class is found in
   "importlib.resources.abc".


"importlib.resources" -- Recursos
=================================

**Source code:** Lib/importlib/resources.py

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

Novo na versão 3.7.

This module leverages Python's import system to provide access to
*resources* within *packages*.  If you can import a package, you can
access resources within that package.  Resources can be opened or
read, in either binary or text mode.

Resources are roughly akin to files inside directories, though it's
important to keep in mind that this is just a metaphor.  Resources and
packages **do not** have to exist as physical files and directories on
the file system.

Nota:

  This module provides functionality similar to pkg_resources Basic
  Resource Access without the performance overhead of that package.
  This makes reading resources included in packages easier, with more
  stable and consistent semantics.The standalone backport of this
  module provides more information on using importlib.resources and
  migrating from pkg_resources to importlib.resources.

Loaders that wish to support resource reading should implement a
"get_resource_reader(fullname)" method as specified by
"importlib.abc.ResourceReader".

The following types are defined.

importlib.resources.Package

   The "Package" type is defined as "Union[str, ModuleType]".  This
   means that where the function describes accepting a "Package", you
   can pass in either a string or a module.  Module objects must have
   a resolvable "__spec__.submodule_search_locations" that is not
   "None".

importlib.resources.Resource

   This type describes the resource names passed into the various
   functions in this package.  This is defined as "Union[str,
   os.PathLike]".

The following functions are available.

importlib.resources.files(package)

   Returns an "importlib.abc.Traversable" object representing the
   resource container for the package (think directory) and its
   resources (think files). A Traversable may contain other containers
   (think subdirectories).

   *package* é um nome ou um objeto módulo que está em conformidade
   com os requisitos de "Package".

   Novo na versão 3.9.

importlib.resources.as_file(traversable)

   Given a "importlib.abc.Traversable" object representing a file,
   typically from "importlib.resources.files()", return a context
   manager for use in a "with" statement. The context manager provides
   a "pathlib.Path" object.

   Exiting the context manager cleans up any temporary file created
   when the resource was extracted from e.g. a zip file.

   Use "as_file" when the Traversable methods ("read_text", etc) are
   insufficient and an actual file on the file system is required.

   Novo na versão 3.9.

importlib.resources.open_binary(package, resource)

   Abre para leitura binária o *resource* dentro do *package*.

   *package* é um nome ou um objeto módulo que está em conformidade
   com os requisitos do "Package". *resource* é o nome do recurso a
   ser aberto dentro de *package*; ele não pode conter separadores de
   caminho e não pode ter sub-recursos (ou seja, não pode ser um
   diretório). Essa função retorna uma instância de "typing.BinaryIO",
   um fluxo de E/S binário aberto para leitura.

importlib.resources.open_text(package, resource, encoding='utf-8', errors='strict')

   Abre para leitura de texto o *resource* dentro do *package*.  Por
   padrão, o recurso é aberto para leitura como UTF-8.

   *package* é um nome ou um objeto módulo que está em conformidade
   com os requisitos do "Package". *resource* é o nome do recurso a
   ser aberto dentro de *package*; ele não pode conter separadores de
   caminho e não pode ter sub-recursos (ou seja, não pode ser um
   diretório). *encoding* e *errors* têm o mesmo significado que com
   "open()" embutido.

   Essa função retorna uma instância de "typing.TextIO", um fluxo de
   E/S de texto aberto para leitura.

importlib.resources.read_binary(package, resource)

   Lê e retorna o conteúdo do *resource* dentro do *package* como
   "bytes".

   *package* é um nome ou um objeto módulo que está em conformidade
   com os requisitos do "Package". *resource* é o nome do recurso a
   ser aberto dentro de *package*; ele não pode conter separadores de
   caminho e não pode ter sub-recursos (ou seja, não pode ser um
   diretório). Essa função retorna o conteúdo do recurso como "bytes".

importlib.resources.read_text(package, resource, encoding='utf-8', errors='strict')

   Lê e retorna o conteúdo de *resource* em *package* como "str". Por
   padrão, o conteúdo é lido como UTF-8 estrito.

   *package* é um nome ou um objeto módulo que está em conformidade
   com os requisitos do "Package". *resource* é o nome do recurso a
   ser aberto dentro de *package*; ele não pode conter separadores de
   caminho e não pode ter sub-recursos (ou seja, não pode ser um
   diretório). *encoding* e *errors* têm o mesmo significado que com
   "open()" embutido. Esta função retorna o conteúdo do recurso como
   "str".

importlib.resources.path(package, resource)

   Retorna o caminho para o *resource* como um caminho real do sistema
   de arquivos.  Essa função retorna um gerenciador de contexto para
   uso em uma instrução "with". O gerenciador de contexto fornece um
   objeto "pathlib.Path".

   Sair do gerenciador de contexto limpa qualquer arquivo temporário
   criado quando o recurso precisa ser extraído, por exemplo, de um
   arquivo zip.

   *package* é um nome ou um objeto módulo que está em conformidade
   com os requisitos do "Package". *resource* é o nome do recurso a
   ser aberto dentro de *package*; ele não pode conter separadores de
   caminho e não pode ter sub-recursos (ou seja, não pode ser um
   diretório).

importlib.resources.is_resource(package, name)

   Return "True" if there is a resource named *name* in the package,
   otherwise "False".  Remember that directories are *not* resources!
   *package* is either a name or a module object which conforms to the
   "Package" requirements.

importlib.resources.contents(package)

   Retorna um iterável sobre os itens nomeados no pacote.  O iterável
   retorna "str" recursos (por exemplo, arquivos) e não recursos (por
   exemplo, diretórios).  O iterável não recorre a subdiretórios.

   *package* é um nome ou um objeto módulo que está em conformidade
   com os requisitos de "Package".


"importlib.machinery" -- Importadores e ganchos de caminho
==========================================================

**Código-fonte:** Lib/importlib/machinery.py

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

Este módulo contém vários objetos que ajudam o "import" a localizar e
carregar módulos.

importlib.machinery.SOURCE_SUFFIXES

   Uma lista de strings representando os sufixos de arquivo
   reconhecidos para módulos em código-fonte.

   Novo na versão 3.3.

importlib.machinery.DEBUG_BYTECODE_SUFFIXES

   Uma lista de strings representando os sufixos de arquivo para
   módulos em bytecode não otimizado.

   Novo na versão 3.3.

   Obsoleto desde a versão 3.5: Use "BYTECODE_SUFFIXES".

importlib.machinery.OPTIMIZED_BYTECODE_SUFFIXES

   Uma lista de strings representando os sufixos de arquivo para
   módulos em bytecode otimizado.

   Novo na versão 3.3.

   Obsoleto desde a versão 3.5: Use "BYTECODE_SUFFIXES".

importlib.machinery.BYTECODE_SUFFIXES

   Uma lista de strings representando os sufixos de arquivo
   reconhecidos para módulos em bytecode (incluindo com ponto no
   início).

   Novo na versão 3.3.

   Alterado na versão 3.5: O valor não mais depende de "__debug__".

importlib.machinery.EXTENSION_SUFFIXES

   Uma lista de strings representando os sufixos de arquivo
   reconhecidos para módulos de extensão.

   Novo na versão 3.3.

importlib.machinery.all_suffixes()

   Retorna uma lista combinada de strings representando todos os
   sufixos de arquivo para módulos reconhecidos pelo maquinário de
   importação padrão. Este é um auxiliar para código que simplesmente
   precisa saber se um caminho de sistema de arquivos potencialmente
   se refere a um módulo sem precisar de detalhes sobre o tipo de
   módulo (por exemplo, "inspect.getmodulename()").

   Novo na versão 3.3.

class importlib.machinery.BuiltinImporter

   Um *importador* para módulos embutidos. Todos os módulos embutidos
   conhecidos estão listados em "sys.builtin_module_names". Esta
   classe implementa os ABCs "importlib.abc.MetaPathFinder" e
   "importlib.abc.InspectLoader".

   Somente métodos de classe são definidos por esta classe para
   aliviar a necessidade de instanciação.

   Alterado na versão 3.5: Como parte da **PEP 489**, o importador
   embutido agora implementa "Loader.create_module()" e
   "Loader.exec_module()"

class importlib.machinery.FrozenImporter

   Um *importador* para módulos congelados. Esta classe implementa os
   ABCs "importlib.abc.MetaPathFinder" e
   "importlib.abc.InspectLoader".

   Somente métodos de classe são definidos por esta classe para
   aliviar a necessidade de instanciação.

   Alterado na versão 3.4: Ganhou os métodos "create_module()" e
   "exec_module()".

class importlib.machinery.WindowsRegistryFinder

   *Localizador* para módulos declarados no registro do Windows. Esta
   classe implementa a ABC "importlib.abc.MetaPathFinder".

   Somente métodos de classe são definidos por esta classe para
   aliviar a necessidade de instanciação.

   Novo na versão 3.3.

   Obsoleto desde a versão 3.6: Use a configuração de "site" em vez
   disso. Versões futuras do Python podem não habilitar esse
   localizador por padrão.

class importlib.machinery.PathFinder

   Um *Localizador* para atributos "sys.path" e pacote "__path__".
   Esta classe implementa a ABC "importlib.abc.MetaPathFinder".

   Somente métodos de classe são definidos por esta classe para
   aliviar a necessidade de instanciação.

   classmethod find_spec(fullname, path=None, target=None)

      Método de classe que tenta encontrar um *spec* para o módulo
      especificado por *fullname* em "sys.path" ou, se definido, em
      *path*. Para cada entrada de caminho pesquisada,
      "sys.path_importer_cache" é verificado. Se um objeto não falso
      for encontrado, ele será usado como o *localizador de entrada de
      caminho* para procurar o módulo que está sendo pesquisado. Se
      nenhuma entrada for encontrada em "sys.path_importer_cache",
      então "sys.path_hooks" será pesquisado para um localizador para
      a entrada de caminho e, se encontrado, será armazenado em
      "sys.path_importer_cache" junto com a consulta sobre o módulo.
      Se nenhum localizador for encontrado, então "None" será
      armazenado no cache e retornado.

      Novo na versão 3.4.

      Alterado na versão 3.5: Se o diretório de trabalho atual —
      representado por uma string vazia — não for mais válido, "None"
      será retornado, mas nenhum valor será armazenado em cache em
      "sys.path_importer_cache".

   classmethod find_module(fullname, path=None)

      A legacy wrapper around "find_spec()".

      Obsoleto desde a versão 3.4: Use "find_spec()" instead.

   classmethod invalidate_caches()

      Chama "importlib.abc.PathEntryFinder.invalidate_caches()" em
      todos os localizadores armazenados em "sys.path_importer_cache"
      que definem o método. Caso contrário, as entradas em
      "sys.path_importer_cache" definidas como "None" são excluídas.

      Alterado na versão 3.7: Entradas de "None" em
      "sys.path_importer_cache" são excluídas.

   Alterado na versão 3.4: Chama objetos em "sys.path_hooks" com o
   diretório de trabalho atual para "''" (ou seja, a string vazia).

class importlib.machinery.FileFinder(path, *loader_details)

   Uma implementação concreta de "importlib.abc.PathEntryFinder" que
   armazena em cache os resultados do sistema de arquivos.

   O argumento *path* é o diretório que o localizador é responsável
   por pesquisar.

   O argumento *loader_details* é um número variável de tuplas de 2
   itens, cada uma contendo um carregador e uma sequência de sufixos
   de arquivo que o carregador reconhece. Espera-se que os
   carregadores sejam chamáveis que aceitam dois argumentos do nome do
   módulo e o caminho para o arquivo encontrado.

   O localizador armazenará em cache o conteúdo do diretório conforme
   necessário, fazendo chamadas de "stat" para cada pesquisa de módulo
   para verificar se o cache não está desatualizado. Como a
   obsolescência do cache depende da granularidade das informações de
   estado do sistema operacional do sistema de arquivos, há uma
   condição de corrida potencial de busca por um módulo, criação de um
   novo arquivo e, em seguida, busca pelo módulo que o novo arquivo
   representa. Se as operações ocorrerem rápido o suficiente para
   caber na granularidade das chamadas de "stat", a pesquisa do módulo
   falhará. Para evitar que isso aconteça, ao criar um módulo
   dinamicamente, certifique-se de chamar
   "importlib.invalidate_caches()".

   Novo na versão 3.3.

   path

      O caminho que o localizador irá procurar.

   find_spec(fullname, target=None)

      Tenta encontrar o spec para manipular *fullname* dentro de
      "path".

      Novo na versão 3.4.

   find_loader(fullname)

      Attempt to find the loader to handle *fullname* within "path".

      Obsoleto desde a versão 3.10: Use "find_spec()" instead.

   invalidate_caches()

      Limpa o cache interno.

   classmethod path_hook(*loader_details)

      A class method which returns a closure for use on
      "sys.path_hooks". An instance of "FileFinder" is returned by the
      closure using the path argument given to the closure directly
      and *loader_details* indirectly.

      Se o argumento para a clausura não for um diretório existente,
      "ImportError" será levantada.

class importlib.machinery.SourceFileLoader(fullname, path)

   Uma implementação concreta de "importlib.abc.SourceLoader"
   subclassificando "importlib.abc.FileLoader" e fornecendo algumas
   implementações concretas de outros métodos.

   Novo na versão 3.3.

   name

      O nome do módulo que este carregador irá manipular.

   path

      O caminho para o arquivo fonte.

   is_package(fullname)

      Retorna "True" se "path" parecer ser para um pacote.

   path_stats(path)

      Implementação concreta de
      "importlib.abc.SourceLoader.path_stats()".

   set_data(path, data)

      Implementação concreta de
      "importlib.abc.SourceLoader.set_data()".

   load_module(name=None)

      Implementação concreta de "importlib.abc.Loader.load_module()"
      onde a especificação do nome do módulo para carregar é opcional

      Obsoleto desde a versão 3.6: Use
      "importlib.abc.Loader.exec_module()".

class importlib.machinery.SourcelessFileLoader(fullname, path)

   Uma implementação concreta de "importlib.abc.FileLoader" que pode
   importar arquivos de bytecode (ou seja, não existem arquivos de
   código-fonte).

   Observe que o uso direto de arquivos de bytecode (e, portanto, não
   de arquivos de código-fonte) impede que seus módulos sejam
   utilizáveis por todas as implementações do Python ou novas versões
   do Python que alteram o formato do bytecode.

   Novo na versão 3.3.

   name

      O nome do módulo que o carregador vai manipular.

   path

      O caminho para o arquivo de bytecode.

   is_package(fullname)

      Determina se o módulo é um pacote baseado em "path".

   get_code(fullname)

      Retorna o objeto código para "name" criado a partir de "path".

   get_source(fullname)

      Retorna "None", pois os arquivos de bytecode não têm código-
      fonte quando este carregador é usado.

   load_module(name=None)

   Implementação concreta de "importlib.abc.Loader.load_module()" onde
   a especificação do nome do módulo para carregar é opcional

   Obsoleto desde a versão 3.6: Use
   "importlib.abc.Loader.exec_module()".

class importlib.machinery.ExtensionFileLoader(fullname, path)

   Uma implementação concreta de "importlib.abc.ExecutionLoader" para
   módulos de extensão.

   O argumento *fullname* especifica o nome do módulo ao qual o
   carregador deve dar suporte. O argumento *path* é o caminho para o
   arquivo do módulo de extensão.

   Novo na versão 3.3.

   name

      Nome do módulo ao qual o carregador dá suporte.

   path

      Caminho para o módulo de extensão.

   create_module(spec)

      Cria o objeto do módulo a partir da especificação fornecida de
      acordo com a **PEP 489**.

      Novo na versão 3.5.

   exec_module(module)

      Inicializa o objeto do módulo fornecido de acordo com a **PEP
      489**.

      Novo na versão 3.5.

   is_package(fullname)

      Retorna "True" se o caminho do arquivo aponta para o módulo
      "__init__" de um pacote com base em "EXTENSION_SUFFIXES".

   get_code(fullname)

      Retorna "None", pois os módulos de extensão não possuem um
      objeto código.

   get_source(fullname)

      Retorna "None" pois os módulos de extensão não possuem código-
      fonte.

   get_filename(fullname)

      Retorna "path".

      Novo na versão 3.4.

class importlib.machinery.ModuleSpec(name, loader, *, origin=None, loader_state=None, is_package=None)

   A specification for a module's import-system-related state.  This
   is typically exposed as the module's "__spec__" attribute.  In the
   descriptions below, the names in parentheses give the corresponding
   attribute available directly on the module object. E.g.
   "module.__spec__.origin == module.__file__".  Note however that
   while the *values* are usually equivalent, they can differ since
   there is no synchronization between the two objects.  Thus it is
   possible to update the module's "__path__" at runtime, and this
   will not be automatically reflected in
   "__spec__.submodule_search_locations".

   Novo na versão 3.4.

   name

   ("__name__")

   A string for the fully qualified name of the module.

   loader

   ("__loader__")

   The *Loader* that should be used when loading the module.
   *Finders* should always set this.

   origin

   ("__file__")

   Name of the place from which the module is loaded, e.g. "builtin"
   for built-in modules and the filename for modules loaded from
   source. Normally "origin" should be set, but it may be "None" (the
   default) which indicates it is unspecified (e.g. for namespace
   packages).

   submodule_search_locations

   ("__path__")

   List of strings for where to find submodules, if a package ("None"
   otherwise).

   loader_state

   Container of extra module-specific data for use during loading (or
   "None").

   cached

   ("__cached__")

   String for where the compiled module should be stored (or "None").

   parent

   ("__package__")

   (Read-only) The fully qualified name of the package under which the
   module should be loaded as a submodule (or the empty string for
   top-level modules). For packages, it is the same as "__name__".

   has_location

   Boolean indicating whether or not the module's "origin" attribute
   refers to a loadable location.


"importlib.util" -- Utility code for importers
==============================================

**Source code:** Lib/importlib/util.py

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

This module contains the various objects that help in the construction
of an *importer*.

importlib.util.MAGIC_NUMBER

   The bytes which represent the bytecode version number. If you need
   help with loading/writing bytecode then consider
   "importlib.abc.SourceLoader".

   Novo na versão 3.4.

importlib.util.cache_from_source(path, debug_override=None, *, optimization=None)

   Return the **PEP 3147**/**PEP 488** path to the byte-compiled file
   associated with the source *path*.  For example, if *path* is
   "/foo/bar/baz.py" the return value would be
   "/foo/bar/__pycache__/baz.cpython-32.pyc" for Python 3.2. The
   "cpython-32" string comes from the current magic tag (see
   "get_tag()"; if "sys.implementation.cache_tag" is not defined then
   "NotImplementedError" will be raised).

   The *optimization* parameter is used to specify the optimization
   level of the bytecode file. An empty string represents no
   optimization, so "/foo/bar/baz.py" with an *optimization* of "''"
   will result in a bytecode path of
   "/foo/bar/__pycache__/baz.cpython-32.pyc". "None" causes the
   interpreter's optimization level to be used. Any other value's
   string representation is used, so "/foo/bar/baz.py" with an
   *optimization* of "2" will lead to the bytecode path of
   "/foo/bar/__pycache__/baz.cpython-32.opt-2.pyc". The string
   representation of *optimization* can only be alphanumeric, else
   "ValueError" is raised.

   The *debug_override* parameter is deprecated and can be used to
   override the system's value for "__debug__". A "True" value is the
   equivalent of setting *optimization* to the empty string. A "False"
   value is the same as setting *optimization* to "1". If both
   *debug_override* an *optimization* are not "None" then "TypeError"
   is raised.

   Novo na versão 3.4.

   Alterado na versão 3.5: The *optimization* parameter was added and
   the *debug_override* parameter was deprecated.

   Alterado na versão 3.6: Aceita um *objeto caminho ou similar*.

importlib.util.source_from_cache(path)

   Given the *path* to a **PEP 3147** file name, return the associated
   source code file path.  For example, if *path* is
   "/foo/bar/__pycache__/baz.cpython-32.pyc" the returned path would
   be "/foo/bar/baz.py".  *path* need not exist, however if it does
   not conform to **PEP 3147** or **PEP 488** format, a "ValueError"
   is raised. If "sys.implementation.cache_tag" is not defined,
   "NotImplementedError" is raised.

   Novo na versão 3.4.

   Alterado na versão 3.6: Aceita um *objeto caminho ou similar*.

importlib.util.decode_source(source_bytes)

   Decode the given bytes representing source code and return it as a
   string with universal newlines (as required by
   "importlib.abc.InspectLoader.get_source()").

   Novo na versão 3.4.

importlib.util.resolve_name(name, package)

   Resolve a relative module name to an absolute one.

   If  **name** has no leading dots, then **name** is simply returned.
   This allows for usage such as "importlib.util.resolve_name('sys',
   __spec__.parent)" without doing a check to see if the **package**
   argument is needed.

   "ImportError" is raised if **name** is a relative module name but
   **package** is a false value (e.g. "None" or the empty string).
   "ImportError" is also raised a relative name would escape its
   containing package (e.g. requesting "..bacon" from within the
   "spam" package).

   Novo na versão 3.3.

   Alterado na versão 3.9: To improve consistency with import
   statements, raise "ImportError" instead of "ValueError" for invalid
   relative import attempts.

importlib.util.find_spec(name, package=None)

   Find the *spec* for a module, optionally relative to the specified
   **package** name. If the module is in "sys.modules", then
   "sys.modules[name].__spec__" is returned (unless the spec would be
   "None" or is not set, in which case "ValueError" is raised).
   Otherwise a search using "sys.meta_path" is done. "None" is
   returned if no spec is found.

   If **name** is for a submodule (contains a dot), the parent module
   is automatically imported.

   **name** and **package** work the same as for "import_module()".

   Novo na versão 3.4.

   Alterado na versão 3.7: Raises "ModuleNotFoundError" instead of
   "AttributeError" if **package** is in fact not a package (i.e.
   lacks a "__path__" attribute).

importlib.util.module_from_spec(spec)

   Create a new module based on **spec** and
   "spec.loader.create_module".

   If "spec.loader.create_module" does not return "None", then any
   pre-existing attributes will not be reset. Also, no
   "AttributeError" will be raised if triggered while accessing
   **spec** or setting an attribute on the module.

   This function is preferred over using "types.ModuleType" to create
   a new module as **spec** is used to set as many import-controlled
   attributes on the module as possible.

   Novo na versão 3.5.

@importlib.util.module_for_loader

   A *decorator* for "importlib.abc.Loader.load_module()" to handle
   selecting the proper module object to load with. The decorated
   method is expected to have a call signature taking two positional
   arguments (e.g. "load_module(self, module)") for which the second
   argument will be the module **object** to be used by the loader.
   Note that the decorator will not work on static methods because of
   the assumption of two arguments.

   The decorated method will take in the **name** of the module to be
   loaded as expected for a *loader*. If the module is not found in
   "sys.modules" then a new one is constructed. Regardless of where
   the module came from, "__loader__" set to **self** and
   "__package__" is set based on what
   "importlib.abc.InspectLoader.is_package()" returns (if available).
   These attributes are set unconditionally to support reloading.

   If an exception is raised by the decorated method and a module was
   added to "sys.modules", then the module will be removed to prevent
   a partially initialized module from being in left in "sys.modules".
   If the module was already in "sys.modules" then it is left alone.

   Alterado na versão 3.3: "__loader__" and "__package__" are
   automatically set (when possible).

   Alterado na versão 3.4: Set "__name__", "__loader__" "__package__"
   unconditionally to support reloading.

   Obsoleto desde a versão 3.4: The import machinery now directly
   performs all the functionality provided by this function.

@importlib.util.set_loader

   A *decorator* for "importlib.abc.Loader.load_module()" to set the
   "__loader__" attribute on the returned module. If the attribute is
   already set the decorator does nothing. It is assumed that the
   first positional argument to the wrapped method (i.e. "self") is
   what "__loader__" should be set to.

   Alterado na versão 3.4: Set "__loader__" if set to "None", as if
   the attribute does not exist.

   Obsoleto desde a versão 3.4: The import machinery takes care of
   this automatically.

@importlib.util.set_package

   A *decorator* for "importlib.abc.Loader.load_module()" to set the
   "__package__" attribute on the returned module. If "__package__" is
   set and has a value other than "None" it will not be changed.

   Obsoleto desde a versão 3.4: The import machinery takes care of
   this automatically.

importlib.util.spec_from_loader(name, loader, *, origin=None, is_package=None)

   A factory function for creating a "ModuleSpec" instance based on a
   loader.  The parameters have the same meaning as they do for
   ModuleSpec.  The function uses available *loader* APIs, such as
   "InspectLoader.is_package()", to fill in any missing information on
   the spec.

   Novo na versão 3.4.

importlib.util.spec_from_file_location(name, location, *, loader=None, submodule_search_locations=None)

   A factory function for creating a "ModuleSpec" instance based on
   the path to a file.  Missing information will be filled in on the
   spec by making use of loader APIs and by the implication that the
   module will be file-based.

   Novo na versão 3.4.

   Alterado na versão 3.6: Aceita um *objeto caminho ou similar*.

importlib.util.source_hash(source_bytes)

   Return the hash of *source_bytes* as bytes. A hash-based ".pyc"
   file embeds the "source_hash()" of the corresponding source file's
   contents in its header.

   Novo na versão 3.7.

class importlib.util.LazyLoader(loader)

   A class which postpones the execution of the loader of a module
   until the module has an attribute accessed.

   This class **only** works with loaders that define "exec_module()"
   as control over what module type is used for the module is
   required. For those same reasons, the loader's "create_module()"
   method must return "None" or a type for which its "__class__"
   attribute can be mutated along with not using *slots*. Finally,
   modules which substitute the object placed into "sys.modules" will
   not work as there is no way to properly replace the module
   references throughout the interpreter safely; "ValueError" is
   raised if such a substitution is detected.

   Nota:

     For projects where startup time is critical, this class allows
     for potentially minimizing the cost of loading a module if it is
     never used. For projects where startup time is not essential then
     use of this class is **heavily** discouraged due to error
     messages created during loading being postponed and thus
     occurring out of context.

   Novo na versão 3.5.

   Alterado na versão 3.6: Began calling "create_module()", removing
   the compatibility warning for "importlib.machinery.BuiltinImporter"
   and "importlib.machinery.ExtensionFileLoader".

   classmethod factory(loader)

      A class method which returns a callable that creates a lazy
      loader. This is meant to be used in situations where the loader
      is passed by class instead of by instance.

         suffixes = importlib.machinery.SOURCE_SUFFIXES
         loader = importlib.machinery.SourceFileLoader
         lazy_loader = importlib.util.LazyLoader.factory(loader)
         finder = importlib.machinery.FileFinder(path, (lazy_loader, suffixes))


Exemplos
========


Importing programmatically
--------------------------

To programmatically import a module, use "importlib.import_module()".

   import importlib

   itertools = importlib.import_module('itertools')


Checando se o módulo pode ser importado
---------------------------------------

If you need to find out if a module can be imported without actually
doing the import, then you should use "importlib.util.find_spec()".

Note that if "name" is a submodule (contains a dot),
"importlib.util.find_spec()" will import the parent module.

   import importlib.util
   import sys

   # For illustrative purposes.
   name = 'itertools'

   if name in sys.modules:
       print(f"{name!r} already in sys.modules")
   elif (spec := importlib.util.find_spec(name)) is not None:
       # If you chose to perform the actual import ...
       module = importlib.util.module_from_spec(spec)
       sys.modules[name] = module
       spec.loader.exec_module(module)
       print(f"{name!r} has been imported")
   else:
       print(f"can't find the {name!r} module")


Importa o arquivo de origem diretamente
---------------------------------------

Importação um arquivo Python diretamente da fonte, use o seguinte
caminho (Somente versões Python 3.5 acima)

   import importlib.util
   import sys

   # For illustrative purposes.
   import tokenize
   file_path = tokenize.__file__
   module_name = tokenize.__name__

   spec = importlib.util.spec_from_file_location(module_name, file_path)
   module = importlib.util.module_from_spec(spec)
   sys.modules[module_name] = module
   spec.loader.exec_module(module)


Implementing lazy imports
-------------------------

The example below shows how to implement lazy imports:

   >>> import importlib.util
   >>> import sys
   >>> def lazy_import(name):
   ...     spec = importlib.util.find_spec(name)
   ...     loader = importlib.util.LazyLoader(spec.loader)
   ...     spec.loader = loader
   ...     module = importlib.util.module_from_spec(spec)
   ...     sys.modules[name] = module
   ...     loader.exec_module(module)
   ...     return module
   ...
   >>> lazy_typing = lazy_import("typing")
   >>> #lazy_typing is a real module object,
   >>> #but it is not loaded in memory yet.
   >>> lazy_typing.TYPE_CHECKING
   False


Setting up an importer
----------------------

For deep customizations of import, you typically want to implement an
*importer*. This means managing both the *finder* and *loader* side of
things. For finders there are two flavours to choose from depending on
your needs: a *meta path finder* or a *path entry finder*. The former
is what you would put on "sys.meta_path" while the latter is what you
create using a *path entry hook* on "sys.path_hooks" which works with
"sys.path" entries to potentially create a finder. This example will
show you how to register your own importers so that import will use
them (for creating an importer for yourself, read the documentation
for the appropriate classes defined within this package):

   import importlib.machinery
   import sys

   # For illustrative purposes only.
   SpamMetaPathFinder = importlib.machinery.PathFinder
   SpamPathEntryFinder = importlib.machinery.FileFinder
   loader_details = (importlib.machinery.SourceFileLoader,
                     importlib.machinery.SOURCE_SUFFIXES)

   # Setting up a meta path finder.
   # Make sure to put the finder in the proper location in the list in terms of
   # priority.
   sys.meta_path.append(SpamMetaPathFinder)

   # Setting up a path entry finder.
   # Make sure to put the path hook in the proper location in the list in terms
   # of priority.
   sys.path_hooks.append(SpamPathEntryFinder.path_hook(loader_details))


Approximating "importlib.import_module()"
-----------------------------------------

Import itself is implemented in Python code, making it possible to
expose most of the import machinery through importlib. The following
helps illustrate the various APIs that importlib exposes by providing
an approximate implementation of "importlib.import_module()" (Python
3.4 and newer for the importlib usage, Python 3.6 and newer for other
parts of the code).

   import importlib.util
   import sys

   def import_module(name, package=None):
       """An approximate implementation of import."""
       absolute_name = importlib.util.resolve_name(name, package)
       try:
           return sys.modules[absolute_name]
       except KeyError:
           pass

       path = None
       if '.' in absolute_name:
           parent_name, _, child_name = absolute_name.rpartition('.')
           parent_module = import_module(parent_name)
           path = parent_module.__spec__.submodule_search_locations
       for finder in sys.meta_path:
           spec = finder.find_spec(absolute_name, path)
           if spec is not None:
               break
       else:
           msg = f'No module named {absolute_name!r}'
           raise ModuleNotFoundError(msg, name=absolute_name)
       module = importlib.util.module_from_spec(spec)
       sys.modules[absolute_name] = module
       spec.loader.exec_module(module)
       if path is not None:
           setattr(parent_module, child_name, module)
       return module
