python-docs-fr/library/textwrap.po

# 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: 2022-04-05 10:05+0200\n"
"PO-Revision-Date: 2022-10-19 16:51+0200\n"
"Last-Translator: Loc Cosnier <loc.cosnier@pm.me>\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: Gtranslator 3.38.0\n"

#: library/textwrap.rst:2
msgid ":mod:`textwrap` --- Text wrapping and filling"
msgstr ":mod:`textwrap` --- Encapsulation et remplissage de texte"

#: library/textwrap.rst:10
msgid "**Source code:** :source:`Lib/textwrap.py`"
msgstr "**Source code:** :source:`Lib/textwrap.py`"

#: library/textwrap.rst:14
msgid ""
"The :mod:`textwrap` module provides some convenience functions, as well as :"
"class:`TextWrapper`, the class that does all the work. If you're just "
"wrapping or filling one or two text strings, the convenience functions "
"should be good enough; otherwise, you should use an instance of :class:"
"`TextWrapper` for efficiency."
msgstr ""
"Le module :mod:`textwrap` fournit quelques fonctions pratiques, comme :class:"
"`TextWrapper`, la classe qui fait tout le travail. Si vous ne faites que "
"formater ou ajuster une ou deux chaînes de texte, les fonctions de commodité "
"devraient être assez bonnes ; sinon, nous vous conseillons d'utiliser une "
"instance de :class:`TextWrapper` pour une meilleure efficacité."

#: library/textwrap.rst:27
msgid ""
"Wraps the single paragraph in *text* (a string) so every line is at most "
"*width* characters long.  Returns a list of output lines, without final "
"newlines."
msgstr ""
"Reformate le paragraphe simple dans *text* (une chaîne de caractères) de "
"sorte que chaque ligne ait au maximum *largeur* caractères. Renvoie une "
"liste de lignes de sortie, sans ligne vide ou caractère de fin de ligne à la "
"fin."

#: library/textwrap.rst:31
#, fuzzy
msgid ""
"Optional keyword arguments correspond to the instance attributes of :class:"
"`TextWrapper`, documented below."
msgstr ""
"Les arguments nommés optionnels correspondent aux attributs d'instance de :"
"class:`TextWrapper`, documentés ci-dessous. *width* vaut ``70`` par défaut."

#: library/textwrap.rst:34
msgid ""
"See the :meth:`TextWrapper.wrap` method for additional details on how :func:"
"`wrap` behaves."
msgstr ""
"Consultez la méthode :meth:`TextWrapper.wrap` pour plus de détails sur le "
"comportement de :func:`wrap`."

#: library/textwrap.rst:45
msgid ""
"Wraps the single paragraph in *text*, and returns a single string containing "
"the wrapped paragraph.  :func:`fill` is shorthand for  ::"
msgstr ""
"Formate le paragraphe unique dans *text* et renvoie une seule chaîne dont le "
"contenu est le paragraphe formaté. :func:`fill` est un raccourci pour ::"

#: library/textwrap.rst:50
msgid ""
"In particular, :func:`fill` accepts exactly the same keyword arguments as :"
"func:`wrap`."
msgstr ""
"En particulier, :func:`fill` accepte exactement les mêmes arguments nommés "
"que :func:`wrap`."

#: library/textwrap.rst:58
msgid "Collapse and truncate the given *text* to fit in the given *width*."
msgstr ""
"Réduit et tronque le *text* donné pour l'adapter à la *largeur* donnée."

#: library/textwrap.rst:60
msgid ""
"First the whitespace in *text* is collapsed (all whitespace is replaced by "
"single spaces).  If the result fits in the *width*, it is returned. "
"Otherwise, enough words are dropped from the end so that the remaining words "
"plus the :attr:`placeholder` fit within :attr:`width`::"
msgstr ""
"Tout d'abord, les espaces dans *text* sont réduites (toutes les espaces "
"blancs sont remplacées par des espaces simples). Si le résultat tient dans "
"la *width*, il est renvoyé. Sinon, suffisamment de mots sont supprimés en "
"fin de chaîne de manière à ce que les mots restants plus le :attr:"
"`placeholder` tiennent dans :attr:`width` ::"

