# `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.

    Novo na versão 3.2.