"mimetypes" --- Mapeia nomes de arquivos para tipos MIME
********************************************************

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

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

O módulo "mimetypes" converte entre um nome de arquivo ou URL e o tipo
MIME associado à extensão do arquivo. As conversões são fornecidas do
nome do arquivo para o tipo MIME e da extensão do tipo MIME para o
nome do arquivo; codificações não são suportadas para a última
conversão.

O módulo fornece uma classe e várias funções convenientes. As funções
são a interface normal para este módulo, mas algumas aplicações também
podem estar interessadas na classe.

As funções descritas abaixo fornecem a interface principal para este
módulo. Se o módulo não foi inicializado, eles chamarão "init()" se
confiarem nas informações configuradas por "init()".

mimetypes.guess_type(url, strict=True)

   Adivinha o tipo de arquivo com base em seu nome de arquivo, caminho
   ou URL, fornecido por *url*. A URL pode ser uma string ou um
   *objeto caminho ou similar*.

   O valor de retorno é uma tupla "(type, encoding)" onde o *tipo* é
   "None" se o tipo não puder ser ser adivinhado (sufixo ausente ou
   desconhecido) ou uma string no formato "'type/subtype'", utilizável
   para um cabeçalho MIME *content-type*.

   *encoding* é "None" para nenhuma codificação ou o nome do programa
   usado para codificar (por exemplo **compress** ou **gzip**). A
   codificação é adequada para uso como cabeçalho *Content-Encoding* ,
   **não** como cabeçalho *Content-Transfer-Encoding*. Os mapeamentos
   são orientados por tabela. Os sufixos de codificação diferenciam
   maiúsculas de minúsculas; os sufixos de tipo são testados primeiro
   considerando maiúsculas e minúsculas e depois sem considerar.

   O argumento opcional *strict* é um sinalizador que especifica se a
   lista de tipos MIME conhecidos é limitada apenas aos tipos oficiais
   registrados na IANA. Quando *strict* é "True" (o padrão), apenas os
   tipos IANA são suportados; quando *strict* é "False", alguns tipos
   MIME adicionais não padronizados, mas geralmente usados, também são
   reconhecidos.

   Alterado na versão 3.8: Adicionado suporte para que a URL seja um
   *objeto caminho ou similar*.

mimetypes.guess_all_extensions(type, strict=True)

   Adivinhe as extensões para um arquivo com base em seu tipo MIME,
   fornecido pelo *tipo*. O valor de retorno é uma lista de cadeias
   que fornecem todas as extensões possíveis de nome de arquivo,
   incluindo o ponto ("'.'"). Não é garantido que as extensões tenham
   sido associadas a qualquer fluxo de dados específico, mas seriam
   mapeadas para o tipo MIME *tipo* por "guess_type()".

   O argumento opcional *strict* tem o mesmo significado que usado com
   a função "guess_type()".

mimetypes.guess_extension(type, strict=True)

   Guess the extension for a file based on its MIME type, given by
   *type*. The return value is a string giving a filename extension,
   including the leading dot ("'.'").  The extension is not guaranteed
   to have been associated with any particular data stream, but would
   be mapped to the MIME type *type* by "guess_type()".  If no
   extension can be guessed for *type*, "None" is returned.

   O argumento opcional *strict* tem o mesmo significado que usado com
   a função "guess_type()".

Algumas funções e dados adicionais estão disponíveis para controlar o
comportamento do módulo.

mimetypes.init(files=None)

   Inicializa as estruturas de dados internas.  Se fornecido, *files*
   deverá ser uma sequência de nomes de arquivos que devem ser usados
   para aumentar o mapa de tipos padrão.  Se for omitido, os nomes de
   arquivos a serem usados serão retirados de "knownfiles"; no
   Windows, as configurações atuais do registro são carregadas.  Cada
   arquivo nomeado em *files* ou "knownfiles" tem precedência sobre os
   definidos anteriormente.  É permitido chamar "init()"
   repetidamente.

   Especificar uma lista vazia para *files* impedirá que os padrões do
   sistema sejam carregados: apenas os valores bem conhecidos estarão
   presentes em uma lista interna.

   Se *files* for "None", a estrutura de dados interna será
   completamente reconstruída com seu valor inicial padrão. Essa é uma
   operação estável e produzirá os mesmos resultados quando chamada
   várias vezes.

   Alterado na versão 3.2: Anteriormente, as configurações do registro
   do Windows eram ignoradas.

mimetypes.read_mime_types(filename)

   Carrega o mapa de tipos fornecido no arquivo *filename*, se
   existir. O mapa de tipos é retornado como um dicionário que faz o
   mapeamento de extensões de nome de arquivo, incluindo o ponto
   inicial ("'.'"), para strings no formato "'tipo/subtipo'". Se o
   arquivo *filename* não existir ou não puder ser lido, "None" é
   retornado.