#: library/textwrap.rst:72
msgid ""
"Optional keyword arguments correspond to the instance attributes of :class:"
"`TextWrapper`, documented below.  Note that the whitespace is collapsed "
"before the text is passed to the :class:`TextWrapper` :meth:`fill` function, "
"so changing the value of :attr:`.tabsize`, :attr:`.expand_tabs`, :attr:`."
"drop_whitespace`, and :attr:`.replace_whitespace` will have no effect."
msgstr ""
"Les arguments nommés optionnels correspondent aux attributs d'instance de :"
"class:`TextWrapper`, documentés ci-dessous. Notez que l'espace blanc est "
"réduit avant que le texte ne soit passé à la fonction :meth:`fill` de :class:"
"`TextWrapper`, donc changer la valeur de :attr:`.tabsize`, :attr:`."
"expand_tabs`, :attr:`.drop_whitespace`, et :attr:`.replace_whitespace` est "
"sans effet."

#: library/textwrap.rst:82
msgid "Remove any common leading whitespace from every line in *text*."
msgstr "Supprime toutes les espaces en de tête de chaque ligne dans *text*."

#: library/textwrap.rst:84
msgid ""
"This can be used to make triple-quoted strings line up with the left edge of "
"the display, while still presenting them in the source code in indented form."
msgstr ""
"Ceci peut être utilisé pour aligner les chaînes à trois guillemets avec le "
"bord gauche de l'affichage, tout en les présentant sous forme indentée dans "
"le code source."

#: library/textwrap.rst:87
msgid ""
"Note that tabs and spaces are both treated as whitespace, but they are not "
"equal: the lines ``\"  hello\"`` and ``\"\\thello\"`` are considered to have "
"no common leading whitespace."
msgstr ""
"Notez que les tabulations et les espaces sont traitées comme des espaces, "
"mais qu'elles ne sont pas égales : les lignes ``\"  hello\"`` et "
"``\"\\thello\"`` sont considérées comme n'ayant pas d'espaces de tête "
"communes."

#: library/textwrap.rst:91
msgid ""
"Lines containing only whitespace are ignored in the input and normalized to "
"a single newline character in the output."
msgstr ""
"Les lignes contenant uniquement des espaces sont ignorées en entrée et "
"réduites à un seul caractère de saut de ligne en sortie."

#: library/textwrap.rst:115
msgid "For example::"
msgstr "Par exemple ::"

#: library/textwrap.rst:108
msgid "Add *prefix* to the beginning of selected lines in *text*."
msgstr "Ajoute *prefix* au début des lignes sélectionnées dans *text*."

#: library/textwrap.rst:110
msgid "Lines are separated by calling ``text.splitlines(True)``."
msgstr "Les lignes sont séparées en appelant ``text.splitlines(True)``."

#: library/textwrap.rst:112
msgid ""
"By default, *prefix* is added to all lines that do not consist solely of "
"whitespace (including any line endings)."
msgstr ""
"Par défaut, *prefix* est ajouté à toutes les lignes qui ne sont pas "
"constituées uniquement d'espaces (y compris les fins de ligne)."

#: library/textwrap.rst:121
msgid ""
"The optional *predicate* argument can be used to control which lines are "
"indented. For example, it is easy to add *prefix* to even empty and "
"whitespace-only lines::"
msgstr ""
"L'argument optionnel *predicate* peut être utilisé pour contrôler quelles "
"lignes sont en retrait. Par exemple, il est facile d'ajouter *prefix* aux "
"lignes vides et aux lignes blanches seulement ::"

#: library/textwrap.rst:134
msgid ""
":func:`wrap`, :func:`fill` and :func:`shorten` work by creating a :class:"
"`TextWrapper` instance and calling a single method on it.  That instance is "
"not reused, so for applications that process many text strings using :func:"
"`wrap` and/or :func:`fill`, it may be more efficient to create your own :"
"class:`TextWrapper` object."
msgstr ""
":func:`wrap`, :func:`fill` et :func:`shorten` travaillent en créant une "
"instance :class:`TextWrapper` et en appelant une méthode unique sur celle-"
"ci. Cette instance n'est pas réutilisée, donc pour les applications qui "
"traitent plusieurs chaînes de texte en utilisant :func:`wrap` et/ou :func:"
"`fill`, il peut être plus efficace de créer votre propre objet :class:"
"`TextWrapper`."

