# `lzma` — Compactação usando o algoritmo LZMA

Novo na versão 3.3.

Código-fonte: Lib/lzma.py

Este módulo fornece classes e funções de conveniência para comprimir e descomprimir dados usando o algoritmo de compressão LZMA. Também está incluída uma interface de arquivo que oferece suporte aos formatos de arquivo `.xz` e legado `.lzma` usados pelo utilitário xz, bem como fluxos brutos comprimidos.

A interface fornecida por este módulo é muito semelhante à do módulo `bz2`. Observe que `LZMAFile` e `bz2.BZ2File` não são seguro para thread, portanto, se você precisar usar uma única instância `LZMAFile` de vários threads, é necessário protegê-la com uma trava.

exception `lzma.``LZMAError`

  Essa exceção é levantada quando ocorre um erro durante a compressão ou descompressão ou durante a inicialização do estado compressor/descompressor.

## Lendo e escrevendo arquivos comprimidos

`lzma.``open`(filename, mode='rb', *, format=None, check=- 1, preset=None, filters=None, encoding=None, errors=None, newline=None)

  Abre um arquivo comprimido com LZMA no modo binário ou texto, retornando um objeto arquivo.

  O argumento filename pode ser um nome de arquivo real (dado como um objeto `str`, `bytes` ou caminho ou similar), neste caso o arquivo nomeado é aberto , ou pode ser um objeto arquivo existente para leitura ou escrita.

  O argumento mode pode ser qualquer um de `"r"`, `"rb"`, `"w"`, `"wb"`, `"x"`, `"xb"`, `"a"` ou `"ab"` para modo binário, ou `"rt"`, `"wt"`, `"xt"` , ou `"at"` para o modo de texto. O padrão é `"rb"`.

  Ao abrir um arquivo para leitura, os argumentos format e filters têm os mesmos significados que em `LZMADecompressor`. Neste caso, os argumentos check e preset não devem ser usados.

  Ao abrir um arquivo para escrita, os argumentos format, check, preset e filters têm os mesmos significados que em `LZMACompressor`.

  Para o modo binário, esta função é equivalente ao construtor `LZMAFile`: `LZMAFile(filename, mode, ...)`. Nesse caso, os argumentos encoding, errors e newline não devem ser fornecidos.

  Para o modo texto, um objeto `LZMAFile` é criado e encapsulado em uma instância `io.TextIOWrapper` com a codificação especificada, comportamento de tratamento de erros e final(is) de linha.

  Alterado na versão 3.4: Adicionado suporte para os modos `"x"`, `"xb"` e `"xt"`.

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

class `lzma.``LZMAFile`(filename=None, mode='r', *, format=None, check=- 1, preset=None, filters=None)

  Abre um arquivo comprimido com LZMA no modo binário.

  Um `LZMAFile` pode envolver um objeto arquivo já aberto, ou operar diretamente em um arquivo nomeado. O argumento filename especifica o objeto arquivo a ser encapsulado ou o nome do arquivo a ser aberto (como um objeto `str`, `bytes` ou objeto caminho ou similar). Ao agrupar um objeto arquivo existente, o arquivo agrupado não será fechado quando o `LZMAFile` for fechado.

  O argumento mode pode ser `"r"` para leitura (padrão), `"w"` para substituição, `"x"` para criação exclusiva ou `"a"` para anexar. Estes podem ser equivalentemente dados como `"rb"`, `"wb"`, `"xb"` e `"ab"` respectivamente.

  Se filename for um objeto arquivo (em vez de um nome de arquivo real), um modo de `"w"` não truncará o arquivo e será equivalente a `"a"`.

  Ao abrir um arquivo para leitura, o arquivo de entrada pode ser a concatenação de vários fluxos comprimidos separados. Estes são decodificados de forma transparente como um único fluxo lógico.

  Ao abrir um arquivo para leitura, os argumentos format e filters têm os mesmos significados que em `LZMADecompressor`. Neste caso, os argumentos check e preset não devem ser usados.

  Ao abrir um arquivo para escrita, os argumentos format, check, preset e filters têm os mesmos significados que em `LZMACompressor`.

  `LZMAFile` oferece suporte a todos os membros especificados por `io.BufferedIOBase`, exceto `detach()` e `truncate()`. Iteração e a instrução `with` são suportadas.

  O seguinte método também é fornecido:

  `peek`(size=- 1)

    Retorna dados armazenados em buffer sem avançar a posição do arquivo. Pelo menos um byte de dados será retornado, a menos que o EOF tenha sido atingido. O número exato de bytes retornados não é especificado (o argumento size é ignorado).

    Nota

    Enquanto chamar `peek()` não altera a posição do arquivo de `LZMAFile`, pode alterar a posição do objeto arquivo subjacente (por exemplo, se o `LZMAFile` foi construído passando um objeto arquivo para nome do arquivo).

  Alterado na versão 3.4: Adicionado suporte para os modos `"x"` e `"xb"`.

  Alterado na versão 3.5: O método `read()` agora aceita um argumento de `None`.

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

