"bz2" --- Support for **bzip2** compression
*******************************************

**Code Source :** Lib/bz2.py

======================================================================

Ce module fournit une interface complète pour compresser et
décompresser les données en utilisant l'algorithme de compression
*bzip2*.

Le module "bz2" contient :

* La fonction "open()" et la classe "BZ2File" pour lire et écrire des
  fichiers compressés.

* Les classes "BZ2Compressor" et "BZ2Decompressor" pour la
  (dé)compression incrémentielle.

* Les fonctions "compress()" et "decompress()" pour la (dé)compression
  en une seule fois.


(Dé)compression de fichiers
===========================

bz2.open(filename, mode='rb', compresslevel=9, encoding=None, errors=None, newline=None)

   Ouvre un fichier compressé par *bzip2* en mode binaire ou texte, le
   renvoyant en *file object*.

   Tout comme avec le constructeur pour la classe "BZ2File",
   l'argument *filename* peut être un nom de fichier réel (un objet
   "str" ou "bytes"), ou un objet fichier existant à lire ou à écrire.

   L'argument *mode* peut valoir "'r'", "'rb'", "'w'", "'wb'", "'x'",
   "'xb'", "'a'" ou "'ab'" pour le mode binaire, ou "'rt'", "'wt'",
   "'xt'" ou "'at'" pour le mode texte. Il vaut par défaut "'rb'".

   L'argument *compresslevel* est un entier de 1 à 9, comme pour le
   constructeur "BZ2File".

   Pour le mode binaire, cette fonction est équivalente au
   constructeur "BZ2File" : "BZ2File(filename, mode,
   compresslevel=compresslevel)". Dans ce cas, les arguments
   *encoding*, *errors* et *newline* arguments ne doivent pas être
   fournis.

   Pour le mode texte, un objet "BZ2File" est créé et encapsulé dans
   une instance "io.TextIOWrapper" avec l'encodage spécifié, le
   comportement de gestion des erreurs et les fins de ligne.

   Ajouté dans la version 3.3.

   Modifié dans la version 3.4: Le mode "'x'" (création exclusive) est
   ajouté.

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

class bz2.BZ2File(filename, mode='r', *, compresslevel=9)

   Ouvre un fichier *bzip2* en mode binaire.

   Si *filename* est un objet "str" ou "bytes", ouvre le nom de
   fichier directement. Autrement, *filename* doit être un *file
   object*, qui est utilisé pour lire ou écrire les données
   compressées.

   L'argument *mode* peut être soit "'r'" pour lire (par défaut),
   "'w'" pour écraser, "'x'" pour créer exclusivement, ou "'a'" pour
   ajouter. Ils peuvent également être écrits respectivement comme
   "'rb'", "'wb'", "'xb'" et "'ab'".

   Si *filename* est un objet fichier (plutôt que le nom de fichier
   réel), le mode "'w'" ne tronque pas le fichier, mais équivaut à
   "'a'".

   Si *mode* est "'w'" ou "'a'", *compresslevel* peut être un entier
   entre "1" et "9" spécifiant le niveau de compression : "1" utilise
   la compression la moins forte, et "9" (par défaut) la compression
   la plus forte.

   Si *mode* est "'r'", le fichier d'entrée peut être la concaténation
   de plusieurs flux compressés.

   "BZ2File" provides all of the members specified by the
   "io.BufferedIOBase", except for "detach()" and "truncate()".
   Iteration and the "with" statement are supported.

   "BZ2File" also provides the following methods:

   peek([n])

      Renvoie des données en mémoire tampon sans avancer la position
      du fichier. Au moins un octet de donnée (sauf l'EOF) est
      renvoyé. Le nombre exact d'octets renvoyés n'est pas spécifié.

      Note:

        Bien que l'appel à la méthode "peek()" ne change pas la
        position du fichier de la classe "BZ2File", il peut changer la
        position de l'objet fichier sous-jacent (e.g. si la classe
        "BZ2File" a été construite en passant un objet fichier à
        *filename*).

      Ajouté dans la version 3.3.

   fileno()

      Return the file descriptor for the underlying file.

      Ajouté dans la version 3.3.

   readable()

      Return whether the file was opened for reading.

      Ajouté dans la version 3.3.

   seekable()

      Return whether the file supports seeking.

      Ajouté dans la version 3.3.

   writable()

      Return whether the file was opened for writing.

      Ajouté dans la version 3.3.

   read1(size=-1)

      Read up to *size* uncompressed bytes, while trying to avoid
      making multiple reads from the underlying stream. Reads up to a
      buffer's worth of data if size is negative.

      Returns "b''" if the file is at EOF.

      Ajouté dans la version 3.3.

   readinto(b)

      Read bytes into *b*.

      Returns the number of bytes read (0 for EOF).

      Ajouté dans la version 3.3.

   Modifié dans la version 3.1: La prise en charge de l'instruction
   "with" a été ajoutée.

   Modifié dans la version 3.3: La gestion de *filename* comme *file
   object* au lieu d'un nom de fichier réel a été ajoutée.Le mode
   "'a'" (ajout) a été ajouté, avec la prise en charge de la lecture
   des fichiers *multiflux*.

   Modifié dans la version 3.4: Le mode "'x'" (création exclusive) est
   ajouté.

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

   Modifié dans la version 3.9: Le paramètre *buffering* a été
   supprimé. Il était ignoré et obsolète depuis Python 3.0. Passez un
   objet fichier déjà ouvert si vous voulez contrôler la façon dont le
   fichier est ouvert.Le paramètre *compresslevel* est devenu un
   paramètre exclusivement nommé.

   Modifié dans la version 3.10: Cette classe n'est plus protégée d'un
   accès concurrent malheureux par plusieurs lecteurs ou compresseurs.
   C'était déjà le cas depuis toujours des classes analogues dans les
   modules "gzip" et "lzma".