#: library/textwrap.rst:140
msgid ""
"Text is preferably wrapped on whitespaces and right after the hyphens in "
"hyphenated words; only then will long words be broken if necessary, unless :"
"attr:`TextWrapper.break_long_words` is set to false."
msgstr ""
"Le formatage du texte s'effectue en priorité sur les espaces puis juste "
"après les traits d'union dans des mots séparés par des traits d'union ; ce "
"n'est qu'alors que les mots longs seront cassés si nécessaire, à moins que :"
"attr:`TextWrapper.break_long_words` soit défini sur *False*."

#: library/textwrap.rst:146
msgid ""
"The :class:`TextWrapper` constructor accepts a number of optional keyword "
"arguments.  Each keyword argument corresponds to an instance attribute, so "
"for example ::"
msgstr ""
"Le constructeur :class:`TextWrapper` accepte un certain nombre d'arguments "
"nommés optionnels. Chaque argument nommé correspond à un attribut "
"d'instance, donc par exemple ::"

#: library/textwrap.rst:152
msgid "is the same as  ::"
msgstr "est identique à ::"

#: library/textwrap.rst:157
msgid ""
"You can re-use the same :class:`TextWrapper` object many times, and you can "
"change any of its options through direct assignment to instance attributes "
"between uses."
msgstr ""
"Vous pouvez réutiliser le même objet :class:`TextWrapper` plusieurs fois et "
"vous pouvez changer n'importe laquelle de ses options par assignation "
"directe aux attributs d'instance entre les utilisations."

#: library/textwrap.rst:161
msgid ""
"The :class:`TextWrapper` instance attributes (and keyword arguments to the "
"constructor) are as follows:"
msgstr ""
"Les attributs d'instance de la classe :class:`TextWrapper` (et les arguments "
"nommés au constructeur) sont les suivants :"

#: library/textwrap.rst:167
msgid ""
"(default: ``70``) The maximum length of wrapped lines.  As long as there are "
"no individual words in the input text longer than :attr:`width`, :class:"
"`TextWrapper` guarantees that no output line will be longer than :attr:"
"`width` characters."
msgstr ""
"(par défaut : ``70``) Longueur maximale des lignes reformatées. Tant qu'il "
"n'y a pas de mots individuels dans le texte d'entrée plus longs que :attr:"
"`width`, :class:`TextWrapper` garantit qu'aucune ligne de sortie n'est plus "
"longue que :attr:`width` caractères."

#: library/textwrap.rst:175
msgid ""
"(default: ``True``) If true, then all tab characters in *text* will be "
"expanded to spaces using the :meth:`expandtabs` method of *text*."
msgstr ""
"(par défaut : ``True``) Si vrai, alors tous les caractères de tabulation "
"dans *text* sont transformés en espaces en utilisant la méthode :meth:"
"`expandtabs` de *text*."

#: library/textwrap.rst:181
msgid ""
"(default: ``8``) If :attr:`expand_tabs` is true, then all tab characters in "
"*text* will be expanded to zero or more spaces, depending on the current "
"column and the given tab size."
msgstr ""
"(par défaut : ``8``) Si :attr:`expand_tabs` est vrai, alors tous les "
"caractères de tabulation dans *text* sont transformés en zéro ou plus "
"d'espaces, selon la colonne courante et la taille de tabulation donnée."

#: library/textwrap.rst:190
msgid ""
"(default: ``True``) If true, after tab expansion but before wrapping, the :"
"meth:`wrap` method will replace each whitespace character with a single "
"space.  The whitespace characters replaced are as follows: tab, newline, "
"vertical tab, formfeed, and carriage return (``'\\t\\n\\v\\f\\r'``)."
msgstr ""
"(par défaut : ``True``) Si vrai, après l'expansion des tabulations mais "
"avant le formatage, la méthode :meth:`wrap` remplace chaque *blanc* par une "
"espace unique. Les *blancs* remplacés sont les suivants : tabulation, "
"nouvelle ligne, tabulation verticale, saut de page et retour chariot "
"(``'\\t\\n\\v\\f\\r'``)."

#: library/textwrap.rst:198
msgid ""
"If :attr:`expand_tabs` is false and :attr:`replace_whitespace` is true, each "
"tab character will be replaced by a single space, which is *not* the same as "
"tab expansion."
msgstr ""
"Si :attr:`expand_tabs` est *False* et :attr:`replace_whitespace` est vrai, "
"chaque caractère de tabulation est remplacé par une espace unique, ce qui "
"*n'est pas* la même chose que l'extension des tabulations."

