# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-08-24 09:01+0200\n"
"PO-Revision-Date: 2020-02-04 09:23+0100\n"
"Last-Translator: Durand <antoine.durand@ynov.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 2.2.4\n"

#: library/zlib.rst:2
msgid ":mod:`zlib` --- Compression compatible with :program:`gzip`"
msgstr ":mod:`zlib` — Compression compatible avec :program:`gzip`"

#: library/zlib.rst:10
#, fuzzy
msgid ""
"For applications that require data compression, the functions in this module "
"allow compression and decompression, using the zlib library. The zlib "
"library has its own home page at https://www.zlib.net.   There are known "
"incompatibilities between the Python module and versions of the zlib library "
"earlier than 1.1.3; 1.1.3 has a `security vulnerability <https://zlib.net/"
"zlib_faq.html#faq33>`_, so we recommend using 1.1.4 or later."
msgstr ""
"Pour des applications nécessitant de compresser des données, les fonctions "
"de ce module permettent la compression et la décompression via la "
"bibliothèque *zlib*. La bibliothèque *zlib* a sa propre page web sur http://"
"www.zlib.net. Il existe des incompatibilités connues entre le module Python "
"et les versions de la bibliothèque *zlib* plus anciennes que la 1.1.3 ; "
"1.1.3 contient des failles de sécurité et nous recommandons d'utiliser "
"plutôt la version 1.14 ou plus récente."

#: library/zlib.rst:17
msgid ""
"zlib's functions have many options and often need to be used in a particular "
"order.  This documentation doesn't attempt to cover all of the permutations; "
"consult the zlib manual at http://www.zlib.net/manual.html for authoritative "
"information."
msgstr ""
"Les fonctions *zlib* recèlent de nombreuses options et il est nécessaire de "
"suivre un ordre précis. Cette documentation n'a pas pour but de couvrir la "
"globalité des possibilités. Aussi, veuillez consulter le manuel *zlib* en "
"ligne sur http://www.zlib.net/manual.html pour compléter davantage son "
"utilisation."

#: library/zlib.rst:22
msgid "For reading and writing ``.gz`` files see the :mod:`gzip` module."
msgstr ""
"Pour lire ou écrire des fichiers ``.gz`` veuillez consulter le module :mod:"
"`gzip`."

#: library/zlib.rst:24
msgid "The available exception and functions in this module are:"
msgstr "Les exceptions et fonctions disponibles dans ce module sont :"

#: library/zlib.rst:29
msgid "Exception raised on compression and decompression errors."
msgstr "Exception levée lors d'erreurs de compression et de décompression."

#: library/zlib.rst:34
msgid ""
"Computes an Adler-32 checksum of *data*.  (An Adler-32 checksum is almost as "
"reliable as a CRC32 but can be computed much more quickly.)  The result is "
"an unsigned 32-bit integer.  If *value* is present, it is used as the "
"starting value of the checksum; otherwise, a default value of 1 is used.  "
"Passing in *value* allows computing a running checksum over the "
"concatenation of several inputs.  The algorithm is not cryptographically "
"strong, and should not be used for authentication or digital signatures.  "
"Since the algorithm is designed for use as a checksum algorithm, it is not "
"suitable for use as a general hash algorithm."
msgstr ""
"Calcule une somme de contrôle Adler-32 de *data* (une somme de contrôle "
"Adler-32 est aussi fiable qu'un CRC32 mais peut être calculée bien plus "
"rapidement). Le résultat produit est un entier non signé de 32-bit. Si "
"*value* est défini, il devient la valeur initiale de la somme de contrôle ; "
"sinon une valeur par défaut de 1 est utilisée. Définir *value* permet de "
"calculer une somme de contrôle continue pendant la concaténation de "
"plusieurs entrées. Cet algorithme n'a aucune garantie cryptographique "
"puissante, et ne doit pas être utilisé ni pour l'authentification, ni pour "
"des signatures numériques. Conçu comme un algorithme de somme de contrôle, "
"il n'est pas adapté pour une utilisation sous forme de clé de hachage "
"générique."

