lzma --- Compression using the LZMA algorithm

Ajouté 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.

The interface provided by this module is very similar to that of the bz2 module. Note that LZMAFile and bz2.BZ2File are not thread-safe, 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

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.

The following method and attributes are also provided:

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

mode

'rb' for reading and 'wb' for writing.

Ajouté dans la version 3.13.

name

The lzma file name. Equivalent to the name attribute of the underlying file object.

Ajouté dans la version 3.13.

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.

Attempting to decompress data after the end of stream is reached raises an EOFError. Any data found after the end of the stream is ignored and saved in the unused_data attribute.

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.

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