# 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: 2023-01-15 22:33+0100\n"
"PO-Revision-Date: 2022-10-18 15:43+0200\n"
"Last-Translator: Julien Palard <julien@palard.fr>\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"
"X-Generator: Poedit 2.0.6\n"

#: library/base64.rst:2
msgid ":mod:`base64` --- Base16, Base32, Base64, Base85 Data Encodings"
msgstr ":mod:`base64` — Encodages base16, base32, base64 et base85"

#: library/base64.rst:8
msgid "**Source code:** :source:`Lib/base64.py`"
msgstr "**Code source :** :source:`Lib/base64.py`"

#: library/base64.rst:16
#, fuzzy
msgid ""
"This module provides functions for encoding binary data to printable ASCII "
"characters and decoding such encodings back to binary data. It provides "
"encoding and decoding functions for the encodings specified in :rfc:`4648`, "
"which defines the Base16, Base32, and Base64 algorithms, and for the de-"
"facto standard Ascii85 and Base85 encodings."
msgstr ""
"Ce module fournit des fonctions permettant de coder des données binaires en "
"caractères ASCII affichables ainsi que de décoder ces caractères vers des "
"données binaires en retour. Il fournit des fonctions d'encodage et de "
"décodage pour les codages spécifiés par la :rfc:`3548` qui définit les "
"algorithmes base16, base32 et base64, ainsi que les encodages standards *de "
"facto* Ascii85 et base85."

#: library/base64.rst:22
#, fuzzy
msgid ""
"The :rfc:`4648` encodings are suitable for encoding binary data so that it "
"can be safely sent by email, used as parts of URLs, or included as part of "
"an HTTP POST request.  The encoding algorithm is not the same as the :"
"program:`uuencode` program."
msgstr ""
"Les encodages définis par la :rfc:`3548` sont adaptés au codage des données "
"binaires pour leur transfert par courriel, comme éléments d'une URL ou d'une "
"requête HTTP POST. L'algorithme d'encodage ne doit pas être confondu avec le "
"programme :program:`uuencode`."

#: library/base64.rst:27
#, fuzzy
msgid ""
"There are two interfaces provided by this module.  The modern interface "
"supports encoding :term:`bytes-like objects <bytes-like object>` to ASCII :"
"class:`bytes`, and decoding :term:`bytes-like objects <bytes-like object>` "
"or strings containing ASCII to :class:`bytes`.  Both base-64 alphabets "
"defined in :rfc:`4648` (normal, and URL- and filesystem-safe) are supported."
msgstr ""
"Ce module présente deux interfaces. L'interface moderne gère l'encodage d':"
"term:`objets octet-compatibles <bytes-like object>` en :class:`bytes` ASCII "
"ainsi que le décodage d':term:`objets octet-compatibles <bytes-like object>` "
"ou de chaînes de caractères contenant de l'ASCII en :class:`bytes`. Les deux "
"alphabets de l'algorithme base64 définis par la :rfc:`3548` (normal et sûr "
"pour les systèmes de fichiers ou URL) sont gérés."

#: library/base64.rst:33
msgid ""
"The legacy interface does not support decoding from strings, but it does "
"provide functions for encoding and decoding to and from :term:`file objects "
"<file object>`.  It only supports the Base64 standard alphabet, and it adds "
"newlines every 76 characters as per :rfc:`2045`.  Note that if you are "
"looking for :rfc:`2045` support you probably want to be looking at the :mod:"
"`email` package instead."
msgstr ""
"L'interface historique ne permet pas le décodage des chaînes de caractères "
"mais fournit des fonctions permettant d'encoder et décoder depuis et vers "
"des :term:`objets fichiers <file object>`. Elle ne gère que l'alphabet "
"base64 standard et ajoute une nouvelle ligne tous les 76 caractères, comme "
"spécifié par la :rfc:`2045`. Notez que le paquet :mod:`email` est "
"probablement ce que vous cherchez si vous souhaitez une implémentation de "
"la :rfc:`2045`."