## Comprimindo e descomprimindo dados na memória

class `lzma.``LZMACompressor`(format=FORMAT_XZ, check=- 1, preset=None, filters=None)

  Cria um objeto compressão, que pode ser usado para comprimir dados de forma incremental.

  Para uma maneira mais conveniente de comprimir um único bloco de dados, consulte `compress()`.

  O argumento format especifica qual formato de contêiner deve ser usado. Os valores possíveis são:

  - `FORMAT_XZ`: O formato de contêiner `.xz`.

      Este é o formato padrão.

  - `FORMAT_ALONE`: O formato de contêiner legado `.lzma`.

      Este formato é mais limitado que `.xz` – ele não oferece suporte a verificações de integridade ou filtros múltiplos.

  - `FORMAT_RAW`: Um fluxo de dados brutos, que não usa nenhum formato de contêiner.

      Esse especificador de formato não oferece suporte a verificações de integridade e exige que você sempre especifique uma cadeia de filtros personalizada (para compressão e descompressão). Além disso, dados comprimidos dessa maneira não podem ser descomprimidos usando `FORMAT_AUTO` (veja `LZMADecompressor`).

  O argumento check especifica o tipo de verificação de integridade a ser incluída nos dados comprimidos. Essa verificação é usada ao descomprimir, para garantir que os dados não foram corrompidos. Os valores possíveis são:

  - `CHECK_NONE`: Sem verificação de integridade. Este é o padrão (e o único valor aceitável) para `FORMAT_ALONE` e `FORMAT_RAW`.

  - `CHECK_CRC32`: Verificação de redundância cíclica de 32 bits.

  - `CHECK_CRC64`: Verificação de redundância cíclica de 64 bits. Este é o padrão para `FORMAT_XZ`.

  - `CHECK_SHA256`: Algoritmo de hash seguro de 256 bits.

  Se a verificação especificada não for suportada, uma exceção `LZMAError` será levantada.

  As configurações de compressão podem ser especificadas como um nível de compressão predefinido (com o argumento preset) ou em detalhes como uma cadeia de filtros personalizada (com o argumento filters).

  O argumento preset (se fornecido) deve ser um inteiro entre `0` e `9` (inclusive), opcionalmente com OR com a constante `PRESET_EXTREME`. Se nem preset nem filters forem fornecidos, o comportamento padrão é usar `PRESET_DEFAULT` (nível predefinido `6`). Predefinições mais altas produzem uma saída menor, mas tornam o processo de compressão mais lento.

  Nota

  Além de consumir mais CPU, a compressão com predefinições mais altas também requer muito mais memória (e produz uma saída que precisa de mais memória para descompressão). Com a predefinição `9` por exemplo, a sobrecarga para um objeto `LZMACompressor` pode chegar a 800 MiB. Por esse motivo, geralmente é melhor ficar com a predefinição padrão.

  O argumento filters (se fornecido) deve ser um especificador de cadeia de filtros. Veja Especificando cadeias de filtros personalizadas para detalhes.

  `compress`(data)

    Comprime data (um objeto `bytes`), retornando um objeto `bytes` contendo dados comprimidos para pelo menos parte da entrada. Alguns dos data podem ser armazenados internamente, para uso em chamadas posteriores para `compress()` e `flush()`. Os dados retornados devem ser concatenados com a saída de quaisquer chamadas anteriores para `compress()`.

  `flush`()

    Conclui o processo de compressão, retornando um objeto `bytes` contendo todos os dados armazenados nos buffers internos do compressor.

    O compressor não pode ser usado após a chamada deste método.