(Dé)compression incrémentielle
==============================

class bz2.BZ2Compressor(compresslevel=9)

   Crée un nouvel objet compresseur. Cet objet peut être utilisé pour
   compresser les données de manière incrémentielle. Pour une
   compression en une seule fois, utilisez à la place la fonction
   "compress()".

   *compresslevel*, s'il est fourni, doit être un entier entre "1" et
   "9". Sa valeur par défaut est "9".

   compress(data)

      Fournit la donnée à l'objet compresseur. Renvoie un bloc de
      données compressées si possible, ou autrement une chaîne d'octet
      vide.

      Quand vous avez fini de fournir des données au compresseur,
      appelez la méthode "flush()" pour finir le processus de
      compression.

   flush()

      Finit le processus de compression. Renvoie la donnée compressée
      restante dans les tampons internes.

      L'objet compresseur ne peut pas être utilisé après que cette
      méthode a été appelée.

class bz2.BZ2Decompressor

   Crée un nouvel objet décompresseur. Cet objet peut être utilisé
   pour décompresser les données de manière incrémentielle. Pour une
   compression en une seule fois, utilisez à la place la fonction
   "decompress()".

   Note:

     Cette classe ne gère pas de manière transparente les entrées
     contenant plusieurs flux compressés, à la différence de
     "decompress()" et "BZ2File". Si vous avez besoin de décompresser
     une entrée *multiflux* avec la classe "BZ2Decompressor", vous
     devez utiliser un nouveau décompresseur pour 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*.

   eof

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

      Ajouté dans la version 3.3.

   unused_data

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

      Si l'attribut est accédé avant que la fin du flux ait été
      atteint, sa valeur 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.


(Dé)compression en une fois
===========================

bz2.compress(data, compresslevel=9)

   Compresse *data*, un *bytes-like object*.

   *compresslevel*, s'il est fourni, doit être un entier entre "1" et
   "9". Sa valeur par défaut est "9".

   Pour la compression incrémentielle, utilisez à la place la classe
   "BZ2Compressor".

bz2.decompress(data)

   Décompresse *data*, un *bytes-like object*.

   Si *data* est la concaténation de multiples flux compressés,
   décompresse tous les flux.

   Pour une décompression incrémentielle, utilisez à la place la
   classe "BZ2Decompressor".

   Modifié dans la version 3.3: Prise en charge des entrées
   *multiflux*.


Exemples d'utilisation
======================

Ci-dessous, nous présentons quelques exemples typiques de
l'utilisation du module "bz2".

Utilise les fonctions "compress()" et "decompress()" pour démontrer
une compression aller-retour :

>>> import bz2
>>> data = b"""\
... Donec rhoncus quis sapien sit amet molestie. Fusce scelerisque vel augue
... nec ullamcorper. Nam rutrum pretium placerat. Aliquam vel tristique lorem,
... sit amet cursus ante. In interdum laoreet mi, sit amet ultrices purus
... pulvinar a. Nam gravida euismod magna, non varius justo tincidunt feugiat.
... Aliquam pharetra lacus non risus vehicula rutrum. Maecenas aliquam leo
... felis. Pellentesque semper nunc sit amet nibh ullamcorper, ac elementum
... dolor luctus. Curabitur lacinia mi ornare consectetur vestibulum."""
>>> c = bz2.compress(data)
>>> len(data) / len(c)  # Data compression ratio
1.513595166163142
>>> d = bz2.decompress(c)
>>> data == d  # Check equality to original object after round-trip
True

Utilise la classe "BZ2Compressor" pour une compression incrémentielle
:

>>> import bz2
>>> def gen_data(chunks=10, chunksize=1000):
...     """Yield incremental blocks of chunksize bytes."""
...     for _ in range(chunks):
...         yield b"z" * chunksize
...
>>> comp = bz2.BZ2Compressor()
>>> out = b""
>>> for chunk in gen_data():
...     # Provide data to the compressor object
...     out = out + comp.compress(chunk)
...
>>> # Finish the compression process.  Call this once you have
>>> # finished providing data to the compressor.
>>> out = out + comp.flush()

The example above uses a very "nonrandom" stream of data (a stream of
"b"z"" chunks).  Random data tends to compress poorly, while ordered,
repetitive data usually yields a high compression ratio.

Écriture et lecture en mode binaire d'un fichier compressé avec
*bzip2* :

>>> import bz2
>>> data = b"""\
... Donec rhoncus quis sapien sit amet molestie. Fusce scelerisque vel augue
... nec ullamcorper. Nam rutrum pretium placerat. Aliquam vel tristique lorem,
... sit amet cursus ante. In interdum laoreet mi, sit amet ultrices purus
... pulvinar a. Nam gravida euismod magna, non varius justo tincidunt feugiat.
... Aliquam pharetra lacus non risus vehicula rutrum. Maecenas aliquam leo
... felis. Pellentesque semper nunc sit amet nibh ullamcorper, ac elementum
... dolor luctus. Curabitur lacinia mi ornare consectetur vestibulum."""
>>> with bz2.open("myfile.bz2", "wb") as f:
...     # Write compressed data to file
...     unused = f.write(data)
...
>>> with bz2.open("myfile.bz2", "rb") as f:
...     # Decompress data from file
...     content = f.read()
...
>>> content == data  # Check equality to original object after round-trip
True