#: library/zlib.rst:44
msgid ""
"Always returns an unsigned value. To generate the same numeric value across "
"all Python versions and platforms, use ``adler32(data) & 0xffffffff``."
msgstr ""
"Renvoie une valeur non-signée. Pour produire la même valeur avec toutes les "
"versions de Python sur différentes plateformes, utilisez ``adler32(data) & "
"0xffffffff``."

#: library/zlib.rst:52
msgid ""
"Compresses the bytes in *data*, returning a bytes object containing "
"compressed data. *level* is an integer from ``0`` to ``9`` or ``-1`` "
"controlling the level of compression; ``1`` (Z_BEST_SPEED) is fastest and "
"produces the least compression, ``9`` (Z_BEST_COMPRESSION) is slowest and "
"produces the most.  ``0`` (Z_NO_COMPRESSION) is no compression. The default "
"value is ``-1`` (Z_DEFAULT_COMPRESSION).  Z_DEFAULT_COMPRESSION represents a "
"default compromise between speed and compression (currently equivalent to "
"level 6). Raises the :exc:`error` exception if any error occurs."
msgstr ""
"Compresse les octets contenus dans *data*, renvoie un objet *bytes* "
"contenant les données compressées. *level* permet d'ajuster le niveau de "
"compression, ce doit être un nombre entier compris entre ``0`` et ``9`` ou "
"``-1`` ; ``1`` étant plus rapide et procède à une compression légère, ``9`` "
"est plus lent mais compresse plus fortement. ``0`` n'effectue aucune "
"compression. La valeur par défaut est ``-1`` (*Z_DEFAULT_COMPRESSION*). "
"*Z_DEFAULT_COMPRESSION* donne une valeur par défaut proposant un équilibre "
"entre vitesse et taux de compression (actuellement équivalente à 6). Si une "
"erreur surgit, l'exception :exc:`error` est levée."

#: library/zlib.rst:60
msgid "*level* can now be used as a keyword parameter."
msgstr "*level* peut maintenant être passé par son nom."

#: library/zlib.rst:66
msgid ""
"Returns a compression object, to be used for compressing data streams that "
"won't fit into memory at once."
msgstr ""
"Renvoie un objet \"compresseur\", à utiliser pour compresser des flux de "
"données qui ne peuvent pas être stockés entièrement en mémoire."

#: library/zlib.rst:69
msgid ""
"*level* is the compression level -- an integer from ``0`` to ``9`` or "
"``-1``. A value of ``1`` (Z_BEST_SPEED) is fastest and produces the least "
"compression, while a value of ``9`` (Z_BEST_COMPRESSION) is slowest and "
"produces the most. ``0`` (Z_NO_COMPRESSION) is no compression.  The default "
"value is ``-1`` (Z_DEFAULT_COMPRESSION). Z_DEFAULT_COMPRESSION represents a "
"default compromise between speed and compression (currently equivalent to "
"level 6)."
msgstr ""
"*level* est le taux de compression -- un entier compris entre ``0`` et ``9`` "
"ou ``-1``. La valeur ``1`` est la plus rapide avec taux de compression "
"minimal, tandis que la valeur ``9`` est la plus lente mais produit une "
"compression maximale. ``0`` ne produit aucune compression. La valeur par "
"défaut est ``-1`` (*Z_DEFAULT_COMPRESSION*). La constante "
"*Z_DEFAULT_COMPRESSION* équivaut à un bon compromis par défaut entre "
"rapidité et bonne compression (valeur équivalente au niveau 6)."

#: library/zlib.rst:76
msgid ""
"*method* is the compression algorithm. Currently, the only supported value "
"is :const:`DEFLATED`."
msgstr ""
"*method* définit l'algorithme de compression. Pour le moment, la seule "
"valeur acceptée est :const:`DEFLATED`."