#: library/textwrap.rst:204
msgid ""
"If :attr:`replace_whitespace` is false, newlines may appear in the middle of "
"a line and cause strange output. For this reason, text should be split into "
"paragraphs (using :meth:`str.splitlines` or similar) which are wrapped "
"separately."
msgstr ""
"Si :attr:`replace_whitespace` est faux, de nouvelles lignes peuvent "
"apparaître au milieu d'une ligne et provoquer une sortie étrange. Pour cette "
"raison, le texte doit être divisé en paragraphes (en utilisant :meth:`str."
"splitlines` ou similaire) qui sont formatés séparément."

#: library/textwrap.rst:212
msgid ""
"(default: ``True``) If true, whitespace at the beginning and ending of every "
"line (after wrapping but before indenting) is dropped. Whitespace at the "
"beginning of the paragraph, however, is not dropped if non-whitespace "
"follows it.  If whitespace being dropped takes up an entire line, the whole "
"line is dropped."
msgstr ""
"(par défaut : ``True``) Si *True*, l'espace au début et à la fin de chaque "
"ligne (après le formatage mais avant l'indentation) est supprimée. L'espace "
"au début du paragraphe n'est cependant pas supprimée si elle n'est pas "
"suivie par une espace. Si les espaces en cours de suppression occupent une "
"ligne entière, la ligne entière est supprimée."

#: library/textwrap.rst:221
msgid ""
"(default: ``''``) String that will be prepended to the first line of wrapped "
"output.  Counts towards the length of the first line.  The empty string is "
"not indented."
msgstr ""
"(par défaut : ``''``) Chaîne qui est ajoutée à la première ligne de la "
"sortie formatée. Elle compte pour le calcul de la longueur de la première "
"ligne. La chaîne vide n'est pas indentée."

#: library/textwrap.rst:228
msgid ""
"(default: ``''``) String that will be prepended to all lines of wrapped "
"output except the first.  Counts towards the length of each line except the "
"first."
msgstr ""
"(par défaut : ``''``) Chaîne qui préfixe toutes les lignes de la sortie "
"formatée sauf la première. Elle compte pour le calcul de la longueur de "
"chaque ligne à l'exception de la première."

#: library/textwrap.rst:235
msgid ""
"(default: ``False``) If true, :class:`TextWrapper` attempts to detect "
"sentence endings and ensure that sentences are always separated by exactly "
"two spaces.  This is generally desired for text in a monospaced font. "
"However, the sentence detection algorithm is imperfect: it assumes that a "
"sentence ending consists of a lowercase letter followed by one of ``'.'``, "
"``'!'``, or ``'?'``, possibly followed by one of ``'\"'`` or ``\"'\"``, "
"followed by a space.  One problem with this is algorithm is that it is "
"unable to detect the difference between \"Dr.\" in ::"
msgstr ""
"(par défaut : ``Faux``) Si vrai, :class:`TextWrapper` tente de détecter les "
"fins de phrases et de s'assurer que les phrases sont toujours séparées par "
"exactement deux espaces. Ceci est généralement souhaité pour un texte en "
"police à chasse fixe. Cependant, l'algorithme de détection de phrase est "
"imparfait : il suppose qu'une fin de phrase consiste en une lettre minuscule "
"suivie de l'une des lettres suivantes : ``'.'``, ``'!'``, ou ``'?'``, "
"éventuellement suivie d'une des lettres ``'\"'`` ou ``\"'\"``, suivie par "
"une espace. Un problème avec cet algorithme est qu'il est incapable de "
"détecter la différence entre \"Dr\" dans ::"

#: library/textwrap.rst:246
msgid "and \"Spot.\" in ::"
msgstr "et \"Spot.\" dans ::"

#: library/textwrap.rst:250
msgid ":attr:`fix_sentence_endings` is false by default."
msgstr ":attr:`fix_sentence_endings` est *False* par défaut."