class `lzma.``LZMADecompressor`(format=FORMAT_AUTO, memlimit=None, filters=None)

  Cria um objeto descompressor, que pode ser usado para descomprimir dados de forma incremental.

  Para uma maneira mais conveniente de descomprimir um fluxo comprimido inteiro de uma só vez, consulte `decompress()`.

  O argumento format especifica o formato do contêiner que deve ser usado. O padrão é `FORMAT_AUTO`, que pode descomprimir os arquivos `.xz` e `.lzma`. Outros valores possíveis são `FORMAT_XZ`, `FORMAT_ALONE` e `FORMAT_RAW`.

  O argumento memlimit especifica um limite (em bytes) na quantidade de memória que o descompressor pode usar. Quando esse argumento é usado, a descompressão falhará com um `LZMAError` se não for possível descomprimir a entrada dentro do limite de memória fornecido.

  O argumento filters especifica a cadeia de filtros que foi usada para criar o fluxo que está sendo descomprimido. Este argumento é necessário se format for `FORMAT_RAW`, mas não deve ser usado para outros formatos. Veja Especificando cadeias de filtros personalizadas para mais informações sobre cadeias de filtros.

  Nota

  Esta classe não manipula de forma transparente entradas contendo múltiplos fluxos comprimidos, diferentemente de `decompress()` e `LZMAFile`. Para descomprimir uma entrada multi-fluxo com `LZMADecompressor`, você deve criar um novo descompactador para cada fluxo.

  `decompress`(data, max_length=- 1)

    Descomprime dados data (um objeto bytes ou similar), retornando dados não comprimidos como bytes. Alguns dos data podem ser armazenados em buffer internamente, para uso em chamadas posteriores para `decompress()`. Os dados retornados devem ser concatenados com a saída de qualquer chamada anterior para `decompress()`.

    Se max_length for não negativo, retornará no máximo max_length bytes de dados descomprimidos. Se este limite for atingido e mais saída puder ser produzida, o atributo `needs_input` será definido como `False`. Neste caso, a próxima chamada para `decompress()` pode fornecer data como `b''` para obter mais saída.

    Se todos os dados de entrada foram descomprimidos e retornados (seja porque era menor que max_length bytes, ou porque max_length era negativo), o atributo `needs_input` será definido como `True` .

    A tentativa de descomprimir os dados após o final do fluxo ser atingido gera um `EOFError`. Quaisquer dados encontrados após o final do fluxo são ignorados e salvos no atributo `unused_data`.

    Alterado na versão 3.5: Adicionado o parâmetro max_length.

  `check`

    O ID da verificação de integridade usada pelo fluxo de entrada. Pode ser `CHECK_UNKNOWN` até que o suficiente da entrada tenha sido decodificado para determinar qual verificação de integridade ela usa.

  `eof`

    `True` se o marcador de fim de fluxo foi atingido.

  `unused_data`

    Dados encontrados após o término do fluxo comprimido.

    Antes do final do fluxo ser alcançado, isso será `b""`.

  `needs_input`

    `False` se o método `decompress()` puder fornecer mais dados descomprimidos antes de exigir uma nova entrada não comprimida.

    Novo na versão 3.5.

`lzma.``compress`(data, format=FORMAT_XZ, check=- 1, preset=None, filters=None)

  Comprime data (um objeto `bytes`), retornando os dados comprimidos como um objeto `bytes`.

  Veja `LZMACompressor` acima para uma descrição dos argumentos format, check, preset e filters.

`lzma.``decompress`(data, format=FORMAT_AUTO, memlimit=None, filters=None)

  Descomprime data (um objeto `bytes`), retornando os dados não comprimidos como um objeto `bytes`.

  Se data forem a concatenação de vários fluxos comprimidos distintos, descomprime todos esses fluxos e retorna a concatenação dos resultados.

  Veja `LZMADecompressor` acima para uma descrição dos argumentos format, memlimit e filters.

## Diversos

`lzma.``is_check_supported`(check)

  Retorna `True` se a verificação de integridade fornecida for suportada neste sistema.

  `CHECK_NONE` e `CHECK_CRC32` são sempre suportados. `CHECK_CRC64` e `CHECK_SHA256` podem não estar disponíveis se você estiver usando uma versão do liblzma que foi compilada com um conjunto de recursos limitado.

## Especificando cadeias de filtros personalizadas

