From ef713a61cc361115ca1b57ae8da8af4c4ce762db Mon Sep 17 00:00:00 2001 From: Julien Palard Date: Thu, 12 Dec 2019 00:36:35 +0100 Subject: [PATCH 1/5] Few tests, tox, and travis. --- .travis.yml | 14 + README.md | 17 + potodo/_github.py | 31 +- potodo/_po_file.py | 9 +- potodo/potodo.py | 49 +- tests/fixtures/python-docs-fr/bugs.po | 248 ++ tests/fixtures/python-docs-fr/glossary.po | 2773 +++++++++++++++++++++ tests/test_potodo.py | 21 + tox.ini | 22 + 9 files changed, 3146 insertions(+), 38 deletions(-) create mode 100644 .travis.yml create mode 100644 tests/fixtures/python-docs-fr/bugs.po create mode 100644 tests/fixtures/python-docs-fr/glossary.po create mode 100644 tests/test_potodo.py create mode 100644 tox.ini diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..c90c1b8 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,14 @@ +language: python +matrix: + include: + - python: "3.6" + env: TOX_ENV=py36 + - python: "3.7" + env: TOX_ENV=py37 + - python: "3.8" + env: TOX_ENV=py38,black,flake8,mypy +install: + - pip uninstall -y virtualenv + - pip install tox +script: + - tox -e $TOX_ENV diff --git a/README.md b/README.md index 790d772..8594bf2 100644 --- a/README.md +++ b/README.md @@ -26,3 +26,20 @@ optional arguments: -b BELOW, --below BELOW Will list all TODOs BELOW given INT% completion ``` + +## Contributing + +You can run the tests using `tox` locally like: + + tox -p auto + +before commiting. + +A pre-commit hook like: +```sh +cat < .git/hooks/pre-commit +#!/bin/sh +exec tox -s -p all +EOF +``` +may help. \ No newline at end of file diff --git a/potodo/_github.py b/potodo/_github.py index e495f61..bc046e0 100644 --- a/potodo/_github.py +++ b/potodo/_github.py @@ -1,16 +1,24 @@ import re -import requests - from typing import Mapping from subprocess import check_output +import requests + def get_repo_url(repo_path: str) -> str: """Tries to get the repository url from git commands """ - url = check_output("git remote get-url --all upstream".split(), universal_newlines=True, cwd=repo_path) + url = check_output( + "git remote get-url --all upstream".split(), + universal_newlines=True, + cwd=repo_path, + ) if "fatal" in url: - url = check_output("git remote get-url --all upstream".split(), universal_newlines=True, cwd=repo_path) + url = check_output( + "git remote get-url --all upstream".split(), + universal_newlines=True, + cwd=repo_path, + ) if "fatal" in url: # If the commands didn't work raise RuntimeError( @@ -20,7 +28,8 @@ def get_repo_url(repo_path: str) -> str: def get_repo_name(repo_path: str) -> str: - """Will get the repository url from git commands then remove useless stuff to get ORG/NAME + """Will get the repository url from git commands then remove useless + stuff to get ORG/NAME. """ repo_url = get_repo_url(repo_path) # Removes useless stuff. If it isn't there then nothing happens @@ -28,7 +37,7 @@ def get_repo_name(repo_path: str) -> str: repo_name = repo_url.replace("https://github.com/", "") repo_name = repo_name.replace("git@github.com:", "") repo_name = repo_name.replace(".git", "") - repo_name = repo_name.strip('\n') + repo_name = repo_name.strip("\n") return repo_name @@ -38,7 +47,11 @@ def get_reservation_list(repo_path: str) -> Mapping[str, str]: """ issues: list = [] - next_url = "https://api.github.com/repos/" + get_repo_name(repo_path) + "/issues?state=open" + next_url = ( + "https://api.github.com/repos/" + + get_repo_name(repo_path) + + "/issues?state=open" + ) while next_url: resp = requests.get(next_url) issues.extend(resp.json()) @@ -48,8 +61,8 @@ def get_reservation_list(repo_path: str) -> Mapping[str, str]: for issue in issues: # Maybe find a better way for not using python 3.8 ? - yes = re.search(r'\w*/\w*\.po', issue['title']) + yes = re.search(r"\w*/\w*\.po", issue["title"]) if yes: - reservations[yes.group()] = issue['user']['login'] + reservations[yes.group()] = issue["user"]["login"] return reservations diff --git a/potodo/_po_file.py b/potodo/_po_file.py index f2090a8..e239ada 100644 --- a/potodo/_po_file.py +++ b/potodo/_po_file.py @@ -1,8 +1,8 @@ -import polib - from typing import Mapping, Sequence from pathlib import Path +import polib + class PoFileStats: """Class for each `.po` file containing all the necessary information about its progress @@ -50,8 +50,9 @@ class PoFileStats: def get_po_files_from_repo(repo_path: str) -> Mapping[str, Sequence[PoFileStats]]: - """Gets all the po files from a given repository. - Will return a list with all directories and PoFile instances of `.po` files in those directories + """Gets all the po files from a given repository. Will return a list + with all directories and PoFile instances of `.po` files in those + directories. """ # Get all the files matching `**/*.po` and not being `.git/` in the given path diff --git a/potodo/potodo.py b/potodo/potodo.py index bba2624..70628ee 100644 --- a/potodo/potodo.py +++ b/potodo/potodo.py @@ -1,20 +1,12 @@ #!/usr/bin/env python3 import os -import sys import argparse import statistics from typing import Tuple, Mapping from pathlib import Path -try: - import polib - import requests -except ImportError: - print("You need to install polib and requests to be able to run potodo.") - sys.exit(1) - from potodo import __version__ from potodo._github import get_reservation_list from potodo._po_file import PoFileStats, get_po_files_from_repo @@ -36,7 +28,8 @@ def initialize_arguments( if above and below: if below < above: - # If above and below are specified and that below is superior to above, raise an error + # If above and below are specified and that below is superior to above, + # raise an error raise ValueError("Below must be inferior to above") if not offline and not hide_reserved: @@ -54,9 +47,10 @@ def print_dir_stats( """This function prints the directory name, its stats and the buffer """ if True in printed_list: - # If at least one of the files isn't done then print the folder stats and file(s) - # Each time a file is went over True or False is placed in the printed_list list. - # If False is placed it means it doesnt need to be printed + # If at least one of the files isn't done then print the + # folder stats and file(s) Each time a file is went over True + # or False is placed in the printed_list list. If False is + # placed it means it doesnt need to be printed print(f"\n\n# {directory_name} ({statistics.mean(folder_stats):.2f}% done)\n") print("\n".join(buffer)) @@ -71,8 +65,9 @@ def buffer_add( below: int, counts: bool, ) -> None: - """Will add to the buffer the information to print about the file is the file isn't translated - entirely or above or below requested values + """Will add to the buffer the information to print about the file is + the file isn't translated entirely or above or below requested + values. """ if po_file_stats.percent_translated == 100: # If the file is completely translated @@ -118,9 +113,11 @@ def buffer_add( if po_file_stats.fuzzy_entries else "" ) - # The `reserved by` if the file is reserved unless the offline/hide_reservation are enabled + # The `reserved by` if the file is reserved unless the + # offline/hide_reservation are enabled + ( - f", réservé par {issue_reservations[po_file_stats.filename_dir.lower()]}" + f", réservé par " + f"{issue_reservations[po_file_stats.filename_dir.lower()]}" if po_file_stats.filename_dir.lower() in issue_reservations else "" ) @@ -139,9 +136,11 @@ def buffer_add( if po_file_stats.fuzzy_entries else "" ) - # The `reserved by` if the file is reserved unless the offline/hide_reservation are enabled + # The `reserved by` if the file is reserved unless the + # offline/hide_reservation are enabled + ( - f", réservé par {issue_reservations[po_file_stats.filename_dir.lower()]}" + f", réservé par " + f"{issue_reservations[po_file_stats.filename_dir.lower()]}" if po_file_stats.filename_dir.lower() in issue_reservations else "" ) @@ -173,7 +172,7 @@ def exec_potodo( :param counts: Render list with counts not percentage """ - # Initialize the arguments + # initialize the arguments above, below, issue_reservations = initialize_arguments( above, below, offline, hide_reserved, path ) @@ -226,10 +225,7 @@ def main(): ) parser.add_argument( - "-p", - "--path", - type=Path, - help="Execute Potodo in the given path" + "-p", "--path", type=Path, help="Execute Potodo in the given path" ) parser.add_argument( @@ -271,10 +267,13 @@ def main(): "-c", "--counts", action="store_true", - help="Render list with the count of remaining entries (translate or review) rather than percentage done", + help="Render list with the count of remaining entries " + "(translate or review) rather than percentage done", ) - parser.add_argument('--version', action='version', version='%(prog)s ' + __version__) + parser.add_argument( + "--version", action="version", version="%(prog)s " + __version__ + ) args = parser.parse_args() # If no path is specified, then use the current path diff --git a/tests/fixtures/python-docs-fr/bugs.po b/tests/fixtures/python-docs-fr/bugs.po new file mode 100644 index 0000000..8ef75aa --- /dev/null +++ b/tests/fixtures/python-docs-fr/bugs.po @@ -0,0 +1,248 @@ +# 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: 2019-09-04 11:33+0200\n" +"PO-Revision-Date: 2019-12-12 00:24+0100\n" +"Last-Translator: Antoine Wecxsteen\n" +"Language-Team: FRENCH \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.2.3\n" + +#: ../Doc/bugs.rst:5 +msgid "Dealing with Bugs" +msgstr "S'attaquer aux bogues" + +#: ../Doc/bugs.rst:7 +msgid "" +"Python is a mature programming language which has established a reputation " +"for stability. In order to maintain this reputation, the developers would " +"like to know of any deficiencies you find in Python." +msgstr "" +"Python est un langage de programmation robuste réputé pour sa stabilité. " +"Afin de maintenir cette réputation, les développeurs souhaitent connaître " +"tout problème que vous pourriez rencontrer dans Python." + +#: ../Doc/bugs.rst:11 +msgid "" +"It can be sometimes faster to fix bugs yourself and contribute patches to " +"Python as it streamlines the process and involves less people. Learn how to :" +"ref:`contribute `." +msgstr "" +"Il est parfois plus rapide de réparer les bogues soi-même et d'en proposer " +"les correctifs, ça simplifie le processus et implique moins de monde. " +"Apprenez à :ref:`contribuer `." + +#: ../Doc/bugs.rst:16 +msgid "Documentation bugs" +msgstr "Bogues de documentation" + +#: ../Doc/bugs.rst:18 +msgid "" +"If you find a bug in this documentation or would like to propose an " +"improvement, please submit a bug report on the :ref:`tracker `. If you have a suggestion on how to fix it, include that as well." +msgstr "" +"Si vous trouvez un bogue dans cette documentation ou si vous désirez " +"proposer une amélioration, si cela concerne aussi la documentation en " +"anglais, ouvrez un rapport sur le :ref:`tracker ` " +"décrivant en anglais le bogue et où vous l'avez trouvé. Si le problème ne " +"touche que la traduction en français, ouvrez un ticket sur https://github." +"com/python/python-docs-fr/issues, ou venez nous en toucher un mot sur le " +"canal #python-fr sur *freenode* (https://webchat.freenode.net/). Si vous " +"avez une suggestion de correction, merci de l'inclure également." + +#: ../Doc/bugs.rst:22 +msgid "" +"If you're short on time, you can also email documentation bug reports to " +"docs@python.org (behavioral bugs can be sent to python-list@python.org). " +"'docs@' is a mailing list run by volunteers; your request will be noticed, " +"though it may take a while to be processed." +msgstr "" +"Si vous êtes limité par le temps, vous pouvez aussi envoyer un courriel à " +"docs@python.org (les bogues de comportement peuvent être envoyés à python-" +"list@python.org). 'docs@' est une liste de diffusion gérée par des " +"volontaires, votre requête sera vue, mais elle peut prendre un moment pour " +"être traitée." + +#: ../Doc/bugs.rst:30 +msgid "`Documentation bugs`_" +msgstr "`Bogues de documentation`_" + +#: ../Doc/bugs.rst:30 +msgid "" +"A list of documentation bugs that have been submitted to the Python issue " +"tracker." +msgstr "" +"Liste des bogues de documentation soumis à l'outil de suivi des problèmes " +"Python." + +#: ../Doc/bugs.rst:33 +msgid "`Issue Tracking `_" +msgstr "`Outil de suivi des problèmes `_" + +#: ../Doc/bugs.rst:33 +msgid "" +"Overview of the process involved in reporting an improvement on the tracker." +msgstr "" +"Vue d'ensemble du processus pour proposer une amélioration avec l'outil de " +"suivi." + +#: ../Doc/bugs.rst:35 +msgid "" +"`Helping with Documentation `_" +msgstr "" +"`Aider avec la documentation `_" + +#: ../Doc/bugs.rst:36 +msgid "" +"Comprehensive guide for individuals that are interested in contributing to " +"Python documentation." +msgstr "Guide complet pour qui souhaite contribuer à la documentation Python." + +#: ../Doc/bugs.rst:41 +msgid "Using the Python issue tracker" +msgstr "Utilisation du gestionnaire de tickets Python" + +#: ../Doc/bugs.rst:43 +msgid "" +"Bug reports for Python itself should be submitted via the Python Bug Tracker " +"(https://bugs.python.org/). The bug tracker offers a Web form which allows " +"pertinent information to be entered and submitted to the developers." +msgstr "" +"Les rapports de bogues pour Python lui-même devraient être soumis via le " +"*Bug Tracker Python* (http://bugs.python.org/). Le gestionnaire de tickets " +"propose un formulaire Web permettant de saisir des informations pertinentes " +"à soumettre aux développeurs." + +#: ../Doc/bugs.rst:47 +msgid "" +"The first step in filing a report is to determine whether the problem has " +"already been reported. The advantage in doing so, aside from saving the " +"developers time, is that you learn what has been done to fix it; it may be " +"that the problem has already been fixed for the next release, or additional " +"information is needed (in which case you are welcome to provide it if you " +"can!). To do this, search the bug database using the search box on the top " +"of the page." +msgstr "" +"La première étape pour remplir un rapport est de déterminer si le problème a " +"déjà été rapporté. L'avantage de cette approche, en plus d'économiser du " +"temps aux développeurs, est d'apprendre ce qui a été fait pour le résoudre ; " +"il se peut que le problème soit déjà résolu dans la prochaine version, ou " +"que des informations complémentaires soient attendues (auquel cas votre " +"contribution est la bienvenue !). Pour ce faire, cherchez dans la base de " +"données de bogues grâce à la boîte de recherche en haut de la page." + +#: ../Doc/bugs.rst:54 +msgid "" +"If the problem you're reporting is not already in the bug tracker, go back " +"to the Python Bug Tracker and log in. If you don't already have a tracker " +"account, select the \"Register\" link or, if you use OpenID, one of the " +"OpenID provider logos in the sidebar. It is not possible to submit a bug " +"report anonymously." +msgstr "" +"Si le problème que vous soumettez n'est pas déjà dans le *bug tracker*, " +"revenez au *Python Bug Tracker* et connectez-vous. Si vous n'avez pas déjà " +"un compte pour le *tracker*, cliquez sur le lien « S'enregistrer », ou, si " +"vous utilisez *OpenID*, sur l'un des logos des fournisseurs *OpenID* dans la " +"barre latérale. Il n'est pas possible de soumettre un rapport de bogue de " +"manière anonyme." + +#: ../Doc/bugs.rst:59 +msgid "" +"Being now logged in, you can submit a bug. Select the \"Create New\" link " +"in the sidebar to open the bug reporting form." +msgstr "" +"Une fois identifié, pour pouvez rapporter un bogue. Sélectionnez le lien " +"*Create New* dans la barre latérale pour ouvrir un nouveau formulaire de " +"rapport de bogue." + +#: ../Doc/bugs.rst:62 +msgid "" +"The submission form has a number of fields. For the \"Title\" field, enter " +"a *very* short description of the problem; less than ten words is good. In " +"the \"Type\" field, select the type of your problem; also select the " +"\"Component\" and \"Versions\" to which the bug relates." +msgstr "" +"Le formulaire de soumission a un certain nombre de champs. Pour le champ " +"« Titre », saisissez une *très* courte description du problème ; moins de " +"dix mots est approprié. Dans le champ « Type », sélectionnez le type de " +"problème ; sélectionnez aussi « Composant » et « Versions » en rapport avec " +"le bogue." + +#: ../Doc/bugs.rst:67 +msgid "" +"In the \"Comment\" field, describe the problem in detail, including what you " +"expected to happen and what did happen. Be sure to include whether any " +"extension modules were involved, and what hardware and software platform you " +"were using (including version information as appropriate)." +msgstr "" +"Dans le champ « Commentaire », décrivez le problème de manière détaillée, " +"incluant ce à quoi vous vous attendiez et ce qui s'est vraiment produit. " +"Assurez-vous d'y inclure les éventuels modules d'extensions impliqués et la " +"plateforme matérielle et logicielle vous utilisiez (en incluant les " +"informations de versions)." + +#: ../Doc/bugs.rst:72 +msgid "" +"Each bug report will be assigned to a developer who will determine what " +"needs to be done to correct the problem. You will receive an update each " +"time action is taken on the bug." +msgstr "" +"Chaque bogue sera attribué à un développeur qui déterminera ce qui est " +"nécessaire d'entreprendre pour corriger le problème. Vous recevrez une " +"notification à chaque action effectuée sur le bogue." + +#: ../Doc/bugs.rst:81 +msgid "" +"`How to Report Bugs Effectively `_" +msgstr "" +"`Comment signaler des bogues de manière efficace `_ (en anglais)" + +#: ../Doc/bugs.rst:80 +msgid "" +"Article which goes into some detail about how to create a useful bug report. " +"This describes what kind of information is useful and why it is useful." +msgstr "" +"Article qui entre dans les détails sur la manière de créer un rapport de " +"bogue utile. Il décrit quel genre d'information est utile et pourquoi elle " +"est utile." + +#: ../Doc/bugs.rst:84 +msgid "" +"`Bug Report Writing Guidelines `_" +msgstr "" +"`Guide pour la rédaction de rapports de bogues `_" + +#: ../Doc/bugs.rst:84 +msgid "" +"Information about writing a good bug report. Some of this is specific to " +"the Mozilla project, but describes general good practices." +msgstr "" +"Conseils pour écrire un bon rapport de bogue. Certains sont spécifiques au " +"projet Mozilla mais présentent des bonnes pratiques générales." + +#: ../Doc/bugs.rst:90 +msgid "Getting started contributing to Python yourself" +msgstr "Commencer à contribuer à Python vous-même" + +#: ../Doc/bugs.rst:92 +msgid "" +"Beyond just reporting bugs that you find, you are also welcome to submit " +"patches to fix them. You can find more information on how to get started " +"patching Python in the `Python Developer's Guide`_. If you have questions, " +"the `core-mentorship mailing list`_ is a friendly place to get answers to " +"any and all questions pertaining to the process of fixing issues in Python." +msgstr "" diff --git a/tests/fixtures/python-docs-fr/glossary.po b/tests/fixtures/python-docs-fr/glossary.po new file mode 100644 index 0000000..4644293 --- /dev/null +++ b/tests/fixtures/python-docs-fr/glossary.po @@ -0,0 +1,2773 @@ +# 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: 2019-10-09 17:54+0200\n" +"PO-Revision-Date: 2019-11-02 14:46+0100\n" +"Last-Translator: Grenoya \n" +"Language-Team: FRENCH \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.2.1\n" + +#: ../Doc/glossary.rst:5 +msgid "Glossary" +msgstr "Glossaire" + +#: ../Doc/glossary.rst:10 +msgid "``>>>``" +msgstr "``>>>``" + +#: ../Doc/glossary.rst:12 +msgid "" +"The default Python prompt of the interactive shell. Often seen for code " +"examples which can be executed interactively in the interpreter." +msgstr "" +"L'invite de commande utilisée par défaut dans l'interpréteur interactif. On " +"la voit souvent dans des exemples de code qui peuvent être exécutés " +"interactivement dans l'interpréteur." + +#: ../Doc/glossary.rst:14 +msgid "``...``" +msgstr "``...``" + +#: ../Doc/glossary.rst:16 +msgid "Can refer to:" +msgstr "Peut faire référence à :" + +#: ../Doc/glossary.rst:18 +msgid "" +"The default Python prompt of the interactive shell when entering the code " +"for an indented code block, when within a pair of matching left and right " +"delimiters (parentheses, square brackets, curly braces or triple quotes), or " +"after specifying a decorator." +msgstr "" +"L'invite de commande utilisée par défaut dans l'interpréteur interactif " +"lorsqu'on entre un bloc de code indenté, dans des délimiteurs fonctionnant " +"par paires (parenthèses, crochets, accolades, triple guillemets), ou après " +"un avoir spécifié un décorateur." + +#: ../Doc/glossary.rst:23 +msgid "The :const:`Ellipsis` built-in constant." +msgstr "La constante :const:`Ellipsis`." + +#: ../Doc/glossary.rst:24 +msgid "2to3" +msgstr "*2to3*" + +#: ../Doc/glossary.rst:26 +msgid "" +"A tool that tries to convert Python 2.x code to Python 3.x code by handling " +"most of the incompatibilities which can be detected by parsing the source " +"and traversing the parse tree." +msgstr "" +"Outil qui essaie de convertir du code pour Python 2.x en code pour Python 3." +"x en gérant la plupart des incompatibilités qui peuvent être détectées en " +"analysant la source et parcourant son arbre syntaxique." + +#: ../Doc/glossary.rst:30 +msgid "" +"2to3 is available in the standard library as :mod:`lib2to3`; a standalone " +"entry point is provided as :file:`Tools/scripts/2to3`. See :ref:`2to3-" +"reference`." +msgstr "" +"*2to3* est disponible dans la bibliothèque standard sous le nom de :mod:" +"`lib2to3`; un point d’entrée indépendant est fourni via :file:`Tools/" +"scripts/2to3`. Cf. :ref:`2to3-reference`." + +#: ../Doc/glossary.rst:33 +msgid "abstract base class" +msgstr "classe de base abstraite" + +#: ../Doc/glossary.rst:35 +msgid "" +"Abstract base classes complement :term:`duck-typing` by providing a way to " +"define interfaces when other techniques like :func:`hasattr` would be clumsy " +"or subtly wrong (for example with :ref:`magic methods `). " +"ABCs introduce virtual subclasses, which are classes that don't inherit from " +"a class but are still recognized by :func:`isinstance` and :func:" +"`issubclass`; see the :mod:`abc` module documentation. Python comes with " +"many built-in ABCs for data structures (in the :mod:`collections.abc` " +"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` " +"module), import finders and loaders (in the :mod:`importlib.abc` module). " +"You can create your own ABCs with the :mod:`abc` module." +msgstr "" +"Les classes de base abstraites (ABC, suivant l'abréviation anglaise " +"*Abstract Base Class*) complètent le :term:`duck-typing` en fournissant un " +"moyen de définir des interfaces pour les cas où d'autres techniques comme :" +"func:`hasattr` seraient inélégantes ou subtilement fausses (par exemple avec " +"les :ref:`méthodes magiques `). Les ABC introduisent des " +"sous-classes virtuelles qui n'héritent pas d'une classe mais qui sont quand " +"même reconnues par :func:`isinstance` ou :func:`issubclass` (voir la " +"documentation du module :mod:`abc`). Python contient de nombreuses ABC pour " +"les structures de données (dans le module :mod:`collections.abc`), les " +"nombres (dans le module :mod:`numbers`), les flux (dans le module :mod:`io`) " +"et les chercheurs-chargeurs du système d'importation (dans le module :mod:" +"`importlib.abc`). Vous pouvez créer vos propres ABC avec le module :mod:" +"`abc`." + +#: ../Doc/glossary.rst:46 +msgid "annotation" +msgstr "annotation" + +#: ../Doc/glossary.rst:48 +msgid "" +"A label associated with a variable, a class attribute or a function " +"parameter or return value, used by convention as a :term:`type hint`." +msgstr "" +"Étiquette associée à une variable, un attribut de classe, un paramètre de " +"fonction ou une valeur de retour. Elle est utilisé par convention comme :" +"term:`type hint`." + +#: ../Doc/glossary.rst:52 +msgid "" +"Annotations of local variables cannot be accessed at runtime, but " +"annotations of global variables, class attributes, and functions are stored " +"in the :attr:`__annotations__` special attribute of modules, classes, and " +"functions, respectively." +msgstr "" +"Les annotations de variables locales ne sont pas accessibles au moment de " +"l'exécution, mais les annotations de variables globales, d'attributs de " +"classe et de fonctions sont stockées dans l'attribut spécial :attr:" +"`__annotations__` des modules, classes et fonctions, respectivement." + +#: ../Doc/glossary.rst:58 +msgid "" +"See :term:`variable annotation`, :term:`function annotation`, :pep:`484` " +"and :pep:`526`, which describe this functionality." +msgstr "" +"Voir :term:`variable annotation`, :term:`function annotation`, :pep:`484` " +"et :pep:`526`, qui décrivent cette fonctionnalité." + +#: ../Doc/glossary.rst:60 +msgid "argument" +msgstr "argument" + +#: ../Doc/glossary.rst:62 +msgid "" +"A value passed to a :term:`function` (or :term:`method`) when calling the " +"function. There are two kinds of argument:" +msgstr "" +"Valeur, donnée à une :term:`fonction` ou à une :term:`méthode` lors de son " +"appel. Il existe deux types d'arguments :" + +#: ../Doc/glossary.rst:65 +msgid "" +":dfn:`keyword argument`: an argument preceded by an identifier (e.g. " +"``name=``) in a function call or passed as a value in a dictionary preceded " +"by ``**``. For example, ``3`` and ``5`` are both keyword arguments in the " +"following calls to :func:`complex`::" +msgstr "" +":dfn:`argument nommé` : un argument précédé d'un identifiant (comme " +"``name=``) ou un dictionnaire précédé de ``**``, lors d'un appel de " +"fonction. Par exemple, ``3`` et ``5`` sont tous les deux des arguments " +"nommés dans l'appel à :func:`complex` ici ::" + +#: ../Doc/glossary.rst:73 +msgid "" +":dfn:`positional argument`: an argument that is not a keyword argument. " +"Positional arguments can appear at the beginning of an argument list and/or " +"be passed as elements of an :term:`iterable` preceded by ``*``. For example, " +"``3`` and ``5`` are both positional arguments in the following calls::" +msgstr "" +":dfn:`argument positionnel` : Un argument qui n'est pas nommé. Les arguments " +"positionnels apparaissent au début de la liste des arguments, ou donnés sous " +"forme d'un :term:`itérable` précédé par ``*``. Par exemple, ``3`` et ``5`` " +"sont tous les deux des arguments positionnels dans les appels suivants ::" + +#: ../Doc/glossary.rst:82 +msgid "" +"Arguments are assigned to the named local variables in a function body. See " +"the :ref:`calls` section for the rules governing this assignment. " +"Syntactically, any expression can be used to represent an argument; the " +"evaluated value is assigned to the local variable." +msgstr "" +"Les arguments se retrouvent dans le corps de la fonction appelée parmi les " +"variables locales. Voir la section :ref:`calls` à propos des règles dictant " +"cette affectation. Syntaxiquement, toute expression est acceptée comme " +"argument, et c'est la valeur résultante de l'expression qui sera affectée à " +"la variable locale." + +#: ../Doc/glossary.rst:87 +msgid "" +"See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the " +"difference between arguments and parameters `, " +"and :pep:`362`." +msgstr "" +"Voir aussi :term:`parameter` dans le glossaire, la question :ref:" +"`Différence entre argument et paramètre ` de la " +"FAQ et la :pep:`362`." + +#: ../Doc/glossary.rst:90 +msgid "asynchronous context manager" +msgstr "gestionnaire de contexte asynchrone" + +#: ../Doc/glossary.rst:92 +msgid "" +"An object which controls the environment seen in an :keyword:`async with` " +"statement by defining :meth:`__aenter__` and :meth:`__aexit__` methods. " +"Introduced by :pep:`492`." +msgstr "" +"(*asynchronous context manager* en anglais) Objet contrôlant l'environnement " +"à l'intérieur d'une instruction :keyword:`with` en définissant les méthodes :" +"meth:`__aenter__` et :meth:`__aexit__`. A été Introduit par la :pep:`492`." + +#: ../Doc/glossary.rst:95 +msgid "asynchronous generator" +msgstr "générateur asynchrone" + +#: ../Doc/glossary.rst:97 +msgid "" +"A function which returns an :term:`asynchronous generator iterator`. It " +"looks like a coroutine function defined with :keyword:`async def` except " +"that it contains :keyword:`yield` expressions for producing a series of " +"values usable in an :keyword:`async for` loop." +msgstr "" +"Fonction qui renvoie un :term:`asynchronous generator iterator`. Cela " +"ressemble à une coroutine définie par :keyword:`async def`, sauf qu'elle " +"contient une ou des expressions :keyword:`yield` produisant ainsi uns série " +"de valeurs utilisables dans une boucle :keyword:`async for`." + +#: ../Doc/glossary.rst:102 +msgid "" +"Usually refers to an asynchronous generator function, but may refer to an " +"*asynchronous generator iterator* in some contexts. In cases where the " +"intended meaning isn't clear, using the full terms avoids ambiguity." +msgstr "" +"Générateur asynchrone fait généralement référence à une fonction, mais peut " +"faire référence à un *itérateur de générateur asynchrone* dans certains " +"contextes. Dans les cas où le sens voulu n'est pas clair, utiliser " +"l'ensemble des termes lève l’ambiguïté." + +#: ../Doc/glossary.rst:106 +msgid "" +"An asynchronous generator function may contain :keyword:`await` expressions " +"as well as :keyword:`async for`, and :keyword:`async with` statements." +msgstr "" +"Un générateur asynchrone peut contenir des expressions :keyword:`await` " +"ainsi que des instructions :keyword:`async for`, et :keyword:`async with`." + +#: ../Doc/glossary.rst:109 +msgid "asynchronous generator iterator" +msgstr "itérateur de générateur asynchrone" + +#: ../Doc/glossary.rst:111 +msgid "An object created by a :term:`asynchronous generator` function." +msgstr "Objet créé par une fonction :term:`asynchronous generator`." + +#: ../Doc/glossary.rst:113 +msgid "" +"This is an :term:`asynchronous iterator` which when called using the :meth:" +"`__anext__` method returns an awaitable object which will execute the body " +"of the asynchronous generator function until the next :keyword:`yield` " +"expression." +msgstr "" +"C'est un :term:`asynchronous iterator` qui, lorsqu'il est appelé via la " +"méthode :meth:`__anext__` renvoie un objet *awaitable* qui exécute le corps " +"de la fonction du générateur asynchrone jusqu'au prochain :keyword:`yield`." + +#: ../Doc/glossary.rst:118 +msgid "" +"Each :keyword:`yield` temporarily suspends processing, remembering the " +"location execution state (including local variables and pending try-" +"statements). When the *asynchronous generator iterator* effectively resumes " +"with another awaitable returned by :meth:`__anext__`, it picks up where it " +"left off. See :pep:`492` and :pep:`525`." +msgstr "" +"Chaque :keyword:`yield` suspend temporairement l'exécution, en gardant en " +"mémoire l'endroit et l'état de l'exécution (ce qui inclut les variables " +"locales et les *try* en cours). Lorsque l'exécution de l'itérateur de " +"générateur asynchrone reprend avec un nouvel *awaitable* renvoyé par :meth:" +"`__anext__`, elle repart de là où elle s'était arrêtée. Voir la :pep:`492` " +"et la :pep:`525`." + +#: ../Doc/glossary.rst:123 +msgid "asynchronous iterable" +msgstr "itérable asynchrone" + +#: ../Doc/glossary.rst:125 +msgid "" +"An object, that can be used in an :keyword:`async for` statement. Must " +"return an :term:`asynchronous iterator` from its :meth:`__aiter__` method. " +"Introduced by :pep:`492`." +msgstr "" +"Objet qui peut être utilisé dans une instruction :keyword:`async for`. Sa " +"méthode :meth:`__aiter__` doit renvoyer un :term:`asynchronous iterator`. A " +"été introduit par la :pep:`492`." + +#: ../Doc/glossary.rst:128 +msgid "asynchronous iterator" +msgstr "itérateur asynchrone" + +#: ../Doc/glossary.rst:130 +msgid "" +"An object that implements the :meth:`__aiter__` and :meth:`__anext__` " +"methods. ``__anext__`` must return an :term:`awaitable` object. :keyword:" +"`async for` resolves the awaitables returned by an asynchronous iterator's :" +"meth:`__anext__` method until it raises a :exc:`StopAsyncIteration` " +"exception. Introduced by :pep:`492`." +msgstr "" +"Objet qui implémente les méthodes :meth:`__aiter__` et :meth:`__anext__`. " +"``__anext__`` doit renvoyer un objet :term:`awaitable`. Tant que la méthode :" +"meth:`__anext__` produit des objets *awaitable*, le :keyword:`async for` " +"appelant les consomme. L'itérateur asynchrone lève une exception :exc:" +"`StopAsyncIteration` pour signifier la fin de l'itération. A été introduit " +"par la :pep:`492`." + +#: ../Doc/glossary.rst:135 +msgid "attribute" +msgstr "attribut" + +#: ../Doc/glossary.rst:137 +msgid "" +"A value associated with an object which is referenced by name using dotted " +"expressions. For example, if an object *o* has an attribute *a* it would be " +"referenced as *o.a*." +msgstr "" +"Valeur associée à un objet et désignée par son nom via une notation " +"utilisant des points. Par exemple, si un objet *o* possède un attribut *a*, " +"il sera référencé par *o.a*." + +#: ../Doc/glossary.rst:140 +msgid "awaitable" +msgstr "*awaitable*" + +#: ../Doc/glossary.rst:142 +msgid "" +"An object that can be used in an :keyword:`await` expression. Can be a :" +"term:`coroutine` or an object with an :meth:`__await__` method. See also :" +"pep:`492`." +msgstr "" +"Objet pouvant être utilisé dans une expression :keyword:`await`. Peut être " +"une :term:`coroutine` ou un objet avec une méthode :meth:`__await__`. Voir " +"aussi la :pep:`492`." + +#: ../Doc/glossary.rst:145 +msgid "BDFL" +msgstr "*BDFL*" + +#: ../Doc/glossary.rst:147 +msgid "" +"Benevolent Dictator For Life, a.k.a. `Guido van Rossum `_, Python's creator." +msgstr "" +"Dictateur bienveillant à vie (*Benevolent Dictator For Life* en anglais). " +"Pseudonyme de `Guido van Rossum `_, le " +"créateur de Python." + +#: ../Doc/glossary.rst:149 +msgid "binary file" +msgstr "fichier binaire" + +#: ../Doc/glossary.rst:151 +msgid "" +"A :term:`file object` able to read and write :term:`bytes-like objects " +"`. Examples of binary files are files opened in binary " +"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer`, :data:`sys." +"stdout.buffer`, and instances of :class:`io.BytesIO` and :class:`gzip." +"GzipFile`." +msgstr "" +"Un :term:`file object` capable de lire et d'écrire des :term:`bytes-like " +"objects `. Des fichiers binaires sont, par exemple, les " +"fichiers ouverts en mode binaire (``'rb'``, ``'wb'``, ou ``'rb+'``), :data:" +"`sys.stdin.buffer`, :data:`sys.stdout.buffer`, les instances de :class:`io." +"BytesIO` ou de :class:`gzip.GzipFile`." + +#: ../Doc/glossary.rst:158 +msgid "" +"See also :term:`text file` for a file object able to read and write :class:" +"`str` objects." +msgstr "" +"Consultez :term:`fichier texte`, un objet fichier capable de lire et " +"d'écrire des objets :class:`str`." + +#: ../Doc/glossary.rst:160 +msgid "bytes-like object" +msgstr "objet octet-compatible" + +#: ../Doc/glossary.rst:162 +msgid "" +"An object that supports the :ref:`bufferobjects` and can export a C-:term:" +"`contiguous` buffer. This includes all :class:`bytes`, :class:`bytearray`, " +"and :class:`array.array` objects, as well as many common :class:`memoryview` " +"objects. Bytes-like objects can be used for various operations that work " +"with binary data; these include compression, saving to a binary file, and " +"sending over a socket." +msgstr "" +"Un objet gérant les :ref:`bufferobjects` et pouvant exporter un tampon " +"(*buffer* en anglais) C-:term:`contiguous`. Cela inclut les objets :class:" +"`bytes`, :class:`bytearray` et :class:`array.array`, ainsi que beaucoup " +"d'objets :class:`memoryview`. Les objets bytes-compatibles peuvent être " +"utilisés pour diverses opérations sur des données binaires, comme la " +"compression, la sauvegarde dans un fichier binaire ou l'envoi sur le réseau." + +#: ../Doc/glossary.rst:169 +msgid "" +"Some operations need the binary data to be mutable. The documentation often " +"refers to these as \"read-write bytes-like objects\". Example mutable " +"buffer objects include :class:`bytearray` and a :class:`memoryview` of a :" +"class:`bytearray`. Other operations require the binary data to be stored in " +"immutable objects (\"read-only bytes-like objects\"); examples of these " +"include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object." +msgstr "" +"Certaines opérations nécessitent de travailler sur des données binaires " +"variables. La documentation parle de ceux-ci comme des *read-write bytes-" +"like objects*. Par exemple, :class:`bytearray` ou une :class:`memoryview` " +"d'un :class:`bytearray` en font partie. D'autres opérations nécessitent de " +"travailler sur des données binaires stockées dans des objets immuables (*" +"\"read-only bytes-like objects\"*), par exemples :class:`bytes` ou :class:" +"`memoryview` d'un objet :class:`byte`." + +#: ../Doc/glossary.rst:177 +msgid "bytecode" +msgstr "code intermédiaire (*bytecode*)" + +#: ../Doc/glossary.rst:179 +msgid "" +"Python source code is compiled into bytecode, the internal representation of " +"a Python program in the CPython interpreter. The bytecode is also cached in " +"``.pyc`` files so that executing the same file is faster the second time " +"(recompilation from source to bytecode can be avoided). This \"intermediate " +"language\" is said to run on a :term:`virtual machine` that executes the " +"machine code corresponding to each bytecode. Do note that bytecodes are not " +"expected to work between different Python virtual machines, nor to be stable " +"between Python releases." +msgstr "" +"Le code source, en Python, est compilé en un code intermédiaire (*bytecode* " +"en anglais), la représentation interne à CPython d'un programme Python. Le " +"code intermédiaire est mis en cache dans un fichier ``.pyc`` de manière à ce " +"qu'une seconde exécution soit plus rapide (la compilation en code " +"intermédiaire a déjà été faite). On dit que ce *langage intermédiaire* est " +"exécuté sur une :term:`virtual machine` qui exécute des instructions machine " +"pour chaque instruction du code intermédiaire. Notez que le code " +"intermédiaire n'a pas vocation à fonctionner sur différentes machines " +"virtuelles Python ou à être stable entre différentes versions de Python." + +#: ../Doc/glossary.rst:189 +msgid "" +"A list of bytecode instructions can be found in the documentation for :ref:" +"`the dis module `." +msgstr "" +"La documentation du :ref:`module dis ` fournit une liste des " +"instructions du code intermédiaire." + +#: ../Doc/glossary.rst:191 +msgid "class" +msgstr "classe" + +#: ../Doc/glossary.rst:193 +msgid "" +"A template for creating user-defined objects. Class definitions normally " +"contain method definitions which operate on instances of the class." +msgstr "" +"Modèle pour créer des objets définis par l'utilisateur. Une définition de " +"classe (*class*) contient normalement des définitions de méthodes qui " +"agissent sur les instances de la classe." + +#: ../Doc/glossary.rst:196 +msgid "class variable" +msgstr "variable de classe" + +#: ../Doc/glossary.rst:198 +msgid "" +"A variable defined in a class and intended to be modified only at class " +"level (i.e., not in an instance of the class)." +msgstr "" +"Une variable définie dans une classe et destinée à être modifiée uniquement " +"au niveau de la classe (c'est-à-dire, pas dans une instance de la classe)." + +#: ../Doc/glossary.rst:200 +msgid "coercion" +msgstr "coercition" + +#: ../Doc/glossary.rst:202 +msgid "" +"The implicit conversion of an instance of one type to another during an " +"operation which involves two arguments of the same type. For example, " +"``int(3.15)`` converts the floating point number to the integer ``3``, but " +"in ``3+4.5``, each argument is of a different type (one int, one float), and " +"both must be converted to the same type before they can be added or it will " +"raise a :exc:`TypeError`. Without coercion, all arguments of even " +"compatible types would have to be normalized to the same value by the " +"programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``." +msgstr "" +"Conversion implicite d'une instance d'un type vers un autre lors d'une " +"opération dont les deux opérandes doivent être de même type. Par exemple " +"``int(3.15)`` convertit explicitement le nombre à virgule flottante en " +"nombre entier ``3``. Mais dans l'opération ``3 + 4.5``, les deux opérandes " +"sont d'un type différent (Un entier et un nombre à virgule flottante), alors " +"qu'elles doivent avoir le même type pour être additionnées (sinon une " +"exception :exc:`TypeError` serait levée). Sans coercition, toutes les " +"opérandes, même de types compatibles, devraient être converties (on parle " +"aussi de *cast*) explicitement par le développeur, par exemple : ``float(3) " +"+ 4.5`` au lieu du simple ``3 + 4.5``." + +#: ../Doc/glossary.rst:210 +msgid "complex number" +msgstr "nombre complexe" + +#: ../Doc/glossary.rst:212 +msgid "" +"An extension of the familiar real number system in which all numbers are " +"expressed as a sum of a real part and an imaginary part. Imaginary numbers " +"are real multiples of the imaginary unit (the square root of ``-1``), often " +"written ``i`` in mathematics or ``j`` in engineering. Python has built-in " +"support for complex numbers, which are written with this latter notation; " +"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``. To get " +"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`. " +"Use of complex numbers is a fairly advanced mathematical feature. If you're " +"not aware of a need for them, it's almost certain you can safely ignore them." +msgstr "" +"Extension des nombres réels familiers, dans laquelle tous les nombres sont " +"exprimés sous la forme d'une somme d'une partie réelle et d'une partie " +"imaginaire. Les nombres imaginaires sont les nombres réels multipliés par " +"l'unité imaginaire (la racine carrée de ``-1``, souvent écrite ``i`` en " +"mathématiques ou ``j`` par les ingénieurs). Python comprend nativement les " +"nombres complexes, écrits avec cette dernière notation : la partie " +"imaginaire est écrite avec un suffixe ``j``, exemple, ``3+1j``. Pour " +"utiliser les équivalents complexes de :mod:`math`, utilisez :mod:`cmath`. " +"Les nombres complexes sont un concept assez avancé en mathématiques. Si vous " +"ne connaissez pas ce concept, vous pouvez tranquillement les ignorer." + +#: ../Doc/glossary.rst:222 +msgid "context manager" +msgstr "gestionnaire de contexte" + +#: ../Doc/glossary.rst:224 +msgid "" +"An object which controls the environment seen in a :keyword:`with` statement " +"by defining :meth:`__enter__` and :meth:`__exit__` methods. See :pep:`343`." +msgstr "" +"Objet contrôlant l'environnement à l'intérieur d'un bloc :keyword:`with` en " +"définissant les méthodes :meth:`__enter__` et :meth:`__exit__`. Consultez " +"la :pep:`343`." + +#: ../Doc/glossary.rst:227 +msgid "context variable" +msgstr "variable de contexte" + +#: ../Doc/glossary.rst:229 +msgid "" +"A variable which can have different values depending on its context. This is " +"similar to Thread-Local Storage in which each execution thread may have a " +"different value for a variable. However, with context variables, there may " +"be several contexts in one execution thread and the main usage for context " +"variables is to keep track of variables in concurrent asynchronous tasks. " +"See :mod:`contextvars`." +msgstr "" +"Une variable qui peut avoir des valeurs différentes en fonction de son " +"contexte. Cela est similaire au stockage par fil d’exécution (*Thread Local " +"Storage* en anglais) dans lequel chaque fil d’exécution peut avoir une " +"valeur différente pour une variable. Toutefois, avec les variables de " +"contexte, il peut y avoir plusieurs contextes dans un fil d’exécution et " +"l’utilisation principale pour les variables de contexte est de garder une " +"trace des variables dans les tâches asynchrones concourantes. Voir :mod:" +"`contextvars`." + +#: ../Doc/glossary.rst:236 +msgid "contiguous" +msgstr "contigu" + +#: ../Doc/glossary.rst:240 +msgid "" +"A buffer is considered contiguous exactly if it is either *C-contiguous* or " +"*Fortran contiguous*. Zero-dimensional buffers are C and Fortran " +"contiguous. In one-dimensional arrays, the items must be laid out in memory " +"next to each other, in order of increasing indexes starting from zero. In " +"multidimensional C-contiguous arrays, the last index varies the fastest when " +"visiting items in order of memory address. However, in Fortran contiguous " +"arrays, the first index varies the fastest." +msgstr "" +"Un tampon (*buffer* en anglais) est considéré comme contigu s’il est soit *C-" +"contigu* soit *Fortran-contigu*. Les tampons de dimension zéro sont C-" +"contigus et Fortran-contigus. Pour un tableau à une dimension, ses éléments " +"doivent être placés en mémoire l’un à côté de l’autre, dans l’ordre " +"croissant de leur indice, en commençant à zéro. Pour qu’un tableau " +"multidimensionnel soit C-contigu, le dernier indice doit être celui qui " +"varie le plus rapidement lors du parcours de ses éléments dans l’ordre de " +"leur adresse mémoire. À l'inverse, dans les tableaux Fortran-contigu, c’est " +"le premier indice qui doit varier le plus rapidement." + +#: ../Doc/glossary.rst:248 +msgid "coroutine" +msgstr "coroutine" + +#: ../Doc/glossary.rst:250 +msgid "" +"Coroutines are a more generalized form of subroutines. Subroutines are " +"entered at one point and exited at another point. Coroutines can be " +"entered, exited, and resumed at many different points. They can be " +"implemented with the :keyword:`async def` statement. See also :pep:`492`." +msgstr "" +"Les coroutines sont une forme généralisées des fonctions. On entre dans une " +"fonction en un point et on en sort en un autre point. On peut entrer, sortir " +"et reprendre l'exécution d'une coroutine en plusieurs points. Elles peuvent " +"être implémentées en utilisant l'instruction :keyword:`async def`. Voir " +"aussi la :pep:`492`." + +#: ../Doc/glossary.rst:255 +msgid "coroutine function" +msgstr "fonction coroutine" + +#: ../Doc/glossary.rst:257 +msgid "" +"A function which returns a :term:`coroutine` object. A coroutine function " +"may be defined with the :keyword:`async def` statement, and may contain :" +"keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords. " +"These were introduced by :pep:`492`." +msgstr "" +"Fonction qui renvoie un objet :term:`coroutine`. Une fonction coroutine peut " +"être définie par l'instruction :keyword:`async def` et peut contenir les " +"mots clés :keyword:`await`, :keyword:`async for` ainsi que :keyword:`async " +"with`. A été introduit par la :pep:`492`." + +#: ../Doc/glossary.rst:262 +msgid "CPython" +msgstr "CPython" + +#: ../Doc/glossary.rst:264 +msgid "" +"The canonical implementation of the Python programming language, as " +"distributed on `python.org `_. The term \"CPython\" " +"is used when necessary to distinguish this implementation from others such " +"as Jython or IronPython." +msgstr "" +"L'implémentation canonique du langage de programmation Python, tel que " +"distribué sur `python.org `_. Le terme \"CPython\" " +"est utilisé dans certains contextes lorsqu'il est nécessaire de distinguer " +"cette implémentation des autres comme *Jython* ou *IronPython*." + +#: ../Doc/glossary.rst:268 +msgid "decorator" +msgstr "décorateur" + +#: ../Doc/glossary.rst:270 +msgid "" +"A function returning another function, usually applied as a function " +"transformation using the ``@wrapper`` syntax. Common examples for " +"decorators are :func:`classmethod` and :func:`staticmethod`." +msgstr "" +"Fonction dont la valeur de retour est une autre fonction. Un décorateur est " +"habituellement utilisé pour transformer une fonction via la syntaxe " +"``@wrapper``, dont les exemples typiques sont : :func:`classmethod` et :func:" +"`staticmethod`." + +#: ../Doc/glossary.rst:274 +msgid "" +"The decorator syntax is merely syntactic sugar, the following two function " +"definitions are semantically equivalent::" +msgstr "" +"La syntaxe des décorateurs est simplement du sucre syntaxique, les " +"définitions des deux fonctions suivantes sont sémantiquement équivalentes ::" + +#: ../Doc/glossary.rst:285 +msgid "" +"The same concept exists for classes, but is less commonly used there. See " +"the documentation for :ref:`function definitions ` and :ref:`class " +"definitions ` for more about decorators." +msgstr "" +"Quoique moins fréquemment utilisé, le même concept existe pour les classes. " +"Consultez la documentation :ref:`définitions de fonctions ` et :" +"ref:`définitions de classes ` pour en savoir plus sur les décorateurs." + +#: ../Doc/glossary.rst:288 +msgid "descriptor" +msgstr "descripteur" + +#: ../Doc/glossary.rst:290 +msgid "" +"Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or :" +"meth:`__delete__`. When a class attribute is a descriptor, its special " +"binding behavior is triggered upon attribute lookup. Normally, using *a.b* " +"to get, set or delete an attribute looks up the object named *b* in the " +"class dictionary for *a*, but if *b* is a descriptor, the respective " +"descriptor method gets called. Understanding descriptors is a key to a deep " +"understanding of Python because they are the basis for many features " +"including functions, methods, properties, class methods, static methods, and " +"reference to super classes." +msgstr "" +"N'importe quel objet définissant les méthodes :meth:`__get__`, :meth:" +"`__set__`, ou :meth:`__delete__`. Lorsque l'attribut d'une classe est un " +"descripteur, son comportement spécial est déclenché lors de la recherche des " +"attributs. Normalement, lorsque vous écrivez *a.b* pour obtenir, affecter " +"ou effacer un attribut, Python recherche l'objet nommé *b* dans le " +"dictionnaire de la classe de *a*. Mais si *b* est un descripteur, c'est la " +"méthode de ce descripteur qui est alors appelée. Comprendre les descripteurs " +"est requis pour avoir une compréhension approfondie de Python, ils sont la " +"base de nombre de ses caractéristiques notamment les fonctions, méthodes, " +"propriétés, méthodes de classes, méthodes statiques et les références aux " +"classes parentes." + +#: ../Doc/glossary.rst:300 +msgid "" +"For more information about descriptors' methods, see :ref:`descriptors`." +msgstr "" +"Pour plus d'informations sur les méthodes des descripteurs, consultez :ref:" +"`descriptors`." + +#: ../Doc/glossary.rst:301 +msgid "dictionary" +msgstr "dictionnaire" + +#: ../Doc/glossary.rst:303 +msgid "" +"An associative array, where arbitrary keys are mapped to values. The keys " +"can be any object with :meth:`__hash__` and :meth:`__eq__` methods. Called a " +"hash in Perl." +msgstr "" +"Structure de donnée associant des clés à des valeurs. Les clés peuvent être " +"n'importe quel objet possédant les méthodes :meth:`__hash__` et :meth:" +"`__eq__`. En Perl, les dictionnaires sont appelés \"*hash*\"." + +#: ../Doc/glossary.rst:306 +msgid "dictionary view" +msgstr "vue de dictionnaire" + +#: ../Doc/glossary.rst:308 +msgid "" +"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and :meth:" +"`dict.items` are called dictionary views. They provide a dynamic view on the " +"dictionary’s entries, which means that when the dictionary changes, the view " +"reflects these changes. To force the dictionary view to become a full list " +"use ``list(dictview)``. See :ref:`dict-views`." +msgstr "" +"Objets retournés par les méthodes :meth:`dict.keys`, :meth:`dict.values` et :" +"meth:`dict.items`. Ils fournissent des vues dynamiques des entrées du " +"dictionnaire, ce qui signifie que lorsque le dictionnaire change, la vue " +"change. Pour transformer une vue en vraie liste, utilisez " +"``list(dictview)``. Voir :ref:`dict-views`." + +#: ../Doc/glossary.rst:314 +msgid "docstring" +msgstr "*docstring* (chaîne de documentation)" + +#: ../Doc/glossary.rst:316 +msgid "" +"A string literal which appears as the first expression in a class, function " +"or module. While ignored when the suite is executed, it is recognized by " +"the compiler and put into the :attr:`__doc__` attribute of the enclosing " +"class, function or module. Since it is available via introspection, it is " +"the canonical place for documentation of the object." +msgstr "" +"Première chaîne littérale qui apparaît dans l'expression d'une classe, " +"fonction, ou module. Bien qu'ignorée à l'exécution, elles est reconnue par " +"le compilateur et placée dans l'attribut :attr:`__doc__` de la classe, de la " +"fonction ou du module. Comme cette chaîne est disponible par introspection, " +"c'est l'endroit idéal pour documenter l'objet." + +#: ../Doc/glossary.rst:322 +msgid "duck-typing" +msgstr "*duck-typing*" + +#: ../Doc/glossary.rst:324 +msgid "" +"A programming style which does not look at an object's type to determine if " +"it has the right interface; instead, the method or attribute is simply " +"called or used (\"If it looks like a duck and quacks like a duck, it must be " +"a duck.\") By emphasizing interfaces rather than specific types, well-" +"designed code improves its flexibility by allowing polymorphic " +"substitution. Duck-typing avoids tests using :func:`type` or :func:" +"`isinstance`. (Note, however, that duck-typing can be complemented with :" +"term:`abstract base classes `.) Instead, it typically " +"employs :func:`hasattr` tests or :term:`EAFP` programming." +msgstr "" +"Style de programmation qui ne prend pas en compte le type d'un objet pour " +"déterminer s'il respecte une interface, mais qui appelle simplement la " +"méthode ou l'attribut (*Si ça a un bec et que ça cancane, ça doit être un " +"canard*, *duck* signifie canard en anglais). En se concentrant sur les " +"interfaces plutôt que les types, du code bien construit améliore sa " +"flexibilité en autorisant des substitutions polymorphiques. Le *duck-typing* " +"évite de vérifier les types via :func:`type` ou :func:`isinstance`, Notez " +"cependant que le *duck-typing* peut travailler de pair avec les :term:" +"`classes de base abstraites `. À la place, le " +"*duck-typing* utilise plutôt :func:`hasattr` ou la programmation :term:" +"`EAFP`." + +#: ../Doc/glossary.rst:333 +msgid "EAFP" +msgstr "EAFP" + +#: ../Doc/glossary.rst:335 +msgid "" +"Easier to ask for forgiveness than permission. This common Python coding " +"style assumes the existence of valid keys or attributes and catches " +"exceptions if the assumption proves false. This clean and fast style is " +"characterized by the presence of many :keyword:`try` and :keyword:`except` " +"statements. The technique contrasts with the :term:`LBYL` style common to " +"many other languages such as C." +msgstr "" +"Il est plus simple de demander pardon que demander la permission (*Easier to " +"Ask for Forgiveness than Permission* en anglais). Ce style de développement " +"Python fait l'hypothèse que le code est valide et traite les exceptions si " +"cette hypothèse s'avère fausse. Ce style, propre et efficace, est " +"caractérisé par la présence de beaucoup de mots clés :keyword:`try` et :" +"keyword:`except`. Cette technique de programmation contraste avec le style :" +"term:`LBYL` utilisé couramment dans les langages tels que C." + +#: ../Doc/glossary.rst:341 +msgid "expression" +msgstr "expression" + +#: ../Doc/glossary.rst:343 +msgid "" +"A piece of syntax which can be evaluated to some value. In other words, an " +"expression is an accumulation of expression elements like literals, names, " +"attribute access, operators or function calls which all return a value. In " +"contrast to many other languages, not all language constructs are " +"expressions. There are also :term:`statement`\\s which cannot be used as " +"expressions, such as :keyword:`while`. Assignments are also statements, not " +"expressions." +msgstr "" +"Suite logique de termes et chiffres conformes à la syntaxe Python dont " +"l'évaluation fournit une valeur. En d'autres termes, une expression est une " +"suite d'éléments tels que des noms, opérateurs, littéraux, accès " +"d'attributs, méthodes ou fonctions qui aboutissent à une valeur. " +"Contrairement à beaucoup d'autres langages, les différentes constructions du " +"langage ne sont pas toutes des expressions. On trouve également des :term:" +"`instructions ` qui ne peuvent pas être utilisées comme " +"expressions, tel que :keyword:`while`. Les affectations sont également des " +"instructions et non des expressions." + +#: ../Doc/glossary.rst:350 +msgid "extension module" +msgstr "module d'extension" + +#: ../Doc/glossary.rst:352 +msgid "" +"A module written in C or C++, using Python's C API to interact with the core " +"and with user code." +msgstr "" +"Module écrit en C ou C++, utilisant l'API C de Python pour interagir avec " +"Python et le code de l'utilisateur." + +#: ../Doc/glossary.rst:354 +msgid "f-string" +msgstr "f-string" + +#: ../Doc/glossary.rst:356 +msgid "" +"String literals prefixed with ``'f'`` or ``'F'`` are commonly called \"f-" +"strings\" which is short for :ref:`formatted string literals `. " +"See also :pep:`498`." +msgstr "" +"Chaîne littérale préfixée de ``'f'`` ou ``'F'``. Les \"f-strings\" sont un " +"raccourci pour :ref:`formatted string literals `. Voir la :pep:" +"`498`." + +#: ../Doc/glossary.rst:359 +msgid "file object" +msgstr "objet fichier" + +#: ../Doc/glossary.rst:361 +msgid "" +"An object exposing a file-oriented API (with methods such as :meth:`read()` " +"or :meth:`write()`) to an underlying resource. Depending on the way it was " +"created, a file object can mediate access to a real on-disk file or to " +"another type of storage or communication device (for example standard input/" +"output, in-memory buffers, sockets, pipes, etc.). File objects are also " +"called :dfn:`file-like objects` or :dfn:`streams`." +msgstr "" +"Objet exposant une ressource via une API orientée fichier (avec les " +"méthodes :meth:`read()` ou :meth:`write()`). En fonction de la manière dont " +"il a été créé, un objet fichier peut interfacer l'accès à un fichier sur le " +"disque ou à un autre type de stockage ou de communication (typiquement " +"l'entrée standard, la sortie standard, un tampon en mémoire, une socket " +"réseau, ...). Les objets fichiers sont aussi appelés :dfn:`file-like-" +"objects` ou :dfn:`streams`." + +#: ../Doc/glossary.rst:369 +msgid "" +"There are actually three categories of file objects: raw :term:`binary files " +"`, buffered :term:`binary files ` and :term:`text " +"files `. Their interfaces are defined in the :mod:`io` module. " +"The canonical way to create a file object is by using the :func:`open` " +"function." +msgstr "" +"Il existe en réalité trois catégories de fichiers objets : les :term:" +"`fichiers binaires ` bruts, les :term:`fichiers binaires " +"` avec tampon (*buffer*) et les :term:`fichiers textes " +"`. Leurs interfaces sont définies dans le module :mod:`io`. " +"Le moyen le plus simple et direct de créer un objet fichier est d'utiliser " +"la fonction :func:`open`." + +#: ../Doc/glossary.rst:374 +msgid "file-like object" +msgstr "objet fichier-compatible" + +#: ../Doc/glossary.rst:376 +msgid "A synonym for :term:`file object`." +msgstr "Synonyme de :term:`objet fichier`." + +#: ../Doc/glossary.rst:377 +msgid "finder" +msgstr "chercheur" + +#: ../Doc/glossary.rst:379 +msgid "" +"An object that tries to find the :term:`loader` for a module that is being " +"imported." +msgstr "" +"Objet qui essaie de trouver un :term:`chargeur ` pour le module en " +"cours d'importation." + +#: ../Doc/glossary.rst:382 +msgid "" +"Since Python 3.3, there are two types of finder: :term:`meta path finders " +"` for use with :data:`sys.meta_path`, and :term:`path " +"entry finders ` for use with :data:`sys.path_hooks`." +msgstr "" +"Depuis Python 3.3, il existe deux types de chercheurs : les :term:" +"`chercheurs dans les méta-chemins ` à utiliser avec :data:" +"`sys.meta_path` ; les :term:`chercheurs d'entrée dans path ` à utiliser avec :data:`sys.path_hooks`." + +#: ../Doc/glossary.rst:386 +msgid "See :pep:`302`, :pep:`420` and :pep:`451` for much more detail." +msgstr "Voir les :pep:`302`, :pep:`420` et :pep:`451` pour plus de détails." + +#: ../Doc/glossary.rst:387 +msgid "floor division" +msgstr "division entière" + +#: ../Doc/glossary.rst:389 +msgid "" +"Mathematical division that rounds down to nearest integer. The floor " +"division operator is ``//``. For example, the expression ``11 // 4`` " +"evaluates to ``2`` in contrast to the ``2.75`` returned by float true " +"division. Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` " +"rounded *downward*. See :pep:`238`." +msgstr "" +"Division mathématique arrondissant à l'entier inférieur. L'opérateur de la " +"division entière est ``//``. Par exemple l'expression ``11 // 4`` vaut " +"``2``, contrairement à ``11 / 4`` qui vaut ``2.75``. Notez que ``(-11) // " +"4`` vaut ``-3`` car l'arrondi se fait à l'entier inférieur. Voir la :pep:" +"`328`." + +#: ../Doc/glossary.rst:394 +msgid "function" +msgstr "fonction" + +#: ../Doc/glossary.rst:396 +msgid "" +"A series of statements which returns some value to a caller. It can also be " +"passed zero or more :term:`arguments ` which may be used in the " +"execution of the body. See also :term:`parameter`, :term:`method`, and the :" +"ref:`function` section." +msgstr "" +"Suite d'instructions qui renvoie une valeur à son appelant. On peut lui " +"passer des :term:`arguments ` qui pourront être utilisés dans le " +"corps de la fonction. Voir aussi :term:`paramètre`, :term:`méthode` et :ref:" +"`function`." + +#: ../Doc/glossary.rst:400 +msgid "function annotation" +msgstr "annotation de fonction" + +#: ../Doc/glossary.rst:402 +msgid "An :term:`annotation` of a function parameter or return value." +msgstr ":term:`annotation` d'un paramètre de fonction ou valeur de retour." + +#: ../Doc/glossary.rst:404 +msgid "" +"Function annotations are usually used for :term:`type hints `: " +"for example, this function is expected to take two :class:`int` arguments " +"and is also expected to have an :class:`int` return value::" +msgstr "" +"Les annotations de fonctions sont généralement utilisées pour des :term:" +"`indications de types ` : par exemple, cette fonction devrait " +"prendre deux arguments :class:`int` et devrait également avoir une valeur de " +"retour de type :class:`int` ::" + +#: ../Doc/glossary.rst:412 +msgid "Function annotation syntax is explained in section :ref:`function`." +msgstr "" +"L'annotation syntaxique de la fonction est expliquée dans la section :ref:" +"`function`." + +#: ../Doc/glossary.rst:414 +msgid "" +"See :term:`variable annotation` and :pep:`484`, which describe this " +"functionality." +msgstr "" +"Voir :term:`variable annotation` et :pep:` 484`, qui décrivent cette " +"fonctionnalité." + +#: ../Doc/glossary.rst:416 +msgid "__future__" +msgstr "__future__" + +#: ../Doc/glossary.rst:418 +msgid "" +"A pseudo-module which programmers can use to enable new language features " +"which are not compatible with the current interpreter." +msgstr "" +"Pseudo-module que les développeurs peuvent utiliser pour activer de " +"nouvelles fonctionnalités du langage qui ne sont pas compatibles avec " +"l'interpréteur utilisé." + +#: ../Doc/glossary.rst:421 +msgid "" +"By importing the :mod:`__future__` module and evaluating its variables, you " +"can see when a new feature was first added to the language and when it " +"becomes the default::" +msgstr "" +"En important le module :mod:`__future__` et en affichant ses variables, vous " +"pouvez voir à quel moment une nouvelle fonctionnalité a été rajoutée dans le " +"langage et quand elle devient le comportement par défaut ::" + +#: ../Doc/glossary.rst:428 +msgid "garbage collection" +msgstr "ramasse-miettes" + +#: ../Doc/glossary.rst:430 +msgid "" +"The process of freeing memory when it is not used anymore. Python performs " +"garbage collection via reference counting and a cyclic garbage collector " +"that is able to detect and break reference cycles. The garbage collector " +"can be controlled using the :mod:`gc` module." +msgstr "" +"(*garbage collection* en anglais) Mécanisme permettant de libérer de la " +"mémoire lorsqu'elle n'est plus utilisée. Python utilise un ramasse-miettes " +"par comptage de référence et un ramasse-miettes cyclique capable de détecter " +"et casser les références circulaires. Le ramasse-miettes peut être contrôlé " +"en utilisant le module :mod:`gc`." + +#: ../Doc/glossary.rst:436 +msgid "generator" +msgstr "générateur" + +#: ../Doc/glossary.rst:438 +msgid "" +"A function which returns a :term:`generator iterator`. It looks like a " +"normal function except that it contains :keyword:`yield` expressions for " +"producing a series of values usable in a for-loop or that can be retrieved " +"one at a time with the :func:`next` function." +msgstr "" +"Fonction qui renvoie un :term:`itérateur de générateur`. Cela ressemble à " +"une fonction normale, en dehors du fait qu'elle contient une ou des " +"expressions :keyword:`yield` produisant une série de valeurs utilisable dans " +"une boucle *for* ou récupérées une à une via la fonction :func:`next`." + +#: ../Doc/glossary.rst:443 +msgid "" +"Usually refers to a generator function, but may refer to a *generator " +"iterator* in some contexts. In cases where the intended meaning isn't " +"clear, using the full terms avoids ambiguity." +msgstr "" +"Fait généralement référence à une fonction générateur mais peut faire " +"référence à un *itérateur de générateur* dans certains contextes. Dans les " +"cas où le sens voulu n'est pas clair, utiliser les termes complets lève " +"l’ambigüité." + +#: ../Doc/glossary.rst:446 +msgid "generator iterator" +msgstr "itérateur de générateur" + +#: ../Doc/glossary.rst:448 +msgid "An object created by a :term:`generator` function." +msgstr "Objet créé par une fonction :term:`générateur`." + +#: ../Doc/glossary.rst:450 +msgid "" +"Each :keyword:`yield` temporarily suspends processing, remembering the " +"location execution state (including local variables and pending try-" +"statements). When the *generator iterator* resumes, it picks up where it " +"left off (in contrast to functions which start fresh on every invocation)." +msgstr "" +"Chaque :keyword:`yield` suspend temporairement l'exécution, en se rappelant " +"l'endroit et l'état de l'exécution (y compris les variables locales et les " +"*try* en cours). Lorsque l'itérateur de générateur reprend, il repart là où " +"il en était (contrairement à une fonction qui prendrait un nouveau départ à " +"chaque invocation)." + +#: ../Doc/glossary.rst:457 +msgid "generator expression" +msgstr "expression génératrice" + +#: ../Doc/glossary.rst:459 +msgid "" +"An expression that returns an iterator. It looks like a normal expression " +"followed by a :keyword:`!for` clause defining a loop variable, range, and an " +"optional :keyword:`!if` clause. The combined expression generates values " +"for an enclosing function::" +msgstr "" +"Expression qui donne un itérateur. Elle ressemble à une expression normale, " +"suivie d'une clause :keyword:`!for` définissant une variable de boucle, un " +"intervalle et une clause :keyword:`!if` optionnelle. Toute cette expression " +"génère des valeurs pour la fonction qui l'entoure ::" + +#: ../Doc/glossary.rst:466 +msgid "generic function" +msgstr "fonction générique" + +#: ../Doc/glossary.rst:468 +msgid "" +"A function composed of multiple functions implementing the same operation " +"for different types. Which implementation should be used during a call is " +"determined by the dispatch algorithm." +msgstr "" +"Fonction composée de plusieurs fonctions implémentant les mêmes opérations " +"pour différents types. L'implémentation à utiliser est déterminée lors de " +"l'appel par l'algorithme de répartition." + +#: ../Doc/glossary.rst:472 +msgid "" +"See also the :term:`single dispatch` glossary entry, the :func:`functools." +"singledispatch` decorator, and :pep:`443`." +msgstr "" +"Voir aussi :term:`single dispatch`, le décorateur :func:`functools." +"singledispatch` et la :pep:`443`." + +#: ../Doc/glossary.rst:475 +msgid "GIL" +msgstr "GIL" + +#: ../Doc/glossary.rst:477 +msgid "See :term:`global interpreter lock`." +msgstr "Voir :term:`global interpreter lock`." + +#: ../Doc/glossary.rst:478 +msgid "global interpreter lock" +msgstr "verrou global de l'interpréteur" + +#: ../Doc/glossary.rst:480 +msgid "" +"The mechanism used by the :term:`CPython` interpreter to assure that only " +"one thread executes Python :term:`bytecode` at a time. This simplifies the " +"CPython implementation by making the object model (including critical built-" +"in types such as :class:`dict`) implicitly safe against concurrent access. " +"Locking the entire interpreter makes it easier for the interpreter to be " +"multi-threaded, at the expense of much of the parallelism afforded by multi-" +"processor machines." +msgstr "" +"(*global interpreter lock* en anglais) Mécanisme utilisé par l'interpréteur :" +"term:`CPython` pour s'assurer qu'un seul fil d'exécution (*thread* en " +"anglais) n'exécute le :term:`bytecode` à la fois. Cela simplifie " +"l'implémentation de CPython en rendant le modèle objet (incluant des parties " +"critiques comme la classe native :class:`dict`) implicitement protégé contre " +"les accès concourants. Verrouiller l'interpréteur entier rend plus facile " +"l'implémentation de multiples fils d'exécution (*multi-thread* en anglais), " +"au détriment malheureusement de beaucoup du parallélisme possible sur les " +"machines ayant plusieurs processeurs." + +#: ../Doc/glossary.rst:489 +msgid "" +"However, some extension modules, either standard or third-party, are " +"designed so as to release the GIL when doing computationally-intensive tasks " +"such as compression or hashing. Also, the GIL is always released when doing " +"I/O." +msgstr "" +"Cependant, certains modules d'extension, standards ou non, sont conçus de " +"manière à libérer le GIL lorsqu'ils effectuent des tâches lourdes tel que la " +"compression ou le hachage. De la même manière, le GIL est toujours libéré " +"lors des entrées / sorties." + +#: ../Doc/glossary.rst:494 +msgid "" +"Past efforts to create a \"free-threaded\" interpreter (one which locks " +"shared data at a much finer granularity) have not been successful because " +"performance suffered in the common single-processor case. It is believed " +"that overcoming this performance issue would make the implementation much " +"more complicated and therefore costlier to maintain." +msgstr "" +"Les tentatives précédentes d'implémenter un interpréteur Python avec une " +"granularité de verrouillage plus fine ont toutes échouées, à cause de leurs " +"mauvaises performances dans le cas d'un processeur unique. Il est admis que " +"corriger ce problème de performance induit mènerait à une implémentation " +"beaucoup plus compliquée et donc plus coûteuse à maintenir." + +#: ../Doc/glossary.rst:500 +msgid "hash-based pyc" +msgstr "*pyc* utilisant le hachage" + +#: ../Doc/glossary.rst:502 +msgid "" +"A bytecode cache file that uses the hash rather than the last-modified time " +"of the corresponding source file to determine its validity. See :ref:`pyc-" +"invalidation`." +msgstr "" +"Un fichier de cache de code intermédiaire (*bytecode* en anglais) qui " +"utilise le hachage plutôt que l'heure de dernière modification du fichier " +"source correspondant pour déterminer sa validité. Voir :ref:`pyc-" +"invalidation`." + +#: ../Doc/glossary.rst:505 +msgid "hashable" +msgstr "hachable" + +#: ../Doc/glossary.rst:507 +msgid "" +"An object is *hashable* if it has a hash value which never changes during " +"its lifetime (it needs a :meth:`__hash__` method), and can be compared to " +"other objects (it needs an :meth:`__eq__` method). Hashable objects which " +"compare equal must have the same hash value." +msgstr "" +"Un objet est *hachable* s'il a une empreinte (*hash*) qui ne change jamais " +"(il doit donc implémenter une méthode :meth:`__hash__`) et s'il peut être " +"comparé à d'autres objets (avec la méthode :meth:`__eq__`). Les objets " +"hachables dont la comparaison par ``__eq__`` est vraie doivent avoir la même " +"empreinte." + +#: ../Doc/glossary.rst:512 +msgid "" +"Hashability makes an object usable as a dictionary key and a set member, " +"because these data structures use the hash value internally." +msgstr "" +"La hachabilité permet à un objet d'être utilisé comme clé de dictionnaire ou " +"en tant que membre d'un ensemble (type *set*), car ces structures de données " +"utilisent ce *hash*." + +#: ../Doc/glossary.rst:515 +msgid "" +"Most of Python's immutable built-in objects are hashable; mutable containers " +"(such as lists or dictionaries) are not; immutable containers (such as " +"tuples and frozensets) are only hashable if their elements are hashable. " +"Objects which are instances of user-defined classes are hashable by " +"default. They all compare unequal (except with themselves), and their hash " +"value is derived from their :func:`id`." +msgstr "" +"La plupart des types immuables natifs de Python sont hachables, mais les " +"conteneurs muables (comme les listes ou les dictionnaires) ne le sont pas ; " +"les conteneurs immuables (comme les n-uplets ou les ensembles gelés) ne sont " +"hachables que si leurs éléments sont hachables. Les instances de classes " +"définies par les utilisateurs sont hachables par défaut. Elles sont toutes " +"considérées différentes (sauf avec elles-mêmes) et leur valeur de hachage " +"est calculée à partir de leur :func:`id`." + +#: ../Doc/glossary.rst:522 +msgid "IDLE" +msgstr "IDLE" + +#: ../Doc/glossary.rst:524 +msgid "" +"An Integrated Development Environment for Python. IDLE is a basic editor " +"and interpreter environment which ships with the standard distribution of " +"Python." +msgstr "" +"Environnement de développement intégré pour Python. IDLE est un éditeur " +"basique et un interpréteur livré avec la distribution standard de Python." + +#: ../Doc/glossary.rst:527 +msgid "immutable" +msgstr "immuable" + +#: ../Doc/glossary.rst:529 +msgid "" +"An object with a fixed value. Immutable objects include numbers, strings " +"and tuples. Such an object cannot be altered. A new object has to be " +"created if a different value has to be stored. They play an important role " +"in places where a constant hash value is needed, for example as a key in a " +"dictionary." +msgstr "" +"Objet dont la valeur ne change pas. Les nombres, les chaînes et les n-uplets " +"sont immuables. Ils ne peuvent être modifiés. Un nouvel objet doit être créé " +"si une valeur différente doit être stockée. Ils jouent un rôle important " +"quand une valeur de *hash* constante est requise, typiquement en clé de " +"dictionnaire." + +#: ../Doc/glossary.rst:534 +msgid "import path" +msgstr "chemin des importations" + +#: ../Doc/glossary.rst:536 +msgid "" +"A list of locations (or :term:`path entries `) that are searched " +"by the :term:`path based finder` for modules to import. During import, this " +"list of locations usually comes from :data:`sys.path`, but for subpackages " +"it may also come from the parent package's ``__path__`` attribute." +msgstr "" +"Liste de :term:`entrées ` dans lesquelles le :term:`chercheur " +"basé sur les chemins ` cherche les modules à importer. " +"Typiquement, lors d'une importation, cette liste vient de :data:`sys.path` ; " +"pour les sous-paquets, elle peut aussi venir de l'attribut ``__path__`` du " +"paquet parent." + +#: ../Doc/glossary.rst:541 +msgid "importing" +msgstr "importer" + +#: ../Doc/glossary.rst:543 +msgid "" +"The process by which Python code in one module is made available to Python " +"code in another module." +msgstr "Processus rendant le code Python d'un module disponible dans un autre." + +#: ../Doc/glossary.rst:545 +msgid "importer" +msgstr "importateur" + +#: ../Doc/glossary.rst:547 +msgid "" +"An object that both finds and loads a module; both a :term:`finder` and :" +"term:`loader` object." +msgstr "" +"Objet qui trouve et charge un module, en même temps un :term:`chercheur " +"` et un :term:`chargeur `." + +#: ../Doc/glossary.rst:549 +msgid "interactive" +msgstr "interactif" + +#: ../Doc/glossary.rst:551 +msgid "" +"Python has an interactive interpreter which means you can enter statements " +"and expressions at the interpreter prompt, immediately execute them and see " +"their results. Just launch ``python`` with no arguments (possibly by " +"selecting it from your computer's main menu). It is a very powerful way to " +"test out new ideas or inspect modules and packages (remember ``help(x)``)." +msgstr "" +"Python a un interpréteur interactif, ce qui signifie que vous pouvez écrire " +"des expressions et des instructions à l'invite de l'interpréteur. " +"L'interpréteur Python va les exécuter immédiatement et vous en présenter le " +"résultat. Démarrez juste ``python`` (probablement depuis le menu principal " +"de votre ordinateur). C'est un moyen puissant pour tester de nouvelles idées " +"ou étudier de nouveaux modules (souvenez-vous de ``help(x)``)." + +#: ../Doc/glossary.rst:557 +msgid "interpreted" +msgstr "interprété" + +#: ../Doc/glossary.rst:559 +msgid "" +"Python is an interpreted language, as opposed to a compiled one, though the " +"distinction can be blurry because of the presence of the bytecode compiler. " +"This means that source files can be run directly without explicitly creating " +"an executable which is then run. Interpreted languages typically have a " +"shorter development/debug cycle than compiled ones, though their programs " +"generally also run more slowly. See also :term:`interactive`." +msgstr "" +"Python est un langage interprété, en opposition aux langages compilés, bien " +"que la frontière soit floue en raison de la présence d'un compilateur en " +"code intermédiaire. Cela signifie que les fichiers sources peuvent être " +"exécutés directement, sans avoir à compiler un fichier exécutable " +"intermédiaire. Les langages interprétés ont généralement un cycle de " +"développement / débogage plus court que les langages compilés. Cependant, " +"ils s'exécutent généralement plus lentement. Voir aussi :term:`interactif`." + +#: ../Doc/glossary.rst:566 +msgid "interpreter shutdown" +msgstr "arrêt de l'interpréteur" + +#: ../Doc/glossary.rst:568 +msgid "" +"When asked to shut down, the Python interpreter enters a special phase where " +"it gradually releases all allocated resources, such as modules and various " +"critical internal structures. It also makes several calls to the :term:" +"`garbage collector `. This can trigger the execution of " +"code in user-defined destructors or weakref callbacks. Code executed during " +"the shutdown phase can encounter various exceptions as the resources it " +"relies on may not function anymore (common examples are library modules or " +"the warnings machinery)." +msgstr "" +"Lorsqu'on lui demande de s'arrêter, l'interpréteur Python entre dans une " +"phase spéciale où il libère graduellement les ressources allouées, comme les " +"modules ou quelques structures de données internes. Il fait aussi quelques " +"appels au :term:`ramasse-miettes`. Cela peut déclencher l'exécution de code " +"dans des destructeurs ou des fonctions de rappels de *weakrefs*. Le code " +"exécuté lors de l'arrêt peut rencontrer quelques exception puisque les " +"ressources auxquelles il fait appel pourraient ne plus fonctionner, " +"(typiquement les modules des bibliothèques ou le mécanisme de *warning*)." + +#: ../Doc/glossary.rst:577 +msgid "" +"The main reason for interpreter shutdown is that the ``__main__`` module or " +"the script being run has finished executing." +msgstr "" +"La principale raison d'arrêt de l'interpréteur est que le module " +"``__main__`` ou le script en cours d'exécution a terminé de s'exécuter." + +#: ../Doc/glossary.rst:579 +msgid "iterable" +msgstr "itérable" + +#: ../Doc/glossary.rst:581 +msgid "" +"An object capable of returning its members one at a time. Examples of " +"iterables include all sequence types (such as :class:`list`, :class:`str`, " +"and :class:`tuple`) and some non-sequence types like :class:`dict`, :term:" +"`file objects `, and objects of any classes you define with an :" +"meth:`__iter__` method or with a :meth:`__getitem__` method that implements :" +"term:`Sequence` semantics." +msgstr "" +"Objet capable de renvoyer ses éléments un à un. Par exemple, tous les types " +"séquence (comme :class:`list`, :class:`str`, et :class:`tuple`), quelques " +"autres types comme :class:`dict`, :term:`objets fichiers ` ou " +"tout objet d'une classe ayant une méthode :meth:`__iter__` ou :meth:" +"`__getitem__` qui implémente la sémantique d'une :term:`Sequence`." + +#: ../Doc/glossary.rst:588 +msgid "" +"Iterables can be used in a :keyword:`for` loop and in many other places " +"where a sequence is needed (:func:`zip`, :func:`map`, ...). When an " +"iterable object is passed as an argument to the built-in function :func:" +"`iter`, it returns an iterator for the object. This iterator is good for " +"one pass over the set of values. When using iterables, it is usually not " +"necessary to call :func:`iter` or deal with iterator objects yourself. The " +"``for`` statement does that automatically for you, creating a temporary " +"unnamed variable to hold the iterator for the duration of the loop. See " +"also :term:`iterator`, :term:`sequence`, and :term:`generator`." +msgstr "" +"Les itérables peuvent être utilisés dans des boucles :keyword:`for` et à " +"beaucoup d'autres endroits où une séquence est requise (:func:`zip`, :func:" +"`map`, ...). Lorsqu'un itérable est passé comme argument à la fonction " +"native :func:`iter`, celle-ci fournit en retour un itérateur sur cet " +"itérable. Cet itérateur n'est valable que pour une seule passe sur le jeu de " +"valeurs. Lors de l'utilisation d'itérables, il n'est habituellement pas " +"nécessaire d'appeler :func:`iter` ou de s'occuper soi-même des objets " +"itérateurs. L'instruction ``for`` le fait automatiquement pour vous, créant " +"une variable temporaire anonyme pour garder l'itérateur durant la boucle. " +"Voir aussi :term:`itérateur`, :term:`séquence` et :term:`générateur`." + +#: ../Doc/glossary.rst:598 +msgid "iterator" +msgstr "itérateur" + +#: ../Doc/glossary.rst:600 +msgid "" +"An object representing a stream of data. Repeated calls to the iterator's :" +"meth:`~iterator.__next__` method (or passing it to the built-in function :" +"func:`next`) return successive items in the stream. When no more data are " +"available a :exc:`StopIteration` exception is raised instead. At this " +"point, the iterator object is exhausted and any further calls to its :meth:" +"`__next__` method just raise :exc:`StopIteration` again. Iterators are " +"required to have an :meth:`__iter__` method that returns the iterator object " +"itself so every iterator is also iterable and may be used in most places " +"where other iterables are accepted. One notable exception is code which " +"attempts multiple iteration passes. A container object (such as a :class:" +"`list`) produces a fresh new iterator each time you pass it to the :func:" +"`iter` function or use it in a :keyword:`for` loop. Attempting this with an " +"iterator will just return the same exhausted iterator object used in the " +"previous iteration pass, making it appear like an empty container." +msgstr "" +"Objet représentant un flux de donnée. Des appels successifs à la méthode :" +"meth:`~iterator.__next__` de l'itérateur (ou le passer à la fonction native :" +"func:`next`) donne successivement les objets du flux. Lorsque plus aucune " +"donnée n'est disponible, une exception :exc:`StopIteration` est levée. À ce " +"point, l'itérateur est épuisé et tous les appels suivants à sa méthode :meth:" +"`__next__` lèveront encore une exception :exc:`StopIteration`. Les " +"itérateurs doivent avoir une méthode :meth:`__iter__` qui renvoie l'objet " +"itérateur lui même, de façon à ce que chaque itérateur soit aussi itérable " +"et puisse être utilisé dans la plupart des endroits où d'autres itérables " +"sont attendus. Une exception notable est un code qui tente plusieurs " +"itérations complètes. Un objet conteneur, (tel que :class:`list`) produit un " +"nouvel itérateur neuf à chaque fois qu'il est passé à la fonction :func:" +"`iter` ou s'il est utilisé dans une boucle :keyword:`for`. Faire ceci sur un " +"itérateur donnerait simplement le même objet itérateur épuisé utilisé dans " +"son itération précédente, le faisant ressembler à un conteneur vide." + +#: ../Doc/glossary.rst:615 +msgid "More information can be found in :ref:`typeiter`." +msgstr "Vous trouverez davantage d'informations dans :ref:`typeiter`." + +#: ../Doc/glossary.rst:616 +msgid "key function" +msgstr "fonction clé" + +#: ../Doc/glossary.rst:618 +msgid "" +"A key function or collation function is a callable that returns a value used " +"for sorting or ordering. For example, :func:`locale.strxfrm` is used to " +"produce a sort key that is aware of locale specific sort conventions." +msgstr "" +"Une fonction clé est un objet appelable qui renvoie une valeur à fins de tri " +"ou de classement. Par exemple, la fonction :func:`locale.strxfrm` est " +"utilisée pour générer une clé de classement prenant en compte les " +"conventions de classement spécifiques aux paramètres régionaux courants." + +#: ../Doc/glossary.rst:623 +msgid "" +"A number of tools in Python accept key functions to control how elements are " +"ordered or grouped. They include :func:`min`, :func:`max`, :func:`sorted`, :" +"meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, :func:`heapq." +"nlargest`, and :func:`itertools.groupby`." +msgstr "" +"Plusieurs outils dans Python acceptent des fonctions clés pour déterminer " +"comment les éléments sont classés ou groupés. On peut citer les fonctions :" +"func:`min`, :func:`max`, :func:`sorted`, :meth:`list.sort`, :func:`heapq." +"merge`, :func:`heapq.nsmallest`, :func:`heapq.nlargest` et :func:`itertools." +"groupby`." + +#: ../Doc/glossary.rst:629 +msgid "" +"There are several ways to create a key function. For example. the :meth:" +"`str.lower` method can serve as a key function for case insensitive sorts. " +"Alternatively, a key function can be built from a :keyword:`lambda` " +"expression such as ``lambda r: (r[0], r[2])``. Also, the :mod:`operator` " +"module provides three key function constructors: :func:`~operator." +"attrgetter`, :func:`~operator.itemgetter`, and :func:`~operator." +"methodcaller`. See the :ref:`Sorting HOW TO ` for examples of " +"how to create and use key functions." +msgstr "" +"Il existe plusieurs moyens de créer une fonction clé. Par exemple, la " +"méthode :meth:`str.lower` peut servir de fonction clé pour effectuer des " +"recherches insensibles à la casse. Aussi, il est possible de créer des " +"fonctions clés avec des expressions :keyword:`lambda`, comme ``lambda r: " +"(r[0], r[2])``. Vous noterez que le module :mod:`operator` propose des " +"constructeurs de fonctions clefs : :func:`~operator.attrgetter`, :func:" +"`~operator.itemgetter` et :func:`~operator.methodcaller`. Voir :ref:`Comment " +"Trier ` pour des exemples de création et d'utilisation de " +"fonctions clefs." + +#: ../Doc/glossary.rst:637 +msgid "keyword argument" +msgstr "argument nommé" + +#: ../Doc/glossary.rst:639 ../Doc/glossary.rst:914 +msgid "See :term:`argument`." +msgstr "Voir :term:`argument`." + +#: ../Doc/glossary.rst:640 +msgid "lambda" +msgstr "lambda" + +#: ../Doc/glossary.rst:642 +msgid "" +"An anonymous inline function consisting of a single :term:`expression` which " +"is evaluated when the function is called. The syntax to create a lambda " +"function is ``lambda [parameters]: expression``" +msgstr "" +"Fonction anonyme sous la forme d'une :term:`expression` et ne contenant " +"qu'une seule expression, exécutée lorsque la fonction est appelée. La " +"syntaxe pour créer des fonctions lambda est: ``lambda [parameters]: " +"expression``" + +#: ../Doc/glossary.rst:645 +msgid "LBYL" +msgstr "LBYL" + +#: ../Doc/glossary.rst:647 +msgid "" +"Look before you leap. This coding style explicitly tests for pre-conditions " +"before making calls or lookups. This style contrasts with the :term:`EAFP` " +"approach and is characterized by the presence of many :keyword:`if` " +"statements." +msgstr "" +"Regarde avant de sauter, (*Look before you leap* en anglais). Ce style de " +"programmation consiste à vérifier des conditions avant d'effectuer des " +"appels ou des accès. Ce style contraste avec le style :term:`EAFP` et se " +"caractérise par la présence de beaucoup d'instructions :keyword:`if`." + +#: ../Doc/glossary.rst:652 +msgid "" +"In a multi-threaded environment, the LBYL approach can risk introducing a " +"race condition between \"the looking\" and \"the leaping\". For example, " +"the code, ``if key in mapping: return mapping[key]`` can fail if another " +"thread removes *key* from *mapping* after the test, but before the lookup. " +"This issue can be solved with locks or by using the EAFP approach." +msgstr "" +"Dans un environnement avec plusieurs fils d'exécution (*multi-threaded* en " +"anglais), le style *LBYL* peut engendrer un séquencement critique (*race " +"condition* en anglais) entre le \"regarde\" et le \"sauter\". Par exemple, " +"le code ``if key in mapping: return mapping[key]`` peut échouer si un autre " +"fil d'exécution supprime la clé *key* du *mapping* après le test mais avant " +"l'accès. Ce problème peut être résolu avec des verrous (*locks*) ou avec " +"l'approche EAFP." + +#: ../Doc/glossary.rst:657 +msgid "list" +msgstr "*list*" + +#: ../Doc/glossary.rst:659 +msgid "" +"A built-in Python :term:`sequence`. Despite its name it is more akin to an " +"array in other languages than to a linked list since access to elements is " +"O(1)." +msgstr "" +"Un type natif de :term:`sequence` dans Python. En dépit de son nom, une " +"``list`` ressemble plus à un tableau (*array* dans la plupart des langages) " +"qu'à une liste chaînée puisque les accès se font en O(1)." + +#: ../Doc/glossary.rst:662 +msgid "list comprehension" +msgstr "liste en compréhension (ou liste en intension)" + +#: ../Doc/glossary.rst:664 +msgid "" +"A compact way to process all or part of the elements in a sequence and " +"return a list with the results. ``result = ['{:#04x}'.format(x) for x in " +"range(256) if x % 2 == 0]`` generates a list of strings containing even hex " +"numbers (0x..) in the range from 0 to 255. The :keyword:`if` clause is " +"optional. If omitted, all elements in ``range(256)`` are processed." +msgstr "" +"Écriture concise pour manipuler tout ou partie des éléments d'une séquence " +"et renvoyer une liste contenant les résultats. ``result = ['{:#04x}'." +"format(x) for x in range(256) if x % 2 == 0]`` génère la liste composée des " +"nombres pairs de 0 à 255 écrits sous formes de chaînes de caractères et en " +"hexadécimal (``0x``...). La clause :keyword:`if` est optionnelle. Si elle " +"est omise, tous les éléments du ``range(256)`` seront utilisés." + +#: ../Doc/glossary.rst:670 +msgid "loader" +msgstr "chargeur" + +#: ../Doc/glossary.rst:672 +msgid "" +"An object that loads a module. It must define a method named :meth:" +"`load_module`. A loader is typically returned by a :term:`finder`. See :pep:" +"`302` for details and :class:`importlib.abc.Loader` for an :term:`abstract " +"base class`." +msgstr "" +"Objet qui charge un module. Il doit définir une méthode nommée :meth:" +"`load_module`. Un chargeur est typiquement donné par un :term:`chercheur " +"`. Voir la :pep:`302` pour plus de détails et :class:`importlib.ABC." +"Loader` pour sa :term:`classe de base abstraite`." + +#: ../Doc/glossary.rst:676 +msgid "magic method" +msgstr "méthode magique" + +#: ../Doc/glossary.rst:680 +msgid "An informal synonym for :term:`special method`." +msgstr "Un synonyme informel de :term:`special method`." + +#: ../Doc/glossary.rst:681 +msgid "mapping" +msgstr "tableau de correspondances" + +#: ../Doc/glossary.rst:683 +msgid "" +"A container object that supports arbitrary key lookups and implements the " +"methods specified in the :class:`~collections.abc.Mapping` or :class:" +"`~collections.abc.MutableMapping` :ref:`abstract base classes `. Examples include :class:`dict`, :class:" +"`collections.defaultdict`, :class:`collections.OrderedDict` and :class:" +"`collections.Counter`." +msgstr "" +"(*mapping* en anglais) Conteneur permettant de rechercher des éléments à " +"partir de clés et implémentant les méthodes spécifiées dans les :ref:" +"`classes de base abstraites ` :class:" +"`collections.abc.Mapping` ou :class:`collections.abc.MutableMapping`. Les " +"classes suivantes sont des exemples de tableaux de correspondances : :class:" +"`dict`, :class:`collections.defaultdict`, :class:`collections.OrderedDict` " +"et :class:`collections.Counter`." + +#: ../Doc/glossary.rst:689 +msgid "meta path finder" +msgstr "chercheur dans les méta-chemins" + +#: ../Doc/glossary.rst:691 +msgid "" +"A :term:`finder` returned by a search of :data:`sys.meta_path`. Meta path " +"finders are related to, but different from :term:`path entry finders `." +msgstr "" +"Un :term:`chercheur ` renvoyé par une recherche dans :data:`sys." +"meta_path`. Les chercheurs dans les méta-chemins ressemblent, mais sont " +"différents des :term:`chercheurs d'entrée dans path `." + +#: ../Doc/glossary.rst:695 +msgid "" +"See :class:`importlib.abc.MetaPathFinder` for the methods that meta path " +"finders implement." +msgstr "" +"Voir :class:`importlib.abc.MetaPathFinder` pour les méthodes que les " +"chercheurs dans les méta-chemins doivent implémenter." + +#: ../Doc/glossary.rst:697 +msgid "metaclass" +msgstr "métaclasse" + +#: ../Doc/glossary.rst:699 +msgid "" +"The class of a class. Class definitions create a class name, a class " +"dictionary, and a list of base classes. The metaclass is responsible for " +"taking those three arguments and creating the class. Most object oriented " +"programming languages provide a default implementation. What makes Python " +"special is that it is possible to create custom metaclasses. Most users " +"never need this tool, but when the need arises, metaclasses can provide " +"powerful, elegant solutions. They have been used for logging attribute " +"access, adding thread-safety, tracking object creation, implementing " +"singletons, and many other tasks." +msgstr "" +"Classe d'une classe. Les définitions de classe créent un nom pour la classe, " +"un dictionnaire de classe et une liste de classes parentes. La métaclasse a " +"pour rôle de réunir ces trois paramètres pour construire la classe. La " +"plupart des langages orientés objet fournissent une implémentation par " +"défaut. La particularité de Python est la possibilité de créer des " +"métaclasses personnalisées. La plupart des utilisateurs n'aura jamais besoin " +"de cet outil, mais lorsque le besoin survient, les métaclasses offrent des " +"solutions élégantes et puissantes. Elles sont utilisées pour journaliser les " +"accès à des propriétés, rendre sûr les environnements *multi-threads*, " +"suivre la création d'objets, implémenter des singletons et bien d'autres " +"tâches." + +#: ../Doc/glossary.rst:709 +msgid "More information can be found in :ref:`metaclasses`." +msgstr "Plus d'informations sont disponibles dans : :ref:`metaclasses`." + +#: ../Doc/glossary.rst:710 +msgid "method" +msgstr "méthode" + +#: ../Doc/glossary.rst:712 +msgid "" +"A function which is defined inside a class body. If called as an attribute " +"of an instance of that class, the method will get the instance object as its " +"first :term:`argument` (which is usually called ``self``). See :term:" +"`function` and :term:`nested scope`." +msgstr "" +"Fonction définie à l'intérieur d'une classe. Lorsqu'elle est appelée comme " +"un attribut d'une instance de cette classe, la méthode reçoit l'instance en " +"premier :term:`argument` (qui, par convention, est habituellement nommé " +"``self``). Voir :term:`function` et :term:`nested scope`." + +#: ../Doc/glossary.rst:716 +msgid "method resolution order" +msgstr "ordre de résolution des méthodes" + +#: ../Doc/glossary.rst:718 +msgid "" +"Method Resolution Order is the order in which base classes are searched for " +"a member during lookup. See `The Python 2.3 Method Resolution Order `_ for details of the algorithm " +"used by the Python interpreter since the 2.3 release." +msgstr "" +"L'ordre de résolution des méthodes (*MRO* pour *Method Resolution Order* en " +"anglais) est, lors de la recherche d'un attribut dans les classes parentes, " +"la façon dont l'interpréteur Python classe ces classes parentes. Voir `The " +"Python 2.3 Method Resolution Order `_ pour plus de détails sur l'algorithme utilisé par " +"l'interpréteur Python depuis la version 2.3." + +#: ../Doc/glossary.rst:722 +msgid "module" +msgstr "module" + +#: ../Doc/glossary.rst:724 +msgid "" +"An object that serves as an organizational unit of Python code. Modules " +"have a namespace containing arbitrary Python objects. Modules are loaded " +"into Python by the process of :term:`importing`." +msgstr "" +"Objet utilisé pour organiser une portion unitaire de code en Python. Les " +"modules ont un espace de nommage et peuvent contenir n'importe quels objets " +"Python. Charger des modules est appelé :term:`importer `." + +#: ../Doc/glossary.rst:728 +msgid "See also :term:`package`." +msgstr "Voir aussi :term:`paquet`." + +#: ../Doc/glossary.rst:729 +msgid "module spec" +msgstr "spécificateur de module" + +#: ../Doc/glossary.rst:731 +msgid "" +"A namespace containing the import-related information used to load a module. " +"An instance of :class:`importlib.machinery.ModuleSpec`." +msgstr "" +"Espace de nommage contenant les informations, relatives à l'importation, " +"utilisées pour charger un module. C'est une instance de la classe :class:" +"`importlib.machinery.ModuleSpec`." + +#: ../Doc/glossary.rst:733 +msgid "MRO" +msgstr "MRO" + +#: ../Doc/glossary.rst:735 +msgid "See :term:`method resolution order`." +msgstr "Voir :term:`ordre de résolution des méthodes`." + +#: ../Doc/glossary.rst:736 +msgid "mutable" +msgstr "muable" + +#: ../Doc/glossary.rst:738 +msgid "" +"Mutable objects can change their value but keep their :func:`id`. See also :" +"term:`immutable`." +msgstr "" +"Un objet muable peut changer de valeur tout en gardant le même :func:`id`. " +"Voir aussi :term:`immuable`." + +#: ../Doc/glossary.rst:740 +msgid "named tuple" +msgstr "n-uplet nommé" + +#: ../Doc/glossary.rst:742 +msgid "" +"The term \"named tuple\" applies to any type or class that inherits from " +"tuple and whose indexable elements are also accessible using named " +"attributes. The type or class may have other features as well." +msgstr "" +"Le terme \"n-uplet nommé\" s'applique à tous les types ou classes qui " +"héritent de la classe ``tuple`` et dont les éléments indexables sont aussi " +"accessibles en utilisant des attributs nommés. Les types et classes peuvent " +"avoir aussi d'autres caractéristiques." + +#: ../Doc/glossary.rst:746 +msgid "" +"Several built-in types are named tuples, including the values returned by :" +"func:`time.localtime` and :func:`os.stat`. Another example is :data:`sys." +"float_info`::" +msgstr "" +"Plusieurs types natifs sont appelés n-uplets, y compris les valeurs " +"retournées par :func:`time.localtime` et :func:`os.stat`. Un autre exemple " +"est :data:`sys.float_info` ::" + +#: ../Doc/glossary.rst:757 +msgid "" +"Some named tuples are built-in types (such as the above examples). " +"Alternatively, a named tuple can be created from a regular class definition " +"that inherits from :class:`tuple` and that defines named fields. Such a " +"class can be written by hand or it can be created with the factory function :" +"func:`collections.namedtuple`. The latter technique also adds some extra " +"methods that may not be found in hand-written or built-in named tuples." +msgstr "" +"Certains *n-uplets nommés* sont des types natifs (comme les exemples ci-" +"dessus). Sinon, un *n-uplet nommé* peut être créé à partir d'une définition " +"de classe habituelle qui hérite de :class:`tuple` et qui définit les champs " +"nommés. Une telle classe peut être écrite à la main ou être créée avec la " +"fonction :func:`collections.namedtuple`. Cette dernière méthode ajoute des " +"méthodes supplémentaires qui ne seront pas trouvées dans celles écrites à la " +"main ni dans les n-uplets nommés natifs." + +#: ../Doc/glossary.rst:764 +msgid "namespace" +msgstr "espace de nommage" + +#: ../Doc/glossary.rst:766 +msgid "" +"The place where a variable is stored. Namespaces are implemented as " +"dictionaries. There are the local, global and built-in namespaces as well " +"as nested namespaces in objects (in methods). Namespaces support modularity " +"by preventing naming conflicts. For instance, the functions :func:`builtins." +"open <.open>` and :func:`os.open` are distinguished by their namespaces. " +"Namespaces also aid readability and maintainability by making it clear which " +"module implements a function. For instance, writing :func:`random.seed` or :" +"func:`itertools.islice` makes it clear that those functions are implemented " +"by the :mod:`random` and :mod:`itertools` modules, respectively." +msgstr "" +"L'endroit où une variable est stockée. Les espaces de nommage sont " +"implémentés avec des dictionnaires. Il existe des espaces de nommage " +"globaux, natifs ou imbriqués dans les objets (dans les méthodes). Les " +"espaces de nommage favorisent la modularité car ils permettent d'éviter les " +"conflits de noms. Par exemple, les fonctions :func:`builtins.open <.open>` " +"et :func:`os.open` sont différenciées par leurs espaces de nom. Les espaces " +"de nommage aident aussi à la lisibilité et la maintenabilité en rendant " +"clair quel module implémente une fonction. Par exemple, écrire :func:`random." +"seed` ou :func:`itertools.islice` affiche clairement que ces fonctions sont " +"implémentées respectivement dans les modules :mod:`random` et :mod:" +"`itertools`." + +#: ../Doc/glossary.rst:776 +msgid "namespace package" +msgstr "paquet-espace de nommage" + +#: ../Doc/glossary.rst:778 +msgid "" +"A :pep:`420` :term:`package` which serves only as a container for " +"subpackages. Namespace packages may have no physical representation, and " +"specifically are not like a :term:`regular package` because they have no " +"``__init__.py`` file." +msgstr "" +"Un :term:`paquet` tel que défini dans la :pep:`421` qui ne sert qu'à " +"contenir des sous-paquets. Les paquets-espace de nommage peuvent n'avoir " +"aucune représentation physique et, plus spécifiquement, ne sont pas comme " +"un :term:`paquet classique` puisqu'ils n'ont pas de fichier ``__init__.py``." + +#: ../Doc/glossary.rst:783 +msgid "See also :term:`module`." +msgstr "Voir aussi :term:`module`." + +#: ../Doc/glossary.rst:784 +msgid "nested scope" +msgstr "portée imbriquée" + +#: ../Doc/glossary.rst:786 +msgid "" +"The ability to refer to a variable in an enclosing definition. For " +"instance, a function defined inside another function can refer to variables " +"in the outer function. Note that nested scopes by default work only for " +"reference and not for assignment. Local variables both read and write in " +"the innermost scope. Likewise, global variables read and write to the " +"global namespace. The :keyword:`nonlocal` allows writing to outer scopes." +msgstr "" +"Possibilité de faire référence à une variable déclarée dans une définition " +"englobante. Typiquement, une fonction définie à l'intérieur d'une autre " +"fonction a accès aux variables de cette dernière. Souvenez-vous cependant " +"que cela ne fonctionne que pour accéder à des variables, pas pour les " +"assigner. Les variables locales sont lues et assignées dans l'espace de " +"nommage le plus proche. Tout comme les variables globales qui sont stockés " +"dans l'espace de nommage global, le mot clef :keyword:`nonlocal` permet " +"d'écrire dans l'espace de nommage dans lequel est déclarée la variable." + +#: ../Doc/glossary.rst:793 +msgid "new-style class" +msgstr "nouvelle classe" + +#: ../Doc/glossary.rst:795 +msgid "" +"Old name for the flavor of classes now used for all class objects. In " +"earlier Python versions, only new-style classes could use Python's newer, " +"versatile features like :attr:`~object.__slots__`, descriptors, properties, :" +"meth:`__getattribute__`, class methods, and static methods." +msgstr "" +"Ancien nom pour l'implémentation actuelle des classes, pour tous les objets. " +"Dans les anciennes versions de Python, seules les nouvelles classes " +"pouvaient utiliser les nouvelles fonctionnalités telles que :attr:`~object." +"__slots__`, les descripteurs, les propriétés, :meth:`__getattribute__`, les " +"méthodes de classe et les méthodes statiques." + +#: ../Doc/glossary.rst:799 +msgid "object" +msgstr "objet" + +#: ../Doc/glossary.rst:801 +msgid "" +"Any data with state (attributes or value) and defined behavior (methods). " +"Also the ultimate base class of any :term:`new-style class`." +msgstr "" +"N'importe quelle donnée comportant des états (sous forme d'attributs ou " +"d'une valeur) et un comportement (des méthodes). C'est aussi (``object``) " +"l'ancêtre commun à absolument toutes les :term:`nouvelles classes `." + +#: ../Doc/glossary.rst:804 +msgid "package" +msgstr "paquet" + +#: ../Doc/glossary.rst:806 +msgid "" +"A Python :term:`module` which can contain submodules or recursively, " +"subpackages. Technically, a package is a Python module with an ``__path__`` " +"attribute." +msgstr "" +":term:`module` Python qui peut contenir des sous-modules ou des sous-" +"paquets. Techniquement, un paquet est un module qui possède un attribut " +"``__path__``." + +#: ../Doc/glossary.rst:810 +msgid "See also :term:`regular package` and :term:`namespace package`." +msgstr "Voir aussi :term:`paquet classique` et :term:`namespace package`." + +#: ../Doc/glossary.rst:811 +msgid "parameter" +msgstr "paramètre" + +#: ../Doc/glossary.rst:813 +msgid "" +"A named entity in a :term:`function` (or method) definition that specifies " +"an :term:`argument` (or in some cases, arguments) that the function can " +"accept. There are five kinds of parameter:" +msgstr "" +"Entité nommée dans la définition d'une :term:`fonction` (ou méthode), " +"décrivant un :term:`argument` (ou dans certains cas des arguments) que la " +"fonction accepte. Il existe cinq sortes de paramètres :" + +#: ../Doc/glossary.rst:817 +msgid "" +":dfn:`positional-or-keyword`: specifies an argument that can be passed " +"either :term:`positionally ` or as a :term:`keyword argument " +"`. This is the default kind of parameter, for example *foo* and " +"*bar* in the following::" +msgstr "" +":dfn:`positional-or-keyword`: l'argument peut être passé soit par sa :term:" +"`position `, soit en tant que :term:`argument nommé `. " +"C'est le type de paramètre par défaut. Par exemple, *foo* et *bar* dans " +"l'exemple suivant ::" + +#: ../Doc/glossary.rst:826 +msgid "" +":dfn:`positional-only`: specifies an argument that can be supplied only by " +"position. Python has no syntax for defining positional-only parameters. " +"However, some built-in functions have positional-only parameters (e.g. :func:" +"`abs`)." +msgstr "" +":dfn:`positional-only`: l'argument ne peut être donné que par sa position. " +"Python n'a pas de syntaxe pour déclarer de tels paramètres, cependant des " +"fonctions natives, comme :func:`abs`, en utilisent." + +#: ../Doc/glossary.rst:833 +msgid "" +":dfn:`keyword-only`: specifies an argument that can be supplied only by " +"keyword. Keyword-only parameters can be defined by including a single var-" +"positional parameter or bare ``*`` in the parameter list of the function " +"definition before them, for example *kw_only1* and *kw_only2* in the " +"following::" +msgstr "" +":dfn:`keyword-only`: l'argument ne peut être fourni que nommé. Les " +"paramètres *keyword-only* peuvent être définis en utilisant un seul " +"paramètre *var-positional*, ou en ajoutant une étoile (``*``) seule dans la " +"liste des paramètres avant eux. Par exemple, *kw_only1* et *kw_only2* dans " +"le code suivant ::" + +#: ../Doc/glossary.rst:841 +msgid "" +":dfn:`var-positional`: specifies that an arbitrary sequence of positional " +"arguments can be provided (in addition to any positional arguments already " +"accepted by other parameters). Such a parameter can be defined by " +"prepending the parameter name with ``*``, for example *args* in the " +"following::" +msgstr "" +":dfn:`var-positional`: une séquence d'arguments positionnels peut être " +"fournie (en plus de tous les arguments positionnels déjà acceptés par " +"d'autres paramètres). Un tel paramètre peut être défini en préfixant son nom " +"par une ``*``. Par exemple *args* ci-après ::" + +#: ../Doc/glossary.rst:849 +msgid "" +":dfn:`var-keyword`: specifies that arbitrarily many keyword arguments can be " +"provided (in addition to any keyword arguments already accepted by other " +"parameters). Such a parameter can be defined by prepending the parameter " +"name with ``**``, for example *kwargs* in the example above." +msgstr "" +":dfn:`var-keyword`: une quantité arbitraire d'arguments peut être passée, " +"chacun étant nommé (en plus de tous les arguments nommés déjà acceptés par " +"d'autres paramètres). Un tel paramètre est défini en préfixant le nom du " +"paramètre par ``**``. Par exemple, *kwargs* ci-dessus." + +#: ../Doc/glossary.rst:855 +msgid "" +"Parameters can specify both optional and required arguments, as well as " +"default values for some optional arguments." +msgstr "" +"Les paramètres peuvent spécifier des arguments obligatoires ou optionnels, " +"ainsi que des valeurs par défaut pour les arguments optionnels." + +#: ../Doc/glossary.rst:858 +msgid "" +"See also the :term:`argument` glossary entry, the FAQ question on :ref:`the " +"difference between arguments and parameters `, " +"the :class:`inspect.Parameter` class, the :ref:`function` section, and :pep:" +"`362`." +msgstr "" +"Voir aussi :term:`argument` dans le glossaire, la question sur :ref:`la " +"différence entre les arguments et les paramètres ` dans la FAQ, la classe :class:`inspect.Parameter`, la section :" +"ref:`function` et la :pep:`362`." + +#: ../Doc/glossary.rst:862 +msgid "path entry" +msgstr "entrée de chemin" + +#: ../Doc/glossary.rst:864 +msgid "" +"A single location on the :term:`import path` which the :term:`path based " +"finder` consults to find modules for importing." +msgstr "" +"Emplacement dans le :term:`chemin des importations ` (*import " +"path* en anglais, d'où le *path*) que le :term:`chercheur basé sur les " +"chemins ` consulte pour trouver des modules à importer." + +#: ../Doc/glossary.rst:866 +msgid "path entry finder" +msgstr "chercheur de chemins" + +#: ../Doc/glossary.rst:868 +msgid "" +"A :term:`finder` returned by a callable on :data:`sys.path_hooks` (i.e. a :" +"term:`path entry hook`) which knows how to locate modules given a :term:" +"`path entry`." +msgstr "" +":term:`chercheur ` renvoyé par un appelable sur un :data:`sys." +"path_hooks` (c'est-à-dire un :term:`point d'entrée pour la recherche dans " +"path `) qui sait où trouver des modules lorsqu'on lui donne " +"une :term:`entrée de path `." + +#: ../Doc/glossary.rst:872 +msgid "" +"See :class:`importlib.abc.PathEntryFinder` for the methods that path entry " +"finders implement." +msgstr "" +"Voir :class:`importlib.abc.PathEntryFinder` pour les méthodes qu'un " +"chercheur d'entrée dans *path* doit implémenter." + +#: ../Doc/glossary.rst:874 +msgid "path entry hook" +msgstr "point d'entrée pour la recherche dans *path*" + +#: ../Doc/glossary.rst:876 +msgid "" +"A callable on the :data:`sys.path_hook` list which returns a :term:`path " +"entry finder` if it knows how to find modules on a specific :term:`path " +"entry`." +msgstr "" +"Appelable dans la liste :data:`sys.path_hook` qui donne un :term:`chercheur " +"d'entrée dans path ` s'il sait où trouver des modules " +"pour une :term:`entrée dans path ` donnée." + +#: ../Doc/glossary.rst:879 +msgid "path based finder" +msgstr "chercheur basé sur les chemins" + +#: ../Doc/glossary.rst:881 +msgid "" +"One of the default :term:`meta path finders ` which " +"searches an :term:`import path` for modules." +msgstr "" +"L'un des :term:`chercheurs dans les méta-chemins ` par " +"défaut qui cherche des modules dans un :term:`chemin des importations " +"`." + +#: ../Doc/glossary.rst:883 +msgid "path-like object" +msgstr "objet simili-chemin" + +#: ../Doc/glossary.rst:885 +msgid "" +"An object representing a file system path. A path-like object is either a :" +"class:`str` or :class:`bytes` object representing a path, or an object " +"implementing the :class:`os.PathLike` protocol. An object that supports the :" +"class:`os.PathLike` protocol can be converted to a :class:`str` or :class:" +"`bytes` file system path by calling the :func:`os.fspath` function; :func:" +"`os.fsdecode` and :func:`os.fsencode` can be used to guarantee a :class:" +"`str` or :class:`bytes` result instead, respectively. Introduced by :pep:" +"`519`." +msgstr "" +"Objet représentant un chemin du système de fichiers. Un objet simili-chemin " +"est un objet :class:`str` ou un objet :class:`bytes` représentant un chemin " +"ou un objet implémentant le protocole :class:`os.PathLike`. Un objet qui " +"accepte le protocole :class:`os.PathLike` peut être converti en un chemin :" +"class:`str` ou :class:`bytes` du système de fichiers en appelant la " +"fonction :func:`os.fspath`. :func:`os.fsdecode` et :func:`os.fsencode` " +"peuvent être utilisées, respectivement, pour garantir un résultat de type :" +"class:`str` ou :class:`bytes` à la place. A été Introduit par la :pep:`519`." + +#: ../Doc/glossary.rst:893 +msgid "PEP" +msgstr "PEP" + +#: ../Doc/glossary.rst:895 +msgid "" +"Python Enhancement Proposal. A PEP is a design document providing " +"information to the Python community, or describing a new feature for Python " +"or its processes or environment. PEPs should provide a concise technical " +"specification and a rationale for proposed features." +msgstr "" +"*Python Enhancement Proposal* (Proposition d'amélioration Python). Un PEP " +"est un document de conception fournissant des informations à la communauté " +"Python ou décrivant une nouvelle fonctionnalité pour Python, ses processus " +"ou son environnement. Les PEP doivent fournir une spécification technique " +"concise et une justification des fonctionnalités proposées." + +#: ../Doc/glossary.rst:901 +msgid "" +"PEPs are intended to be the primary mechanisms for proposing major new " +"features, for collecting community input on an issue, and for documenting " +"the design decisions that have gone into Python. The PEP author is " +"responsible for building consensus within the community and documenting " +"dissenting opinions." +msgstr "" +"Les PEPs sont censés être les principaux mécanismes pour proposer de " +"nouvelles fonctionnalités majeures, pour recueillir les commentaires de la " +"communauté sur une question et pour documenter les décisions de conception " +"qui sont intégrées en Python. L’auteur du PEP est responsable de " +"l’établissement d’un consensus au sein de la communauté et de documenter les " +"opinions contradictoires." + +#: ../Doc/glossary.rst:907 +msgid "See :pep:`1`." +msgstr "Voir :pep:`1`." + +#: ../Doc/glossary.rst:908 +msgid "portion" +msgstr "portion" + +#: ../Doc/glossary.rst:910 +msgid "" +"A set of files in a single directory (possibly stored in a zip file) that " +"contribute to a namespace package, as defined in :pep:`420`." +msgstr "" +"Jeu de fichiers dans un seul dossier (pouvant être stocké sous forme de " +"fichier zip) qui contribue à l'espace de nommage d'un paquet, tel que défini " +"dans la :pep:`420`." + +#: ../Doc/glossary.rst:912 +msgid "positional argument" +msgstr "argument positionnel" + +#: ../Doc/glossary.rst:915 +msgid "provisional API" +msgstr "API provisoire" + +#: ../Doc/glossary.rst:917 +msgid "" +"A provisional API is one which has been deliberately excluded from the " +"standard library's backwards compatibility guarantees. While major changes " +"to such interfaces are not expected, as long as they are marked provisional, " +"backwards incompatible changes (up to and including removal of the " +"interface) may occur if deemed necessary by core developers. Such changes " +"will not be made gratuitously -- they will occur only if serious fundamental " +"flaws are uncovered that were missed prior to the inclusion of the API." +msgstr "" +"Une API provisoire est une API qui n'offre aucune garantie de " +"rétrocompatibilité (la bibliothèque standard exige la rétrocompatibilité). " +"Bien que des changements majeurs d'une telle interface ne soient pas " +"attendus, tant qu'elle est étiquetée provisoire, des changement cassant la " +"rétrocompatibilité (y compris sa suppression complète) peuvent survenir si " +"les développeurs principaux le jugent nécessaire. Ces modifications ne " +"surviendront que si de sérieux problèmes sont découverts et qu'ils n'avaient " +"pas été identifiés avant l'ajout de l'API." + +#: ../Doc/glossary.rst:926 +msgid "" +"Even for provisional APIs, backwards incompatible changes are seen as a " +"\"solution of last resort\" - every attempt will still be made to find a " +"backwards compatible resolution to any identified problems." +msgstr "" +"Même pour les API provisoires, les changement cassant la rétrocompatibilité " +"sont considérées comme des \"solutions de dernier recours\". Tout ce qui est " +"possible sera fait pour tenter de résoudre les problème en conservant la " +"rétrocompatibilité." + +#: ../Doc/glossary.rst:930 +msgid "" +"This process allows the standard library to continue to evolve over time, " +"without locking in problematic design errors for extended periods of time. " +"See :pep:`411` for more details." +msgstr "" +"Ce processus permet à la bibliothèque standard de continuer à évoluer avec " +"le temps, sans se bloquer longtemps sur des erreurs d'architecture. Voir la :" +"pep:`411` pour plus de détails." + +#: ../Doc/glossary.rst:933 +msgid "provisional package" +msgstr "paquet provisoire" + +#: ../Doc/glossary.rst:935 +msgid "See :term:`provisional API`." +msgstr "Voir :term:`provisional API`." + +#: ../Doc/glossary.rst:936 +msgid "Python 3000" +msgstr "Python 3000" + +#: ../Doc/glossary.rst:938 +msgid "" +"Nickname for the Python 3.x release line (coined long ago when the release " +"of version 3 was something in the distant future.) This is also abbreviated " +"\"Py3k\"." +msgstr "" +"Surnom donné à la série des Python 3.x (très vieux surnom donné à l'époque " +"où Python 3 représentait un futur lointain). Aussi abrégé *Py3k*." + +#: ../Doc/glossary.rst:941 +msgid "Pythonic" +msgstr "*Pythonique*" + +#: ../Doc/glossary.rst:943 +msgid "" +"An idea or piece of code which closely follows the most common idioms of the " +"Python language, rather than implementing code using concepts common to " +"other languages. For example, a common idiom in Python is to loop over all " +"elements of an iterable using a :keyword:`for` statement. Many other " +"languages don't have this type of construct, so people unfamiliar with " +"Python sometimes use a numerical counter instead::" +msgstr "" +"Idée, ou bout de code, qui colle aux idiomes de Python plutôt qu'aux " +"concepts communs rencontrés dans d'autres langages. Par exemple, il est " +"idiomatique en Python de parcourir les éléments d'un itérable en utilisant :" +"keyword:`for`. Beaucoup d'autres langages n'ont pas cette possibilité, donc " +"les gens qui ne sont pas habitués à Python utilisent parfois un compteur " +"numérique à la place ::" + +#: ../Doc/glossary.rst:953 +msgid "As opposed to the cleaner, Pythonic method::" +msgstr "" +"Plutôt qu'utiliser la méthode, plus propre et élégante, donc *Pythonique* ::" + +#: ../Doc/glossary.rst:957 +msgid "qualified name" +msgstr "nom qualifié" + +#: ../Doc/glossary.rst:959 +msgid "" +"A dotted name showing the \"path\" from a module's global scope to a class, " +"function or method defined in that module, as defined in :pep:`3155`. For " +"top-level functions and classes, the qualified name is the same as the " +"object's name::" +msgstr "" +"Nom, comprenant des points, montrant le \"chemin\" de l'espace de nommage " +"global d'un module vers une classe, fonction ou méthode définie dans ce " +"module, tel que défini dans la :pep:`3155`. Pour les fonctions et classes de " +"premier niveau, le nom qualifié est le même que le nom de l'objet ::" + +#: ../Doc/glossary.rst:976 +msgid "" +"When used to refer to modules, the *fully qualified name* means the entire " +"dotted path to the module, including any parent packages, e.g. ``email.mime." +"text``::" +msgstr "" +"Lorsqu'il est utilisé pour nommer des modules, le *nom qualifié complet* " +"(*fully qualified name - FQN* en anglais) signifie le chemin complet (séparé " +"par des points) vers le module, incluant tous les paquets parents. Par " +"exemple : ``email.mime.text`` ::" + +#: ../Doc/glossary.rst:983 +msgid "reference count" +msgstr "nombre de références" + +#: ../Doc/glossary.rst:985 +msgid "" +"The number of references to an object. When the reference count of an " +"object drops to zero, it is deallocated. Reference counting is generally " +"not visible to Python code, but it is a key element of the :term:`CPython` " +"implementation. The :mod:`sys` module defines a :func:`~sys.getrefcount` " +"function that programmers can call to return the reference count for a " +"particular object." +msgstr "" +"Nombre de références à un objet. Lorsque le nombre de références à un objet " +"descend à zéro, l'objet est désalloué. Le comptage de référence n'est " +"généralement pas visible dans le code Python, mais c'est un élément clé de " +"l'implémentation :term:`CPython`. Le module :mod:`sys` définit une fonction :" +"func:`~sys.getrefcount` que les développeurs peuvent utiliser pour obtenir " +"le nombre de références à un objet donné." + +#: ../Doc/glossary.rst:991 +msgid "regular package" +msgstr "paquet classique" + +#: ../Doc/glossary.rst:993 +msgid "" +"A traditional :term:`package`, such as a directory containing an ``__init__." +"py`` file." +msgstr "" +":term:`paquet` traditionnel, tel qu'un dossier contenant un fichier " +"``__init__.py``." + +#: ../Doc/glossary.rst:996 +msgid "See also :term:`namespace package`." +msgstr "Voir aussi :term:`paquet-espace de nommage `." + +#: ../Doc/glossary.rst:997 +msgid "__slots__" +msgstr "``__slots__``" + +#: ../Doc/glossary.rst:999 +msgid "" +"A declaration inside a class that saves memory by pre-declaring space for " +"instance attributes and eliminating instance dictionaries. Though popular, " +"the technique is somewhat tricky to get right and is best reserved for rare " +"cases where there are large numbers of instances in a memory-critical " +"application." +msgstr "" +"Déclaration dans une classe qui économise de la mémoire en pré-allouant de " +"l'espace pour les attributs des instances et qui élimine le dictionnaire " +"(des attributs) des instances. Bien que populaire, cette technique est " +"difficile à maîtriser et devrait être réservée à de rares cas où un grand " +"nombre d'instances dans une application devient un sujet critique pour la " +"mémoire." + +#: ../Doc/glossary.rst:1004 +msgid "sequence" +msgstr "séquence" + +#: ../Doc/glossary.rst:1006 +msgid "" +"An :term:`iterable` which supports efficient element access using integer " +"indices via the :meth:`__getitem__` special method and defines a :meth:" +"`__len__` method that returns the length of the sequence. Some built-in " +"sequence types are :class:`list`, :class:`str`, :class:`tuple`, and :class:" +"`bytes`. Note that :class:`dict` also supports :meth:`__getitem__` and :meth:" +"`__len__`, but is considered a mapping rather than a sequence because the " +"lookups use arbitrary :term:`immutable` keys rather than integers." +msgstr "" +":term:`itérable` qui offre un accès efficace à ses éléments par un indice " +"sous forme de nombre entier via la méthode spéciale :meth:`__getitem__` et " +"qui définit une méthode :meth:`__len__` donnant sa taille. Voici quelques " +"séquences natives : :class:`list`, :class:`str`, :class:`tuple`, et :class:" +"`bytes`. Notez que :class:`dict` possède aussi une méthode :meth:" +"`__getitem__` et une méthode :meth:`__len__`, mais il est considéré comme un " +"*mapping* plutôt qu'une séquence, car ses accès se font par une clé " +"arbitraire :term:`immuable` plutôt qu'un nombre entier." + +#: ../Doc/glossary.rst:1015 +msgid "" +"The :class:`collections.abc.Sequence` abstract base class defines a much " +"richer interface that goes beyond just :meth:`__getitem__` and :meth:" +"`__len__`, adding :meth:`count`, :meth:`index`, :meth:`__contains__`, and :" +"meth:`__reversed__`. Types that implement this expanded interface can be " +"registered explicitly using :func:`~abc.register`." +msgstr "" +"La classe abstraite de base :class:`collections.abc.Sequence` définit une " +"interface plus riche qui va au-delà des simples :meth:`__getitem__` et :meth:" +"`__len__`, en ajoutant :meth:`count`, :meth:`index`, :meth:`__contains__` " +"et :meth:`__reversed__`. Les types qui implémentent cette interface étendue " +"peuvent s'enregistrer explicitement en utilisant :func:`~abc.register`." + +#: ../Doc/glossary.rst:1022 +msgid "single dispatch" +msgstr "distribution simple" + +#: ../Doc/glossary.rst:1024 +msgid "" +"A form of :term:`generic function` dispatch where the implementation is " +"chosen based on the type of a single argument." +msgstr "" +"Forme de distribution, comme les :term:`fonction génériques `, où l'implémentation est choisie en fonction du type d'un seul " +"argument." + +#: ../Doc/glossary.rst:1026 +msgid "slice" +msgstr "tranche" + +#: ../Doc/glossary.rst:1028 +msgid "" +"An object usually containing a portion of a :term:`sequence`. A slice is " +"created using the subscript notation, ``[]`` with colons between numbers " +"when several are given, such as in ``variable_name[1:3:5]``. The bracket " +"(subscript) notation uses :class:`slice` objects internally." +msgstr "" +"(*slice* en anglais), un objet contenant habituellement une portion de :term:" +"`séquence`. Une tranche est créée en utilisant la notation ``[]`` avec des " +"``:`` entre les nombres lorsque plusieurs sont fournis, comme dans " +"``variable_name[1:3:5]``. Cette notation utilise des objets :class:`slice` " +"en interne." + +#: ../Doc/glossary.rst:1032 +msgid "special method" +msgstr "méthode spéciale" + +#: ../Doc/glossary.rst:1036 +msgid "" +"A method that is called implicitly by Python to execute a certain operation " +"on a type, such as addition. Such methods have names starting and ending " +"with double underscores. Special methods are documented in :ref:" +"`specialnames`." +msgstr "" +"(*special method* en anglais) Méthode appelée implicitement par Python pour " +"exécuter une opération sur un type, comme une addition. De telles méthodes " +"ont des noms commençant et terminant par des doubles tirets bas. Les " +"méthodes spéciales sont documentées dans :ref:`specialnames`." + +#: ../Doc/glossary.rst:1040 +msgid "statement" +msgstr "instruction" + +#: ../Doc/glossary.rst:1042 +msgid "" +"A statement is part of a suite (a \"block\" of code). A statement is either " +"an :term:`expression` or one of several constructs with a keyword, such as :" +"keyword:`if`, :keyword:`while` or :keyword:`for`." +msgstr "" +"Une instruction (*statement* en anglais) est un composant d'un \"bloc\" de " +"code. Une instruction est soit une :term:`expression`, soit une ou plusieurs " +"constructions basées sur un mot-clé, comme :keyword:`if`, :keyword:`while` " +"ou :keyword:`for`." + +#: ../Doc/glossary.rst:1045 +msgid "text encoding" +msgstr "encodage de texte" + +#: ../Doc/glossary.rst:1047 +msgid "A codec which encodes Unicode strings to bytes." +msgstr "" +"Codec (codeur-décodeur) qui convertit des chaînes de caractères Unicode en " +"octets (classe *bytes*)." + +#: ../Doc/glossary.rst:1048 +msgid "text file" +msgstr "fichier texte" + +#: ../Doc/glossary.rst:1050 +msgid "" +"A :term:`file object` able to read and write :class:`str` objects. Often, a " +"text file actually accesses a byte-oriented datastream and handles the :term:" +"`text encoding` automatically. Examples of text files are files opened in " +"text mode (``'r'`` or ``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, and " +"instances of :class:`io.StringIO`." +msgstr "" +":term:`file object` capable de lire et d'écrire des objets :class:`str`. " +"Souvent, un fichier texte (*text file* en anglais) accède en fait à un flux " +"de donnée en octets et gère l':term:`text encoding` automatiquement. Des " +"exemples de fichiers textes sont les fichiers ouverts en mode texte (``'r'`` " +"ou ``'w'``), :data:`sys.stdin`, :data:`sys.stdout` et les instances de :" +"class:`io.StringIO`." + +#: ../Doc/glossary.rst:1057 +msgid "" +"See also :term:`binary file` for a file object able to read and write :term:" +"`bytes-like objects `." +msgstr "" +"Voir aussi :term:`binary file` pour un objet fichier capable de lire et " +"d'écrire :term:`bytes-like objects `." + +#: ../Doc/glossary.rst:1059 +msgid "triple-quoted string" +msgstr "chaîne entre triple guillemets" + +#: ../Doc/glossary.rst:1061 +msgid "" +"A string which is bound by three instances of either a quotation mark (\") " +"or an apostrophe ('). While they don't provide any functionality not " +"available with single-quoted strings, they are useful for a number of " +"reasons. They allow you to include unescaped single and double quotes " +"within a string and they can span multiple lines without the use of the " +"continuation character, making them especially useful when writing " +"docstrings." +msgstr "" +"Chaîne qui est délimitée par trois guillemets simples (``'``) ou trois " +"guillemets doubles (``\"``). Bien qu'elle ne fournisse aucune fonctionnalité " +"qui ne soit pas disponible avec une chaîne entre guillemets, elle est utile " +"pour de nombreuses raisons. Elle vous autorise à insérer des guillemets " +"simples et doubles dans une chaîne sans avoir à les protéger et elle peut " +"s'étendre sur plusieurs lignes sans avoir à terminer chaque ligne par un ``" +"\\``. Elle est ainsi particulièrement utile pour les chaînes de " +"documentation (*docstrings*)." + +#: ../Doc/glossary.rst:1068 +msgid "type" +msgstr "type" + +#: ../Doc/glossary.rst:1070 +msgid "" +"The type of a Python object determines what kind of object it is; every " +"object has a type. An object's type is accessible as its :attr:`~instance." +"__class__` attribute or can be retrieved with ``type(obj)``." +msgstr "" +"Le type d'un objet Python détermine quel genre d'objet c'est. Tous les " +"objets ont un type. Le type d'un objet peut être obtenu via son attribut :" +"attr:`~instance.__class__` ou via ``type(obj)``." + +#: ../Doc/glossary.rst:1074 +msgid "type alias" +msgstr "alias de type" + +#: ../Doc/glossary.rst:1076 +msgid "A synonym for a type, created by assigning the type to an identifier." +msgstr "Synonyme d'un type, créé en affectant le type à un identifiant." + +#: ../Doc/glossary.rst:1078 +msgid "" +"Type aliases are useful for simplifying :term:`type hints `. For " +"example::" +msgstr "" +"Les alias de types sont utiles pour simplifier les :term:`indications de " +"types `. Par exemple ::" + +#: ../Doc/glossary.rst:1087 +msgid "could be made more readable like this::" +msgstr "pourrait être rendu plus lisible comme ceci ::" + +#: ../Doc/glossary.rst:1096 ../Doc/glossary.rst:1110 +msgid "See :mod:`typing` and :pep:`484`, which describe this functionality." +msgstr "Voir :mod:`typing` et :pep:`484`, qui décrivent cette fonctionnalité." + +#: ../Doc/glossary.rst:1097 +msgid "type hint" +msgstr "indication de type" + +#: ../Doc/glossary.rst:1099 +msgid "" +"An :term:`annotation` that specifies the expected type for a variable, a " +"class attribute, or a function parameter or return value." +msgstr "" +"Le :term:`annotation` qui spécifie le type attendu pour une variable, un " +"attribut de classe, un paramètre de fonction ou une valeur de retour." + +#: ../Doc/glossary.rst:1102 +msgid "" +"Type hints are optional and are not enforced by Python but they are useful " +"to static type analysis tools, and aid IDEs with code completion and " +"refactoring." +msgstr "" +"Les indications de type sont facultatifs et ne sont pas indispensables à " +"l'interpréteur Python, mais ils sont utiles aux outils d'analyse de type " +"statique et aident les IDE à compléter et à réusiner (*code refactoring* en " +"anglais) le code." + +#: ../Doc/glossary.rst:1106 +msgid "" +"Type hints of global variables, class attributes, and functions, but not " +"local variables, can be accessed using :func:`typing.get_type_hints`." +msgstr "" +"Les indicateurs de type de variables globales, d'attributs de classe et de " +"fonctions, mais pas de variables locales, peuvent être consultés en " +"utilisant :func:`typing.get_type_hints`." + +#: ../Doc/glossary.rst:1111 +msgid "universal newlines" +msgstr "retours à la ligne universels" + +#: ../Doc/glossary.rst:1113 +msgid "" +"A manner of interpreting text streams in which all of the following are " +"recognized as ending a line: the Unix end-of-line convention ``'\\n'``, the " +"Windows convention ``'\\r\\n'``, and the old Macintosh convention " +"``'\\r'``. See :pep:`278` and :pep:`3116`, as well as :func:`bytes." +"splitlines` for an additional use." +msgstr "" +"Une manière d'interpréter des flux de texte dans lesquels sont reconnues " +"toutes les fins de ligne suivantes : la convention Unix ``'\\n'``, la " +"convention Windows ``'\\r\\n'`` et l'ancienne convention Macintosh " +"``'\\r'``. Voir la :pep:`278` et la :pep:`3116`, ainsi que la fonction :func:" +"`bytes.splitlines` pour d'autres usages." + +#: ../Doc/glossary.rst:1118 +msgid "variable annotation" +msgstr "annotation de variable" + +#: ../Doc/glossary.rst:1120 +msgid "An :term:`annotation` of a variable or a class attribute." +msgstr ":term:`annotation` d'une variable ou d'un attribut de classe." + +#: ../Doc/glossary.rst:1122 +msgid "" +"When annotating a variable or a class attribute, assignment is optional::" +msgstr "" +"Lorsque vous annotez une variable ou un attribut de classe, l'affectation " +"est facultative ::" + +#: ../Doc/glossary.rst:1127 +msgid "" +"Variable annotations are usually used for :term:`type hints `: " +"for example this variable is expected to take :class:`int` values::" +msgstr "" +"Les annotations de variables sont généralement utilisées pour des :term:" +"`indications de types ` : par exemple, cette variable devrait " +"prendre des valeurs de type :class:`int` ::" + +#: ../Doc/glossary.rst:1133 +msgid "Variable annotation syntax is explained in section :ref:`annassign`." +msgstr "" +"La syntaxe d'annotation de la variable est expliquée dans la section :ref:" +"`annassign`." + +#: ../Doc/glossary.rst:1135 +msgid "" +"See :term:`function annotation`, :pep:`484` and :pep:`526`, which describe " +"this functionality." +msgstr "" +"Reportez-vous à :term:`function annotation`, à la :pep:` 484` et à la :pep:" +"`526` qui décrivent cette fonctionnalité." + +#: ../Doc/glossary.rst:1137 +msgid "virtual environment" +msgstr "environnement virtuel" + +#: ../Doc/glossary.rst:1139 +msgid "" +"A cooperatively isolated runtime environment that allows Python users and " +"applications to install and upgrade Python distribution packages without " +"interfering with the behaviour of other Python applications running on the " +"same system." +msgstr "" +"Environnement d'exécution isolé (en mode coopératif) qui permet aux " +"utilisateurs de Python et aux applications d'installer et de mettre à jour " +"des paquets sans interférer avec d'autres applications Python fonctionnant " +"sur le même système." + +#: ../Doc/glossary.rst:1144 +msgid "See also :mod:`venv`." +msgstr "Voir aussi :mod:`venv`." + +#: ../Doc/glossary.rst:1145 +msgid "virtual machine" +msgstr "machine virtuelle" + +#: ../Doc/glossary.rst:1147 +msgid "" +"A computer defined entirely in software. Python's virtual machine executes " +"the :term:`bytecode` emitted by the bytecode compiler." +msgstr "" +"Ordinateur défini entièrement par du logiciel. La machine virtuelle " +"(*virtual machine*) de Python exécute le :term:`bytecode` produit par le " +"compilateur de *bytecode*." + +#: ../Doc/glossary.rst:1149 +msgid "Zen of Python" +msgstr "Le zen de Python" + +#: ../Doc/glossary.rst:1151 +msgid "" +"Listing of Python design principles and philosophies that are helpful in " +"understanding and using the language. The listing can be found by typing " +"\"``import this``\" at the interactive prompt." +msgstr "" +"Liste de principes et de préceptes utiles pour comprendre et utiliser le " +"langage. Cette liste peut être obtenue en tapant \"``import this``\" dans " +"une invite Python interactive." + +#~ msgid "" +#~ "Any tuple-like class whose indexable elements are also accessible using " +#~ "named attributes (for example, :func:`time.localtime` returns a tuple-" +#~ "like object where the *year* is accessible either with an index such as " +#~ "``t[0]`` or with a named attribute like ``t.tm_year``)." +#~ msgstr "" +#~ "(*named-tuple* en anglais) Classe qui, comme un *n-uplet* (*tuple* en " +#~ "anglais), a ses éléments accessibles par leur indice. Et en plus, les " +#~ "éléments sont accessibles par leur nom. Par exemple, :func:`time." +#~ "localtime` donne un objet ressemblant à un *n-uplet*, dont *year* est " +#~ "accessible par son indice : ``t[0]`` ou par son nom : ``t.tm_year``)." + +#~ msgid "struct sequence" +#~ msgstr "*struct sequence*" + +#~ msgid "" +#~ "A tuple with named elements. Struct sequences expose an interface similar " +#~ "to :term:`named tuple` in that elements can be accessed either by index " +#~ "or as an attribute. However, they do not have any of the named tuple " +#~ "methods like :meth:`~collections.somenamedtuple._make` or :meth:" +#~ "`~collections.somenamedtuple._asdict`. Examples of struct sequences " +#~ "include :data:`sys.float_info` and the return value of :func:`os.stat`." +#~ msgstr "" +#~ "Un n-uplet (*tuple* en anglais) dont les éléments sont nommés. Les " +#~ "*struct sequences* exposent une interface similaire au :term:`n-uplet " +#~ "nommé` car on peut accéder à leurs éléments par un nom d'attribut ou par " +#~ "un indice. Cependant, elles n'ont aucune des méthodes du *n-uplet " +#~ "nommé* : ni :meth:`collections.somenamedtuple._make` ou :meth:" +#~ "`~collections.somenamedtuple._asdict`. Par exemple :data:`sys.float_info` " +#~ "ou les valeurs données par :func:`os.stat` sont des *struct sequence*." + +#~ msgid "" +#~ "An arbitrary metadata value associated with a function parameter or " +#~ "return value. Its syntax is explained in section :ref:`function`. " +#~ "Annotations may be accessed via the :attr:`__annotations__` special " +#~ "attribute of a function object." +#~ msgstr "" +#~ "Métadonnée quelconque associée au paramètre d'une fonction ou à sa valeur " +#~ "de retour (NdT : la traduction canonique du terme anglais *annotation* " +#~ "est \"décoration\", notamment dans le cas des arbres syntaxiques, ce qui " +#~ "est le cas ici. Cependant, Python ayant déjà utilisé le terme *decorator* " +#~ "dans une autre acception, nous traduisons *annotation* par \"annotation" +#~ "\"). Sa syntaxe est documentée dans la section :ref:`function`. Vous " +#~ "pouvez accéder aux annotations d'une fonction *via* l'attribut spécial :" +#~ "attr:`__annotations__`." + +#~ msgid "" +#~ "Python itself does not assign any particular meaning to function " +#~ "annotations. They are intended to be interpreted by third-party libraries " +#~ "or tools. See :pep:`3107`, which describes some of their potential uses." +#~ msgstr "" +#~ "Python lui-même ne prend pas en compte les annotations. Leur but est " +#~ "d'être interprétées par des bibliothèques ou outils tiers. Voir la :pep:" +#~ "`3207` qui décrit certains usages possibles." + +#~ msgid "A :term:`binary file` reads and write :class:`bytes` objects." +#~ msgstr "Un :term:`fichier binaire` lit et écrit des objets :class:`bytes`." + +#~ msgid "" +#~ "A type metadata value associated with a module global variable or a class " +#~ "attribute. Its syntax is explained in section :ref:`annassign`. " +#~ "Annotations are stored in the :attr:`__annotations__` special attribute " +#~ "of a class or module object and can be accessed using :func:`typing." +#~ "get_type_hints`." +#~ msgstr "" +#~ "Métadonnée associée à une variable globale de module ou a un attribut de " +#~ "classe et qui donne la valeur du type (NdT : la traduction canonique du " +#~ "terme anglais *annotation* est \"décoration\", notamment dans le cas des " +#~ "arbres syntaxiques, ce qui est le cas ici. Cependant, Python ayant déjà " +#~ "utilisé le terme *decorator* dans une autre acception, nous traduisons " +#~ "*annotation* par \"annotation\"). Sa syntaxe est expliquée dans la " +#~ "section :ref:`annassign`. Les annotations sont stockées dans un attribut :" +#~ "attr:`__annotations__` spécial de classe ou de module et sont accessibles " +#~ "en utilisant :func:`typing.get_type_hints`." + +#~ msgid "" +#~ "Python itself does not assign any particular meaning to variable " +#~ "annotations. They are intended to be interpreted by third-party libraries " +#~ "or type checking tools. See :pep:`526`, :pep:`484` which describe some of " +#~ "their potential uses." +#~ msgstr "" +#~ "Python lui-même n'attache aucune signification particulière aux " +#~ "annotations de variables. Elles sont destinées à être interprétées par " +#~ "des bibliothèques tierces ou des outils de contrôle de type. Voir la :pep:" +#~ "`526` et la :pep:`484` qui décrivent certaines de leurs utilisations " +#~ "potentielles." diff --git a/tests/test_potodo.py b/tests/test_potodo.py new file mode 100644 index 0000000..4c9e6ab --- /dev/null +++ b/tests/test_potodo.py @@ -0,0 +1,21 @@ +from pathlib import Path + +from potodo.potodo import exec_potodo + + +FIXTURE_DIR = Path(__file__).resolve().parent / "fixtures" + + +def test_potodo(capsys): + exec_potodo( + path=FIXTURE_DIR / "python-docs-fr", + above=0, + below=100, + fuzzy=False, + hide_reserved=False, + counts=False, + offline=True, + ) + captured = capsys.readouterr() + assert "bugs.po" in captured.out + assert "sphinx.po" not in captured.out diff --git a/tox.ini b/tox.ini new file mode 100644 index 0000000..88b7af2 --- /dev/null +++ b/tox.ini @@ -0,0 +1,22 @@ +[flake8] +max-line-length = 88 + +[tox] +envlist = py36, py37, py38, flake8, mypy, black +skip_missing_interpreters = True + +[testenv] +deps = pytest +commands = pytest + +[testenv:flake8] +deps = flake8 +commands = flake8 tests/ potodo/ + +[testenv:black] +deps = black +commands = black --check --diff tests/ potodo/ + +[testenv:mypy] +deps = mypy +commands = mypy --ignore-missing-imports potodo/ From b5178bdc0a68f5813d4f6a3b453327c9376d8a4b Mon Sep 17 00:00:00 2001 From: Julien Palard Date: Fri, 13 Dec 2019 13:55:29 +0100 Subject: [PATCH 2/5] line too long --- potodo/_github.py | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/potodo/_github.py b/potodo/_github.py index db7d4cf..2292b3a 100644 --- a/potodo/_github.py +++ b/potodo/_github.py @@ -9,17 +9,23 @@ def get_repo_url(repo_path: str) -> str: """Tries to get the repository url from git commands """ try: - url = subprocess.check_output("git remote get-url --all upstream".split(), - universal_newlines=True, cwd=repo_path, - stderr=subprocess.STDOUT) + url = subprocess.check_output( + "git remote get-url --all upstream".split(), + universal_newlines=True, + cwd=repo_path, + stderr=subprocess.STDOUT, + ) except subprocess.CalledProcessError: try: - url = subprocess.check_output("git remote get-url --all origin".split(), - universal_newlines=True, cwd=repo_path, - stderr=subprocess.STDOUT) + url = subprocess.check_output( + "git remote get-url --all origin".split(), + universal_newlines=True, + cwd=repo_path, + stderr=subprocess.STDOUT, + ) except subprocess.CalledProcessError as e: raise RuntimeError( - f"Unknown error. `git get-url --all upstream|origin` returned \"{e.output.rstrip()}\"." + f'Unknown error. `{e.cmd}` returned "{e.output.rstrip()}".' ) return url From 75b1abd55e76206d893a8d475c9f310b3fb5a108 Mon Sep 17 00:00:00 2001 From: "Jules Lasne (jlasne - seluj78)" Date: Fri, 13 Dec 2019 14:21:56 +0100 Subject: [PATCH 3/5] Added new test file and new tests --- .../fixtures/python-docs-fr/library/token.po | 331 ++++++++++++++++++ tests/test_potodo.py | 3 + 2 files changed, 334 insertions(+) create mode 100644 tests/fixtures/python-docs-fr/library/token.po diff --git a/tests/fixtures/python-docs-fr/library/token.po b/tests/fixtures/python-docs-fr/library/token.po new file mode 100644 index 0000000..a0f0115 --- /dev/null +++ b/tests/fixtures/python-docs-fr/library/token.po @@ -0,0 +1,331 @@ +# 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: 2019-11-15 18:54+0100\n" +"PO-Revision-Date: 2018-09-28 10:04+0200\n" +"Last-Translator: Mickaël Bergem \n" +"Language-Team: FRENCH \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.9\n" + +#: ../Doc/library/token.rst:2 +msgid ":mod:`token` --- Constants used with Python parse trees" +msgstr "" +":mod:`token` --- Constantes utilisées avec les arbres d'analyse Python " +"(*parse trees*)" + +#: ../Doc/library/token.rst:9 +msgid "**Source code:** :source:`Lib/token.py`" +msgstr "**Code source :** :source:`Lib/token.py`" + +#: ../Doc/library/token.rst:13 +msgid "" +"This module provides constants which represent the numeric values of leaf " +"nodes of the parse tree (terminal tokens). Refer to the file :file:`Grammar/" +"Grammar` in the Python distribution for the definitions of the names in the " +"context of the language grammar. The specific numeric values which the " +"names map to may change between Python versions." +msgstr "" +"Ce module fournit des constantes qui représentent les valeurs numériques des " +"nœuds enfants du *parse tree* (les jetons \"terminaux\"). Voir le fichier :" +"file:`Grammar/Grammar` dans la distribution Python pour la définitions des " +"noms dans le contexte de la grammaire. Les valeurs numériques correspondant " +"aux noms sont susceptibles de changer entre deux versions de Python." + +#: ../Doc/library/token.rst:19 +msgid "" +"The module also provides a mapping from numeric codes to names and some " +"functions. The functions mirror definitions in the Python C header files." +msgstr "" +"Le module fournit également une correspondance entre les codes numériques et " +"les noms et certaines fonctions. Les fonctions reflètent les définitions des " +"fichiers d'en-tête C de Python." + +#: ../Doc/library/token.rst:25 +msgid "" +"Dictionary mapping the numeric values of the constants defined in this " +"module back to name strings, allowing more human-readable representation of " +"parse trees to be generated." +msgstr "" +"Dictionnaire faisant correspondre les valeurs numériques des constantes " +"définies dans ce module à leurs noms, permettant de générer une " +"représentation plus humaine des arbres syntaxiques." + +#: ../Doc/library/token.rst:32 +#, fuzzy +msgid "Return ``True`` for terminal token values." +msgstr "Renvoie ``True`` pour les valeurs des jetons terminaux." + +#: ../Doc/library/token.rst:37 +#, fuzzy +msgid "Return ``True`` for non-terminal token values." +msgstr "Renvoie ``True`` pour les valeurs des jetons non terminaux." + +#: ../Doc/library/token.rst:42 +#, fuzzy +msgid "Return ``True`` if *x* is the marker indicating the end of input." +msgstr "" +"Renvoie ``True`` si *x* est le marqueur indiquant la fin de de la source." + +#: ../Doc/library/token.rst:45 +msgid "The token constants are:" +msgstr "Les constantes associées aux jetons sont :" + +#: ../Doc/library/token-list.inc:18 +msgid "Token value for ``\"(\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:22 +msgid "Token value for ``\")\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:26 +msgid "Token value for ``\"[\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:30 +msgid "Token value for ``\"]\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:34 +msgid "Token value for ``\":\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:38 +msgid "Token value for ``\",\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:42 +msgid "Token value for ``\";\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:46 +msgid "Token value for ``\"+\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:50 +msgid "Token value for ``\"-\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:54 +msgid "Token value for ``\"*\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:58 +msgid "Token value for ``\"/\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:62 +msgid "Token value for ``\"|\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:66 +msgid "Token value for ``\"&\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:70 +msgid "Token value for ``\"<\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:74 +msgid "Token value for ``\">\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:78 +msgid "Token value for ``\"=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:82 +msgid "Token value for ``\".\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:86 +msgid "Token value for ``\"%\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:90 +msgid "Token value for ``\"{\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:94 +msgid "Token value for ``\"}\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:98 +msgid "Token value for ``\"==\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:102 +msgid "Token value for ``\"!=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:106 +msgid "Token value for ``\"<=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:110 +msgid "Token value for ``\">=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:114 +msgid "Token value for ``\"~\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:118 +msgid "Token value for ``\"^\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:122 +msgid "Token value for ``\"<<\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:126 +msgid "Token value for ``\">>\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:130 +msgid "Token value for ``\"**\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:134 +msgid "Token value for ``\"+=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:138 +msgid "Token value for ``\"-=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:142 +msgid "Token value for ``\"*=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:146 +msgid "Token value for ``\"/=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:150 +msgid "Token value for ``\"%=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:154 +msgid "Token value for ``\"&=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:158 +msgid "Token value for ``\"|=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:162 +msgid "Token value for ``\"^=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:166 +msgid "Token value for ``\"<<=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:170 +msgid "Token value for ``\">>=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:174 +msgid "Token value for ``\"**=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:178 +msgid "Token value for ``\"//\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:182 +msgid "Token value for ``\"//=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:186 +msgid "Token value for ``\"@\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:190 +msgid "Token value for ``\"@=\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:194 +msgid "Token value for ``\"->\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:198 +msgid "Token value for ``\"...\"``." +msgstr "" + +#: ../Doc/library/token-list.inc:202 +msgid "Token value for ``\":=\"``." +msgstr "" + +#: ../Doc/library/token.rst:49 +msgid "" +"The following token type values aren't used by the C tokenizer but are " +"needed for the :mod:`tokenize` module." +msgstr "" +"Les types de jetons suivants ne sont pas utilisés par l'analyseur lexical C " +"mais sont requis par le module :mod:`tokenize`." + +#: ../Doc/library/token.rst:54 +msgid "Token value used to indicate a comment." +msgstr "Valeur du jeton utilisée pour indiquer un commentaire." + +#: ../Doc/library/token.rst:59 +msgid "" +"Token value used to indicate a non-terminating newline. The :data:`NEWLINE` " +"token indicates the end of a logical line of Python code; ``NL`` tokens are " +"generated when a logical line of code is continued over multiple physical " +"lines." +msgstr "" +"Valeur du jeton utilisée pour indiquer un retour à la ligne non terminal. Le " +"jeton :data:`NEWLINE` indique la fin d'une ligne logique de code Python; les " +"jetons ``NL`` sont générés quand une ligne logique de code s'étend sur " +"plusieurs lignes." + +#: ../Doc/library/token.rst:67 +msgid "" +"Token value that indicates the encoding used to decode the source bytes into " +"text. The first token returned by :func:`tokenize.tokenize` will always be " +"an ``ENCODING`` token." +msgstr "" +"Valeur de jeton qui indique l'encodage utilisé pour décoder le fichier " +"initial. Le premier jeton renvoyé par :func:`tokenize.tokenize` sera " +"toujours un jeton ``ENCODING``." + +#: ../Doc/library/token.rst:74 +msgid "" +"Token value indicating that a type comment was recognized. Such tokens are " +"only produced when :func:`ast.parse()` is invoked with " +"``type_comments=True``." +msgstr "" + +#: ../Doc/library/token.rst:79 +msgid "Added :data:`AWAIT` and :data:`ASYNC` tokens." +msgstr "Ajout des jetons :data:`AWAIT` et :data:`ASYNC`." + +#: ../Doc/library/token.rst:82 +msgid "Added :data:`COMMENT`, :data:`NL` and :data:`ENCODING` tokens." +msgstr "Ajout des jetons :data:`COMMENT`, :data:`NL` et :data:`ENCODING`." + +#: ../Doc/library/token.rst:85 +msgid "" +"Removed :data:`AWAIT` and :data:`ASYNC` tokens. \"async\" and \"await\" are " +"now tokenized as :data:`NAME` tokens." +msgstr "" +"Suppression des jetons :data:`AWAIT` et :data:`ASYNC`. ``async`` et " +"``await`` sont maintenant transformés en jetons :data:`NAME`." + +#: ../Doc/library/token.rst:89 +msgid "" +"Added :data:`TYPE_COMMENT`. Added :data:`AWAIT` and :data:`ASYNC` tokens " +"back (they're needed to support parsing older Python versions for :func:`ast." +"parse` with ``feature_version`` set to 6 or lower)." +msgstr "" diff --git a/tests/test_potodo.py b/tests/test_potodo.py index 4c9e6ab..d4ba2a8 100644 --- a/tests/test_potodo.py +++ b/tests/test_potodo.py @@ -18,4 +18,7 @@ def test_potodo(capsys): ) captured = capsys.readouterr() assert "bugs.po" in captured.out + assert "# library" in captured.out + assert "token.po" in captured.out + assert "glossary.po" not in captured.out assert "sphinx.po" not in captured.out From 14a61206cc5c5a8fa7e3c9276306c705e613f874 Mon Sep 17 00:00:00 2001 From: Julien Palard Date: Fri, 13 Dec 2019 14:40:09 +0100 Subject: [PATCH 4/5] Initialize and tox cache. --- .travis.yml | 4 ++++ potodo/potodo.py | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index c90c1b8..e0cc4cb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,8 @@ language: python +cache: + directories: + - .tox/ + - $HOME/.cache/pip matrix: include: - python: "3.6" diff --git a/potodo/potodo.py b/potodo/potodo.py index 70628ee..1d7e3de 100644 --- a/potodo/potodo.py +++ b/potodo/potodo.py @@ -172,7 +172,7 @@ def exec_potodo( :param counts: Render list with counts not percentage """ - # initialize the arguments + # Initialize the arguments above, below, issue_reservations = initialize_arguments( above, below, offline, hide_reserved, path ) From 440d0998a41f104b429220ce60c20c619840e49b Mon Sep 17 00:00:00 2001 From: Julien Palard Date: Fri, 13 Dec 2019 14:40:53 +0100 Subject: [PATCH 5/5] More readable like this. --- potodo/_github.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/potodo/_github.py b/potodo/_github.py index 2292b3a..65a8901 100644 --- a/potodo/_github.py +++ b/potodo/_github.py @@ -25,7 +25,7 @@ def get_repo_url(repo_path: str) -> str: ) except subprocess.CalledProcessError as e: raise RuntimeError( - f'Unknown error. `{e.cmd}` returned "{e.output.rstrip()}".' + f'Unknown error. `{" ".join(e.cmd)}` returned "{e.output.rstrip()}".' ) return url