#: library/textwrap.rst:252
msgid ""
"Since the sentence detection algorithm relies on ``string.lowercase`` for "
"the definition of \"lowercase letter\", and a convention of using two spaces "
"after a period to separate sentences on the same line, it is specific to "
"English-language texts."
msgstr ""
"Étant donné que l'algorithme de détection de phrases repose sur ``string."
"lowercase`` pour la définition de « lettres minuscules » et sur une "
"convention consistant à utiliser deux espaces après un point pour séparer "
"les phrases sur la même ligne, ceci est spécifique aux textes de langue "
"anglaise."

#: library/textwrap.rst:260
msgid ""
"(default: ``True``) If true, then words longer than :attr:`width` will be "
"broken in order to ensure that no lines are longer than :attr:`width`.  If "
"it is false, long words will not be broken, and some lines may be longer "
"than :attr:`width`.  (Long words will be put on a line by themselves, in "
"order to minimize the amount by which :attr:`width` is exceeded.)"
msgstr ""
"(par défaut : ``True``) Si *True*, alors les mots plus longs que :attr:"
"`width` sont cassés afin de s'assurer qu'aucune ligne ne soit plus longue "
"que :attr:`width`. Si c'est *False*, les mots longs ne sont pas cassés et "
"certaines lignes peuvent être plus longues que :attr:`width` (les mots longs "
"seront mis sur une ligne qui leur est propre, afin de minimiser le "
"dépassement de :attr:`width`)."

#: library/textwrap.rst:269
msgid ""
"(default: ``True``) If true, wrapping will occur preferably on whitespaces "
"and right after hyphens in compound words, as it is customary in English. If "
"false, only whitespaces will be considered as potentially good places for "
"line breaks, but you need to set :attr:`break_long_words` to false if you "
"want truly insecable words.  Default behaviour in previous versions was to "
"always allow breaking hyphenated words."
msgstr ""
"(par défaut : ``True``) Si c'est vrai, le formatage se fait de préférence "
"sur les espaces et juste après sur les traits d'union des mots composés, "
"comme il est d'usage en anglais. Si *False*, seuls les espaces sont "
"considérées comme de bons endroits pour les sauts de ligne, mais vous devez "
"définir :attr:`break_long_words` à *False* si vous voulez des mots vraiment "
"insécables. Le comportement par défaut dans les versions précédentes était "
"de toujours permettre de couper les mots avec trait d'union."

#: library/textwrap.rst:279
msgid ""
"(default: ``None``) If not ``None``, then the output will contain at most "
"*max_lines* lines, with *placeholder* appearing at the end of the output."
msgstr ""
"(par défaut : ``None``) Si ce n'est pas ``None``, alors la sortie contient "
"au maximum *max_lines* lignes, avec *placeholder* à la fin de la sortie."

#: library/textwrap.rst:289
msgid ""
"(default: ``' [...]'``) String that will appear at the end of the output "
"text if it has been truncated."
msgstr ""
"(par défaut : ``'' [...]'``) Chaîne qui apparaît à la fin du texte de sortie "
"s'il a été tronqué."

#: library/textwrap.rst:295
msgid ""
":class:`TextWrapper` also provides some public methods, analogous to the "
"module-level convenience functions:"
msgstr ""
":class:`TextWrapper` fournit également quelques méthodes publiques, "
"analogues aux fonctions de commodité au niveau du module :"

#: library/textwrap.rst:300
msgid ""
"Wraps the single paragraph in *text* (a string) so every line is at most :"
"attr:`width` characters long.  All wrapping options are taken from instance "
"attributes of the :class:`TextWrapper` instance.  Returns a list of output "
"lines, without final newlines.  If the wrapped output has no content, the "
"returned list is empty."
msgstr ""
"Formate le paragraphe unique dans *text* (une chaîne de caractères) de sorte "
"que chaque ligne ait au maximum :attr:`width` caractères. Toutes les options "
"de formatage sont tirées des attributs d'instance de l'instance de classe :"
"class:`TextWrapper`. Renvoie une liste de lignes de sortie, sans nouvelles "
"lignes finales. Si la sortie formatée n'a pas de contenu, la liste vide est "
"renvoyée."

#: library/textwrap.rst:309
msgid ""
"Wraps the single paragraph in *text*, and returns a single string containing "
"the wrapped paragraph."
msgstr ""
"Formate le paragraphe unique de *text* et renvoie une seule chaîne contenant "
"le paragraphe formaté."