Um especificador de cadeia de filtros é uma sequência de dicionários, onde cada dicionário contém o ID e as opções para um único filtro. Cada dicionário deve conter a chave `"id"` e pode conter chaves adicionais para especificar opções dependentes do filtro. Os IDs de filtro válidos são os seguintes:

- Filtro Compression:

    - `FILTER_LZMA1` (para ser usado com `FORMAT_ALONE`)

    - `FILTER_LZMA2` (para ser utilizado com `FORMAT_XZ` and `FORMAT_RAW`)

- Filtro delta:

    - `FILTER_DELTA`

- Filtros Branch-Call-Jump (BCJ):

    - `FILTER_X86`

    - `FILTER_IA64`

    - `FILTER_ARM`

    - `FILTER_ARMTHUMB`

    - `FILTER_POWERPC`

    - `FILTER_SPARC`

Uma cadeia de filtros pode consistir em até 4 filtros e não pode estar vazia. O último filtro na cadeia deve ser um filtro de compressão e quaisquer outros filtros devem ser filtros delta ou BCJ.

Os filtros de compressão suportam as seguintes opções (especificadas como entradas adicionais no dicionário que representa o filtro):

> - `preset`: Uma predefinição de compressão para usar como fonte de valores padrão para opções que não são especificadas explicitamente.

> - `dict_size`: Tamanho do dicionário em bytes. Deve estar entre 4 KiB e 1,5 GiB (inclusive).

> - `lc`: Número de bits de contexto literal.

> - `lp`: Número de bits de posição literal. A soma `lc + lp` deve ser no máximo 4.

> - `pb`: Número de bits de posição; deve ser no máximo 4.

> - `mode`: `MODE_FAST` ou `MODE_NORMAL`.

> - `nice_len`: O que deve ser considerado um “tamanho agradável” para uma correspondência. Deve ser 273 ou menos.

> - `mf`: Qual localizador de correspondências usar – `MF_HC3`, `MF_HC4`, `MF_BT2`, `MF_BT3` ou `MF_BT4`.

> - `depth`: Profundidade máxima de pesquisa usada pelo localizador de correspondências. 0 (padrão) significa selecionar automaticamente com base em outras opções de filtro.

O filtro delta armazena as diferenças entre bytes, produzindo uma entrada mais repetitiva para o compressor em certas circunstâncias. Ele suporta uma opção, `dist`. Isso indica a distância entre bytes a ser subtraída. O padrão é 1, ou seja, pega as diferenças entre bytes adjacentes.

Os filtros BCJ são destinados a serem aplicados ao código de máquina. Eles convertem ramificações relativas, chamadas e saltos no código para usar endereçamento absoluto, com o objetivo de aumentar a redundância que pode ser explorada pelo compressor. Esses filtros suportam uma opção, `start_offset`. Isso especifica o endereço que deve ser mapeado para o início dos dados de entrada. O padrão é 0.

## Exemplos

Lendo em um arquivo comprimido:

    import lzma
    with lzma.open("file.xz") as f:
        file_content = f.read()

Criando um arquivo comprimido:

    import lzma
    data = b"Insert Data Here"
    with lzma.open("file.xz", "w") as f:
        f.write(data)

Comprimindo dados na memória:

    import lzma
    data_in = b"Insert Data Here"
    data_out = lzma.compress(data_in)

Compressão incremental:

    import lzma
    lzc = lzma.LZMACompressor()
    out1 = lzc.compress(b"Some data\n")
    out2 = lzc.compress(b"Another piece of data\n")
    out3 = lzc.compress(b"Even more data\n")
    out4 = lzc.flush()
    # Concatenate all the partial results:
    result = b"".join([out1, out2, out3, out4])

Escrevendo dados comprimidos em um arquivo já aberto:

    import lzma
    with open("file.xz", "wb") as f:
        f.write(b"This data will not be compressed\n")
        with lzma.open(f, "w") as lzf:
            lzf.write(b"This *will* be compressed\n")
        f.write(b"Not compressed\n")

Criando um arquivo comprimido usando uma cadeia de filtros personalizada:

    import lzma
    my_filters = [
        {"id": lzma.FILTER_DELTA, "dist": 5},
        {"id": lzma.FILTER_LZMA2, "preset": 7 | lzma.PRESET_EXTREME},
    ]
    with lzma.open("file.xz", "w", filters=my_filters) as f:
        f.write(b"blah blah blah")