#: library/base64.rst:41
msgid ""
"ASCII-only Unicode strings are now accepted by the decoding functions of the "
"modern interface."
msgstr ""
"Les chaînes de caractères Unicode contenant uniquement des caractères ASCII "
"sont désormais acceptées par les fonctions de décodage de l'interface "
"moderne."

#: library/base64.rst:45
msgid ""
"Any :term:`bytes-like objects <bytes-like object>` are now accepted by all "
"encoding and decoding functions in this module.  Ascii85/Base85 support "
"added."
msgstr ""
"Tous les :term:`objets octet-compatibles <bytes-like object>` sont désormais "
"acceptés par l'ensemble des fonctions d'encodage et de décodage de ce "
"module. La gestion de Ascii85/base85 a été ajoutée."

#: library/base64.rst:49
msgid "The modern interface provides:"
msgstr "L'interface moderne propose :"

#: library/base64.rst:53
msgid ""
"Encode the :term:`bytes-like object` *s* using Base64 and return the "
"encoded :class:`bytes`."
msgstr ""
"Encode un :term:`objet octet-compatible <bytes-like object>` *s* en "
"utilisant l'algorithme base64 et renvoie les :class:`bytes` encodés."

#: library/base64.rst:56
#, fuzzy
msgid ""
"Optional *altchars* must be a :term:`bytes-like object` of length 2 which "
"specifies an alternative alphabet for the ``+`` and ``/`` characters. This "
"allows an application to e.g. generate URL or filesystem safe Base64 "
"strings.  The default is ``None``, for which the standard Base64 alphabet is "
"used."
msgstr ""
"L'option *altchars* doit être un :term:`bytes-like object` de longueur au "
"moins 2 (les caractères additionnels sont ignorés) qui spécifie un alphabet "
"alternatif pour les délimiteurs ``+`` et ``/``. Cela permet de générer des "
"chaînes de caractères base64 pouvant être utilisées pour une URL ou dans un "
"système de fichiers. La valeur par défaut est ``None``, auquel cas "
"l'alphabet standard base64 est utilisé."

#: library/base64.rst:61
msgid ""
"May assert or raise a a :exc:`ValueError` if the length of *altchars* is not "
"2.  Raises a :exc:`TypeError` if *altchars* is not a :term:`bytes-like "
"object`."
msgstr ""

#: library/base64.rst:67
msgid ""
"Decode the Base64 encoded :term:`bytes-like object` or ASCII string *s* and "
"return the decoded :class:`bytes`."
msgstr ""
"Décode un :term:`objet octet-compatible <bytes-like object>` ou une chaîne "
"de caractères ASCII *s* encodée en base64 et renvoie les :class:`bytes` "
"décodés."

#: library/base64.rst:70
#, fuzzy
msgid ""
"Optional *altchars* must be a :term:`bytes-like object` or ASCII string of "
"length 2 which specifies the alternative alphabet used instead of the ``+`` "
"and ``/`` characters."
msgstr ""
"L'option *altchars* doit être un :term:`bytes-like object` de longueur au "
"moins égale à 2 (les caractères additionnels sont ignorés) qui spécifie un "
"alphabet alternatif pour les délimiteurs ``+`` et ``/``."

#: library/base64.rst:74
msgid ""
"A :exc:`binascii.Error` exception is raised if *s* is incorrectly padded."
msgstr ""
"Une exception :exc:`binascii.Error` est levée si *s* n'est pas remplie à une "
"longueur attendue."

#: library/base64.rst:77
msgid ""
"If *validate* is ``False`` (the default), characters that are neither in the "
"normal base-64 alphabet nor the alternative alphabet are discarded prior to "
"the padding check.  If *validate* is ``True``, these non-alphabet characters "
"in the input result in a :exc:`binascii.Error`."
msgstr ""
"Si *validate* est ``False`` (par défaut), les caractères qui ne sont ni dans "
"l'alphabet base64 normal, ni dans l'alphabet alternatif, sont ignorés avant "
"la vérification de la longueur du remplissage. Si *validate* est ``True``, "
"les caractères hors de l'alphabet de l'entrée produisent une :exc:`binascii."
"Error`."

#: library/base64.rst:83
msgid ""
"For more information about the strict base64 check, see :func:`binascii."
"a2b_base64`"
msgstr ""