#: library/zlib.rst:79
msgid ""
"The *wbits* argument controls the size of the history buffer (or the "
"\"window size\") used when compressing data, and whether a header and "
"trailer is included in the output.  It can take several ranges of values, "
"defaulting to ``15`` (MAX_WBITS):"
msgstr ""
"L'argument *wbits* contrôle la taille du tampon d'historique (\"*window size*"
"\") utilisé lors de la compression, et si un en-tête et un bloc final seront "
"inclus. Il accepte plusieurs intervalles de valeurs, et vaut ``15`` "
"(MAX_WBITS) par défaut :"

#: library/zlib.rst:84
msgid ""
"+9 to +15: The base-two logarithm of the window size, which therefore ranges "
"between 512 and 32768.  Larger values produce better compression at the "
"expense of greater memory usage.  The resulting output will include a zlib-"
"specific header and trailer."
msgstr ""
"De +9 à +15 : le logarithme binaire de la taille du tampon, par conséquent "
"compris entre 512 et 32 768. Des valeurs plus grandes produisent de "
"meilleures compressions aux dépens d'une utilisation mémoire plus grande. Le "
"résultat final inclus des en-têtes et des blocs spécifiques à *zlib*."

#: library/zlib.rst:89
msgid ""
"−9 to −15: Uses the absolute value of *wbits* as the window size logarithm, "
"while producing a raw output stream with no header or trailing checksum."
msgstr ""
"De ``-9`` à ``-15`` : utilise la valeur absolue de *wbits* comme logarithme "
"binaire de la taille du tampon, et ne produit pas d'entêtes ni de bloc final."

#: library/zlib.rst:93
msgid ""
"+25 to +31 = 16 + (9 to 15): Uses the low 4 bits of the value as the window "
"size logarithm, while including a basic :program:`gzip` header and trailing "
"checksum in the output."
msgstr ""
"De +25 à +31 = 16 + (9 à 15) : utilise les 4 bits de poids faible comme "
"logarithme binaire de la taille du tampon, tout en incluant un entête :"
"program:`gzip` et une somme de contrôle finale."

#: library/zlib.rst:97
msgid ""
"The *memLevel* argument controls the amount of memory used for the internal "
"compression state. Valid values range from ``1`` to ``9``. Higher values use "
"more memory, but are faster and produce smaller output."
msgstr ""
"L'argument *memLevel* permet d'ajuster la quantité de mémoire utilisée pour "
"stocker l'état interne de la compression. Les valeurs valides sont comprises "
"entre ``1`` et ``9``. Des valeurs plus élevées occupent davantage de "
"mémoire, mais sont plus rapides et produisent des sorties plus compressées."

#: library/zlib.rst:101
msgid ""
"*strategy* is used to tune the compression algorithm. Possible values are :"
"const:`Z_DEFAULT_STRATEGY`, :const:`Z_FILTERED`, :const:`Z_HUFFMAN_ONLY`, :"
"const:`Z_RLE` (zlib 1.2.0.1) and :const:`Z_FIXED` (zlib 1.2.2.2)."
msgstr ""
"*strategy* permet d'ajuster l'algorithme de compression. Les valeurs "
"possibles sont :const:`Z_DEFAULT_STRATEGY`, :const:`Z_FILTERED`, et :const:"
"`Z_HUFFMAN_ONLY`, :const:`Z_RLE` (*zlib* 1.2.0.1) et :const:`Z_FIXED` "
"(*zlib* 1.2.2.2)."

#: library/zlib.rst:105
msgid ""
"*zdict* is a predefined compression dictionary. This is a sequence of bytes "
"(such as a :class:`bytes` object) containing subsequences that are expected "
"to occur frequently in the data that is to be compressed. Those subsequences "
"that are expected to be most common should come at the end of the dictionary."
msgstr ""
"*zdict* est un dictionnaire de compression prédéfini. C'est une séquence "
"d'octets (tel qu'un objet :class:`bytes`) contenant des sous-séquences "
"attendues régulièrement dans les données à compresser. Les sous-séquences "
"les plus fréquentes sont à placer à la fin du dictionnaire."

