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

   Esta classe representa um banco de dados de tipos MIME. Por padrão,
   ela fornece acesso ao mesmo banco de dados do restante deste
   módulo. O banco de dados inicial é uma cópia daquele fornecido pelo
   módulo e pode ser estendido ao carregar arquivos adicionais no
   formato "mime.types" no banco de dados, usando os métodos "read()"
   ou "readfp()". Os dicionários de mapeamento também podem ser limpos
   antes de carregar dados adicionais, caso os dados padrões não sejam
   desejados.

   O parâmetro opcional *filenames* pode ser usado para carregar
   arquivos adicionais "em cima" do banco de dados padrão.

   suffix_map

      Dicionário mapeando sufixo para sufixo. 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, a extensão ".tgz" é mapeada para ".tar.gz" para
      permitir que a codificação e o tipo sejam reconhecidos
      separadamente.  Inicialmente, isso é uma cópia do "suffix_map"
      global definido no módulo.

   encodings_map

      Dicionário que mapeia extensões de nomes de arquivo para tipos
      de codificação. Inicialmente, é uma cópia do "encodings_map"
      global definido no módulo.

   types_map

      Tupla contendo dois dicionários, mapeando extensões de nomes de
      arquivo para tipos MIME: o primeiro dicionário é para tipos não
      padrão e o segundo, para tipos padrão. Eles são inicializados
      por "common_types" e "types_map".

   types_map_inv

      Tupla contendo dois dicionários, mapeando tipos MIME para uma
      lista de extensões de nomes de arquivo: o primeiro dicionário é
      para os tipos não padrão e o segundo para os tipos padrão. Eles
      são inicializados por "common_types" e "types_map".

   guess_extension(type, strict=True)

      Similar à função "guess_extension()", usando as tabelas
      armazenadas como parte do objeto.

   guess_type(url, strict=True)

      Similar à função "guess_type()", usando as tabelas armazenadas
      como parte do objeto.

   guess_all_extensions(type, strict=True)

      Similar à função "guess_all_extensions()", usando as tabelas
      armazenadas como parte do objeto.

   read(filename, strict=True)

      Carrega as informações do tipo MIME de um arquivo chamado
      *filename*.  Usa "readfp()" para analisar o arquivo.

      Se *strict* for "True", as informações serão adicionadas à lista
      de tipos padrão, caso contrário, à lista de tipos não padrão.

   readfp(fp, strict=True)

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

      Se *strict* for "True", as informações serão adicionadas à lista
      de tipos padrão, caso contrário, à lista de tipos não padrão.

   read_windows_registry(strict=True)

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

      Disponibilidade: Windows.

      Se *strict* for "True", as informações serão adicionadas à lista
      de tipos padrão, caso contrário, à lista de tipos não padrão.

      Novo na versão 3.2.