#: library/base64.rst:85
msgid ""
"May assert or raise a :exc:`ValueError` if the length of *altchars* is not 2."
msgstr ""

#: library/base64.rst:89
msgid ""
"Encode :term:`bytes-like object` *s* using the standard Base64 alphabet and "
"return the encoded :class:`bytes`."
msgstr ""
"Encode un :term:`objet octet-compatible <bytes-like object>` *s* en "
"utilisant l'alphabet standard base64 et renvoie les :class:`bytes` encodés."

#: library/base64.rst:95
msgid ""
"Decode :term:`bytes-like object` or ASCII string *s* using the standard "
"Base64 alphabet and return the decoded :class:`bytes`."
msgstr ""
"Décode un :term:`objet octet-compatible <bytes-like object>` ou une chaîne "
"de caractères ASCII *s* utilisant l'alphabet base64 standard et renvoie les :"
"class:`bytes` décodés."

#: library/base64.rst:101
msgid ""
"Encode :term:`bytes-like object` *s* using the URL- and filesystem-safe "
"alphabet, which substitutes ``-`` instead of ``+`` and ``_`` instead of ``/"
"`` in the standard Base64 alphabet, and return the encoded :class:`bytes`.  "
"The result can still contain ``=``."
msgstr ""
"Encode un :term:`objet byte-compatible <bytes-like object>` *s* en utilisant "
"un alphabet sûr pour les URL et systèmes de fichiers qui substitue ``-`` et "
"``_`` à ``+`` et ``/`` dans l'alphabet standard base64 et renvoie les :class:"
"`bytes` encodés."

#: library/base64.rst:110
msgid ""
"Decode :term:`bytes-like object` or ASCII string *s* using the URL- and "
"filesystem-safe alphabet, which substitutes ``-`` instead of ``+`` and ``_`` "
"instead of ``/`` in the standard Base64 alphabet, and return the decoded :"
"class:`bytes`."
msgstr ""
"Décode un :term:`objet octet-compatible <bytes-like object>` ou une chaîne "
"de caractères ASCII *s* utilisant un alphabet sûr pour les URL et systèmes "
"de fichiers qui substitue ``-`` et ``_`` à ``+`` et ``/`` dans l'alphabet "
"standard base64 et renvoie les :class:`bytes` décodés."

#: library/base64.rst:119
msgid ""
"Encode the :term:`bytes-like object` *s* using Base32 and return the "
"encoded :class:`bytes`."
msgstr ""
"Encode un :term:`objet byte-compatible <bytes-like object>` *s* en utilisant "
"l'algorithme base32 et renvoie les :class:`bytes` encodés."

#: library/base64.rst:125
msgid ""
"Decode the Base32 encoded :term:`bytes-like object` or ASCII string *s* and "
"return the decoded :class:`bytes`."
msgstr ""
"Décode un :term:`objet octet-compatible <bytes-like object>` ou une chaîne "
"de caractères ASCII *s* encodé en base32 et renvoie les :class:`bytes` "
"décodés."

#: library/base64.rst:176
msgid ""
"Optional *casefold* is a flag specifying whether a lowercase alphabet is "
"acceptable as input.  For security purposes, the default is ``False``."
msgstr ""
"L'option *casefold* est un drapeau spécifiant si l'utilisation d'un alphabet "
"en minuscules est acceptable comme entrée. Pour des raisons de sécurité, "
"cette option est à ``False`` par défaut."

#: library/base64.rst:132
#, fuzzy
msgid ""
":rfc:`4648` allows for optional mapping of the digit 0 (zero) to the letter "
"O (oh), and for optional mapping of the digit 1 (one) to either the letter I "
"(eye) or letter L (el).  The optional argument *map01* when not ``None``, "
"specifies which letter the digit 1 should be mapped to (when *map01* is not "
"``None``, the digit 0 is always mapped to the letter O).  For security "
"purposes the default is ``None``, so that 0 and 1 are not allowed in the "
"input."
msgstr ""
"La :rfc:`3548` autorise une correspondance optionnelle du chiffre 0 (zéro) "
"vers la lettre O (/o/) ainsi que du chiffre 1 (un) vers soit la lettre I (/"
"i/) ou la lettre L (/l/). L'argument optionnel *map01*, lorsqu'il diffère de "
"``None``, spécifie en quelle lettre le chiffre 1 doit être transformé "
"(lorsque *map01* n'est pas ``None``, le chiffre 0 est toujours transformé en "
"la lettre O). Pour des raisons de sécurité, le défaut est ``None``, de telle "
"sorte que 0 et 1 ne sont pas autorisés dans l'entrée."