#: library/zlib.rst:110
msgid "Added the *zdict* parameter and keyword argument support."
msgstr "Ajout du paramètre *zdict*."

#: library/zlib.rst:120
msgid ""
"Computes a CRC (Cyclic Redundancy Check) checksum of *data*. The result is "
"an unsigned 32-bit integer. If *value* is present, it is used as the "
"starting value of the checksum; otherwise, a default value of 0 is used.  "
"Passing in *value* allows computing a running checksum over the "
"concatenation of several inputs.  The algorithm is not cryptographically "
"strong, and should not be used for authentication or digital signatures.  "
"Since the algorithm is designed for use as a checksum algorithm, it is not "
"suitable for use as a general hash algorithm."
msgstr ""
"Calcule la somme de contrôle CRC (*Cyclic Redundancy Check* en anglais) de "
"l'argument *data*. Il renvoie un entier non signé de 32 bits. Si l'argument "
"*value* est présent, il permet de définir la valeur de départ de la somme de "
"contrôle. Sinon, la valeur par défaut est 0. L'argument *value* permet de "
"calculer la somme de contrôle glissante d'une concaténation de données. "
"L'algorithme n'est pas fort d'un point de vue cryptographique, et ne doit "
"pas être utilisé pour l'authentification ou des signatures numériques. Cet "
"algorithme a été conçu pour être exploité comme un algorithme de somme de "
"contrôle, ce n'est pas un algorithme de hachage générique."

#: library/zlib.rst:129
msgid ""
"Always returns an unsigned value. To generate the same numeric value across "
"all Python versions and platforms, use ``crc32(data) & 0xffffffff``."
msgstr ""
"Renvoie une valeur non-signée. Pour obtenir la même valeur sur n'importe "
"quelle version de Python et n'importe quelle plateforme, utilisez "
"``crc32(data) & 0xffffffff``."

#: library/zlib.rst:137
msgid ""
"Decompresses the bytes in *data*, returning a bytes object containing the "
"uncompressed data.  The *wbits* parameter depends on the format of *data*, "
"and is discussed further below. If *bufsize* is given, it is used as the "
"initial size of the output buffer.  Raises the :exc:`error` exception if any "
"error occurs."
msgstr ""
"Décompresse les octets de *data*, renvoyant un objet *bytes* contenant les "
"données décompressées. Le paramètre *wbits* dépend du format des données "
"compressées, et est abordé plus loin. Si l'argument *bufsize* est défini, il "
"est utilisé comme taille initiale du tampon de sortie. En cas d'erreur, "
"l'exception :exc:`error` est levée."

#: library/zlib.rst:145
msgid ""
"The *wbits* parameter controls the size of the history buffer (or \"window "
"size\"), and what header and trailer format is expected. It is similar to "
"the parameter for :func:`compressobj`, but accepts more ranges of values:"
msgstr ""
"L'argument *wbits* contrôle la taille du tampon d'historique (\"*window size*"
"\") utilisé lors de la compression, et si un en-tête et un bloc final sont "
"attendus. Similaire au paramètre de :func:`compressobj`, mais accepte une "
"gamme plus large de valeurs :"

#: library/zlib.rst:150
msgid ""
"+8 to +15: The base-two logarithm of the window size.  The input must "
"include a zlib header and trailer."
msgstr ""
"De +8 à +15 : logarithme binaire pour la taille du tampon. L'entrée doit "
"contenir un en-tête et un bloc *zlib*."