mimetypes.add_type(type, ext, strict=True)

   Adiciona um mapeamento do tipo MIME *type* para a extensão *ext*.
   Quando a extensão já for conhecida, o novo tipo substituirá o
   antigo. Quando o tipo já for conhecido, a extensão será adicionada
   à lista de extensões conhecidas.

   Quando *strict* for "True" (o padrão), o mapeamento será adicionado
   aos tipos MIME oficiais, caso contrário, aos não-padrão.

mimetypes.inited

   Sinalizador indicando se as estruturas de dados globais foram
   inicializadas ou não. Isso é definido para "True" por "init()".

mimetypes.knownfiles

   Lista de nomes de arquivos de mapas de tipos comumente instalados.
   Esses arquivos são normalmente nomeado como "mime.types" e são
   instalados em diferentes locais por diferentes pacote.

mimetypes.suffix_map

   Dicionário mapeando sufixos para sufixos.  Isso é usado para
   permitir o reconhecimento de arquivos codificados para os quais a
   codificação e o tipo são indicados pela mesma extensão. Por
   exemplo, em um arquivo codificado, a extensão ".tgz" é mapeada para
   ".tar.gz" para permitir que a codificação e o tipo sejam
   reconhecidos separadamente.

mimetypes.encodings_map

   Dicionário mapeando extensões de nome de arquivo para os tipos de
   codificação.

mimetypes.types_map

   Dicionário mapeando extensões de nome do arquivo para tipos MIME.

mimetypes.common_types

   Dicionário mapeando extensões de nome de arquivo para tipos MIME
   não padronizados, mas comumente encontrados.

Um exemplo de uso do módulo:

   >>> import mimetypes
   >>> mimetypes.init()
   >>> mimetypes.knownfiles
   ['/etc/mime.types', '/etc/httpd/mime.types', ... ]
   >>> mimetypes.suffix_map['.tgz']
   '.tar.gz'
   >>> mimetypes.encodings_map['.gz']
   'gzip'
   >>> mimetypes.types_map['.tgz']
   'application/x-tar-gz'


Objetos MimeTypes
=================

A classe "MimeTypes" pode ser útil para aplicações que podem querer
mais de um banco de dados do tipo MIME; ela fornece uma interface
semelhante à do módulo "mimetypes".

class mimetypes.MimeTypes(filenames=(), strict=True)

   This class represents a MIME-types database.  By default, it
   provides access to the same database as the rest of this module.
   The initial database is a copy of that provided by the module, and
   may be extended by loading additional "mime.types"-style files into
   the database using the "read()" or "readfp()" methods.  The mapping
   dictionaries may also be cleared before loading additional data if
   the default data is not desired.

   The optional *filenames* parameter can be used to cause additional
   files to be loaded "on top" of the default database.

   suffix_map

      Dictionary mapping suffixes to suffixes.  This is used to allow
      recognition of encoded files for which the encoding and the type
      are indicated by the same extension.  For example, the ".tgz"
      extension is mapped to ".tar.gz" to allow the encoding and type
      to be recognized separately.  This is initially a copy of the
      global "suffix_map" defined in the module.

   encodings_map

      Dictionary mapping filename extensions to encoding types.  This
      is initially a copy of the global "encodings_map" defined in the
      module.

   types_map

      Tuple containing two dictionaries, mapping filename extensions
      to MIME types: the first dictionary is for the non-standards
      types and the second one is for the standard types. They are
      initialized by "common_types" and "types_map".

   types_map_inv

      Tuple containing two dictionaries, mapping MIME types to a list
      of filename extensions: the first dictionary is for the non-
      standards types and the second one is for the standard types.
      They are initialized by "common_types" and "types_map".

   guess_extension(type, strict=True)

      Similar to the "guess_extension()" function, using the tables
      stored as part of the object.

   guess_type(url, strict=True)

      Similar to the "guess_type()" function, using the tables stored
      as part of the object.

   guess_all_extensions(type, strict=True)

      Similar to the "guess_all_extensions()" function, using the
      tables stored as part of the object.

   read(filename, strict=True)

      Load MIME information from a file named *filename*.  This uses
      "readfp()" to parse the file.

      If *strict* is "True", information will be added to list of
      standard types, else to the list of non-standard types.

   readfp(fp, strict=True)

      Carrega informações do tipo MIME de um arquivo aberto *fp*. O
      arquivo precisa estar no formato padrão dos arquivos
      "mime.types".

      If *strict* is "True", information will be added to the list of
      standard types, else to the list of non-standard types.

   read_windows_registry(strict=True)

      Carrega informações do tipo MIME a partir do registro do
      Windows.

      Disponibilidade: Windows.

      If *strict* is "True", information will be added to the list of
      standard types, else to the list of non-standard types.

      Adicionado na versão 3.2.

   add_type(type, ext, strict=True)

      Adiciona um mapeamento do tipo MIME *type* para a extensão
      *ext*. Quando a extensão já for conhecida, o novo tipo
      substituirá o antigo. Quando o tipo já for conhecido, a extensão
      será adicionada à lista de extensões conhecidas.

      Quando *strict* for "True" (o padrão), o mapeamento será
      adicionado aos tipos MIME oficiais, caso contrário, aos não-
      padrão.