#: library/base64.rst:180
msgid ""
"A :exc:`binascii.Error` is raised if *s* is incorrectly padded or if there "
"are non-alphabet characters present in the input."
msgstr ""
"Une exception :exc:`binascii.Error` est levée si *s* n'est pas remplie à une "
"longueur attendue ou si elle contient des caractères hors de l'alphabet."

#: library/base64.rst:146
msgid ""
"Similar to :func:`b32encode` but uses the Extended Hex Alphabet, as defined "
"in :rfc:`4648`."
msgstr ""

#: library/base64.rst:154
msgid ""
"Similar to :func:`b32decode` but uses the Extended Hex Alphabet, as defined "
"in :rfc:`4648`."
msgstr ""

#: library/base64.rst:157
msgid ""
"This version does not allow the digit 0 (zero) to the letter O (oh) and "
"digit 1 (one) to either the letter I (eye) or letter L (el) mappings, all "
"these characters are included in the Extended Hex Alphabet and are not "
"interchangeable."
msgstr ""

#: library/base64.rst:167
msgid ""
"Encode the :term:`bytes-like object` *s* using Base16 and return the "
"encoded :class:`bytes`."
msgstr ""
"Encode un :term:`objet byte-compatible <bytes-like object>` *s* en utilisant "
"l'algorithme base16 et renvoie les :class:`bytes` encodés."

#: library/base64.rst:173
msgid ""
"Decode the Base16 encoded :term:`bytes-like object` or ASCII string *s* and "
"return the decoded :class:`bytes`."
msgstr ""
"Décode un :term:`objet octet-compatible <bytes-like object>` ou une chaîne "
"de caractères ASCII *s* encodé en base16 et renvoie les :class:`bytes` "
"décodés."

#: library/base64.rst:187
msgid ""
"Encode the :term:`bytes-like object` *b* using Ascii85 and return the "
"encoded :class:`bytes`."
msgstr ""
"Encode un :term:`objet byte-compatible <bytes-like object>` *s* en utilisant "
"l'algorithme Ascii85 et renvoie les :class:`bytes` encodés."

#: library/base64.rst:190
msgid ""
"*foldspaces* is an optional flag that uses the special short sequence 'y' "
"instead of 4 consecutive spaces (ASCII 0x20) as supported by 'btoa'. This "
"feature is not supported by the \"standard\" Ascii85 encoding."
msgstr ""
"L'option *foldspaces* permet d'utiliser la séquence spéciale 'y' à la place "
"de quatre espaces consécutives (ASCII ``0x20``) comme  pris en charge par "
"*btoa*. Cette fonctionnalité n'est pas gérée par l'encodage « standard » "
"Ascii85."

#: library/base64.rst:194
msgid ""
"*wrapcol* controls whether the output should have newline (``b'\\n'``) "
"characters added to it. If this is non-zero, each output line will be at "
"most this many characters long."
msgstr ""
"*wrapcol* contrôle l'ajout de caractères de saut de ligne (``b'\\n'``)  à la "
"sortie. Chaque ligne de sortie contient au maximum *wrapcol* caractères si "
"cette option diffère de zéro."

#: library/base64.rst:198
msgid ""
"*pad* controls whether the input is padded to a multiple of 4 before "
"encoding. Note that the ``btoa`` implementation always pads."
msgstr ""
"*pad* spécifie l'ajout de caractères de remplissage (*padding* en anglais) à "
"l'entrée jusqu'à ce que sa longueur soit un multiple de 4 avant encodage. "
"Notez que l'implémentation ``btoa`` effectue systématiquement ce remplissage."