#: library/zlib.rst:153
msgid ""
"0: Automatically determine the window size from the zlib header. Only "
"supported since zlib 1.2.3.5."
msgstr ""
"0 : détermine automatiquement la taille du tampon à partir de l'en-tête "
"*zlib*. Géré uniquement depuis *zlib* 1.2.3.5."

#: library/zlib.rst:156
msgid ""
"−8 to −15: Uses the absolute value of *wbits* as the window size logarithm.  "
"The input must be a raw stream with no header or trailer."
msgstr ""
"De ``-8`` à ``-15`` : utilise la valeur absolue de *wbits* comme logarithme "
"binaire pour la taille du tampon. L'entrée doit être un flux brut, sans en-"
"tête ni bloc final."

#: library/zlib.rst:159
msgid ""
"+24 to +31 = 16 + (8 to 15): Uses the low 4 bits of the value as the window "
"size logarithm.  The input must include a gzip header and trailer."
msgstr ""
"De +24 à +31 = 16 + (8 à 15) : utilise les 4 de poids faible comme "
"logarithme binaire pour la taille du tampon. L'entrée doit contenir un en-"
"tête *gzip* et son bloc final."

#: library/zlib.rst:163
msgid ""
"+40 to +47 = 32 + (8 to 15): Uses the low 4 bits of the value as the window "
"size logarithm, and automatically accepts either the zlib or gzip format."
msgstr ""
"De +40 à +47 = 32 + (8 à 15) : utilise les 4 bits de poids faible comme "
"logarithme binaire pour la taille du tampon, et accepte automatiquement les "
"formats *zlib* ou *gzip*."

#: library/zlib.rst:167
msgid ""
"When decompressing a stream, the window size must not be smaller than the "
"size originally used to compress the stream; using a too-small value may "
"result in an :exc:`error` exception. The default *wbits* value corresponds "
"to the largest window size and requires a zlib header and trailer to be "
"included."
msgstr ""
"Lors de la décompression d'un flux, la taille du tampon ne doit pas être "
"inférieure à la taille initialement utilisée pour compresser le flux. "
"L'utilisation d'une valeur trop petite peut déclencher une exception :exc:"
"`error`. La valeur par défaut *wbits* correspond à une taille élevée du "
"tampon et nécessite d'y adjoindre un en-tête *zlib* et son bloc final."

#: library/zlib.rst:173
msgid ""
"*bufsize* is the initial size of the buffer used to hold decompressed data.  "
"If more space is required, the buffer size will be increased as needed, so "
"you don't have to get this value exactly right; tuning it will only save a "
"few calls to :c:func:`malloc`."
msgstr ""
"L'argument *bufsize* correspond à la taille initiale du tampon utilisé pour "
"contenir les données décompressées. Si plus d'espace est nécessaire, la "
"taille du tampon sera augmentée au besoin, donc vous n'avez pas besoin de "
"deviner la valeur exacte. Un réglage précis n'économisera que quelques "
"appels à :c:func:`malloc`."

#: library/zlib.rst:178
msgid "*wbits* and *bufsize* can be used as keyword arguments."
msgstr "*wbits* et *bufsize* peuvent être utilisés comme arguments nommés."

#: library/zlib.rst:183
msgid ""
"Returns a decompression object, to be used for decompressing data streams "
"that won't fit into memory at once."
msgstr ""
"Renvoie un objet \"décompresseur\", à utiliser pour décompresser des flux de "
"données qui ne rentrent pas entièrement en mémoire."

#: library/zlib.rst:186
msgid ""
"The *wbits* parameter controls the size of the history buffer (or the "
"\"window size\"), and what header and trailer format is expected.  It has "
"the same meaning as `described for decompress() <#decompress-wbits>`__."
msgstr ""
"Le paramètre *wbits* contrôle la taille du tampon, et détermine quel format "
"d'en-tête et de bloc sont prévus. Il a la même signification que décrit pour "
"`decompress() <#decompress-wbits>`__."

