# `lzma` — Compression via l'algorithme LZMA

Nouveau dans la version 3.3.

Code source : Lib/lzma.py

Ce module fournit des classes et des fonctions utiles pour compresser et décompresser des données en utilisant l'algorithme de compression LZMA. Ce module inclut aussi aussi une interface prenant en charge les fichiers `.xz` et son format originel `.lzma` utilisés par l'utilitaire xz, ainsi que les flux bruts compressés.

L'interface disponible par ce module ressemble en de nombreux points à celle du module `bz2`. Cependant, notez que la `LZMAFile` n'est pas thread-safe, comme l'est la `bz2.BZ2File`. Donc, si vous souhaitez utiliser une seule instance de `LZMAFile` pour plusieurs fils, il sera alors nécessaire de la protéger avec un verrou (lock).

exception `lzma.``LZMAError`

  Cette exception est levée dès lors qu'une erreur survient pendant la compression ou la décompression, ou pendant l'initialisation de l'état de la compression/décompression.

## Lire et écrire des fichiers compressés

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

  Open an LZMA-compressed file in binary or text mode, returning a file object.

  L'argument nom de fichier peut être soit le nom d'un fichier à créer (donné pour `str`, `bytes` ou un objet path-like), dont le fichier nommé reste ouvert, ou soit un objet fichier existant à lire ou à écrire.

  L'argument mode peut être n'importe quel argument suivant : `"r"`, `"rb"`, `"w"`, `"wb"`, `"x"`, `"xb"`, `"a"` ou `"ab"` pour le mode binaire, ou `"rt"`, `"wt"`, `"xt"`, ou `"at"` pour le mode texte. La valeur par défaut est `"rb"`.

  Quand un fichier est ouvert pour le lire, les arguments format et filters ont les mêmes significations que pour la `LZMADecompressor`. Par conséquent, les arguments check et preset ne devront pas être sollicités.

  Dès ouverture d'un fichier pour l'écriture, les arguments format, check, preset et filters ont le même sens que dans la `LZMACompressor`.

  Pour le mode binaire, cette fonction équivaut au constructeur de la `LZMAFile` : `LZMAFile(filename, mode, ...)`. Dans ce cas précis, les arguments encoding, errors et newline ne sont pas accessibles.

  For text mode, a `LZMAFile` object is created, and wrapped in an `io.TextIOWrapper` instance with the specified encoding, error handling behavior, and line ending(s).

  Modifié dans la version 3.4: Support ajouté pour les modes `"x"`, `"xb"` et `"xt"`.

  Modifié dans la version 3.6: Accepte un path-like object.

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

  Ouvre un fichier LZMA compressé en mode binaire.

  An `LZMAFile` can wrap an already-open file object, or operate directly on a named file. The filename argument specifies either the file object to wrap, or the name of the file to open (as a `str`, `bytes` or path-like object). When wrapping an existing file object, the wrapped file will not be closed when the `LZMAFile` is closed.

  L'argument mode peut être soit `"r"` pour la lecture (défaut), `"w"` pour la ré-écriture, `"x"` pour la création exclusive, ou `"a"` pour l'insertion. Elles peuvent aussi être écrites de la façon suivante : `"rb"`, `"wb"`, `"xb"` et `"ab"` respectivement.

  If filename is a file object (rather than an actual file name), a mode of `"w"` does not truncate the file, and is instead equivalent to `"a"`.

  Dès l'ouverture d'un fichier pour être lu, le fichier d'entrée peut être le résultat d'une concaténation de plusieurs flux distincts et compressés. Ceux-ci sont décodés de manière transparente en un seul flux logique.

  Quand un fichier est ouvert pour le lire, les arguments format et filters ont les mêmes significations que pour la `LZMADecompressor`. Par conséquent, les arguments check et preset ne devront pas être sollicités.

  Dès ouverture d'un fichier pour l'écriture, les arguments format, check, preset et filters ont le même sens que dans la `LZMACompressor`.

  `LZMAFile` supports all the members specified by `io.BufferedIOBase`, except for `detach()` and `truncate()`. Iteration and the `with` statement are supported.

  Les méthodes suivantes sont aussi disponibles :

  `peek`(size=-1)

    Renvoie la donnée en mémoire-tampon sans progression de la position du fichier. Au moins un octet de donnée sera renvoyé, jusqu'à ce que l'EOF soit atteinte. Le nombre exact d'octets renvoyés demeure indéterminé (l'argument taille est ignoré).

    Note

    While calling `peek()` does not change the file position of the `LZMAFile`, it may change the position of the underlying file object (e.g. if the `LZMAFile` was constructed by passing a file object for filename).

  Modifié dans la version 3.4: Added support for the `"x"` and `"xb"` modes.

  Modifié dans la version 3.5: La méthode `read()` accepte maintenant un argument `None`.

  Modifié dans la version 3.6: Accepte un path-like object.