#: library/base64.rst:201
msgid ""
"*adobe* controls whether the encoded byte sequence is framed with ``<~`` and "
"``~>``, which is used by the Adobe implementation."
msgstr ""
"*adobe* contrôle si oui ou non la séquence encodée d'octets est encadrée par "
"``<~`` et ``~>`` comme utilisé dans l'implémentation Adobe."

#: library/base64.rst:209
msgid ""
"Decode the Ascii85 encoded :term:`bytes-like object` or ASCII string *b* and "
"return the decoded :class:`bytes`."
msgstr ""
"Décode un :term:`objet octet-compatible <bytes-like object>` ou une chaîne "
"de caractères ASCII *s* encodé en Ascii85 et renvoie les :class:`bytes` "
"décodés."

#: library/base64.rst:212
msgid ""
"*foldspaces* is a flag that specifies whether the 'y' short sequence should "
"be accepted as shorthand for 4 consecutive spaces (ASCII 0x20). This feature "
"is not supported by the \"standard\" Ascii85 encoding."
msgstr ""
"L'option *foldspaces* permet d'utiliser la séquence spéciale 'y' à la place "
"de quatre espaces consécutives (ASCII ``0x20``) comme  pris en charge par "
"*btoa*. Cette fonctionnalité n'est pas gérée par l'encodage « standard » "
"Ascii85."

#: library/base64.rst:216
msgid ""
"*adobe* controls whether the input sequence is in Adobe Ascii85 format (i.e. "
"is framed with <~ and ~>)."
msgstr ""
"*adobe* indique si la séquence d'entrée utilise le format Adobe Ascii85 "
"(c'est-à-dire utilise l'encadrement par ``<~`` et ``~>``)."

#: library/base64.rst:219
msgid ""
"*ignorechars* should be a :term:`bytes-like object` or ASCII string "
"containing characters to ignore from the input. This should only contain "
"whitespace characters, and by default contains all whitespace characters in "
"ASCII."
msgstr ""
"*ignorechars* doit être un :term:`bytes-like object` ou une chaîne ASCII "
"contenant des caractères à ignorer dans l'entrée. Il ne doit contenir que "
"des caractères d'espacement et contient par défaut l'ensemble des caractères "
"d'espacement de l'alphabet ASCII."

#: library/base64.rst:229
msgid ""
"Encode the :term:`bytes-like object` *b* using base85 (as used in e.g. git-"
"style binary diffs) and return the encoded :class:`bytes`."
msgstr ""
"Encode un :term:`objet byte-compatible <bytes-like object>` *s* en utilisant "
"l'algorithme base85 (tel qu'utilisé par exemple par le programme *git-diff* "
"sur des données binaires) et renvoie les :class:`bytes` encodés."

#: library/base64.rst:232
msgid ""
"If *pad* is true, the input is padded with ``b'\\0'`` so its length is a "
"multiple of 4 bytes before encoding."
msgstr ""
"Si *pad* est vrai, des caractères de remplissage ``b'\\0'`` (*padding* en "
"anglais) sont ajoutés à l'entrée jusqu'à ce que sa longueur soit un multiple "
"de 4 octets avant encodage."

#: library/base64.rst:240
msgid ""
"Decode the base85-encoded :term:`bytes-like object` or ASCII string *b* and "
"return the decoded :class:`bytes`.  Padding is implicitly removed, if "
"necessary."
msgstr ""
"Décode un :term:`objet octet-compatible <bytes-like object>` ou une chaîne "
"de caractères ASCII *b* encodé en base85 et renvoie les :class:`bytes` "
"décodés. Les caractères de remplissage sont implicitement retirés si "
"nécessaire."

#: library/base64.rst:247
msgid "The legacy interface:"
msgstr "L'interface historique :"

#: library/base64.rst:251
msgid ""
"Decode the contents of the binary *input* file and write the resulting "
"binary data to the *output* file. *input* and *output* must be :term:`file "
"objects <file object>`. *input* will be read until ``input.readline()`` "
"returns an empty bytes object."
msgstr ""
"Décode le contenu d'un fichier binaire *input* et écrit les données binaires "
"résultantes dans le fichier *output*. *input* et *output* doivent être des :"
"term:`objets fichiers <file object>`. *input* est lu jusqu'à ce que ``input."
"readline()`` renvoie un objet *bytes* vide."