#: library/zlib.rst:190
msgid ""
"The *zdict* parameter specifies a predefined compression dictionary. If "
"provided, this must be the same dictionary as was used by the compressor "
"that produced the data that is to be decompressed."
msgstr ""
"Le paramètre *zdict* définit un dictionnaire de compression prédéfini. S'il "
"est fourni, il doit être identique au dictionnaire utilisé par le "
"compresseur, à l'origine des données à décompresser."

#: library/zlib.rst:196
msgid ""
"If *zdict* is a mutable object (such as a :class:`bytearray`), you must not "
"modify its contents between the call to :func:`decompressobj` and the first "
"call to the decompressor's ``decompress()`` method."
msgstr ""
"Si *zdict* est un objet modifiable (tel qu'un :class:`bytearray`, par "
"exemple), vous ne devez pas modifier son contenu entre l'appel à la "
"fonction :func:`decompressobj` et le premier appel à la méthode "
"``decompress()`` du décompresseur."

#: library/zlib.rst:200
msgid "Added the *zdict* parameter."
msgstr "Ajout du paramètre *zdict*."

#: library/zlib.rst:204
msgid "Compression objects support the following methods:"
msgstr "Les objets de compression gèrent les méthodes suivantes :"

#: library/zlib.rst:209
msgid ""
"Compress *data*, returning a bytes object containing compressed data for at "
"least part of the data in *data*.  This data should be concatenated to the "
"output produced by any preceding calls to the :meth:`compress` method.  Some "
"input may be kept in internal buffers for later processing."
msgstr ""
"Compresse *data* et renvoie au moins une partie des données compressées sous "
"forme d'objet *bytes*. Ces données doivent être concaténées à la suite des "
"appels précédant à :meth:`compress`. Certaines entrées peuvent être "
"conservées dans des tampons internes pour un traitement ultérieur."

#: library/zlib.rst:217
msgid ""
"All pending input is processed, and a bytes object containing the remaining "
"compressed output is returned.  *mode* can be selected from the constants :"
"const:`Z_NO_FLUSH`, :const:`Z_PARTIAL_FLUSH`, :const:`Z_SYNC_FLUSH`, :const:"
"`Z_FULL_FLUSH`, :const:`Z_BLOCK` (zlib 1.2.3.4), or :const:`Z_FINISH`, "
"defaulting to :const:`Z_FINISH`.  Except :const:`Z_FINISH`, all constants "
"allow compressing further bytestrings of data, while :const:`Z_FINISH` "
"finishes the compressed stream and prevents compressing any more data.  "
"After calling :meth:`flush` with *mode* set to :const:`Z_FINISH`, the :meth:"
"`compress` method cannot be called again; the only realistic action is to "
"delete the object."
msgstr ""
"Toutes les entrées mises en attente sont traitées et un objet *bytes* "
"contenant la sortie des données compressées restantes est renvoyé. "
"L'argument *mode* accepte l'une des constantes suivantes : :const:"
"`Z_NO_FLUSH`, :const:`Z_PARTIAL_FLUSH`, :const:`Z_SYNC_FLUSH`, :const:"
"`Z_FULL_FLUSH`, :const:`Z_BLOCK` (*zlib* 1.2.3.4), et :const:`Z_FINISH`, par "
"défaut :const:`Z_FINISH`. Sauf :const:`Z_FINISH`, toutes les constantes "
"permettent de compresser d'autres chaînes d'octets, tandis que :const:"
"`Z_FINISH` finalise le flux compressé et bloque toute autre tentative de "
"compression. Suite à l'appel de la méthode :meth:`flush` avec l'argument "
"*mode* défini à :const:`Z_FINISH`, la méthode :meth:`compress` ne peut plus "
"être rappelée. Il ne reste plus qu'à supprimer l'objet."

#: library/zlib.rst:230
msgid ""
"Returns a copy of the compression object.  This can be used to efficiently "
"compress a set of data that share a common initial prefix."
msgstr ""
"Renvoie une copie de l'objet \"compresseur\". Utile pour compresser "
"efficacement un ensemble de données qui partagent un préfixe initial commun."

