"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 compactar e
descompactar dados usando o algoritmo de compactaçã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 compactados.

The interface provided by this module is very similar to that of the
"bz2" module. However, note that "LZMAFile" is *not* thread-safe,
unlike "bz2.BZ2File", so if you need to use a single "LZMAFile"
instance from multiple threads, it is necessary to protect it with a
lock.

exception lzma.LZMAError

   Essa exceção é levantada quando ocorre um erro durante a
   compactação ou descompactação ou durante a inicialização do estado
   compactador/descompactador.


Lendo e escrevendo arquivos compactados
=======================================

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

   Abre um arquivo compactado 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 *path-like object*.

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

   Abre um arquivo compactado 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 *caminho ou
   similar*). Ao agrupar um objeto de 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 compactados 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 método a seguir 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 *path-like object*.


Compactando e descompactando dados na memória
=============================================

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

   Cria um objeto compactador, que pode ser usado para compactar dados
   de forma incremental.

   Para uma maneira mais conveniente de compactar 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
        compactação e descompactação). Além disso, dados compactados
        dessa maneira não podem ser descompactados usando
        "FORMAT_AUTO" (veja "LZMADecompressor").

   O argumento *check* especifica o tipo de verificação de integridade
   a ser incluída nos dados compactados. Essa verificação é usada ao
   descompactar, 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 compactação podem ser especificadas como um
   nível de compactaçã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 compactação mais lento.

   Nota:

     Além de consumir mais CPU, a compactaçã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 descompactar). 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 Specifying custom filter chains para
   detalhes.

   compress(data)

      Compress *data* (a "bytes" object), returning a "bytes" object
      containing compressed data for at least part of the input. Some
      of *data* may be buffered internally, for use in later calls to
      "compress()" and "flush()". The returned data should be
      concatenated with the output of any previous calls to
      "compress()".

   flush()

      Finish the compression process, returning a "bytes" object
      containing any data stored in the compressor's internal buffers.

      The compressor cannot be used after this method has been called.

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

   Create a decompressor object, which can be used to decompress data
   incrementally.

   For a more convenient way of decompressing an entire compressed
   stream at once, see "decompress()".

   The *format* argument specifies the container format that should be
   used. The default is "FORMAT_AUTO", which can decompress both ".xz"
   and ".lzma" files. Other possible values are "FORMAT_XZ",
   "FORMAT_ALONE", and "FORMAT_RAW".

   The *memlimit* argument specifies a limit (in bytes) on the amount
   of memory that the decompressor can use. When this argument is
   used, decompression will fail with an "LZMAError" if it is not
   possible to decompress the input within the given memory limit.

   The *filters* argument specifies the filter chain that was used to
   create the stream being decompressed. This argument is required if
   *format* is "FORMAT_RAW", but should not be used for other formats.
   See Specifying custom filter chains for more information about
   filter chains.

   Nota:

     This class does not transparently handle inputs containing
     multiple compressed streams, unlike "decompress()" and
     "LZMAFile". To decompress a multi-stream input with
     "LZMADecompressor", you must create a new decompressor for each
     stream.

   decompress(data, max_length=-1)

      Descompacta dados *data* (um *objeto bytes ou similar*),
      retornando dados não compactados 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 descompactados. 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 descompactados 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 descompactar 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

      The ID of the integrity check used by the input stream. This may
      be "CHECK_UNKNOWN" until enough of the input has been decoded to
      determine what integrity check it uses.

   eof

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

   unused_data

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

      Before the end of the stream is reached, this will be "b""".

   needs_input

      "False" se o método "decompress()" puder fornecer mais dados
      descompactados antes de exigir uma nova entrada descompactada.

      Novo na versão 3.5.

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

   Compress *data* (a "bytes" object), returning the compressed data
   as a "bytes" object.

   See "LZMACompressor" above for a description of the *format*,
   *check*, *preset* and *filters* arguments.

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

   Decompress *data* (a "bytes" object), returning the uncompressed
   data as a "bytes" object.

   If *data* is the concatenation of multiple distinct compressed
   streams, decompress all of these streams, and return the
   concatenation of the results.

   See "LZMADecompressor" above for a description of the *format*,
   *memlimit* and *filters* arguments.


Diversos
========

lzma.is_check_supported(check)

   Return "True" if the given integrity check is supported on this
   system.

   "CHECK_NONE" and "CHECK_CRC32" are always supported. "CHECK_CRC64"
   and "CHECK_SHA256" may be unavailable if you are using a version of
   **liblzma** that was compiled with a limited feature set.


Specifying custom filter chains
===============================

A filter chain specifier is a sequence of dictionaries, where each
dictionary contains the ID and options for a single filter. Each
dictionary must contain the key ""id"", and may contain additional
keys to specify filter-dependent options. Valid filter IDs are as
follows:

* Filtro Compression:
     * "FILTER_LZMA1" (para ser usado com "FORMAT_ALONE")

     * "FILTER_LZMA2" (para ser utilizado com "FORMAT_XZ" and
       "FORMAT_RAW")

* Delta filter:
     * "FILTER_DELTA"

* Branch-Call-Jump (BCJ) filters:
     * "FILTER_X86"

     * "FILTER_IA64"

     * "FILTER_ARM"

     * "FILTER_ARMTHUMB"

     * "FILTER_POWERPC"

     * "FILTER_SPARC"

A filter chain can consist of up to 4 filters, and cannot be empty.
The last filter in the chain must be a compression filter, and any
other filters must be delta or BCJ filters.

Compression filters support the following options (specified as
additional entries in the dictionary representing the filter):

   * "preset": A compression preset to use as a source of default
     values for options that are not specified explicitly.

   * "dict_size": Dictionary size in bytes. This should be between 4
     KiB and 1.5 GiB (inclusive).

   * "lc": Number of literal context bits.

   * "lp": Number of literal position bits. The sum "lc + lp" must be
     at most 4.

   * "pb": Number of position bits; must be at most 4.

   * "mode": "MODE_FAST" or "MODE_NORMAL".

   * "nice_len": What should be considered a "nice length" for a
     match. This should be 273 or less.

   * "mf": What match finder to use -- "MF_HC3", "MF_HC4", "MF_BT2",
     "MF_BT3", or "MF_BT4".

   * "depth": Maximum search depth used by match finder. 0 (default)
     means to select automatically based on other filter options.

The delta filter stores the differences between bytes, producing more
repetitive input for the compressor in certain circumstances. It
supports one option, "dist". This indicates the distance between bytes
to be subtracted. The default is 1, i.e. take the differences between
adjacent bytes.

The BCJ filters are intended to be applied to machine code. They
convert relative branches, calls and jumps in the code to use absolute
addressing, with the aim of increasing the redundancy that can be
exploited by the compressor. These filters support one option,
"start_offset". This specifies the address that should be mapped to
the beginning of the input data. The default is 0.


Exemplos
========

Reading in a compressed file:

   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)

Compressing data in memory:

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

Writing compressed data to an already-open file:

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

Creating a compressed file using a custom filter chain:

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