## Compresser et décompresser une donnée en mémoire

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

  Créé un objet compresseur, qui peut être utilisé pour compresser incrémentalement une donnée.

  Pour une façon plus adaptée de compresser un seul extrait de donnée, voir `compress()`.

  L'argument format définit quel format de conteneur sera mis en œuvre. Les valeurs possibles sont :

  - `FORMAT_XZ`: Le format du conteneur `.xz`.

      C'est le format par défaut.

  - `FORMAT_ALONE`: L'ancien format du conteneur `.lzma`.

      Ce format est davantage limité que `.xz` --il ne supporte pas les vérifications d'intégrité ou les filtres multiples.

  - `FORMAT_RAW`: Un flux de données brut, n'utilisant aucun format de conteneur.

      Ce format spécifique ne prend pas en charge les vérifications d'intégrité et exige systématiquement la définition d'une chaîne de filtrage personnalisée (à la fois pour la compression et la décompression). Par ailleurs, les données compressées par ce biais ne peuvent pas être décompressées par l'usage de `FORMAT_AUTO` (voir : `LZMADecompressor`).

  L'argument check détermine le type de vérification d'intégrité à exploiter avec la donnée compressée. Cette vérification est déclenchée lors de la décompression, pour garantir que la donnée n'a pas été corrompue. Les valeurs possibles sont :

  - `CHECK_NONE`: Pas de vérification d'intégrité. C'est la valeur par défaut (et la seule valeur acceptable) pour `FORMAT_ALONE` et `FORMAT_RAW`.

  - `CHECK_CRC32`: Vérification par Redondance Cyclique 32-bit (Cyclic Redundancy Check).

  - `CHECK_CRC64`: Vérification par Redondance Cyclique 64-bit (Cyclic Redundancy Check). Valeur par défaut pour `FORMAT_XZ`.

  - `CHECK_SHA256`: Algorithme de Hachage Sécurisé 256-bit (Secure Hash Algorithm).

  Si le type de vérification n'est pas supporté par le système, une erreur de type `LZMAError` est levée.

  Les réglages de compression peuvent être définis soit comme un pré-réglage de niveau de compression (avec l'argument preset) ; soit de façon détaillée comme une chaîne particulière de filtres (avec l'argument filters).

  L'argument preset (s'il est fourni) doit être un entier compris entre 0` et `9` (inclus), éventuellement relié à OR avec la constante `PRESET_EXTREME`. Si aucun preset ni filters ne ont définis, le comportement par défaut consiste à utiliser la `PRESET_DEFAULT` (niveau par défaut : `6`). Des pré-réglages plus élevés entraîne une sortie plus petite, mais rend le processus de compression plus lent.

  Note

  En plus d'être plus gourmande en CPU, la compression avec des préréglages plus élevés nécessite beaucoup plus de mémoire (et produit des résultats qui nécessitent plus de mémoire pour décompresser). Par exemple, avec le préréglage `9`, l'objet d'une `LZMACompressor` peut dépasser largement les 800 Mo. Pour cette raison, il est généralement préférable de respecter le préréglage par défaut.

  L'argument filters (s'il est défini) doit être un critère de la chaîne de filtrage. Voir Préciser des chaînes de filtre personnalisées pour plus de précisions.

  `compress`(data)

    Une data compressée (un objet `bytes`), renvoie un objet `bytes` contenant une donnée compressée pour au moins une partie de l'entrée. Certaine data peuvent être mise en tampon, pour être utiliser lors de prochains appels par `compress()` et `flush()`. La donnée renvoyée pourra être concaténée avec la sortie d'appels précédents vers la méthode `compress()`.

  `flush`()

    Conclut l'opération de compression, en renvoyant l'objet `bytes` constitué de toutes les données stockées dans les tampons interne du compresseur.

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

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

  Créé un objet de décompression, pour décompresser de façon incrémentale une donnée.

  Pour un moyen plus pratique de décompresser un flux compressé complet en une seule fois, voir `decompress()`.

  L'argument format spécifie le format du conteneur à utiliser. La valeur par défaut est `FORMAT_AUTO` pouvant à la fois décompresser les fichiers `.xz` et `.lzma`. D'autres valeurs sont possibles comme `FORMAT_XZ`, `FORMAT_ALONE`, et `FORMAT_RAW`.

  L'argument memlimit spécifie une limite (en octets) sur la quantité de mémoire que le décompresseur peut utiliser. Lorsque cet argument est utilisé, la décompression échouera avec une `LZMAError` s'il n'est pas possible de décompresser l'entrée dans la limite mémoire disponible.

  L'argument filters spécifie la chaîne de filtrage utilisée pour créer le flux décompressé. Cet argument est requis si format est `FORMAT_RAW`, mais ne doit pas être utilisé pour d'autres formats. Voir Préciser des chaînes de filtre personnalisées pour plus d'informations sur les chaînes de filtrage.

  Note

  Cette classe ne gère pas de manière transparente les entrées contenant plusieurs flux compressés, contrairement à `decompress()` et `LZMAFile`. Pour décompresser une entrée multi-flux avec `LZMADecompressor`, vous devez créer un nouveau décompresseur à chaque flux.

  `decompress`(data, max_length=-1)

    Décompresse data (un bytes-like object), renvoyant une donnée non compressée en tant que chaîne d'octets. Certaines de ces data peuvent être mises en interne en tampon, pour un usage lors d'appels ultérieurs par la méthode `decompress()`. La donnée renvoyée doit être concaténée avec la sortie des appels précédents à la méthode `decompress()`.

    Si max_length est positif, renvoie au plus max_length octets de données compressées. Si la limite est atteinte et que d'autres sorties peuvent être produites, l'attribut `needs_input` est positionné sur `False`. Dans ce cas, lors de l'appel suivant à la méthode `decompress()`, vous pouvez fournir `b''` dans data afin d'obtenir la suite de la sortie.

    Si toutes les données entrées ont été décompressées et renvoyées (soit parce qu'il y avait moins de max_length octets, ou parce que max_length était négatif), l'attribut `needs_input` sera configuré sur `True`.

    Essayer de décompresser des données après que la fin du flux soit atteinte lève une erreur EOFError. Toute donnée trouvée après la fin du flux est ignorée et sauvegardée dans l'attribut `unused_data`.

    Modifié dans la version 3.5: Ajout du paramètre max_length.

  `check`

    L'ID de la vérification d'intégrité exploité par le flux entrant. Il s'agit de `CHECK_UNKNOWN` tant que ce flux a été décodé pour déterminer quel type de vérification d'intégrité à été utilisé.

  `eof`

    `True` si le marqueur de fin de flux a été atteint.

  `unused_data`

    Donnée trouvée après la fin du flux compressé.

    Avant d'atteindre la fin du flux, ce sera `b""`.

  `needs_input`

    `False` si la méthode `decompress()` peut fournir plus de données décompressées avant l'acquisition d'une nouvelle entrée non compressée.

    Nouveau dans la version 3.5.

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

  data compressée (un objet `bytes`), renvoyant une donnée compressée comme un objet `bytes`.

  Voir `LZMACompressor` ci-dessus pour une description des arguments format, check, preset et filters.

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

  Décompresse data (un objet `bytes` ), et retourne la donnée décompressée sous la forme d'un objet `bytes`.

  Si data est le résultat de la concaténation de plusieurs flux compressés et distincts , il les décompresse tous, et retourne les résultats concaténés.

  Voir `LZMADecompressor` ci-dessus pour une description des arguments format, memlimit et filters.

## Divers

`lzma.``is_check_supported`(check)

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

  `CHECK_NONE` et `CHECK_CRC32` sont toujours pris en charge. `CHECK_CRC64` et `CHECK_SHA256` peuvent être indisponibles si vous utilisez une version de liblzma compilée avec des possibilités restreintes.

## Préciser des chaînes de filtre personnalisées

Une chaîne de filtres est une séquence de dictionnaires, où chaque dictionnaire contient l'ID et les options pour chaque filtre. Le moindre dictionnaire contient la clé `"id"` et peut aussi contenir d'autres clés pour préciser chaque options relative au filtre déclaré. Les ID valides des filtres sont définies comme suit :

- Filtres de compression:

    - `FILTER_LZMA1` (à utiliser avec `FORMAT_ALONE`)

    - `FILTER_LZMA2` (à utiliser avec `FORMAT_XZ` et `FORMAT_RAW`)

- Filtre Delta:

    - `FILTER_DELTA`

- Filtres Branch-Call-Jump (BCJ):

    - `FILTER_X86`

    - `FILTER_IA64`

    - `FILTER_ARM`

    - `FILTER_ARMTHUMB`

    - `FILTER_POWERPC`

    - `FILTER_SPARC`

Une chaîne de filtres peut contenir jusqu'à 4 filtres, et ne peut pas être vide. Le dernier filtre de cette chaîne devra être un filtre de compression, et tous les autres doivent être des filtres delta ou BCJ.

Les filtres de compression contiennent les options suivantes (définies comme entrées additionnelles dans le dictionnaire qui représente le filtre) :

> - `preset`: Un pré-réglage à exploiter comme une source de valeurs par défaut pour les options qui ne sont pas explicitement définies.

> - `dict_size`: La taille du dictionnaire en octets. Comprise entre 4 Ko et 1.5 Go (inclus).

> - `lc`: Nombre de bits dans le contexte littéral.

> - `lp`: Nombre de bits dans la position littérale. La somme `lc + lp` devra être au moins 4.

> - `pb`: Nombre de bits à cette position ; au moins 4.

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

> - `nice_len`: Ce qui devra être pris en compte comme "longueur appréciable" pour une recherche. Il devra être 273 ou moins.

> - `mf`: Quel type d'index de recherche à utiliser -- `MF_HC3`, `MF_HC4`, `MF_BT2`, `MF_BT3`, ou `MF_BT4`.

> - `depth`: Profondeur maximum de la recherche, utilisée par l'index de recherche. 0 (défaut) signifie une sélection automatique basée sur des options de filtres différents.

Le filtre delta stocke les différences entre octets, induisant davantage d'entrées répétitives pour le compresseur, selon les circonstances. Il support une option, `dist`. Ce paramètre définit la distance entre les octets à soustraire. Par défaut : 1, soit la différence entre des octets adjacents.

Les filtres BCJ sont conçus pour être appliqués sur du langage machine. Ils convertissent les branches relatives, les appels et les sauts dans le code à des fins d'adressage strict, dans le but d'augmenter la redondance mise en jeu par le compresseur. Ils ne supportent qu'une seule option : `start_offset`, pour définir l'adresse où sera déclenché le début de la donnée d'entrée. Par défaut : 0.

## Exemples

Lire un fichier compressé:

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

Créer un fichier compressé:

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

Compresser des données en mémoire :

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

Compression incrémentale :

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

Écrire des données compressées dans un fichier préalablement ouvert :

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

Créer un fichier compressé en utilisant une chaîne de filtre personnalisée :

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