#: library/base64.rst:259
msgid ""
"Decode the :term:`bytes-like object` *s*, which must contain one or more "
"lines of base64 encoded data, and return the decoded :class:`bytes`."
msgstr ""
"Décode un :term:`objet octet-compatible <bytes-like object>` *s* devant "
"contenir une ou plusieurs lignes de données encodées en base64 et renvoie "
"les :class:`bytes` décodés."

#: library/base64.rst:267
msgid ""
"Encode the contents of the binary *input* file and write the resulting "
"base64 encoded data to the *output* file. *input* and *output* must be :term:"
"`file objects <file object>`. *input* will be read until ``input.read()`` "
"returns an empty bytes object. :func:`encode` inserts a newline character "
"(``b'\\n'``) after every 76 bytes of the output, as well as ensuring that "
"the output always ends with a newline, as per :rfc:`2045` (MIME)."
msgstr ""
"Encode le contenu du fichier binaire *input* et écrit les données encodées "
"en base64 résultantes dans le fichier *output. *input* et *output* doivent "
"être des :term:`objets fichiers <file object>`. *input* est lu jusqu'à ce "
"que ``input.readline()`` renvoie un objet *bytes* vide. :func:`encode` "
"insère un caractère de saut de ligne (``b'\\n'``) tous les 76 octets de "
"sortie et assure que celle-ci se termine par une nouvelle ligne, comme "
"spécifié par la :rfc:`2045` (MIME)."

#: library/base64.rst:277
msgid ""
"Encode the :term:`bytes-like object` *s*, which can contain arbitrary binary "
"data, and return :class:`bytes` containing the base64-encoded data, with "
"newlines (``b'\\n'``) inserted after every 76 bytes of output, and ensuring "
"that there is a trailing newline, as per :rfc:`2045` (MIME)."
msgstr ""
"Encode un :term:`objet octet-compatible <bytes-like object>` *s* pouvant "
"contenir des données binaires arbitraires et renvoie les :class:`bytes` "
"contenant les données encodées en base64. Un caractère de saut de ligne "
"(``b'\\n'``) est inséré tous les 76 octets de sortie et celle-ci se termine "
"par une nouvelle ligne, comme spécifié par la :rfc:`2045` (MIME)."

#: library/base64.rst:285
msgid "An example usage of the module:"
msgstr "Un exemple d'utilisation du module :"

#: library/base64.rst:298
msgid "Security Considerations"
msgstr ""

#: library/base64.rst:300
msgid ""
"A new security considerations section was added to :rfc:`4648` (section 12); "
"it's recommended to review the security section for any code deployed to "
"production."
msgstr ""

#: library/base64.rst:306
msgid "Module :mod:`binascii`"
msgstr "Module :mod:`binascii`"

#: library/base64.rst:306
msgid ""
"Support module containing ASCII-to-binary and binary-to-ASCII conversions."
msgstr ""
"Module secondaire contenant les conversions ASCII vers binaire et binaire "
"vers ASCII."

#: library/base64.rst:309
msgid ""
":rfc:`1521` - MIME (Multipurpose Internet Mail Extensions) Part One: "
"Mechanisms for Specifying and Describing the Format of Internet Message "
"Bodies"
msgstr ""
":rfc:`1521` — MIME (*Multipurpose Internet Mail Extensions*) *Part One: "
"Mechanisms for Specifying and Describing the Format of Internet Message "
"Bodies*"

#: library/base64.rst:309
msgid ""
"Section 5.2, \"Base64 Content-Transfer-Encoding,\" provides the definition "
"of the base64 encoding."
msgstr ""
"La Section 5.2, \"*Base64 Content-Transfer-Encoding*\", donne la définition "
"de l'encodage base64."

#~ msgid "Deprecated alias of :func:`decodebytes`."
#~ msgstr "Alias obsolète de :func:`decodebytes`."

#~ msgid "Deprecated alias of :func:`encodebytes`."
#~ msgstr "Alias obsolète de :func:`encodebytes`."