#: library/zlib.rst:234
msgid ""
"Added :func:`copy.copy` and :func:`copy.deepcopy` support to compression "
"objects."
msgstr ""
"Les objets compresseurs gère maintenant :func:`copy.copy` et :func:`copy."
"deepcopy`."

#: library/zlib.rst:239
msgid "Decompression objects support the following methods and attributes:"
msgstr ""
"Les objets décompresseurs prennent en charge les méthodes et attributs "
"suivants :"

#: library/zlib.rst:244
msgid ""
"A bytes object which contains any bytes past the end of the compressed data. "
"That is, this remains ``b\"\"`` until the last byte that contains "
"compression data is available.  If the whole bytestring turned out to "
"contain compressed data, this is ``b\"\"``, an empty bytes object."
msgstr ""
"Un objet *bytes* contenant tous les octets restants après les données "
"compressées. Il vaut donc ``b\"\"`` tant que des données compressées sont "
"disponibles. Si toute la chaîne d'octets ne contient que des données "
"compressées, il vaut toujours ``b\"\"``, un objet *bytes* vide."

#: library/zlib.rst:252
msgid ""
"A bytes object that contains any data that was not consumed by the last :"
"meth:`decompress` call because it exceeded the limit for the uncompressed "
"data buffer.  This data has not yet been seen by the zlib machinery, so you "
"must feed it (possibly with further data concatenated to it) back to a "
"subsequent :meth:`decompress` method call in order to get correct output."
msgstr ""
"Un objet *bytes* contenant toutes les données non-traitées par le dernier "
"appel à la méthode :meth:`decompress`, à cause d'un dépassement de la limite "
"du tampon de données décompressées. Ces données n'ont pas encore été "
"traitées par la bibliothèque *zlib*, vous devez donc les envoyer "
"(potentiellement en y concaténant encore des données) par un appel à la "
"méthode :meth:`decompress` pour obtenir une sortie correcte."

#: library/zlib.rst:261
msgid ""
"A boolean indicating whether the end of the compressed data stream has been "
"reached."
msgstr "Booléen qui signale si la fin du flux compressé est atteint."

#: library/zlib.rst:264
msgid ""
"This makes it possible to distinguish between a properly-formed compressed "
"stream, and an incomplete or truncated one."
msgstr ""
"Ceci rend possible la distinction entre un flux correctement compressé et un "
"flux incomplet."

#: library/zlib.rst:272
msgid ""
"Decompress *data*, returning a bytes object containing the uncompressed data "
"corresponding to at least part of the data in *string*.  This data should be "
"concatenated to the output produced by any preceding calls to the :meth:"
"`decompress` method.  Some of the input data may be preserved in internal "
"buffers for later processing."
msgstr ""
"Décompresse *data*, renvoie un objet *bytes*, contenant au moins une partie "
"des données décompressées. Ce résultat doit être concaténé aux résultats des "
"appels précédents à :meth:`decompress`. Des données d'entrée peuvent être "
"conservées dans les tampons internes pour un traitement ultérieur."

#: library/zlib.rst:278
msgid ""
"If the optional parameter *max_length* is non-zero then the return value "
"will be no longer than *max_length*. This may mean that not all of the "
"compressed input can be processed; and unconsumed data will be stored in the "
"attribute :attr:`unconsumed_tail`. This bytestring must be passed to a "
"subsequent call to :meth:`decompress` if decompression is to continue.  If "
"*max_length* is zero then the whole input is decompressed, and :attr:"
"`unconsumed_tail` is empty."
msgstr ""
"Si le paramètre optionnel *max_length* est différent de zéro alors la valeur "
"renvoyée n'est pas plus grande que *max_length*. Cela peut amener à une "
"décompression partielle. Les données non-encore décompressées sont stockées "
"dans l'attribut :attr:`unconsumed_tail`. Cette chaîne d'octets doit être "
"transmise à un appel ultérieur à :meth:`decompress`. Si *max_length* vaut "
"zéro, la totalité de l'entrée est décompressée, et l'attribut :attr:"
"`unconsumed_tail` reste vide."

#: library/zlib.rst:285
msgid "*max_length* can be used as a keyword argument."
msgstr "*max_length* peut être utilisé comme un argument nommé."

#: library/zlib.rst:291
msgid ""
"All pending input is processed, and a bytes object containing the remaining "
"uncompressed output is returned.  After calling :meth:`flush`, the :meth:"
"`decompress` method cannot be called again; the only realistic action is to "
"delete the object."
msgstr ""
"Toutes les entrées en attente sont traitées, et un objet *bytes* est "
"renvoyé, contenant le reste des données à décompresser. Après l'appel à :"
"meth:`flush`, la méthode :meth:`decompress` ne peut pas être rappelée. Il ne "
"reste qu'à détruire l'objet."

#: library/zlib.rst:296
msgid ""
"The optional parameter *length* sets the initial size of the output buffer."
msgstr ""
"Le paramètre optionnel *length* définit la taille initiale du tampon de "
"sortie."

#: library/zlib.rst:301
msgid ""
"Returns a copy of the decompression object.  This can be used to save the "
"state of the decompressor midway through the data stream in order to speed "
"up random seeks into the stream at a future point."
msgstr ""
"Renvoie une copie du décompresseur. Vous pouvez l'utiliser pour sauvegarder "
"l'état de la décompression en cours, afin de pouvoir revenir rapidement à "
"cet endroit plus tard."

#: library/zlib.rst:306
msgid ""
"Added :func:`copy.copy` and :func:`copy.deepcopy` support to decompression "
"objects."
msgstr ""
"Ajout de :func:`copy.copy` et de :func:`copy."
"deepcopy` au support de décompression d'objets."

#: library/zlib.rst:311
msgid ""
"Information about the version of the zlib library in use is available "
"through the following constants:"
msgstr ""
"Des informations relatives à la version de la bibliothèque *zlib* utilisée "
"sont disponibles via les constantes suivantes :"

#: library/zlib.rst:317
msgid ""
"The version string of the zlib library that was used for building the "
"module. This may be different from the zlib library actually used at "
"runtime, which is available as :const:`ZLIB_RUNTIME_VERSION`."
msgstr ""
"Version de la bibliothèque *zlib* utilisée lors de la compilation du module. "
"Elle peut être différente de la bibliothèque *zlib* actuellement utilisée "
"par le système, qui est consultable par :const:`ZLIB_RUNTIME_VERSION`."

#: library/zlib.rst:324
msgid ""
"The version string of the zlib library actually loaded by the interpreter."
msgstr ""
"Chaîne contenant la version de la bibliothèque *zlib* actuellement utilisée "
"par l'interpréteur."

#: library/zlib.rst:332
msgid "Module :mod:`gzip`"
msgstr "Module :mod:`gzip`"

#: library/zlib.rst:332
msgid "Reading and writing :program:`gzip`\\ -format files."
msgstr "Lire et écrire des fichiers au format :program:`gzip`."

#: library/zlib.rst:335
msgid "http://www.zlib.net"
msgstr "http://www.zlib.net"

#: library/zlib.rst:335
msgid "The zlib library home page."
msgstr "Page officielle de la bibliothèque *zlib*."

#: library/zlib.rst:338
msgid "http://www.zlib.net/manual.html"
msgstr "http://www.zlib.net/manual.html"

#: library/zlib.rst:338
msgid ""
"The zlib manual explains  the semantics and usage of the library's many "
"functions."
msgstr ""
"La documentation de *zlib* explique le sens et l'utilisation des nombreuses "
"fonctions fournies par la bibliothèque."
