From ed8855d1168d617317eb7391df6a96cb8e85c287 Mon Sep 17 00:00:00 2001 From: Kyd Date: Wed, 20 Nov 2019 23:06:57 -0500 Subject: [PATCH 01/39] Traduction de library/typing.po --- library/typing.po | 564 +++++++++++++++++++++++++++++++++++++++------- 1 file changed, 488 insertions(+), 76 deletions(-) diff --git a/library/typing.po b/library/typing.po index 2ac12acb1..85e98c80c 100644 --- a/library/typing.po +++ b/library/typing.po @@ -6,17 +6,18 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2019-11-15 18:54+0100\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2019-11-20 23:06-0500\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" +"Last-Translator: \n" +"X-Generator: Poedit 2.2.4\n" #: ../Doc/library/typing.rst:2 msgid ":mod:`typing` --- Support for type hints" -msgstr "" +msgstr ":mod:`typing` — Prise en charge des annotations de type" #: ../Doc/library/typing.rst:9 msgid "**Source code:** :source:`Lib/typing.py`" @@ -28,6 +29,9 @@ msgid "" "They can be used by third party tools such as type checkers, IDEs, linters, " "etc." msgstr "" +"Le moteur d'exécution Python n'applique pas les annotations de type pour les " +"fonction et les variable. Elles peuvent être utilisés par des outils tiers " +"tels que les contrôleurs de type, les IDE, les analyseurs de code, etc." #: ../Doc/library/typing.rst:19 msgid "" @@ -38,11 +42,19 @@ msgid "" "full specification please see :pep:`484`. For a simplified introduction to " "type hints see :pep:`483`." msgstr "" +"Ce module fournit un support d'exécution pour les annotations de type " +"spécifiés par :pep:`484`, :pep:`526`, :pep:`544`, :pep:`586`, :pep:`589`, " +"et :pep:`591`. Le support le plus fondamental se compose des types :data:" +"`Any`, :data:`Union`, :data:`Tuple`, :data:`Callable`, :class:`TypeVar`, et :" +"class:`Generic`. Pour les spécifications complètes, voir :pep:`484`. Pour " +"une introduction simplifiée aux annotations de type, voir :pep:`483`." #: ../Doc/library/typing.rst:27 msgid "" "The function below takes and returns a string and is annotated as follows::" msgstr "" +"La fonction ci-dessous prend et retourne une chaîne de caractères et est " +"annotée comme suit ::" #: ../Doc/library/typing.rst:32 msgid "" @@ -50,42 +62,56 @@ msgid "" "type :class:`str` and the return type :class:`str`. Subtypes are accepted as " "arguments." msgstr "" +"Dans la fonction ``greeting``, l'argument ``name`` doit être de type :class:" +"`str` et le type de retour :class:`str`. Les sous-types sont acceptés comme " +"arguments." #: ../Doc/library/typing.rst:37 msgid "Type aliases" -msgstr "" +msgstr "Alias de type" #: ../Doc/library/typing.rst:39 msgid "" "A type alias is defined by assigning the type to the alias. In this example, " "``Vector`` and ``List[float]`` will be treated as interchangeable synonyms::" msgstr "" +"Un alias de type est défini en assignant le type à l'alias. Dans cet " +"exemple, ``Vector`` et ``List[float]`` seront traités comme des synonymes " +"interchangeables ::" #: ../Doc/library/typing.rst:51 msgid "" "Type aliases are useful for simplifying complex type signatures. For " "example::" msgstr "" +"Les alias de type sont utiles pour simplifier les signatures de type " +"complexes. Par exemple ::" #: ../Doc/library/typing.rst:69 msgid "" "Note that ``None`` as a type hint is a special case and is replaced by " "``type(None)``." msgstr "" +"Notez que ``None`` comme indice de type est un cas particulier et est " +"remplacé par ``type(None)``." #: ../Doc/library/typing.rst:75 msgid "NewType" -msgstr "" +msgstr "*NewType*" #: ../Doc/library/typing.rst:77 msgid "Use the :func:`NewType` helper function to create distinct types::" msgstr "" +"Utilisez la fonction d'aide :func:`NewType` pour créer des types distincts ::" #: ../Doc/library/typing.rst:84 msgid "" "The static type checker will treat the new type as if it were a subclass of " "the original type. This is useful in helping catch logical errors::" msgstr "" +"Le vérificateur de type statique traitera le nouveau type comme s'il " +"s'agissait d'une sous-classe du type original. Ceci est utile pour aider à " +"détecter les erreurs logiques ::" #: ../Doc/library/typing.rst:96 msgid "" @@ -94,6 +120,11 @@ msgid "" "pass in a ``UserId`` wherever an ``int`` might be expected, but will prevent " "you from accidentally creating a ``UserId`` in an invalid way::" msgstr "" +"Vous pouvez toujours effectuer toutes les opérations ``int`` sur une " +"variable de type ``UserId``, mais le résultat sera toujours de type ``int``. " +"Ceci vous permet de passer un ``UserId`` partout où une ``int`` est " +"attendue, mais vous empêchera de créer accidentellement un ``UserId``` d'une " +"manière invalide ::" #: ../Doc/library/typing.rst:104 msgid "" @@ -103,32 +134,46 @@ msgid "" "it. That means the expression ``Derived(some_value)`` does not create a new " "class or introduce any overhead beyond that of a regular function call." msgstr "" +"Notez que ces contrôles ne sont exécutés que par le vérificateur de type " +"statique. A l'exécution, l'instruction ``Derived = NewType('Derived', " +"Base)`` fera de ``Derived``` une fonction qui retourne immédiatement le " +"paramètre que vous lui passez. Cela signifie que l'expression " +"``Derived(some_value)`` ne crée pas une nouvelle classe ou n'introduit pas " +"de surcharge au-delà de celle d'un appel de fonction normal." #: ../Doc/library/typing.rst:110 msgid "" "More precisely, the expression ``some_value is Derived(some_value)`` is " "always true at runtime." msgstr "" +"Plus précisément, l'expression ``some_value is Derived(some_value)``est " +"toujours vraie au moment de l'exécution." #: ../Doc/library/typing.rst:113 msgid "" "This also means that it is not possible to create a subtype of ``Derived`` " "since it is an identity function at runtime, not an actual type::" msgstr "" +"Cela signifie également qu'il n'est pas possible de créer un sous-type de " +"``Derived`` puisqu'il s'agit d'une fonction d'identité au moment de " +"l'exécution, pas d'un type réel ::" #: ../Doc/library/typing.rst:123 msgid "" "However, it is possible to create a :func:`NewType` based on a 'derived' " "``NewType``::" msgstr "" +"Cependant, il est possible de créer un :func:`NewType` basé sur un " +"``NewType`` 'derived' ::" #: ../Doc/library/typing.rst:131 msgid "and typechecking for ``ProUserId`` will work as expected." msgstr "" +"et la vérification de type pour ``ProUserId`` fonctionnera comme prévu." #: ../Doc/library/typing.rst:133 msgid "See :pep:`484` for more details." -msgstr "" +msgstr "Voir :pep:`484` pour plus de détails." #: ../Doc/library/typing.rst:137 msgid "" @@ -137,6 +182,11 @@ msgid "" "treat ``Alias`` as being *exactly equivalent* to ``Original`` in all cases. " "This is useful when you want to simplify complex type signatures." msgstr "" +"Rappelons que l'utilisation d'un alias de type déclare que deux types sont " +"*équivalents* l'un à l'autre. Faire ``Alias = Original`` fera que le " +"vérificateur de type statique traitera ``Alias`` comme étant *exactement " +"équivalent* à ``Original`` dans tous les cas. Ceci est utile lorsque vous " +"voulez simplifier les signatures de type complexe." #: ../Doc/library/typing.rst:142 msgid "" @@ -147,16 +197,26 @@ msgid "" "``Derived`` is expected. This is useful when you want to prevent logic " "errors with minimal runtime cost." msgstr "" +"En revanche, ``NewType`` déclare qu'un type est un *sous-type* d'un autre. " +"Faire ``Derived = NewType('Derived', Original)`` fera en sorte que le " +"vérificateur de type statique traite ``Derived`` comme une *sous-classe* de " +"``Original``, ce qui signifie qu'une valeur de type ``Original`` ne peut " +"être utilisée dans les endroits où une valeur de type ``Derived`` est " +"prévue. Ceci est utile lorsque vous voulez éviter les erreurs logiques avec " +"un coût d'exécution minimal." #: ../Doc/library/typing.rst:152 msgid "Callable" -msgstr "" +msgstr "Appelable" #: ../Doc/library/typing.rst:154 msgid "" "Frameworks expecting callback functions of specific signatures might be type " "hinted using ``Callable[[Arg1Type, Arg2Type], ReturnType]``." msgstr "" +"Les *frameworks* qui attendent des fonctions de rappel de signatures " +"spécifiques peuvent être typés en utilisant ``Callable[[Arg1Type, Arg2Type], " +"ReturnType]``." #: ../Doc/library/typing.rst:157 msgid "For example::" @@ -168,10 +228,13 @@ msgid "" "the call signature by substituting a literal ellipsis for the list of " "arguments in the type hint: ``Callable[..., ReturnType]``." msgstr "" +"Il est possible de déclarer le type de retour d'un appelable sans spécifier " +"la signature de l'appel en substituant une ellipse à la liste des arguments " +"dans l'indice de type : ``Callable[..., ReturnType]``." #: ../Doc/library/typing.rst:175 msgid "Generics" -msgstr "" +msgstr "Génériques" #: ../Doc/library/typing.rst:177 msgid "" @@ -179,20 +242,29 @@ msgid "" "inferred in a generic way, abstract base classes have been extended to " "support subscription to denote expected types for container elements." msgstr "" +"Comme les informations de type sur les objets conservés dans des conteneurs " +"ne peuvent pas être déduites statiquement de manière générique, les classes " +"de base abstraites ont été étendues pour prendre en charge la sélection " +"(*subscription*) et indiquer les types attendus pour les éléments de " +"conteneur." #: ../Doc/library/typing.rst:188 msgid "" "Generics can be parameterized by using a new factory available in typing " "called :class:`TypeVar`." msgstr "" +"Les génériques peuvent être paramétrés en utilisant une nouvelle fabrique " +"(au sens des patrons de conception) disponible en tapant :class:`TypeVar`." #: ../Doc/library/typing.rst:202 msgid "User-defined generic types" -msgstr "" +msgstr "Types génériques définis par l'utilisateur" #: ../Doc/library/typing.rst:204 msgid "A user-defined class can be defined as a generic class." msgstr "" +"Une classe définie par l'utilisateur peut être définie comme une classe " +"générique." #: ../Doc/library/typing.rst:230 msgid "" @@ -200,37 +272,48 @@ msgid "" "single type parameter ``T`` . This also makes ``T`` valid as a type within " "the class body." msgstr "" +"``Generic[T]``en tant que classe de base définit que la classe ``LoggedVar`` " +"prend un paramètre de type unique ``T``. Ceci rend également ``T`` valide en " +"tant que type dans le corps de la classe." #: ../Doc/library/typing.rst:234 msgid "" "The :class:`Generic` base class defines :meth:`__class_getitem__` so that " "``LoggedVar[t]`` is valid as a type::" msgstr "" +"La classe de base :class:``Generic`` définit :meth:`__class_getitem__` de " +"sorte que ``LoggedVar[t]`` est valide comme type ::" #: ../Doc/library/typing.rst:243 msgid "" "A generic type can have any number of type variables, and type variables may " "be constrained::" msgstr "" +"Un type générique peut avoir un nombre quelconque de variables de type, et " +"les variables de type peuvent être limitées ::" #: ../Doc/library/typing.rst:255 msgid "" "Each type variable argument to :class:`Generic` must be distinct. This is " "thus invalid::" msgstr "" +"Chaque argument de variable de type :class:`Generic` doit être distinct. " +"Ceci n'est donc pas valable ::" #: ../Doc/library/typing.rst:266 msgid "You can use multiple inheritance with :class:`Generic`::" -msgstr "" +msgstr "Vous pouvez utiliser l'héritage multiple avec :class:`Generic`: :" #: ../Doc/library/typing.rst:275 msgid "" "When inheriting from generic classes, some type variables could be fixed::" msgstr "" +"Lors de l'héritage de classes génériques, certaines variables de type " +"peuvent être corrigées ::" #: ../Doc/library/typing.rst:284 msgid "In this case ``MyDict`` has a single parameter, ``T``." -msgstr "" +msgstr "Dans ce cas, ``MonDict`` a un seul paramètre, ``T``." #: ../Doc/library/typing.rst:286 msgid "" @@ -238,14 +321,20 @@ msgid "" "for each position. In the following example, ``MyIterable`` is not generic " "but implicitly inherits from ``Iterable[Any]``::" msgstr "" +"L'utilisation d'une classe générique sans spécifier de paramètres de type " +"suppose :data:`Any` pour chaque position. Dans l'exemple suivant, " +"``MyIterable`` n'est pas générique mais hérite implicitement de " +"``Iterable[Any]`` ::" #: ../Doc/library/typing.rst:294 msgid "User defined generic type aliases are also supported. Examples::" msgstr "" +"Les alias de type générique définis par l'utilisateur sont également pris en " +"charge. Exemples ::" #: ../Doc/library/typing.rst:310 msgid ":class:`Generic` no longer has a custom metaclass." -msgstr "" +msgstr ":class:`Generic` n'a plus de métaclasse personnalisée." #: ../Doc/library/typing.rst:313 msgid "" @@ -254,10 +343,15 @@ msgid "" "parameterizing generics is cached, and most types in the typing module are " "hashable and comparable for equality." msgstr "" +"Une classe générique définie par l'utilisateur peut avoir ABC comme classes " +"de base sans conflit de métaclasses. Les métaclasses génériques ne sont pas " +"prises en charge. Le résultat du paramétrage des génériques est mis en " +"cache, et la plupart des types dans le module de typage sont hachables et " +"comparables pour l'égalité." #: ../Doc/library/typing.rst:320 msgid "The :data:`Any` type" -msgstr "" +msgstr "Le type :data:`Any`" #: ../Doc/library/typing.rst:322 msgid "" @@ -265,12 +359,18 @@ msgid "" "every type as being compatible with :data:`Any` and :data:`Any` as being " "compatible with every type." msgstr "" +"Un type spécial de type est :data:`Any`. Un vérificateur de type statique " +"traitera chaque type comme étant compatible avec :data:`Any` et :data:`Any` " +"comme étant compatible avec chaque type." #: ../Doc/library/typing.rst:326 msgid "" "This means that it is possible to perform any operation or method call on a " "value of type on :data:`Any` and assign it to any variable::" msgstr "" +"Cela signifie qu'il est possible d'effectuer n'importe quelle opération ou " +"appel de méthode sur une valeur de type :data:`Any` et de l'affecter à " +"n'importe quelle variable ::" #: ../Doc/library/typing.rst:344 msgid "" @@ -280,18 +380,28 @@ msgid "" "declared to be of type :class:`str` and receives an :class:`int` value at " "runtime!" msgstr "" +"Notez qu'aucun contrôle de typage n'est effectué lors de l'affectation d'une " +"valeur de type :data:`Any` à un type plus précis. Par exemple, le " +"vérificateur de type statique n'a pas signalé d'erreur lors de l'affectation " +"de ``a`` à ``s`` même si ``s`` était déclaré être de type :class:`str` et " +"reçoit une valeur :class:`int` au moment de son exécution !" #: ../Doc/library/typing.rst:350 msgid "" "Furthermore, all functions without a return type or parameter types will " "implicitly default to using :data:`Any`::" msgstr "" +"De plus, toutes les fonctions sans type de retour ni type de paramètre " +"seront implicitement par défaut en utilisant :data:`Any`: :" #: ../Doc/library/typing.rst:363 msgid "" "This behavior allows :data:`Any` to be used as an *escape hatch* when you " "need to mix dynamically and statically typed code." msgstr "" +"Ce comportement permet à :data:`Any` d'être utilisé comme issue de secours " +"lorsque vous avez besoin de mélanger du code typé dynamiquement et " +"statiquement." #: ../Doc/library/typing.rst:366 msgid "" @@ -300,6 +410,10 @@ msgid "" "unlike :data:`Any`, the reverse is not true: :class:`object` is *not* a " "subtype of every other type." msgstr "" +"Comparer le comportement de :data:`Any` avec le comportement de :class:" +"`object`. Similaire à :data:`Any`, chaque type est un sous-type de :class:" +"`object`. Cependant, contrairement à :data:`Any`, l'inverse n'est pas vrai ::" +"class:`object' n'est *pas* un sous-type de chaque autre type." #: ../Doc/library/typing.rst:371 msgid "" @@ -308,16 +422,23 @@ msgid "" "it as a return value) of a more specialized type is a type error. For " "example::" msgstr "" +"Cela signifie que lorsque le type d'une valeur est :class:`object`, un " +"vérificateur de type rejettera presque toutes les opérations sur celle-ci, " +"et l'affecter à une variable (ou l'utiliser comme une valeur de retour) d'un " +"type plus spécialisé est une erreur de typage. Par exemple ::" #: ../Doc/library/typing.rst:393 msgid "" "Use :class:`object` to indicate that a value could be any type in a typesafe " "manner. Use :data:`Any` to indicate that a value is dynamically typed." msgstr "" +"Utilisez :class:`object` pour indiquer qu'une valeur peut être n'importe " +"quel type de manière sûre. Utiliser :data:`Any` pour indiquer qu'une valeur " +"est tapée dynamiquement." #: ../Doc/library/typing.rst:398 msgid "Nominal vs structural subtyping" -msgstr "" +msgstr "Sous-typage nominal vs sous-typage structurel" #: ../Doc/library/typing.rst:400 msgid "" @@ -325,6 +446,10 @@ msgid "" "subtyping*. This means that a class ``A`` is allowed where a class ``B`` is " "expected if and only if ``A`` is a subclass of ``B``." msgstr "" +"Initialement :pep:`484` définissait le système de type statique Python comme " +"utilisant *le sous-type nominal*. Cela signifie qu'une classe ``A`` est " +"permise lorsqu'une classe ``B`` est prévue si et seulement si ``A`` est une " +"sous-classe de ``B``." #: ../Doc/library/typing.rst:404 msgid "" @@ -334,6 +459,12 @@ msgid "" "would normally do in idiomatic dynamically typed Python code. For example, " "this conforms to the :pep:`484`::" msgstr "" +"Ce pré-requis s'appliquait auparavant aussi aux classes de base abstraites, " +"telles que :class:`Iterable`. Le problème avec cette approche est qu'une " +"classe devait être explicitement marquée pour les supporter, ce qui n'est " +"pas *pythonique* et diffère de ce que l'on ferait normalement avec du code " +"Python idiomatique typé dynamiquement. Par exemple, ceci est conforme au :" +"pep:`484` ::" #: ../Doc/library/typing.rst:417 msgid "" @@ -343,6 +474,12 @@ msgid "" "``Iterable[int]`` by static type checkers. This is known as *structural " "subtyping* (or static duck-typing)::" msgstr "" +":pep:`544` permet de résoudre ce problème en permettant aux utilisateurs " +"d'écrire le code ci-dessus sans classes de base explicites dans la " +"définition de classe, permettant à ``Bucket`` d'être implicitement considéré " +"comme un sous-type de ``Sized`` et ``Iterable[int]`` par des vérificateurs " +"de type statique. C'est ce qu'on appelle le *sous-typage structurel* (ou " +"typage canard) ::" #: ../Doc/library/typing.rst:433 msgid "" @@ -350,18 +487,21 @@ msgid "" "define new custom protocols to fully enjoy structural subtyping (see " "examples below)." msgstr "" +"De plus, en sous-classant une classe spéciale :class:`Protocol`, un " +"utilisateur peut définir de nouveaux protocoles personnalisés pour profiter " +"pleinement du sous-typage structurel (voir exemples ci-dessous)." #: ../Doc/library/typing.rst:439 msgid "Classes, functions, and decorators" -msgstr "" +msgstr "Classes, fonctions et décorateurs" #: ../Doc/library/typing.rst:441 msgid "The module defines the following classes, functions and decorators:" -msgstr "" +msgstr "Ce module définit les classes, fonctions et décorateurs suivants :" #: ../Doc/library/typing.rst:445 msgid "Type variable." -msgstr "" +msgstr "Variables de type." #: ../Doc/library/typing.rst:447 ../Doc/library/typing.rst:915 msgid "Usage::" @@ -374,6 +514,11 @@ msgid "" "function definitions. See class Generic for more information on generic " "types. Generic functions work as follows::" msgstr "" +"Les variables de type existent principalement dans l'intérêt des contrôleurs " +"de type statiques. Ils servent de paramètres pour les types génériques " +"ainsi que pour les définitions de fonctions génériques. Voir la classe " +"Generic pour plus d'informations sur les types génériques. Les fonctions " +"génériques fonctionnent comme suit ::" #: ../Doc/library/typing.rst:465 msgid "" @@ -382,12 +527,19 @@ msgid "" "arguments are instances of some subclass of :class:`str`, the return type is " "still plain :class:`str`." msgstr "" +"La signature de ce dernier exemple est essentiellement la surcharge de " +"``(str, str) -> str`` et ``(bytes, bytes) -> bytes``. Notez également que " +"si les arguments sont des instances d'une sous-classe de la classe :class:" +"`str`, le type de retour est toujours la classe :class:`str`." #: ../Doc/library/typing.rst:470 msgid "" "At runtime, ``isinstance(x, T)`` will raise :exc:`TypeError`. In general, :" "func:`isinstance` and :func:`issubclass` should not be used with types." msgstr "" +"Au moment de l'exécution, ``isinstance(x, T)``va lever :exc:`TypeError`. En " +"général, :func:`isinstance` et :func:`issubclass` ne devraient pas être " +"utilisés avec les types." #: ../Doc/library/typing.rst:473 msgid "" @@ -398,10 +550,17 @@ msgid "" "an actual type substituted (explicitly or implicitly) for the type variable " "must be a subclass of the boundary type, see :pep:`484`." msgstr "" +"Les variables de type peuvent être marquées covariantes ou contrevariantes " +"en passant ``covariant=True`` ou ``contravariant=True``. Voir :pep:`484` " +"pour plus de détails. Par défaut, les variables de type sont invariantes. " +"Alternativement, une variable de type peut spécifier une limite supérieure " +"en utilisant ``bound=>``. Cela signifie qu'un type réel substitué " +"(explicitement ou implicitement) à la variable type doit être une sous-" +"classe du type de frontière, voir :pep:`484`." #: ../Doc/library/typing.rst:483 msgid "Abstract base class for generic types." -msgstr "" +msgstr "Classe de base abstraite pour les types génériques." #: ../Doc/library/typing.rst:485 msgid "" @@ -409,21 +568,29 @@ msgid "" "this class with one or more type variables. For example, a generic mapping " "type might be defined as::" msgstr "" +"Un type générique est généralement déclaré en héritant d'une instanciation " +"de cette classe avec une ou plusieurs variables de type. Par exemple, un " +"type de correspondance générique peut être défini comme suit ::" #: ../Doc/library/typing.rst:494 msgid "This class can then be used as follows::" -msgstr "" +msgstr "Cette classe peut alors être utilisée comme suit ::" #: ../Doc/library/typing.rst:507 msgid "" "Base class for protocol classes. Protocol classes are defined like this::" msgstr "" +"Classe de base pour les classes de protocole. Les classes de protocole sont " +"définies comme suit ::" #: ../Doc/library/typing.rst:513 msgid "" "Such classes are primarily used with static type checkers that recognize " "structural subtyping (static duck-typing), for example::" msgstr "" +"Ces classes sont principalement utilisées avec les vérificateurs statiques " +"de type qui reconnaissent les sous-types structurels (typage canard " +"statique), par exemple ::" #: ../Doc/library/typing.rst:525 msgid "" @@ -432,10 +599,14 @@ msgid "" "that check only the presence of given attributes, ignoring their type " "signatures." msgstr "" +"Voir :pep:`544` pour plus de détails. Les classes de protocole décorées " +"avec :func:`runtime_checkable` (décrites plus loin) agissent comme des " +"protocoles d'exécution simples qui ne vérifient que la présence d'attributs " +"donnés, ignorant leurs signatures de type." #: ../Doc/library/typing.rst:530 msgid "Protocol classes can be generic, for example::" -msgstr "" +msgstr "Les classes de protocole peuvent être génériques, par exemple ::" #: ../Doc/library/typing.rst:540 msgid "" @@ -444,10 +615,14 @@ msgid "" "classes themselves -- specifically, it will accept the *class object* of " "``C``. For example::" msgstr "" +"Une variable annotée de ``C`` peut accepter une valeur de type ``C``. En " +"revanche, une variable annotée avec ``Type[C]`` peut accepter des valeurs " +"qui sont des classes elles-mêmes -- spécifiquement, elle acceptera l'objet " +"*class* de ``C``. Par exemple ::" #: ../Doc/library/typing.rst:549 msgid "Note that ``Type[C]`` is covariant::" -msgstr "" +msgstr "Notez que ``Type[C]`` est covariant ::" #: ../Doc/library/typing.rst:561 msgid "" @@ -458,124 +633,147 @@ msgid "" "the indicated base class. How the type checker is required to handle this " "particular case may change in future revisions of :pep:`484`." msgstr "" +"Le fait que ``Type[C]`` soit covariant implique que toutes les sous-classes " +"de ``C`` doivent implémenter la même signature de constructeur et les " +"signatures de méthode de classe que ``C``. Le vérificateur de type doit " +"signaler les manquements à cette règle. Il doit également autoriser les " +"appels du constructeur dans les sous-classes qui correspondent aux appels du " +"constructeur dans la classe de base indiquée. La façon dont le vérificateur " +"de type est nécessaire pour traiter ce cas particulier peut changer dans les " +"futures révisions de :pep:`484`." #: ../Doc/library/typing.rst:569 msgid "" "The only legal parameters for :class:`Type` are classes, :data:`Any`, :ref:" "`type variables `, and unions of any of these types. For example::" msgstr "" +"Les seuls paramètres légaux pour :class:`Type` sont les classes, :data:" +"`Any`, :ref:`type variables `, et les unions de ces types. Par " +"exemple ::" #: ../Doc/library/typing.rst:575 msgid "" "``Type[Any]`` is equivalent to ``Type`` which in turn is equivalent to " "``type``, which is the root of Python's metaclass hierarchy." msgstr "" +"``Type[Any]`` est équivalent à ``Type`` qui à son tour est équivalent à " +"``type``, qui est la racine de la hiérarchie des métaclasses de Python." #: ../Doc/library/typing.rst:582 msgid "A generic version of :class:`collections.abc.Iterable`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.Iterable`." #: ../Doc/library/typing.rst:586 msgid "A generic version of :class:`collections.abc.Iterator`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.Iterator`." #: ../Doc/library/typing.rst:590 msgid "A generic version of :class:`collections.abc.Reversible`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.Reversible`." #: ../Doc/library/typing.rst:594 msgid "An ABC with one abstract method ``__int__``." -msgstr "" +msgstr "Une ABC avec une méthode abstraite ``__int__``." #: ../Doc/library/typing.rst:598 msgid "An ABC with one abstract method ``__float__``." -msgstr "" +msgstr "Une ABC avec une méthode abstraite ``__float__``." #: ../Doc/library/typing.rst:602 msgid "An ABC with one abstract method ``__complex__``." -msgstr "" +msgstr "Une ABC avec une méthode abstraite ``__complex__``." #: ../Doc/library/typing.rst:606 msgid "An ABC with one abstract method ``__bytes__``." -msgstr "" +msgstr "Une ABC avec une méthode abstraite ``__bytes__``." #: ../Doc/library/typing.rst:610 msgid "An ABC with one abstract method ``__index__``." -msgstr "" +msgstr "Une ABC avec une méthode abstraite ``__index__``." #: ../Doc/library/typing.rst:616 msgid "" "An ABC with one abstract method ``__abs__`` that is covariant in its return " "type." msgstr "" +"Une ABC avec une méthode abstraite ``__abs__``qui est covariante dans son " +"type de retour." #: ../Doc/library/typing.rst:621 msgid "" "An ABC with one abstract method ``__round__`` that is covariant in its " "return type." msgstr "" +"Une ABC avec une méthode abstraite ``__round__`` qui est covariante dans son " +"type de retour." #: ../Doc/library/typing.rst:626 msgid "A generic version of :class:`collections.abc.Container`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.Container`." #: ../Doc/library/typing.rst:630 msgid "An alias to :class:`collections.abc.Hashable`" -msgstr "" +msgstr "Un alias pour :class:`collections.abc.Hashable`" #: ../Doc/library/typing.rst:634 msgid "An alias to :class:`collections.abc.Sized`" -msgstr "" +msgstr "Un alias vers :classe:`collections.abc.Sized`" #: ../Doc/library/typing.rst:638 msgid "A generic version of :class:`collections.abc.Collection`" -msgstr "" +msgstr "Une version générique de :class:`collections.abc.Collection`" #: ../Doc/library/typing.rst:644 msgid "A generic version of :class:`collections.abc.Set`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.Set`." #: ../Doc/library/typing.rst:648 msgid "A generic version of :class:`collections.abc.MutableSet`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.MutableSet`." #: ../Doc/library/typing.rst:652 msgid "" "A generic version of :class:`collections.abc.Mapping`. This type can be used " "as follows::" msgstr "" +"Une version générique de :class:`collections.abc.Mapping`. Ce type peut être " +"utilisé comme suit ::" #: ../Doc/library/typing.rst:660 msgid "A generic version of :class:`collections.abc.MutableMapping`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.MutableMapping`." #: ../Doc/library/typing.rst:664 msgid "A generic version of :class:`collections.abc.Sequence`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.Sequence`." #: ../Doc/library/typing.rst:668 msgid "A generic version of :class:`collections.abc.MutableSequence`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.MutableSequence`." #: ../Doc/library/typing.rst:672 msgid "A generic version of :class:`collections.abc.ByteString`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.ByteString`." #: ../Doc/library/typing.rst:674 msgid "" "This type represents the types :class:`bytes`, :class:`bytearray`, and :" "class:`memoryview`." msgstr "" +"Ce type représente les types :class:`bytes`, :class:`bytearray`, et :class:" +"`memoryview`." #: ../Doc/library/typing.rst:677 msgid "" "As a shorthand for this type, :class:`bytes` can be used to annotate " "arguments of any of the types mentioned above." msgstr "" +"Comme abréviation pour ce type, :class:`bytes` peut être utilisé pour " +"annoter des arguments de n'importe lequel des types mentionnés ci-dessus." #: ../Doc/library/typing.rst:682 msgid "A generic version of :class:`collections.deque`." -msgstr "" +msgstr "Une version générique de :class:`collections.deque`." #: ../Doc/library/typing.rst:689 msgid "" @@ -583,10 +781,13 @@ msgid "" "annotate arguments it is preferred to use an abstract collection type such " "as :class:`Sequence` or :class:`Iterable`." msgstr "" +"Version générique de :class:`list`. Utile pour annoter les types de retour. " +"Pour annoter les arguments, il est préférable d'utiliser un type de " +"collection abstraite tel que :class:`Sequence` ou :class:`Iterable`." #: ../Doc/library/typing.rst:694 msgid "This type may be used as follows::" -msgstr "" +msgstr "Ce type peut être utilisé comme suit ::" #: ../Doc/library/typing.rst:706 msgid "" @@ -594,30 +795,33 @@ msgid "" "return types. To annotate arguments it is preferred to use an abstract " "collection type such as :class:`AbstractSet`." msgstr "" +"Une version générique de :class:`builtins.set `. Utile pour annoter les " +"types de retour. Pour annoter les arguments, il est préférable d'utiliser un " +"type de collection abstraite tel que :class:`AbstractSet`." #: ../Doc/library/typing.rst:712 msgid "A generic version of :class:`builtins.frozenset `." -msgstr "" +msgstr "Une version générique de :class:`builtins.frozenset `." #: ../Doc/library/typing.rst:716 msgid "A generic version of :class:`collections.abc.MappingView`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.MappingView`." #: ../Doc/library/typing.rst:720 msgid "A generic version of :class:`collections.abc.KeysView`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.KeysView`." #: ../Doc/library/typing.rst:724 msgid "A generic version of :class:`collections.abc.ItemsView`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.ItemsView`." #: ../Doc/library/typing.rst:728 msgid "A generic version of :class:`collections.abc.ValuesView`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.ValuesView`." #: ../Doc/library/typing.rst:732 msgid "A generic version of :class:`collections.abc.Awaitable`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.Awaitable`." #: ../Doc/library/typing.rst:738 msgid "" @@ -625,22 +829,26 @@ msgid "" "order of type variables correspond to those of :class:`Generator`, for " "example::" msgstr "" +"Une version générique de :class:`collections.abc.Coroutine`. La variance et " +"l'ordre des variables de type correspondent à ceux de la classe :class:" +"`Generator`, par exemple ::" #: ../Doc/library/typing.rst:753 msgid "A generic version of :class:`collections.abc.AsyncIterable`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.AsyncIterable`." #: ../Doc/library/typing.rst:759 msgid "A generic version of :class:`collections.abc.AsyncIterator`." -msgstr "" +msgstr "Une version générique de :class:`collections.abc.AsyncIterator`." #: ../Doc/library/typing.rst:765 msgid "A generic version of :class:`contextlib.AbstractContextManager`." -msgstr "" +msgstr "Une version générique de :class:`contextlib.AbstractContextManager`." #: ../Doc/library/typing.rst:772 msgid "A generic version of :class:`contextlib.AbstractAsyncContextManager`." msgstr "" +"Une version générique de :class:`contextlib.AbstractAsyncContextManager`." #: ../Doc/library/typing.rst:779 msgid "" @@ -648,32 +856,37 @@ msgid "" "annotate arguments it is preferred to use an abstract collection type such " "as :class:`Mapping`." msgstr "" +"Une version générique de :class:`dict`. Utile pour annoter les types de " +"retour. Pour annoter les arguments, il est préférable d'utiliser un type de " +"collection abstraite tel que :class:`Mapping`." #: ../Doc/library/typing.rst:783 msgid "This type can be used as follows::" -msgstr "" +msgstr "Ce type peut être utilisé comme suit ::" #: ../Doc/library/typing.rst:790 msgid "A generic version of :class:`collections.defaultdict`." -msgstr "" +msgstr "Une version générique de :class:`collections.defaultdict`." #: ../Doc/library/typing.rst:796 msgid "A generic version of :class:`collections.OrderedDict`." -msgstr "" +msgstr "Une version générique de :class:`collections.OrderedDict`." #: ../Doc/library/typing.rst:802 msgid "A generic version of :class:`collections.Counter`." -msgstr "" +msgstr "Une version générique de :class:`collections.Counter`." #: ../Doc/library/typing.rst:809 msgid "A generic version of :class:`collections.ChainMap`." -msgstr "" +msgstr "Une version générique de :class:`collections.ChainMap`." #: ../Doc/library/typing.rst:816 msgid "" "A generator can be annotated by the generic type ``Generator[YieldType, " "SendType, ReturnType]``. For example::" msgstr "" +"Un générateur peut être annoté par le type générique ``Generator[YieldType, " +"SendType, ReturnType]``. Par exemple ::" #: ../Doc/library/typing.rst:825 msgid "" @@ -681,24 +894,33 @@ msgid "" "of :class:`Generator` behaves contravariantly, not covariantly or " "invariantly." msgstr "" +"Notez que contrairement à beaucoup d'autres génériques dans le module " +"*typing*, le ``SendType`` de :class:`Generator` se comporte de manière " +"contrevariante, pas de manière covariante ou invariante." #: ../Doc/library/typing.rst:829 msgid "" "If your generator will only yield values, set the ``SendType`` and " "``ReturnType`` to ``None``::" msgstr "" +"Si votre générateur ne donne que des valeurs, réglez les paramètres " +"``SendType`` et ``ReturnType`` sur ``None`` ::" #: ../Doc/library/typing.rst:837 msgid "" "Alternatively, annotate your generator as having a return type of either " "``Iterable[YieldType]`` or ``Iterator[YieldType]``::" msgstr "" +"Alternativement, annotez votre générateur comme ayant un type de retour soit " +"``Iterable[YieldType]``ou ``Iterator[YieldType]`` ::" #: ../Doc/library/typing.rst:847 msgid "" "An async generator can be annotated by the generic type " "``AsyncGenerator[YieldType, SendType]``. For example::" msgstr "" +"Un générateur asynchrone peut être annoté par le type générique " +"``AsyncGenerator[YieldType, SendType]``. Par exemple ::" #: ../Doc/library/typing.rst:856 msgid "" @@ -706,17 +928,25 @@ msgid "" "is no ``ReturnType`` type parameter. As with :class:`Generator`, the " "``SendType`` behaves contravariantly." msgstr "" +"Contrairement aux générateurs normaux, les générateurs asynchrones ne " +"peuvent pas retourner une valeur, il n'y a donc pas de paramètre de type " +"``ReturnType``. Comme avec :class:`Generator`, le ``SendType`` se comporte " +"de manière contrevariante." #: ../Doc/library/typing.rst:860 msgid "" "If your generator will only yield values, set the ``SendType`` to ``None``::" msgstr "" +"Si votre générateur ne donne que des valeurs, réglez le paramètre " +"``SendType`` sur ``None`` ::" #: ../Doc/library/typing.rst:868 msgid "" "Alternatively, annotate your generator as having a return type of either " "``AsyncIterable[YieldType]`` or ``AsyncIterator[YieldType]``::" msgstr "" +"Alternativement, annotez votre générateur comme ayant un type de retour soit " +"``AsyncIterable[YieldType]``ou ``AsyncIterator[YieldType]`` ::" #: ../Doc/library/typing.rst:880 msgid "" @@ -724,12 +954,17 @@ msgid "" "compatible path for Python 2 code: in Python 2, ``Text`` is an alias for " "``unicode``." msgstr "" +"``Text`` est un alias pour ``str``. Il est fourni pour fournir un chemin " +"d'accès compatible pour le code Python 2 : en Python 2, ``Text`` est un " +"alias pour ``unicode``." #: ../Doc/library/typing.rst:884 msgid "" "Use ``Text`` to indicate that a value must contain a unicode string in a " "manner that is compatible with both Python 2 and Python 3::" msgstr "" +"Utilisez ``Text`` pour indiquer qu'une valeur doit contenir une chaîne " +"unicode d'une manière compatible avec Python 2 et Python 3 ::" #: ../Doc/library/typing.rst:896 msgid "" @@ -737,6 +972,9 @@ msgid "" "``BinaryIO(IO[bytes])`` represent the types of I/O streams such as returned " "by :func:`open`." msgstr "" +"Le type générique ``IO[AnyStr]`` et ses sous-classes ``TextIO(IO[str])``et " +"``BinaryIO(IO[bytes])`` représentent les types de flux E/S tels que " +"retournés par :func:`open`." #: ../Doc/library/typing.rst:904 msgid "" @@ -745,24 +983,32 @@ msgid "" "generic in ``AnyStr`` and can be made specific by writing ``Pattern[str]``, " "``Pattern[bytes]``, ``Match[str]``, or ``Match[bytes]``." msgstr "" +"Ces alias de type correspondent aux types de retour de :func:`re.compile` " +"et :func:`re.match`. Ces types (et les fonctions correspondantes) sont " +"génériques dans ``AnyStr`` et peuvent être rendus spécifiques en écrivant " +"``Pattern[str]``, ``Pattern[bytes]``, ``Match[str]`` ou ``Match[bytes]``." #: ../Doc/library/typing.rst:913 msgid "Typed version of :func:`collections.namedtuple`." -msgstr "" +msgstr "Version typée de :func:`collections.namedtuple`." #: ../Doc/library/typing.rst:921 msgid "This is equivalent to::" -msgstr "C’est équivalent à ::" +msgstr "Ce qui est équivalent à ::" #: ../Doc/library/typing.rst:925 msgid "" "To give a field a default value, you can assign to it in the class body::" msgstr "" +"Pour donner une valeur par défaut à une zone, vous pouvez l'affecter dans le " +"corps de classe ::" #: ../Doc/library/typing.rst:934 msgid "" "Fields with a default value must come after any fields without a default." msgstr "" +"Les champs avec une valeur par défaut doivent venir après tous les champs " +"sans valeur par défaut." #: ../Doc/library/typing.rst:936 msgid "" @@ -771,40 +1017,55 @@ msgid "" "``_fields`` attribute and the default values are in the ``_field_defaults`` " "attribute both of which are part of the namedtuple API.)" msgstr "" +"La classe résultante a un attribut supplémentaire ``__annotations__`` " +"donnant un dict qui associe les noms des champs aux types de champs. (Les " +"noms des champs sont dans l'attribut ``_fields`` et les valeurs par défaut " +"sont dans l'attribut ``_field_defaults`` qui font partie de l'API " +"*namedtuple*.)" #: ../Doc/library/typing.rst:942 msgid "``NamedTuple`` subclasses can also have docstrings and methods::" msgstr "" +"Les sous-classes ``NamedTuple`` peuvent aussi avoir des *docstrings* et des " +"méthodes: :" #: ../Doc/library/typing.rst:952 msgid "Backward-compatible usage::" -msgstr "" +msgstr "Utilisation rétrocompatible ::" #: ../Doc/library/typing.rst:956 msgid "Added support for :pep:`526` variable annotation syntax." -msgstr "" +msgstr "Ajout du support de la syntaxe d'annotation variable :pep:`526`." #: ../Doc/library/typing.rst:959 msgid "Added support for default values, methods, and docstrings." msgstr "" +"Ajout de la prise en charge des valeurs par défaut, des méthodes et des " +"chaînes de caractères *docstrings*." #: ../Doc/library/typing.rst:962 msgid "" "Deprecated the ``_field_types`` attribute in favor of the more standard " "``__annotations__`` attribute which has the same information." msgstr "" +"A déprécié l'attribut ``_field_types`` en faveur de l'attribut plus standard " +"``__annotations__`` qui a la même information." #: ../Doc/library/typing.rst:966 msgid "" "The ``_field_types`` and ``__annotations__`` attributes are now regular " "dictionaries instead of instances of ``OrderedDict``." msgstr "" +"Les attributs ``_field_types`` et ``__annotations__`` sont maintenant des " +"dictionnaires réguliers au lieu des instances de ``OrderedDict``." #: ../Doc/library/typing.rst:972 msgid "" "A simple typed namespace. At runtime it is equivalent to a plain :class:" "`dict`." msgstr "" +"Un simple espace de nommage typé. A l'exécution, c'est l'équivalent d'un " +"simple:class:`dict`." #: ../Doc/library/typing.rst:975 msgid "" @@ -813,6 +1074,11 @@ msgid "" "consistent type. This expectation is not checked at runtime but is only " "enforced by type checkers. Usage::" msgstr "" +"``TypedDict`` crée un type de dictionnaire qui s'attend à ce que toutes ses " +"instances aient un certain jeu de clés, où chaque clé est associée à une " +"valeur d'un type cohérent. Cette attente n'est pas vérifiée au moment de " +"l'exécution mais n'est appliquée que par les vérificateurs de type. " +"Utilisation ::" #: ../Doc/library/typing.rst:991 msgid "" @@ -821,12 +1087,19 @@ msgid "" "with older versions of Python that do not support :pep:`526`, ``TypedDict`` " "supports two additional equivalent syntactic forms::" msgstr "" +"Les informations de type pour l'introspection sont accessibles via ``Point2D." +"__annotations__``et ``Point2D.__total__``. Pour permettre l'utilisation de " +"cette fonctionnalité avec les anciennes versions de Python qui ne supportent " +"pas :pep:``526``, ``TypedDict`` supporte deux formes syntaxiques " +"équivalentes supplémentaires ::" #: ../Doc/library/typing.rst:999 msgid "" "See :pep:`589` for more examples and detailed rules of using ``TypedDict`` " "with type checkers." msgstr "" +"Voir :pep:`589` pour plus d'exemples et de règles détaillées d'utilisation " +"de ``TypedDict`` avec les vérificateur de type." #: ../Doc/library/typing.rst:1006 msgid "" @@ -835,6 +1108,12 @@ msgid "" "into ``List[ForwardRef(\"SomeClass\")]``. This class should not be " "instantiated by a user, but may be used by introspection tools." msgstr "" +"Une classe utilisée pour le typage interne de la représentation des " +"références directes des chaînes de caractères. Par exemple, " +"``Liste[\"SomeClass\"]`` est implicitement transformé en " +"``Liste[ForwardRef(\"SomeClass\")]``. Cette classe ne doit pas être " +"instanciée par un utilisateur, mais peut être utilisée par des outils " +"d'introspection." #: ../Doc/library/typing.rst:1013 msgid "" @@ -842,10 +1121,13 @@ msgid "" "`distinct`. At runtime it returns a function that returns its argument. " "Usage::" msgstr "" +"Une fonction d'aide pour indiquer un type distinct à un vérificateur de " +"type, voir :ref:`distinct`. Lors de l'exécution, il retourne une fonction " +"qui retourne son argument. Utilisation ::" #: ../Doc/library/typing.rst:1024 msgid "Cast a value to a type." -msgstr "" +msgstr "Convertir une valeur en un type." #: ../Doc/library/typing.rst:1026 msgid "" @@ -853,12 +1135,18 @@ msgid "" "return value has the designated type, but at runtime we intentionally don't " "check anything (we want this to be as fast as possible)." msgstr "" +"Ceci retourne la valeur inchangée. Pour le vérificateur de type, cela " +"signifie que la valeur de retour a le type désigné, mais au moment de " +"l'exécution, rien n'est vérifié intentionnellement (afin que cela soit aussi " +"rapide que possible)." #: ../Doc/library/typing.rst:1033 msgid "" "Return a dictionary containing type hints for a function, method, module or " "class object." msgstr "" +"Retourne un dictionnaire contenant des indications de type pour une " +"fonction, une méthode, un module ou un objet de classe." #: ../Doc/library/typing.rst:1036 msgid "" @@ -869,10 +1157,19 @@ msgid "" "``None`` is set. For a class ``C``, return a dictionary constructed by " "merging all the ``__annotations__`` along ``C.__mro__`` in reverse order." msgstr "" +"C'est souvent équivalent à ``obj.__annotations__``. De plus, les références " +"directes encodées sous forme de chaîne littérales sont traitées en les " +"évaluant dans les espaces de nommage ``globals`` et ``locals``. Si " +"nécessaire, ``Optional[t]`` est ajouté pour les annotations de fonction et " +"de méthode si une valeur par défaut égale à ``None`` est définie. Pour une " +"classe ``C``, retourne un dictionnaire construit en fusionnant toutes les " +"``__annotations__``le long de ``C.__mro__``en ordre inverse." #: ../Doc/library/typing.rst:1047 msgid "Provide basic introspection for generic types and special typing forms." msgstr "" +"Fournit une introspection de base pour les types génériques et les " +"formulaires de typage spéciaux." #: ../Doc/library/typing.rst:1049 msgid "" @@ -881,6 +1178,11 @@ msgid "" "`collections` class, it gets normalized to the original class. For " "unsupported objects return ``None`` and ``()`` correspondingly. Examples::" msgstr "" +"Pour un objet de typage de la forme``X[Y, Z, ....]``, ces fonctions " +"retournent ``X`` et ``(Y, Z,...)``. Si ``X`` est un alias pour une classe " +"builtin ou :mod:`collections`, il est normalisé à la classe originale. Pour " +"les objets non supportés, retourne ``None'`` et ``()`` en conséquence. " +"Exemples ::" #: ../Doc/library/typing.rst:1065 msgid "" @@ -896,26 +1198,47 @@ msgid "" "gives a more precise type than can be expressed using a union or a type " "variable::" msgstr "" +"Le décorateur ``@overload``` permet de décrire des fonctions et des méthodes " +"qui supportent plusieurs combinaisons différentes de types d'arguments. Une " +"série de définitions décorées avec ``overload``doit être suivie d'une seule " +"définition non décorée de ``overload`` (pour la même fonction/méthode). Les " +"définitions décorées de ``@overload`` sont pour le vérificateur de type " +"seulement, puisqu'elles seront écrasées par la définition non décorée de " +"``@overload``, alors que cette dernière est utilisée au moment de " +"l'exécution mais devrait être ignorée par un vérificateur de type. Lors de " +"l'exécution, l'appel direct d'une fonction décorée avec ``@overload`` " +"lèvera :exc:`NotImplementedError`. Un exemple de surcharge qui donne un type " +"plus précis que celui qui peut être exprimé à l'aide d'une variable union ou " +"type ::" #: ../Doc/library/typing.rst:1089 msgid "See :pep:`484` for details and comparison with other typing semantics." msgstr "" +"Voir :pep:`484` pour plus de détails et comparaison avec d'autres " +"sémantiques de typage." #: ../Doc/library/typing.rst:1093 msgid "" "A decorator to indicate to type checkers that the decorated method cannot be " "overridden, and the decorated class cannot be subclassed. For example::" msgstr "" +"Un décorateur pour indiquer aux contrôleurs de frappe que la méthode décorée " +"ne peut pas être remplacée et que la classe décorée ne peut pas être sous-" +"classée. Par exemple ::" #: ../Doc/library/typing.rst:1111 ../Doc/library/typing.rst:1338 msgid "" "There is no runtime checking of these properties. See :pep:`591` for more " "details." msgstr "" +"Il n'y a pas de vérification d'exécution de ces propriétés. Voir :pep:`591` " +"pour plus de détails." #: ../Doc/library/typing.rst:1118 msgid "Decorator to indicate that annotations are not type hints." msgstr "" +"Décorateur pour indiquer que les annotations ne sont pas des indications de " +"type." #: ../Doc/library/typing.rst:1120 msgid "" @@ -923,24 +1246,33 @@ msgid "" "recursively to all methods defined in that class (but not to methods defined " "in its superclasses or subclasses)." msgstr "" +"Cela fonctionne en tant que classe ou fonction :term:`decorator`. Avec une " +"classe, elle s'applique récursivement à toutes les méthodes définies dans " +"cette classe (mais pas aux méthodes définies dans ses superclasses ou sous-" +"classes)." #: ../Doc/library/typing.rst:1124 msgid "This mutates the function(s) in place." -msgstr "" +msgstr "Cela fait muter la ou les fonctions en place." #: ../Doc/library/typing.rst:1128 msgid "Decorator to give another decorator the :func:`no_type_check` effect." msgstr "" +"Décorateur pour donner à un autre décorateur l'effet :func:`no_type_check`." #: ../Doc/library/typing.rst:1130 msgid "" "This wraps the decorator with something that wraps the decorated function " "in :func:`no_type_check`." msgstr "" +"Ceci enveloppe le décorateur avec quelque chose qui enveloppe la fonction " +"décorée dans :func:`no_type_check`." #: ../Doc/library/typing.rst:1135 msgid "Decorator to mark a class or function to be unavailable at runtime." msgstr "" +"Décorateur pour marquer une classe ou une fonction comme étant indisponible " +"au moment de l'exécution." #: ../Doc/library/typing.rst:1137 msgid "" @@ -948,16 +1280,22 @@ msgid "" "mark classes that are defined in type stub files if an implementation " "returns an instance of a private class::" msgstr "" +"Ce décorateur n'est pas disponible à l'exécution. Il est principalement " +"destiné à marquer les classes qui sont définies dans des fichiers séparés " +"spécifiqueselli de type si une implémentation retourne une instance d'une " +"classe privée ::" #: ../Doc/library/typing.rst:1148 msgid "" "Note that returning instances of private classes is not recommended. It is " "usually preferable to make such classes public." msgstr "" +"Notez qu'il n'est pas recommandé de retourner les instances des classes " +"*private*. Il est généralement préférable de rendre ces classes *public*." #: ../Doc/library/typing.rst:1153 msgid "Mark a protocol class as a runtime protocol." -msgstr "" +msgstr "Marquez une classe de protocole comme protocole d'exécution." #: ../Doc/library/typing.rst:1155 msgid "" @@ -966,80 +1304,94 @@ msgid "" "allows a simple-minded structural check, very similar to \"one trick ponies" "\" in :mod:`collections.abc` such as :class:`Iterable`. For example::" msgstr "" +"Un tel protocole peut être utilisé avec :func:`isinstance` et :func:" +"`issubclass`. Cela lève :exc:`TypeError` lorsqu'il est appliqué à une classe " +"non protocole. Cela permet un contrôle structurel compréhensible, très " +"similaire à \"one trick poneys\" dans :mod:`collections.abc` tel que :class:" +"`Iterable`. Par exemple ::" #: ../Doc/library/typing.rst:1166 msgid "" "**Warning:** this will check only the presence of the required methods, not " "their type signatures!" msgstr "" +"**Attention : ** ceci ne vérifiera que la présence des méthodes requises, et " +"non leur signature de type !" #: ../Doc/library/typing.rst:1173 msgid "Special type indicating an unconstrained type." -msgstr "" +msgstr "Type spécial indiquant un type non contraint." #: ../Doc/library/typing.rst:1175 msgid "Every type is compatible with :data:`Any`." -msgstr "" +msgstr "Chaque type est compatible avec :data:`Any`." #: ../Doc/library/typing.rst:1176 msgid ":data:`Any` is compatible with every type." -msgstr "" +msgstr ":data:`Any` est compatible avec tous les types." #: ../Doc/library/typing.rst:1180 msgid "Special type indicating that a function never returns. For example::" -msgstr "" +msgstr "Type spécial indiquant qu'une fonction ne renvoit rien. Par exemple ::" #: ../Doc/library/typing.rst:1193 msgid "Union type; ``Union[X, Y]`` means either X or Y." -msgstr "" +msgstr "Type d'union ; ``Union[X, Y]`` signifie X ou Y." #: ../Doc/library/typing.rst:1195 msgid "To define a union, use e.g. ``Union[int, str]``. Details:" msgstr "" +"Pour définir une union, utilisez par exemple ``Union[int, str]``. Détail :" #: ../Doc/library/typing.rst:1197 msgid "The arguments must be types and there must be at least one." msgstr "" +"Les arguments doivent être des types et il doit y en avoir au moins un." #: ../Doc/library/typing.rst:1199 msgid "Unions of unions are flattened, e.g.::" -msgstr "" +msgstr "Les unions d'unions sont aplanis, par exemple ::" #: ../Doc/library/typing.rst:1203 msgid "Unions of a single argument vanish, e.g.::" -msgstr "" +msgstr "Les unions d'un seul argument disparaissent, par exemple ::" #: ../Doc/library/typing.rst:1207 msgid "Redundant arguments are skipped, e.g.::" -msgstr "" +msgstr "Les arguments redondants sont ignorés, par exemple ::" #: ../Doc/library/typing.rst:1211 msgid "When comparing unions, the argument order is ignored, e.g.::" msgstr "" +"Lors de la comparaison d'unions, l'ordre des arguments est ignoré, par " +"exemple ::" #: ../Doc/library/typing.rst:1215 msgid "You cannot subclass or instantiate a union." -msgstr "" +msgstr "Vous ne pouvez pas sous-classer ou instancier un union." #: ../Doc/library/typing.rst:1217 msgid "You cannot write ``Union[X][Y]``." -msgstr "" +msgstr "Vous ne pouvez pas écrire ``Union[X][Y]``." #: ../Doc/library/typing.rst:1219 msgid "You can use ``Optional[X]`` as a shorthand for ``Union[X, None]``." msgstr "" +"Vous pouvez utiliser l'abréviation ``Optional[X]`` pour ``Union[X, None]``." #: ../Doc/library/typing.rst:1221 msgid "Don't remove explicit subclasses from unions at runtime." msgstr "" +"Ne supprimez pas les sous-classes explicites des syndicats au moment de " +"l'exécution." #: ../Doc/library/typing.rst:1226 msgid "Optional type." -msgstr "" +msgstr "Type optionnel." #: ../Doc/library/typing.rst:1228 msgid "``Optional[X]`` is equivalent to ``Union[X, None]``." -msgstr "" +msgstr "``Optional[X]`` équivaut à ``Union[X, None]``." #: ../Doc/library/typing.rst:1230 msgid "" @@ -1048,6 +1400,10 @@ msgid "" "the ``Optional`` qualifier on its type annotation just because it is " "optional. For example::" msgstr "" +"Notez que ce n'est pas le même concept qu'un argument optionnel, qui est un " +"argument par défaut. Un argument optionnel avec une valeur par défaut ne " +"nécessite pas le qualificatif ``Optional`` sur son annotation de type " +"simplement parce qu'il est optionnel. Par exemple ::" #: ../Doc/library/typing.rst:1238 msgid "" @@ -1055,6 +1411,9 @@ msgid "" "``Optional`` is appropriate, whether the argument is optional or not. For " "example::" msgstr "" +"Par contre, si une valeur explicite de ``None`` est permise, l'utilisation " +"de ``Optional`` est appropriée, que l'argument soit facultatif ou non. Par " +"exemple ::" #: ../Doc/library/typing.rst:1247 msgid "" @@ -1062,6 +1421,9 @@ msgid "" "first item of type X and the second of type Y. The type of the empty tuple " "can be written as ``Tuple[()]``." msgstr "" +"Type de tuple ; ``Tuple[X, Y]`` est le type d'un tuple de deux éléments avec " +"le premier élément de type X et le second de type Y. Le type du tuple vide " +"peut être écrit comme ``Tuple[()]``." #: ../Doc/library/typing.rst:1251 msgid "" @@ -1069,6 +1431,9 @@ msgid "" "variables T1 and T2. ``Tuple[int, float, str]`` is a tuple of an int, a " "float and a string." msgstr "" +"Exemple : ``Tuple[T1, T2]`` est un tuple de deux éléments correspondant aux " +"variables de type T1 et T2. ``Tuple[int, float, str]`` est un tuple d'un " +"int, d'un float et d'une chaîne." #: ../Doc/library/typing.rst:1255 msgid "" @@ -1076,10 +1441,14 @@ msgid "" "ellipsis, e.g. ``Tuple[int, ...]``. A plain :data:`Tuple` is equivalent to " "``Tuple[Any, ...]``, and in turn to :class:`tuple`." msgstr "" +"Pour spécifier un tuple de longueur variable et de type homogène, utilisez " +"une ellipse, par exemple ``Tuple[int, ....]``. Un tuple :data:`Tuple` est " +"équivalent à ``Tuple[Any, ....]``, et à son tour à :class:`tuple`." #: ../Doc/library/typing.rst:1261 msgid "Callable type; ``Callable[[int], str]`` is a function of (int) -> str." msgstr "" +"Type Appelable ; ``Callable[[int], str]`` est une fonction de (int) -> str." #: ../Doc/library/typing.rst:1263 msgid "" @@ -1087,6 +1456,10 @@ msgid "" "argument list and the return type. The argument list must be a list of " "types or an ellipsis; the return type must be a single type." msgstr "" +"La syntaxe de sélection (*subscription*) doit toujours être utilisée avec " +"exactement deux valeurs : la liste d'arguments et le type de retour. La " +"liste d'arguments doit être une liste de types ou une ellipse ; il doit y " +"avoir un seul type de retour." #: ../Doc/library/typing.rst:1268 msgid "" @@ -1097,6 +1470,12 @@ msgid "" "equivalent to ``Callable[..., Any]``, and in turn to :class:`collections.abc." "Callable`." msgstr "" +"Il n'y a pas de syntaxe pour indiquer les arguments optionnels ou les mots-" +"clés ; de tels types de fonctions sont rarement utilisés comme types de " +"rappel. ``Callable[..., ReturnType]`` (ellipse) peut être utilisé pour " +"annoter le type d'un appelable, prenant un nombre quelconque d'arguments et " +"renvoyant ``ReturnType``. Un simple :data:``Callable`` est équivalent à " +"``Callable[..., Any]``, et à son tour à :class:`collections.abc.Callable`." #: ../Doc/library/typing.rst:1278 msgid "" @@ -1104,6 +1483,9 @@ msgid "" "variable or function parameter has a value equivalent to the provided " "literal (or one of several literals). For example::" msgstr "" +"Un type qui peut être utilisé pour indiquer aux vérificateurs de type que la " +"variable ou le paramètre de fonction correspondant a une valeur équivalente " +"au littéral fourni (ou un parmi plusieurs littéraux). Par exemple ::" #: ../Doc/library/typing.rst:1292 msgid "" @@ -1111,10 +1493,14 @@ msgid "" "allowed as type argument to ``Literal[...]``, but type checkers may impose " "restrictions. See :pep:`586` for more details about literal types." msgstr "" +"``Literal[...]`` ne peut être sous-classé. Lors de l'exécution, une valeur " +"arbitraire est autorisée comme argument de type pour ``Literal[...]``, mais " +"les vérificateurs de type peuvent imposer des restrictions. Voir :pep:`586` " +"pour plus de détails sur les types littéraux." #: ../Doc/library/typing.rst:1300 msgid "Special type construct to mark class variables." -msgstr "" +msgstr "Construction de type spécial pour marquer les variables de classe." #: ../Doc/library/typing.rst:1302 msgid "" @@ -1122,10 +1508,14 @@ msgid "" "indicates that a given attribute is intended to be used as a class variable " "and should not be set on instances of that class. Usage::" msgstr "" +"Tel qu'introduit dans :pep:`526`, une annotation de variable enveloppée dans " +"ClassVar indique qu'un attribut donné est destiné à être utilisé comme une " +"variable de classe et ne doit pas être défini sur des instances de cette " +"classe. Utilisation ::" #: ../Doc/library/typing.rst:1310 msgid ":data:`ClassVar` accepts only types and cannot be further subscribed." -msgstr "" +msgstr "data:`ClassVar` n'accepte que les types et ne peut plus être souscrit." #: ../Doc/library/typing.rst:1312 msgid "" @@ -1134,30 +1524,46 @@ msgid "" "runtime behavior, but it can be used by third-party type checkers. For " "example, a type checker might flag the following code as an error::" msgstr "" +"data:`ClassVar` n'est pas une classe en soi, et ne devrait pas être utilisé " +"avec :func:`isinstance` ou :func:`issubclass`. :data:`ClassVar` ne modifie " +"pas le comportement d'exécution Python, mais il peut être utilisé par des " +"vérificateurs tiers. Par exemple, un vérificateur de type peut marquer le " +"code suivant comme une erreur ::" #: ../Doc/library/typing.rst:1326 msgid "" "A special typing construct to indicate to type checkers that a name cannot " "be re-assigned or overridden in a subclass. For example::" msgstr "" +"Une construction de type spéciale pour indiquer aux vérificateurs de type " +"qu'un nom ne peut pas être réassigné ou remplacé dans une sous-classe. Par " +"exemple ::" #: ../Doc/library/typing.rst:1345 msgid "" "``AnyStr`` is a type variable defined as ``AnyStr = TypeVar('AnyStr', str, " "bytes)``." msgstr "" +"``AnyStr`` est une variable de type définie comme ``AnyStr = " +"TypeVar('AnyStr', str, bytes)``." #: ../Doc/library/typing.rst:1348 msgid "" "It is meant to be used for functions that may accept any kind of string " "without allowing different kinds of strings to mix. For example::" msgstr "" +"Cela est destiné à être utilisé pour des fonctions qui peuvent accepter " +"n'importe quel type de chaîne de caractères sans permettre à différents " +"types de chaînes de caractères de se mélanger. Par exemple ::" #: ../Doc/library/typing.rst:1360 msgid "" "A special constant that is assumed to be ``True`` by 3rd party static type " "checkers. It is ``False`` at runtime. Usage::" msgstr "" +"Une constante spéciale qui est supposée être ``True`` par les vérificateurs " +"de type statiques tiers. C'est ``False`` au moment de l'exécution. " +"Utilisation ::" #: ../Doc/library/typing.rst:1369 msgid "" @@ -1166,3 +1572,9 @@ msgid "" "interpreter runtime. Type annotations for local variables are not " "evaluated, so the second annotation does not need to be enclosed in quotes." msgstr "" +"Notez que la première annotation de type doit être entourée de guillemets, " +"ce qui en fait une \" référence avancée\", pour cacher la référence " +"``expensive_mod`` au moment de l'exécution par l'interpréteur. Les " +"annotations de type pour les variables locales ne sont pas évaluées, de " +"sorte que la deuxième annotation n'a pas besoin d'être placée entre " +"guillemets." From 3679e78231e0683ffaff513758685dd46389232a Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:34:19 -0500 Subject: [PATCH 02/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 85e98c80c..74306cd66 100644 --- a/library/typing.po +++ b/library/typing.po @@ -30,7 +30,7 @@ msgid "" "etc." msgstr "" "Le moteur d'exécution Python n'applique pas les annotations de type pour les " -"fonction et les variable. Elles peuvent être utilisés par des outils tiers " +"fonctions et les variables. Elles peuvent être utilisées par des outils tiers " "tels que les contrôleurs de type, les IDE, les analyseurs de code, etc." #: ../Doc/library/typing.rst:19 From 2e94a3c28a7632c33e9d2e1978a74a7e6611c918 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:34:29 -0500 Subject: [PATCH 03/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 74306cd66..4ad29a125 100644 --- a/library/typing.po +++ b/library/typing.po @@ -146,7 +146,7 @@ msgid "" "More precisely, the expression ``some_value is Derived(some_value)`` is " "always true at runtime." msgstr "" -"Plus précisément, l'expression ``some_value is Derived(some_value)``est " +"Plus précisément, l'expression ``some_value is Derived(some_value)`` est " "toujours vraie au moment de l'exécution." #: ../Doc/library/typing.rst:113 From d51d0e629c80482d569d1b8d4b3e3b41b68eb75b Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:34:45 -0500 Subject: [PATCH 04/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 4ad29a125..de87e336d 100644 --- a/library/typing.po +++ b/library/typing.po @@ -164,7 +164,7 @@ msgid "" "``NewType``::" msgstr "" "Cependant, il est possible de créer un :func:`NewType` basé sur un " -"``NewType`` 'derived' ::" +"``NewType`` 'derived' ::" #: ../Doc/library/typing.rst:131 msgid "and typechecking for ``ProUserId`` will work as expected." From e3324374e65b9bb50e7d6065e6199bccdcd52768 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:35:00 -0500 Subject: [PATCH 05/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index de87e336d..88b84dc0b 100644 --- a/library/typing.po +++ b/library/typing.po @@ -272,7 +272,7 @@ msgid "" "single type parameter ``T`` . This also makes ``T`` valid as a type within " "the class body." msgstr "" -"``Generic[T]``en tant que classe de base définit que la classe ``LoggedVar`` " +"``Generic[T]`` en tant que classe de base définit que la classe ``LoggedVar`` " "prend un paramètre de type unique ``T``. Ceci rend également ``T`` valide en " "tant que type dans le corps de la classe." From 5a804b88f250a53c127553889cb0aad885304df3 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:35:26 -0500 Subject: [PATCH 06/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 88b84dc0b..f59ad243b 100644 --- a/library/typing.po +++ b/library/typing.po @@ -281,7 +281,7 @@ msgid "" "The :class:`Generic` base class defines :meth:`__class_getitem__` so that " "``LoggedVar[t]`` is valid as a type::" msgstr "" -"La classe de base :class:``Generic`` définit :meth:`__class_getitem__` de " +"La classe de base :class:`Generic` définit :meth:`__class_getitem__` de " "sorte que ``LoggedVar[t]`` est valide comme type ::" #: ../Doc/library/typing.rst:243 From a94f191fb2bcdacbe0506db836efd644bfc52082 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:35:35 -0500 Subject: [PATCH 07/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index f59ad243b..04dc44bef 100644 --- a/library/typing.po +++ b/library/typing.po @@ -302,7 +302,7 @@ msgstr "" #: ../Doc/library/typing.rst:266 msgid "You can use multiple inheritance with :class:`Generic`::" -msgstr "Vous pouvez utiliser l'héritage multiple avec :class:`Generic`: :" +msgstr "Vous pouvez utiliser l'héritage multiple avec :class:`Generic` ::" #: ../Doc/library/typing.rst:275 msgid "" From 6c64e9ece345a355870ff3fcc1f7d7186e566d83 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:35:48 -0500 Subject: [PATCH 08/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 04dc44bef..bfb817dba 100644 --- a/library/typing.po +++ b/library/typing.po @@ -384,7 +384,7 @@ msgstr "" "valeur de type :data:`Any` à un type plus précis. Par exemple, le " "vérificateur de type statique n'a pas signalé d'erreur lors de l'affectation " "de ``a`` à ``s`` même si ``s`` était déclaré être de type :class:`str` et " -"reçoit une valeur :class:`int` au moment de son exécution !" +"reçoit une valeur :class:`int` au moment de son exécution !" #: ../Doc/library/typing.rst:350 msgid "" From 683fa855ab4a957d74e900bbff4ce1a5fe822ab3 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:37:00 -0500 Subject: [PATCH 09/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index bfb817dba..289b1098d 100644 --- a/library/typing.po +++ b/library/typing.po @@ -392,7 +392,7 @@ msgid "" "implicitly default to using :data:`Any`::" msgstr "" "De plus, toutes les fonctions sans type de retour ni type de paramètre " -"seront implicitement par défaut en utilisant :data:`Any`: :" +"seront implicitement par défaut en utilisant :data:`Any` ::" #: ../Doc/library/typing.rst:363 msgid "" From c52bee25b3c9e430c24ebc41e3707e4539d2b558 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:39:54 -0500 Subject: [PATCH 10/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 289b1098d..7957966d7 100644 --- a/library/typing.po +++ b/library/typing.po @@ -955,7 +955,7 @@ msgid "" "``unicode``." msgstr "" "``Text`` est un alias pour ``str``. Il est fourni pour fournir un chemin " -"d'accès compatible pour le code Python 2 : en Python 2, ``Text`` est un " +"d'accès compatible pour le code Python 2 : en Python 2, ``Text`` est un " "alias pour ``unicode``." #: ../Doc/library/typing.rst:884 From 1fbddb1dc732caa587c5b6eab63dea4fd93568d4 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:40:11 -0500 Subject: [PATCH 11/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 7957966d7..85982790b 100644 --- a/library/typing.po +++ b/library/typing.po @@ -1027,7 +1027,7 @@ msgstr "" msgid "``NamedTuple`` subclasses can also have docstrings and methods::" msgstr "" "Les sous-classes ``NamedTuple`` peuvent aussi avoir des *docstrings* et des " -"méthodes: :" +"méthodes ::" #: ../Doc/library/typing.rst:952 msgid "Backward-compatible usage::" From c47728c301941bd88d17e810a975ceb4a4af26c8 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:40:24 -0500 Subject: [PATCH 12/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 85982790b..d14c9ffcc 100644 --- a/library/typing.po +++ b/library/typing.po @@ -1065,7 +1065,7 @@ msgid "" "`dict`." msgstr "" "Un simple espace de nommage typé. A l'exécution, c'est l'équivalent d'un " -"simple:class:`dict`." +"simple :class:`dict`." #: ../Doc/library/typing.rst:975 msgid "" From d65eca89ae7055fefc7b7bbdc7c625b7e5114fda Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:40:37 -0500 Subject: [PATCH 13/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index d14c9ffcc..83705a6c7 100644 --- a/library/typing.po +++ b/library/typing.po @@ -1088,7 +1088,7 @@ msgid "" "supports two additional equivalent syntactic forms::" msgstr "" "Les informations de type pour l'introspection sont accessibles via ``Point2D." -"__annotations__``et ``Point2D.__total__``. Pour permettre l'utilisation de " +"__annotations__`` et ``Point2D.__total__``. Pour permettre l'utilisation de " "cette fonctionnalité avec les anciennes versions de Python qui ne supportent " "pas :pep:``526``, ``TypedDict`` supporte deux formes syntaxiques " "équivalentes supplémentaires ::" From 79e6a68c5feb23b7134efa97875ff3a1642c0206 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:40:47 -0500 Subject: [PATCH 14/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 83705a6c7..632ab185b 100644 --- a/library/typing.po +++ b/library/typing.po @@ -1090,7 +1090,7 @@ msgstr "" "Les informations de type pour l'introspection sont accessibles via ``Point2D." "__annotations__`` et ``Point2D.__total__``. Pour permettre l'utilisation de " "cette fonctionnalité avec les anciennes versions de Python qui ne supportent " -"pas :pep:``526``, ``TypedDict`` supporte deux formes syntaxiques " +"pas :pep:`526`, ``TypedDict`` supporte deux formes syntaxiques " "équivalentes supplémentaires ::" #: ../Doc/library/typing.rst:999 From 72f801bd6742bb77d4e1a92483dcfebc3201cf42 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:40:58 -0500 Subject: [PATCH 15/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 632ab185b..0d6a68c6d 100644 --- a/library/typing.po +++ b/library/typing.po @@ -1099,7 +1099,7 @@ msgid "" "with type checkers." msgstr "" "Voir :pep:`589` pour plus d'exemples et de règles détaillées d'utilisation " -"de ``TypedDict`` avec les vérificateur de type." +"de ``TypedDict`` avec les vérificateurs de type." #: ../Doc/library/typing.rst:1006 msgid "" From 0f501e889618ce63980d2b44892ea076dd8f8109 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:41:08 -0500 Subject: [PATCH 16/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 0d6a68c6d..628a928dd 100644 --- a/library/typing.po +++ b/library/typing.po @@ -1111,7 +1111,7 @@ msgstr "" "Une classe utilisée pour le typage interne de la représentation des " "références directes des chaînes de caractères. Par exemple, " "``Liste[\"SomeClass\"]`` est implicitement transformé en " -"``Liste[ForwardRef(\"SomeClass\")]``. Cette classe ne doit pas être " +"``Liste[ForwardRef(\"SomeClass\")]``. Cette classe ne doit pas être " "instanciée par un utilisateur, mais peut être utilisée par des outils " "d'introspection." From 4207fb5e98a0cae448f7509256a013b8cd2cdac7 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:41:23 -0500 Subject: [PATCH 17/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 628a928dd..068f587ec 100644 --- a/library/typing.po +++ b/library/typing.po @@ -230,7 +230,7 @@ msgid "" msgstr "" "Il est possible de déclarer le type de retour d'un appelable sans spécifier " "la signature de l'appel en substituant une ellipse à la liste des arguments " -"dans l'indice de type : ``Callable[..., ReturnType]``." +"dans l'indice de type : ``Callable[..., ReturnType]``." #: ../Doc/library/typing.rst:175 msgid "Generics" From 759fd64d00d212c86f72c659e8c8a940b535d784 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:41:43 -0500 Subject: [PATCH 18/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 068f587ec..dec5fbf20 100644 --- a/library/typing.po +++ b/library/typing.po @@ -412,7 +412,7 @@ msgid "" msgstr "" "Comparer le comportement de :data:`Any` avec le comportement de :class:" "`object`. Similaire à :data:`Any`, chaque type est un sous-type de :class:" -"`object`. Cependant, contrairement à :data:`Any`, l'inverse n'est pas vrai ::" +"`object`. Cependant, contrairement à :data:`Any`, l'inverse n'est pas vrai : :" "class:`object' n'est *pas* un sous-type de chaque autre type." #: ../Doc/library/typing.rst:371 From f043901d3701efdfe0faad5297412ce3ee319f03 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:41:52 -0500 Subject: [PATCH 19/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index dec5fbf20..6afd8c675 100644 --- a/library/typing.po +++ b/library/typing.po @@ -972,7 +972,7 @@ msgid "" "``BinaryIO(IO[bytes])`` represent the types of I/O streams such as returned " "by :func:`open`." msgstr "" -"Le type générique ``IO[AnyStr]`` et ses sous-classes ``TextIO(IO[str])``et " +"Le type générique ``IO[AnyStr]`` et ses sous-classes ``TextIO(IO[str])`` et " "``BinaryIO(IO[bytes])`` représentent les types de flux E/S tels que " "retournés par :func:`open`." From f8aa0c0e3e6a24a5076d0ee8f6676ffa4919904f Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:42:00 -0500 Subject: [PATCH 20/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 6afd8c675..ba866cf0f 100644 --- a/library/typing.po +++ b/library/typing.po @@ -984,7 +984,7 @@ msgid "" "``Pattern[bytes]``, ``Match[str]``, or ``Match[bytes]``." msgstr "" "Ces alias de type correspondent aux types de retour de :func:`re.compile` " -"et :func:`re.match`. Ces types (et les fonctions correspondantes) sont " +"et :func:`re.match`. Ces types (et les fonctions correspondantes) sont " "génériques dans ``AnyStr`` et peuvent être rendus spécifiques en écrivant " "``Pattern[str]``, ``Pattern[bytes]``, ``Match[str]`` ou ``Match[bytes]``." From c3364816dbccf420504c69f85c047c9b3d3412f3 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:42:09 -0500 Subject: [PATCH 21/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index ba866cf0f..0a32c815e 100644 --- a/library/typing.po +++ b/library/typing.po @@ -1018,7 +1018,7 @@ msgid "" "attribute both of which are part of the namedtuple API.)" msgstr "" "La classe résultante a un attribut supplémentaire ``__annotations__`` " -"donnant un dict qui associe les noms des champs aux types de champs. (Les " +"donnant un dict qui associe les noms des champs aux types de champs. (Les " "noms des champs sont dans l'attribut ``_fields`` et les valeurs par défaut " "sont dans l'attribut ``_field_defaults`` qui font partie de l'API " "*namedtuple*.)" From 2d1a223be30888c1e109afeb20e15f30b2c5b003 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:42:22 -0500 Subject: [PATCH 22/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 0a32c815e..780b23557 100644 --- a/library/typing.po +++ b/library/typing.po @@ -515,7 +515,7 @@ msgid "" "types. Generic functions work as follows::" msgstr "" "Les variables de type existent principalement dans l'intérêt des contrôleurs " -"de type statiques. Ils servent de paramètres pour les types génériques " +"de type statiques. Ils servent de paramètres pour les types génériques " "ainsi que pour les définitions de fonctions génériques. Voir la classe " "Generic pour plus d'informations sur les types génériques. Les fonctions " "génériques fonctionnent comme suit ::" From 269c126d927ad5c5260e58a6cb998eaf6d727e27 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:42:35 -0500 Subject: [PATCH 23/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index 780b23557..a07242260 100644 --- a/library/typing.po +++ b/library/typing.po @@ -517,7 +517,7 @@ msgstr "" "Les variables de type existent principalement dans l'intérêt des contrôleurs " "de type statiques. Ils servent de paramètres pour les types génériques " "ainsi que pour les définitions de fonctions génériques. Voir la classe " -"Generic pour plus d'informations sur les types génériques. Les fonctions " +"Generic pour plus d'informations sur les types génériques. Les fonctions " "génériques fonctionnent comme suit ::" #: ../Doc/library/typing.rst:465 From f7615ec83e0944e67db9341c0ce3720ab0be6ce6 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:42:49 -0500 Subject: [PATCH 24/39] Update library/typing.po Co-Authored-By: Vincent Poulailleau --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index a07242260..8c83bfa55 100644 --- a/library/typing.po +++ b/library/typing.po @@ -528,7 +528,7 @@ msgid "" "still plain :class:`str`." msgstr "" "La signature de ce dernier exemple est essentiellement la surcharge de " -"``(str, str) -> str`` et ``(bytes, bytes) -> bytes``. Notez également que " +"``(str, str) -> str`` et ``(bytes, bytes) -> bytes``. Notez également que " "si les arguments sont des instances d'une sous-classe de la classe :class:" "`str`, le type de retour est toujours la classe :class:`str`." From ecd8aae3515cd705346ebd48b515ece909d44014 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Sat, 23 Nov 2019 15:49:18 -0500 Subject: [PATCH 25/39] Apply suggestions from code review Co-Authored-By: Vincent Poulailleau --- library/typing.po | 60 +++++++++++++++++++++++------------------------ 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/library/typing.po b/library/typing.po index 8c83bfa55..c4433ed60 100644 --- a/library/typing.po +++ b/library/typing.po @@ -537,7 +537,7 @@ msgid "" "At runtime, ``isinstance(x, T)`` will raise :exc:`TypeError`. In general, :" "func:`isinstance` and :func:`issubclass` should not be used with types." msgstr "" -"Au moment de l'exécution, ``isinstance(x, T)``va lever :exc:`TypeError`. En " +"Au moment de l'exécution, ``isinstance(x, T)`` va lever :exc:`TypeError`. En " "général, :func:`isinstance` et :func:`issubclass` ne devraient pas être " "utilisés avec les types." @@ -551,8 +551,8 @@ msgid "" "must be a subclass of the boundary type, see :pep:`484`." msgstr "" "Les variables de type peuvent être marquées covariantes ou contrevariantes " -"en passant ``covariant=True`` ou ``contravariant=True``. Voir :pep:`484` " -"pour plus de détails. Par défaut, les variables de type sont invariantes. " +"en passant ``covariant=True`` ou ``contravariant=True``. Voir :pep:`484` " +"pour plus de détails. Par défaut, les variables de type sont invariantes. " "Alternativement, une variable de type peut spécifier une limite supérieure " "en utilisant ``bound=>``. Cela signifie qu'un type réel substitué " "(explicitement ou implicitement) à la variable type doit être une sous-" @@ -696,7 +696,7 @@ msgid "" "An ABC with one abstract method ``__abs__`` that is covariant in its return " "type." msgstr "" -"Une ABC avec une méthode abstraite ``__abs__``qui est covariante dans son " +"Une ABC avec une méthode abstraite ``__abs__`` qui est covariante dans son " "type de retour." #: ../Doc/library/typing.rst:621 @@ -769,7 +769,7 @@ msgid "" "arguments of any of the types mentioned above." msgstr "" "Comme abréviation pour ce type, :class:`bytes` peut être utilisé pour " -"annoter des arguments de n'importe lequel des types mentionnés ci-dessus." +"annoter des arguments de n'importe quel type mentionné ci-dessus." #: ../Doc/library/typing.rst:682 msgid "A generic version of :class:`collections.deque`." @@ -912,7 +912,7 @@ msgid "" "``Iterable[YieldType]`` or ``Iterator[YieldType]``::" msgstr "" "Alternativement, annotez votre générateur comme ayant un type de retour soit " -"``Iterable[YieldType]``ou ``Iterator[YieldType]`` ::" +"``Iterable[YieldType]`` ou ``Iterator[YieldType]`` ::" #: ../Doc/library/typing.rst:847 msgid "" @@ -1135,7 +1135,7 @@ msgid "" "return value has the designated type, but at runtime we intentionally don't " "check anything (we want this to be as fast as possible)." msgstr "" -"Ceci retourne la valeur inchangée. Pour le vérificateur de type, cela " +"Ceci retourne la valeur inchangée. Pour le vérificateur de type, cela " "signifie que la valeur de retour a le type désigné, mais au moment de " "l'exécution, rien n'est vérifié intentionnellement (afin que cela soit aussi " "rapide que possible)." @@ -1163,7 +1163,7 @@ msgstr "" "nécessaire, ``Optional[t]`` est ajouté pour les annotations de fonction et " "de méthode si une valeur par défaut égale à ``None`` est définie. Pour une " "classe ``C``, retourne un dictionnaire construit en fusionnant toutes les " -"``__annotations__``le long de ``C.__mro__``en ordre inverse." +"``__annotations__`` le long de ``C.__mro__`` en ordre inverse." #: ../Doc/library/typing.rst:1047 msgid "Provide basic introspection for generic types and special typing forms." @@ -1178,10 +1178,10 @@ msgid "" "`collections` class, it gets normalized to the original class. For " "unsupported objects return ``None`` and ``()`` correspondingly. Examples::" msgstr "" -"Pour un objet de typage de la forme``X[Y, Z, ....]``, ces fonctions " +"Pour un objet de typage de la forme ``X[Y, Z, ....]``, ces fonctions " "retournent ``X`` et ``(Y, Z,...)``. Si ``X`` est un alias pour une classe " "builtin ou :mod:`collections`, il est normalisé à la classe originale. Pour " -"les objets non supportés, retourne ``None'`` et ``()`` en conséquence. " +"les objets non supportés, retourne ``None`` et ``()`` en conséquence. " "Exemples ::" #: ../Doc/library/typing.rst:1065 @@ -1200,12 +1200,12 @@ msgid "" msgstr "" "Le décorateur ``@overload``` permet de décrire des fonctions et des méthodes " "qui supportent plusieurs combinaisons différentes de types d'arguments. Une " -"série de définitions décorées avec ``overload``doit être suivie d'une seule " +"série de définitions décorées avec ``overload`` doit être suivie d'une seule " "définition non décorée de ``overload`` (pour la même fonction/méthode). Les " "définitions décorées de ``@overload`` sont pour le vérificateur de type " "seulement, puisqu'elles seront écrasées par la définition non décorée de " "``@overload``, alors que cette dernière est utilisée au moment de " -"l'exécution mais devrait être ignorée par un vérificateur de type. Lors de " +"l'exécution mais devrait être ignorée par un vérificateur de type. Lors de " "l'exécution, l'appel direct d'une fonction décorée avec ``@overload`` " "lèvera :exc:`NotImplementedError`. Un exemple de surcharge qui donne un type " "plus précis que celui qui peut être exprimé à l'aide d'une variable union ou " @@ -1246,7 +1246,7 @@ msgid "" "recursively to all methods defined in that class (but not to methods defined " "in its superclasses or subclasses)." msgstr "" -"Cela fonctionne en tant que classe ou fonction :term:`decorator`. Avec une " +"Cela fonctionne en tant que classe ou fonction :term:`decorator`. Avec une " "classe, elle s'applique récursivement à toutes les méthodes définies dans " "cette classe (mais pas aux méthodes définies dans ses superclasses ou sous-" "classes)." @@ -1306,9 +1306,9 @@ msgid "" msgstr "" "Un tel protocole peut être utilisé avec :func:`isinstance` et :func:" "`issubclass`. Cela lève :exc:`TypeError` lorsqu'il est appliqué à une classe " -"non protocole. Cela permet un contrôle structurel compréhensible, très " +"non protocole. Cela permet un contrôle structurel compréhensible, très " "similaire à \"one trick poneys\" dans :mod:`collections.abc` tel que :class:" -"`Iterable`. Par exemple ::" +"`Iterable`. Par exemple ::" #: ../Doc/library/typing.rst:1166 msgid "" @@ -1316,7 +1316,7 @@ msgid "" "their type signatures!" msgstr "" "**Attention : ** ceci ne vérifiera que la présence des méthodes requises, et " -"non leur signature de type !" +"non leur signature de type !" #: ../Doc/library/typing.rst:1173 msgid "Special type indicating an unconstrained type." @@ -1341,7 +1341,7 @@ msgstr "Type d'union ; ``Union[X, Y]`` signifie X ou Y." #: ../Doc/library/typing.rst:1195 msgid "To define a union, use e.g. ``Union[int, str]``. Details:" msgstr "" -"Pour définir une union, utilisez par exemple ``Union[int, str]``. Détail :" +"Pour définir une union, utilisez par exemple ``Union[int, str]``. Détail :" #: ../Doc/library/typing.rst:1197 msgid "The arguments must be types and there must be at least one." @@ -1368,7 +1368,7 @@ msgstr "" #: ../Doc/library/typing.rst:1215 msgid "You cannot subclass or instantiate a union." -msgstr "Vous ne pouvez pas sous-classer ou instancier un union." +msgstr "Vous ne pouvez pas sous-classer ou instancier une union." #: ../Doc/library/typing.rst:1217 msgid "You cannot write ``Union[X][Y]``." @@ -1401,7 +1401,7 @@ msgid "" "optional. For example::" msgstr "" "Notez que ce n'est pas le même concept qu'un argument optionnel, qui est un " -"argument par défaut. Un argument optionnel avec une valeur par défaut ne " +"argument par défaut. Un argument optionnel avec une valeur par défaut ne " "nécessite pas le qualificatif ``Optional`` sur son annotation de type " "simplement parce qu'il est optionnel. Par exemple ::" @@ -1421,7 +1421,7 @@ msgid "" "first item of type X and the second of type Y. The type of the empty tuple " "can be written as ``Tuple[()]``." msgstr "" -"Type de tuple ; ``Tuple[X, Y]`` est le type d'un tuple de deux éléments avec " +"Type de tuple ; ``Tuple[X, Y]`` est le type d'un tuple de deux éléments avec " "le premier élément de type X et le second de type Y. Le type du tuple vide " "peut être écrit comme ``Tuple[()]``." @@ -1431,8 +1431,8 @@ msgid "" "variables T1 and T2. ``Tuple[int, float, str]`` is a tuple of an int, a " "float and a string." msgstr "" -"Exemple : ``Tuple[T1, T2]`` est un tuple de deux éléments correspondant aux " -"variables de type T1 et T2. ``Tuple[int, float, str]`` est un tuple d'un " +"Exemple : ``Tuple[T1, T2]`` est un tuple de deux éléments correspondant aux " +"variables de type T1 et T2. ``Tuple[int, float, str]`` est un tuple d'un " "int, d'un float et d'une chaîne." #: ../Doc/library/typing.rst:1255 @@ -1448,7 +1448,7 @@ msgstr "" #: ../Doc/library/typing.rst:1261 msgid "Callable type; ``Callable[[int], str]`` is a function of (int) -> str." msgstr "" -"Type Appelable ; ``Callable[[int], str]`` est une fonction de (int) -> str." +"Type Appelable ; ``Callable[[int], str]`` est une fonction de (int) -> str." #: ../Doc/library/typing.rst:1263 msgid "" @@ -1457,8 +1457,8 @@ msgid "" "types or an ellipsis; the return type must be a single type." msgstr "" "La syntaxe de sélection (*subscription*) doit toujours être utilisée avec " -"exactement deux valeurs : la liste d'arguments et le type de retour. La " -"liste d'arguments doit être une liste de types ou une ellipse ; il doit y " +"exactement deux valeurs : la liste d'arguments et le type de retour. La " +"liste d'arguments doit être une liste de types ou une ellipse ; il doit y " "avoir un seul type de retour." #: ../Doc/library/typing.rst:1268 @@ -1471,10 +1471,10 @@ msgid "" "Callable`." msgstr "" "Il n'y a pas de syntaxe pour indiquer les arguments optionnels ou les mots-" -"clés ; de tels types de fonctions sont rarement utilisés comme types de " +"clés ; de tels types de fonctions sont rarement utilisés comme types de " "rappel. ``Callable[..., ReturnType]`` (ellipse) peut être utilisé pour " "annoter le type d'un appelable, prenant un nombre quelconque d'arguments et " -"renvoyant ``ReturnType``. Un simple :data:``Callable`` est équivalent à " +"renvoyant ``ReturnType``. Un simple :data:`Callable` est équivalent à " "``Callable[..., Any]``, et à son tour à :class:`collections.abc.Callable`." #: ../Doc/library/typing.rst:1278 @@ -1515,7 +1515,7 @@ msgstr "" #: ../Doc/library/typing.rst:1310 msgid ":data:`ClassVar` accepts only types and cannot be further subscribed." -msgstr "data:`ClassVar` n'accepte que les types et ne peut plus être souscrit." +msgstr ":data:`ClassVar` n'accepte que les types et ne peut plus être souscrit." #: ../Doc/library/typing.rst:1312 msgid "" @@ -1524,7 +1524,7 @@ msgid "" "runtime behavior, but it can be used by third-party type checkers. For " "example, a type checker might flag the following code as an error::" msgstr "" -"data:`ClassVar` n'est pas une classe en soi, et ne devrait pas être utilisé " +":data:`ClassVar` n'est pas une classe en soi, et ne devrait pas être utilisée " "avec :func:`isinstance` ou :func:`issubclass`. :data:`ClassVar` ne modifie " "pas le comportement d'exécution Python, mais il peut être utilisé par des " "vérificateurs tiers. Par exemple, un vérificateur de type peut marquer le " @@ -1574,7 +1574,7 @@ msgid "" msgstr "" "Notez que la première annotation de type doit être entourée de guillemets, " "ce qui en fait une \" référence avancée\", pour cacher la référence " -"``expensive_mod`` au moment de l'exécution par l'interpréteur. Les " +"``expensive_mod`` au moment de l'exécution par l'interpréteur. Les " "annotations de type pour les variables locales ne sont pas évaluées, de " "sorte que la deuxième annotation n'a pas besoin d'être placée entre " "guillemets." From 665a349094a62b548164847dd82ad0eae2334df1 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Mon, 25 Nov 2019 20:19:59 -0500 Subject: [PATCH 26/39] Apply suggestions from code review ChristopherNan reviews #1 Co-Authored-By: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com> Co-Authored-By: Vincent Poulailleau --- library/typing.po | 86 +++++++++++++++++++++++------------------------ 1 file changed, 43 insertions(+), 43 deletions(-) diff --git a/library/typing.po b/library/typing.po index c4433ed60..8aaca6761 100644 --- a/library/typing.po +++ b/library/typing.po @@ -42,18 +42,18 @@ msgid "" "full specification please see :pep:`484`. For a simplified introduction to " "type hints see :pep:`483`." msgstr "" -"Ce module fournit un support d'exécution pour les annotations de type " -"spécifiés par :pep:`484`, :pep:`526`, :pep:`544`, :pep:`586`, :pep:`589`, " +"Ce module fournit la gestion des annotations de type à l'exécution " +"conformément à ce qui est spécifié dans les :pep:`484`, :pep:`526`, :pep:`544`, :pep:`586`, :pep:`589` " "et :pep:`591`. Le support le plus fondamental se compose des types :data:" -"`Any`, :data:`Union`, :data:`Tuple`, :data:`Callable`, :class:`TypeVar`, et :" -"class:`Generic`. Pour les spécifications complètes, voir :pep:`484`. Pour " -"une introduction simplifiée aux annotations de type, voir :pep:`483`." +"`Any`, :data:`Union`, :data:`Tuple`, :data:`Callable`, :class:`TypeVar` et :" +"class:`Generic`. Pour les spécifications complètes, voir la :pep:`484`. Pour " +"une introduction simplifiée aux annotations de type, voir la :pep:`483`." #: ../Doc/library/typing.rst:27 msgid "" "The function below takes and returns a string and is annotated as follows::" msgstr "" -"La fonction ci-dessous prend et retourne une chaîne de caractères et est " +"La fonction ci-dessous prend et renvoie une chaîne de caractères, et est " "annotée comme suit ::" #: ../Doc/library/typing.rst:32 @@ -62,7 +62,7 @@ msgid "" "type :class:`str` and the return type :class:`str`. Subtypes are accepted as " "arguments." msgstr "" -"Dans la fonction ``greeting``, l'argument ``name`` doit être de type :class:" +"La fonction ``greeting`` s'attend à ce que l'argument ``name`` soit de type :class:" "`str` et le type de retour :class:`str`. Les sous-types sont acceptés comme " "arguments." @@ -76,7 +76,7 @@ msgid "" "``Vector`` and ``List[float]`` will be treated as interchangeable synonyms::" msgstr "" "Un alias de type est défini en assignant le type à l'alias. Dans cet " -"exemple, ``Vector`` et ``List[float]`` seront traités comme des synonymes " +"exemple, ``Vector`` et ``List[float]`` sont traités comme des synonymes " "interchangeables ::" #: ../Doc/library/typing.rst:51 @@ -84,7 +84,7 @@ msgid "" "Type aliases are useful for simplifying complex type signatures. For " "example::" msgstr "" -"Les alias de type sont utiles pour simplifier les signatures de type " +"Les alias de type sont utiles pour simplifier les signatures " "complexes. Par exemple ::" #: ../Doc/library/typing.rst:69 @@ -92,7 +92,7 @@ msgid "" "Note that ``None`` as a type hint is a special case and is replaced by " "``type(None)``." msgstr "" -"Notez que ``None`` comme indice de type est un cas particulier et est " +"Notez que ``None`` comme indication de type est un cas particulier et est " "remplacé par ``type(None)``." #: ../Doc/library/typing.rst:75 @@ -102,15 +102,15 @@ msgstr "*NewType*" #: ../Doc/library/typing.rst:77 msgid "Use the :func:`NewType` helper function to create distinct types::" msgstr "" -"Utilisez la fonction d'aide :func:`NewType` pour créer des types distincts ::" +"Aidez-vous de la fonction :func:`NewType` pour créer des types distincts ::" #: ../Doc/library/typing.rst:84 msgid "" "The static type checker will treat the new type as if it were a subclass of " "the original type. This is useful in helping catch logical errors::" msgstr "" -"Le vérificateur de type statique traitera le nouveau type comme s'il " -"s'agissait d'une sous-classe du type original. Ceci est utile pour aider à " +"Le vérificateur de type statique traite le nouveau type comme s'il " +"s'agissait d'une sous-classe du type original. C'est utile pour aider à " "détecter les erreurs logiques ::" #: ../Doc/library/typing.rst:96 @@ -122,8 +122,8 @@ msgid "" msgstr "" "Vous pouvez toujours effectuer toutes les opérations ``int`` sur une " "variable de type ``UserId``, mais le résultat sera toujours de type ``int``. " -"Ceci vous permet de passer un ``UserId`` partout où une ``int`` est " -"attendue, mais vous empêchera de créer accidentellement un ``UserId``` d'une " +"Ceci vous permet de passer un ``UserId`` partout où un ``int`` est " +"attendu, mais vous empêche de créer accidentellement un ``UserId``` d'une " "manière invalide ::" #: ../Doc/library/typing.rst:104 @@ -135,8 +135,8 @@ msgid "" "class or introduce any overhead beyond that of a regular function call." msgstr "" "Notez que ces contrôles ne sont exécutés que par le vérificateur de type " -"statique. A l'exécution, l'instruction ``Derived = NewType('Derived', " -"Base)`` fera de ``Derived``` une fonction qui retourne immédiatement le " +"statique. À l'exécution, l'instruction ``Derived = NewType('Derived', " +"Base)`` fait de ``Derived``` une fonction qui renvoie immédiatement le " "paramètre que vous lui passez. Cela signifie que l'expression " "``Derived(some_value)`` ne crée pas une nouvelle classe ou n'introduit pas " "de surcharge au-delà de celle d'un appel de fonction normal." @@ -169,11 +169,11 @@ msgstr "" #: ../Doc/library/typing.rst:131 msgid "and typechecking for ``ProUserId`` will work as expected." msgstr "" -"et la vérification de type pour ``ProUserId`` fonctionnera comme prévu." +"et la vérification de type pour ``ProUserId`` fonctionne comme prévu." #: ../Doc/library/typing.rst:133 msgid "See :pep:`484` for more details." -msgstr "Voir :pep:`484` pour plus de détails." +msgstr "Voir la :pep:`484` pour plus de détails." #: ../Doc/library/typing.rst:137 msgid "" @@ -183,10 +183,10 @@ msgid "" "This is useful when you want to simplify complex type signatures." msgstr "" "Rappelons que l'utilisation d'un alias de type déclare que deux types sont " -"*équivalents* l'un à l'autre. Faire ``Alias = Original`` fera que le " -"vérificateur de type statique traitera ``Alias`` comme étant *exactement " -"équivalent* à ``Original`` dans tous les cas. Ceci est utile lorsque vous " -"voulez simplifier les signatures de type complexe." +"*équivalents* l'un à l'autre. Écrire ``Alias = Original`` fait que le " +"vérificateur de type statique traite ``Alias`` comme étant *exactement " +"équivalent* à ``Original`` dans tous les cas. C'est utile lorsque vous " +"voulez simplifier des signatures complexes." #: ../Doc/library/typing.rst:142 msgid "" @@ -198,11 +198,11 @@ msgid "" "errors with minimal runtime cost." msgstr "" "En revanche, ``NewType`` déclare qu'un type est un *sous-type* d'un autre. " -"Faire ``Derived = NewType('Derived', Original)`` fera en sorte que le " +"Écrire ``Derived = NewType('Derived', Original)`` fait en sorte que le " "vérificateur de type statique traite ``Derived`` comme une *sous-classe* de " "``Original``, ce qui signifie qu'une valeur de type ``Original`` ne peut " "être utilisée dans les endroits où une valeur de type ``Derived`` est " -"prévue. Ceci est utile lorsque vous voulez éviter les erreurs logiques avec " +"prévue. C'est utile lorsque vous voulez éviter les erreurs logiques avec " "un coût d'exécution minimal." #: ../Doc/library/typing.rst:152 @@ -214,7 +214,7 @@ msgid "" "Frameworks expecting callback functions of specific signatures might be type " "hinted using ``Callable[[Arg1Type, Arg2Type], ReturnType]``." msgstr "" -"Les *frameworks* qui attendent des fonctions de rappel de signatures " +"Les cadriciels (*frameworks* en anglais) qui attendent des fonctions de rappel de signatures " "spécifiques peuvent être typés en utilisant ``Callable[[Arg1Type, Arg2Type], " "ReturnType]``." @@ -229,7 +229,7 @@ msgid "" "arguments in the type hint: ``Callable[..., ReturnType]``." msgstr "" "Il est possible de déclarer le type de retour d'un appelable sans spécifier " -"la signature de l'appel en substituant une ellipse à la liste des arguments " +"la signature de l'appel en indiquant des points de suspension à la liste des arguments " "dans l'indice de type : ``Callable[..., ReturnType]``." #: ../Doc/library/typing.rst:175 @@ -245,7 +245,7 @@ msgstr "" "Comme les informations de type sur les objets conservés dans des conteneurs " "ne peuvent pas être déduites statiquement de manière générique, les classes " "de base abstraites ont été étendues pour prendre en charge la sélection " -"(*subscription*) et indiquer les types attendus pour les éléments de " +"(*subscription* en anglais) et indiquer les types attendus pour les éléments de " "conteneur." #: ../Doc/library/typing.rst:188 @@ -289,7 +289,7 @@ msgid "" "A generic type can have any number of type variables, and type variables may " "be constrained::" msgstr "" -"Un type générique peut avoir un nombre quelconque de variables de type, et " +"Un type générique peut avoir un nombre quelconque de variables de type et " "les variables de type peuvent être limitées ::" #: ../Doc/library/typing.rst:255 @@ -313,7 +313,7 @@ msgstr "" #: ../Doc/library/typing.rst:284 msgid "In this case ``MyDict`` has a single parameter, ``T``." -msgstr "Dans ce cas, ``MonDict`` a un seul paramètre, ``T``." +msgstr "Dans ce cas, ``MyDict`` a un seul paramètre, ``T``." #: ../Doc/library/typing.rst:286 msgid "" @@ -346,7 +346,7 @@ msgstr "" "Une classe générique définie par l'utilisateur peut avoir ABC comme classes " "de base sans conflit de métaclasses. Les métaclasses génériques ne sont pas " "prises en charge. Le résultat du paramétrage des génériques est mis en " -"cache, et la plupart des types dans le module de typage sont hachables et " +"cache et la plupart des types dans le module de typage sont hachables et " "comparables pour l'égalité." #: ../Doc/library/typing.rst:320 @@ -360,7 +360,7 @@ msgid "" "compatible with every type." msgstr "" "Un type spécial de type est :data:`Any`. Un vérificateur de type statique " -"traitera chaque type comme étant compatible avec :data:`Any` et :data:`Any` " +"traite chaque type comme étant compatible avec :data:`Any` et :data:`Any` " "comme étant compatible avec chaque type." #: ../Doc/library/typing.rst:326 @@ -382,7 +382,7 @@ msgid "" msgstr "" "Notez qu'aucun contrôle de typage n'est effectué lors de l'affectation d'une " "valeur de type :data:`Any` à un type plus précis. Par exemple, le " -"vérificateur de type statique n'a pas signalé d'erreur lors de l'affectation " +"vérificateur de type statique ne signale pas d'erreur lors de l'affectation " "de ``a`` à ``s`` même si ``s`` était déclaré être de type :class:`str` et " "reçoit une valeur :class:`int` au moment de son exécution !" @@ -392,14 +392,14 @@ msgid "" "implicitly default to using :data:`Any`::" msgstr "" "De plus, toutes les fonctions sans type de retour ni type de paramètre " -"seront implicitement par défaut en utilisant :data:`Any` ::" +"sont considérées comme utilisant :data:`Any` implicitement par défaut ::" #: ../Doc/library/typing.rst:363 msgid "" "This behavior allows :data:`Any` to be used as an *escape hatch* when you " "need to mix dynamically and statically typed code." msgstr "" -"Ce comportement permet à :data:`Any` d'être utilisé comme issue de secours " +"Ce comportement permet à :data:`Any` d'être utilisé comme succédané " "lorsque vous avez besoin de mélanger du code typé dynamiquement et " "statiquement." @@ -410,10 +410,10 @@ msgid "" "unlike :data:`Any`, the reverse is not true: :class:`object` is *not* a " "subtype of every other type." msgstr "" -"Comparer le comportement de :data:`Any` avec le comportement de :class:" -"`object`. Similaire à :data:`Any`, chaque type est un sous-type de :class:" +"Comparons le comportement de :data:`Any` avec celui de :class:" +"`object`. De la même manière que pour :data:`Any`, chaque type est un sous-type de :class:" "`object`. Cependant, contrairement à :data:`Any`, l'inverse n'est pas vrai : :" -"class:`object' n'est *pas* un sous-type de chaque autre type." +"class:`object` n'est *pas* un sous-type de chaque autre type." #: ../Doc/library/typing.rst:371 msgid "" @@ -423,7 +423,7 @@ msgid "" "example::" msgstr "" "Cela signifie que lorsque le type d'une valeur est :class:`object`, un " -"vérificateur de type rejettera presque toutes les opérations sur celle-ci, " +"vérificateur de type rejette presque toutes les opérations sur celle-ci, " "et l'affecter à une variable (ou l'utiliser comme une valeur de retour) d'un " "type plus spécialisé est une erreur de typage. Par exemple ::" @@ -432,9 +432,9 @@ msgid "" "Use :class:`object` to indicate that a value could be any type in a typesafe " "manner. Use :data:`Any` to indicate that a value is dynamically typed." msgstr "" -"Utilisez :class:`object` pour indiquer qu'une valeur peut être n'importe " +"Utilisez :class:`object` pour indiquer qu'une valeur peut être de n'importe " "quel type de manière sûre. Utiliser :data:`Any` pour indiquer qu'une valeur " -"est tapée dynamiquement." +"est typée dynamiquement." #: ../Doc/library/typing.rst:398 msgid "Nominal vs structural subtyping" @@ -516,7 +516,7 @@ msgid "" msgstr "" "Les variables de type existent principalement dans l'intérêt des contrôleurs " "de type statiques. Ils servent de paramètres pour les types génériques " -"ainsi que pour les définitions de fonctions génériques. Voir la classe " +"ainsi que pour les définitions de fonctions génériques. Voir la classe " "Generic pour plus d'informations sur les types génériques. Les fonctions " "génériques fonctionnent comme suit ::" @@ -946,7 +946,7 @@ msgid "" "``AsyncIterable[YieldType]`` or ``AsyncIterator[YieldType]``::" msgstr "" "Alternativement, annotez votre générateur comme ayant un type de retour soit " -"``AsyncIterable[YieldType]``ou ``AsyncIterator[YieldType]`` ::" +"``AsyncIterable[YieldType]`` ou ``AsyncIterator[YieldType]`` ::" #: ../Doc/library/typing.rst:880 msgid "" From 07ad2e5d42a879924399a802360c68f37a636b85 Mon Sep 17 00:00:00 2001 From: Kyd Date: Tue, 26 Nov 2019 17:24:47 -0500 Subject: [PATCH 27/39] Corrections #1 --- library/typing.po | 372 ++++++++++++++++++++++------------------------ 1 file changed, 181 insertions(+), 191 deletions(-) diff --git a/library/typing.po b/library/typing.po index 85e98c80c..59d3d4e75 100644 --- a/library/typing.po +++ b/library/typing.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2019-11-15 18:54+0100\n" -"PO-Revision-Date: 2019-11-20 23:06-0500\n" +"PO-Revision-Date: 2019-11-23 00:48-0500\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -30,7 +30,7 @@ msgid "" "etc." msgstr "" "Le moteur d'exécution Python n'applique pas les annotations de type pour les " -"fonction et les variable. Elles peuvent être utilisés par des outils tiers " +"fonctions et les variables. Elles peuvent être utilisées par des outils tiers " "tels que les contrôleurs de type, les IDE, les analyseurs de code, etc." #: ../Doc/library/typing.rst:19 @@ -43,11 +43,11 @@ msgid "" "type hints see :pep:`483`." msgstr "" "Ce module fournit un support d'exécution pour les annotations de type " -"spécifiés par :pep:`484`, :pep:`526`, :pep:`544`, :pep:`586`, :pep:`589`, " -"et :pep:`591`. Le support le plus fondamental se compose des types :data:" -"`Any`, :data:`Union`, :data:`Tuple`, :data:`Callable`, :class:`TypeVar`, et :" -"class:`Generic`. Pour les spécifications complètes, voir :pep:`484`. Pour " -"une introduction simplifiée aux annotations de type, voir :pep:`483`." +"spécifiés par :pep:`484`, :pep:`526`, :pep:`544`, :pep:`586`, :pep:`589`, et :" +"pep:`591`. Le support le plus fondamental se compose des types :data:`Any`, :" +"data:`Union`, :data:`Tuple`, :data:`Callable`, :class:`TypeVar`, et :class:" +"`Generic`. Pour les spécifications complètes, voir :pep:`484`. Pour une " +"introduction simplifiée aux annotations de type, voir :pep:`483`." #: ../Doc/library/typing.rst:27 msgid "" @@ -75,14 +75,13 @@ msgid "" "A type alias is defined by assigning the type to the alias. In this example, " "``Vector`` and ``List[float]`` will be treated as interchangeable synonyms::" msgstr "" -"Un alias de type est défini en assignant le type à l'alias. Dans cet " -"exemple, ``Vector`` et ``List[float]`` seront traités comme des synonymes " +"Un alias de type est défini en assignant le type à l'alias. Dans cet exemple, " +"``Vector`` et ``List[float]`` seront traités comme des synonymes " "interchangeables ::" #: ../Doc/library/typing.rst:51 msgid "" -"Type aliases are useful for simplifying complex type signatures. For " -"example::" +"Type aliases are useful for simplifying complex type signatures. For example::" msgstr "" "Les alias de type sont utiles pour simplifier les signatures de type " "complexes. Par exemple ::" @@ -116,15 +115,14 @@ msgstr "" #: ../Doc/library/typing.rst:96 msgid "" "You may still perform all ``int`` operations on a variable of type " -"``UserId``, but the result will always be of type ``int``. This lets you " -"pass in a ``UserId`` wherever an ``int`` might be expected, but will prevent " -"you from accidentally creating a ``UserId`` in an invalid way::" +"``UserId``, but the result will always be of type ``int``. This lets you pass " +"in a ``UserId`` wherever an ``int`` might be expected, but will prevent you " +"from accidentally creating a ``UserId`` in an invalid way::" msgstr "" -"Vous pouvez toujours effectuer toutes les opérations ``int`` sur une " -"variable de type ``UserId``, mais le résultat sera toujours de type ``int``. " -"Ceci vous permet de passer un ``UserId`` partout où une ``int`` est " -"attendue, mais vous empêchera de créer accidentellement un ``UserId``` d'une " -"manière invalide ::" +"Vous pouvez toujours effectuer toutes les opérations ``int`` sur une variable " +"de type ``UserId``, mais le résultat sera toujours de type ``int``. Ceci vous " +"permet de passer un ``UserId`` partout où une ``int`` est attendue, mais vous " +"empêchera de créer accidentellement un ``UserId``` d'une manière invalide ::" #: ../Doc/library/typing.rst:104 msgid "" @@ -135,18 +133,18 @@ msgid "" "class or introduce any overhead beyond that of a regular function call." msgstr "" "Notez que ces contrôles ne sont exécutés que par le vérificateur de type " -"statique. A l'exécution, l'instruction ``Derived = NewType('Derived', " -"Base)`` fera de ``Derived``` une fonction qui retourne immédiatement le " -"paramètre que vous lui passez. Cela signifie que l'expression " -"``Derived(some_value)`` ne crée pas une nouvelle classe ou n'introduit pas " -"de surcharge au-delà de celle d'un appel de fonction normal." +"statique. A l'exécution, l'instruction ``Derived = NewType('Derived', Base)`` " +"fera de ``Derived``` une fonction qui retourne immédiatement le paramètre que " +"vous lui passez. Cela signifie que l'expression ``Derived(some_value)`` ne " +"crée pas une nouvelle classe ou n'introduit pas de surcharge au-delà de celle " +"d'un appel de fonction normal." #: ../Doc/library/typing.rst:110 msgid "" "More precisely, the expression ``some_value is Derived(some_value)`` is " "always true at runtime." msgstr "" -"Plus précisément, l'expression ``some_value is Derived(some_value)``est " +"Plus précisément, l'expression ``some_value is Derived(some_value)`` est " "toujours vraie au moment de l'exécution." #: ../Doc/library/typing.rst:113 @@ -168,8 +166,7 @@ msgstr "" #: ../Doc/library/typing.rst:131 msgid "and typechecking for ``ProUserId`` will work as expected." -msgstr "" -"et la vérification de type pour ``ProUserId`` fonctionnera comme prévu." +msgstr "et la vérification de type pour ``ProUserId`` fonctionnera comme prévu." #: ../Doc/library/typing.rst:133 msgid "See :pep:`484` for more details." @@ -194,16 +191,16 @@ msgid "" "Doing ``Derived = NewType('Derived', Original)`` will make the static type " "checker treat ``Derived`` as a *subclass* of ``Original``, which means a " "value of type ``Original`` cannot be used in places where a value of type " -"``Derived`` is expected. This is useful when you want to prevent logic " -"errors with minimal runtime cost." +"``Derived`` is expected. This is useful when you want to prevent logic errors " +"with minimal runtime cost." msgstr "" "En revanche, ``NewType`` déclare qu'un type est un *sous-type* d'un autre. " "Faire ``Derived = NewType('Derived', Original)`` fera en sorte que le " "vérificateur de type statique traite ``Derived`` comme une *sous-classe* de " -"``Original``, ce qui signifie qu'une valeur de type ``Original`` ne peut " -"être utilisée dans les endroits où une valeur de type ``Derived`` est " -"prévue. Ceci est utile lorsque vous voulez éviter les erreurs logiques avec " -"un coût d'exécution minimal." +"``Original``, ce qui signifie qu'une valeur de type ``Original`` ne peut être " +"utilisée dans les endroits où une valeur de type ``Derived`` est prévue. Ceci " +"est utile lorsque vous voulez éviter les erreurs logiques avec un coût " +"d'exécution minimal." #: ../Doc/library/typing.rst:152 msgid "Callable" @@ -253,8 +250,8 @@ msgid "" "Generics can be parameterized by using a new factory available in typing " "called :class:`TypeVar`." msgstr "" -"Les génériques peuvent être paramétrés en utilisant une nouvelle fabrique " -"(au sens des patrons de conception) disponible en tapant :class:`TypeVar`." +"Les génériques peuvent être paramétrés en utilisant une nouvelle fabrique (au " +"sens des patrons de conception) disponible en tapant :class:`TypeVar`." #: ../Doc/library/typing.rst:202 msgid "User-defined generic types" @@ -297,8 +294,8 @@ msgid "" "Each type variable argument to :class:`Generic` must be distinct. This is " "thus invalid::" msgstr "" -"Chaque argument de variable de type :class:`Generic` doit être distinct. " -"Ceci n'est donc pas valable ::" +"Chaque argument de variable de type :class:`Generic` doit être distinct. Ceci " +"n'est donc pas valable ::" #: ../Doc/library/typing.rst:266 msgid "You can use multiple inheritance with :class:`Generic`::" @@ -308,8 +305,8 @@ msgstr "Vous pouvez utiliser l'héritage multiple avec :class:`Generic`: :" msgid "" "When inheriting from generic classes, some type variables could be fixed::" msgstr "" -"Lors de l'héritage de classes génériques, certaines variables de type " -"peuvent être corrigées ::" +"Lors de l'héritage de classes génériques, certaines variables de type peuvent " +"être corrigées ::" #: ../Doc/library/typing.rst:284 msgid "In this case ``MyDict`` has a single parameter, ``T``." @@ -345,8 +342,8 @@ msgid "" msgstr "" "Une classe générique définie par l'utilisateur peut avoir ABC comme classes " "de base sans conflit de métaclasses. Les métaclasses génériques ne sont pas " -"prises en charge. Le résultat du paramétrage des génériques est mis en " -"cache, et la plupart des types dans le module de typage sont hachables et " +"prises en charge. Le résultat du paramétrage des génériques est mis en cache, " +"et la plupart des types dans le module de typage sont hachables et " "comparables pour l'égalité." #: ../Doc/library/typing.rst:320 @@ -355,9 +352,9 @@ msgstr "Le type :data:`Any`" #: ../Doc/library/typing.rst:322 msgid "" -"A special kind of type is :data:`Any`. A static type checker will treat " -"every type as being compatible with :data:`Any` and :data:`Any` as being " -"compatible with every type." +"A special kind of type is :data:`Any`. A static type checker will treat every " +"type as being compatible with :data:`Any` and :data:`Any` as being compatible " +"with every type." msgstr "" "Un type spécial de type est :data:`Any`. Un vérificateur de type statique " "traitera chaque type comme étant compatible avec :data:`Any` et :data:`Any` " @@ -374,11 +371,10 @@ msgstr "" #: ../Doc/library/typing.rst:344 msgid "" -"Notice that no typechecking is performed when assigning a value of type :" -"data:`Any` to a more precise type. For example, the static type checker did " -"not report an error when assigning ``a`` to ``s`` even though ``s`` was " -"declared to be of type :class:`str` and receives an :class:`int` value at " -"runtime!" +"Notice that no typechecking is performed when assigning a value of type :data:" +"`Any` to a more precise type. For example, the static type checker did not " +"report an error when assigning ``a`` to ``s`` even though ``s`` was declared " +"to be of type :class:`str` and receives an :class:`int` value at runtime!" msgstr "" "Notez qu'aucun contrôle de typage n'est effectué lors de l'affectation d'une " "valeur de type :data:`Any` à un type plus précis. Par exemple, le " @@ -391,8 +387,8 @@ msgid "" "Furthermore, all functions without a return type or parameter types will " "implicitly default to using :data:`Any`::" msgstr "" -"De plus, toutes les fonctions sans type de retour ni type de paramètre " -"seront implicitement par défaut en utilisant :data:`Any`: :" +"De plus, toutes les fonctions sans type de retour ni type de paramètre seront " +"implicitement par défaut en utilisant :data:`Any`: :" #: ../Doc/library/typing.rst:363 msgid "" @@ -423,8 +419,8 @@ msgid "" "example::" msgstr "" "Cela signifie que lorsque le type d'une valeur est :class:`object`, un " -"vérificateur de type rejettera presque toutes les opérations sur celle-ci, " -"et l'affecter à une variable (ou l'utiliser comme une valeur de retour) d'un " +"vérificateur de type rejettera presque toutes les opérations sur celle-ci, et " +"l'affecter à une variable (ou l'utiliser comme une valeur de retour) d'un " "type plus spécialisé est une erreur de typage. Par exemple ::" #: ../Doc/library/typing.rst:393 @@ -432,9 +428,9 @@ msgid "" "Use :class:`object` to indicate that a value could be any type in a typesafe " "manner. Use :data:`Any` to indicate that a value is dynamically typed." msgstr "" -"Utilisez :class:`object` pour indiquer qu'une valeur peut être n'importe " -"quel type de manière sûre. Utiliser :data:`Any` pour indiquer qu'une valeur " -"est tapée dynamiquement." +"Utilisez :class:`object` pour indiquer qu'une valeur peut être n'importe quel " +"type de manière sûre. Utiliser :data:`Any` pour indiquer qu'une valeur est " +"tapée dynamiquement." #: ../Doc/library/typing.rst:398 msgid "Nominal vs structural subtyping" @@ -461,10 +457,10 @@ msgid "" msgstr "" "Ce pré-requis s'appliquait auparavant aussi aux classes de base abstraites, " "telles que :class:`Iterable`. Le problème avec cette approche est qu'une " -"classe devait être explicitement marquée pour les supporter, ce qui n'est " -"pas *pythonique* et diffère de ce que l'on ferait normalement avec du code " -"Python idiomatique typé dynamiquement. Par exemple, ceci est conforme au :" -"pep:`484` ::" +"classe devait être explicitement marquée pour les supporter, ce qui n'est pas " +"*pythonique* et diffère de ce que l'on ferait normalement avec du code Python " +"idiomatique typé dynamiquement. Par exemple, ceci est conforme au :pep:" +"`484` ::" #: ../Doc/library/typing.rst:417 msgid "" @@ -475,17 +471,16 @@ msgid "" "subtyping* (or static duck-typing)::" msgstr "" ":pep:`544` permet de résoudre ce problème en permettant aux utilisateurs " -"d'écrire le code ci-dessus sans classes de base explicites dans la " -"définition de classe, permettant à ``Bucket`` d'être implicitement considéré " -"comme un sous-type de ``Sized`` et ``Iterable[int]`` par des vérificateurs " -"de type statique. C'est ce qu'on appelle le *sous-typage structurel* (ou " -"typage canard) ::" +"d'écrire le code ci-dessus sans classes de base explicites dans la définition " +"de classe, permettant à ``Bucket`` d'être implicitement considéré comme un " +"sous-type de ``Sized`` et ``Iterable[int]`` par des vérificateurs de type " +"statique. C'est ce qu'on appelle le *sous-typage structurel* (ou typage " +"canard) ::" #: ../Doc/library/typing.rst:433 msgid "" -"Moreover, by subclassing a special class :class:`Protocol`, a user can " -"define new custom protocols to fully enjoy structural subtyping (see " -"examples below)." +"Moreover, by subclassing a special class :class:`Protocol`, a user can define " +"new custom protocols to fully enjoy structural subtyping (see examples below)." msgstr "" "De plus, en sous-classant une classe spéciale :class:`Protocol`, un " "utilisateur peut définir de nouveaux protocoles personnalisés pour profiter " @@ -509,28 +504,28 @@ msgstr "Utilisation ::" #: ../Doc/library/typing.rst:452 msgid "" -"Type variables exist primarily for the benefit of static type checkers. " -"They serve as the parameters for generic types as well as for generic " -"function definitions. See class Generic for more information on generic " -"types. Generic functions work as follows::" +"Type variables exist primarily for the benefit of static type checkers. They " +"serve as the parameters for generic types as well as for generic function " +"definitions. See class Generic for more information on generic types. " +"Generic functions work as follows::" msgstr "" "Les variables de type existent principalement dans l'intérêt des contrôleurs " -"de type statiques. Ils servent de paramètres pour les types génériques " -"ainsi que pour les définitions de fonctions génériques. Voir la classe " -"Generic pour plus d'informations sur les types génériques. Les fonctions " -"génériques fonctionnent comme suit ::" +"de type statiques. Ils servent de paramètres pour les types génériques ainsi " +"que pour les définitions de fonctions génériques. Voir la classe Generic " +"pour plus d'informations sur les types génériques. Les fonctions génériques " +"fonctionnent comme suit ::" #: ../Doc/library/typing.rst:465 msgid "" -"The latter example's signature is essentially the overloading of ``(str, " -"str) -> str`` and ``(bytes, bytes) -> bytes``. Also note that if the " -"arguments are instances of some subclass of :class:`str`, the return type is " -"still plain :class:`str`." +"The latter example's signature is essentially the overloading of ``(str, str) " +"-> str`` and ``(bytes, bytes) -> bytes``. Also note that if the arguments " +"are instances of some subclass of :class:`str`, the return type is still " +"plain :class:`str`." msgstr "" "La signature de ce dernier exemple est essentiellement la surcharge de " -"``(str, str) -> str`` et ``(bytes, bytes) -> bytes``. Notez également que " -"si les arguments sont des instances d'une sous-classe de la classe :class:" -"`str`, le type de retour est toujours la classe :class:`str`." +"``(str, str) -> str`` et ``(bytes, bytes) -> bytes``. Notez également que si " +"les arguments sont des instances d'une sous-classe de la classe :class:`str`, " +"le type de retour est toujours la classe :class:`str`." #: ../Doc/library/typing.rst:470 msgid "" @@ -550,13 +545,13 @@ msgid "" "an actual type substituted (explicitly or implicitly) for the type variable " "must be a subclass of the boundary type, see :pep:`484`." msgstr "" -"Les variables de type peuvent être marquées covariantes ou contrevariantes " -"en passant ``covariant=True`` ou ``contravariant=True``. Voir :pep:`484` " -"pour plus de détails. Par défaut, les variables de type sont invariantes. " -"Alternativement, une variable de type peut spécifier une limite supérieure " -"en utilisant ``bound=>``. Cela signifie qu'un type réel substitué " -"(explicitement ou implicitement) à la variable type doit être une sous-" -"classe du type de frontière, voir :pep:`484`." +"Les variables de type peuvent être marquées covariantes ou contrevariantes en " +"passant ``covariant=True`` ou ``contravariant=True``. Voir :pep:`484` pour " +"plus de détails. Par défaut, les variables de type sont invariantes. " +"Alternativement, une variable de type peut spécifier une limite supérieure en " +"utilisant ``bound=>``. Cela signifie qu'un type réel substitué " +"(explicitement ou implicitement) à la variable type doit être une sous-classe " +"du type de frontière, voir :pep:`484`." #: ../Doc/library/typing.rst:483 msgid "Abstract base class for generic types." @@ -568,9 +563,9 @@ msgid "" "this class with one or more type variables. For example, a generic mapping " "type might be defined as::" msgstr "" -"Un type générique est généralement déclaré en héritant d'une instanciation " -"de cette classe avec une ou plusieurs variables de type. Par exemple, un " -"type de correspondance générique peut être défini comme suit ::" +"Un type générique est généralement déclaré en héritant d'une instanciation de " +"cette classe avec une ou plusieurs variables de type. Par exemple, un type de " +"correspondance générique peut être défini comme suit ::" #: ../Doc/library/typing.rst:494 msgid "This class can then be used as follows::" @@ -588,9 +583,9 @@ msgid "" "Such classes are primarily used with static type checkers that recognize " "structural subtyping (static duck-typing), for example::" msgstr "" -"Ces classes sont principalement utilisées avec les vérificateurs statiques " -"de type qui reconnaissent les sous-types structurels (typage canard " -"statique), par exemple ::" +"Ces classes sont principalement utilisées avec les vérificateurs statiques de " +"type qui reconnaissent les sous-types structurels (typage canard statique), " +"par exemple ::" #: ../Doc/library/typing.rst:525 msgid "" @@ -599,10 +594,10 @@ msgid "" "that check only the presence of given attributes, ignoring their type " "signatures." msgstr "" -"Voir :pep:`544` pour plus de détails. Les classes de protocole décorées " -"avec :func:`runtime_checkable` (décrites plus loin) agissent comme des " -"protocoles d'exécution simples qui ne vérifient que la présence d'attributs " -"donnés, ignorant leurs signatures de type." +"Voir :pep:`544` pour plus de détails. Les classes de protocole décorées avec :" +"func:`runtime_checkable` (décrites plus loin) agissent comme des protocoles " +"d'exécution simples qui ne vérifient que la présence d'attributs donnés, " +"ignorant leurs signatures de type." #: ../Doc/library/typing.rst:530 msgid "Protocol classes can be generic, for example::" @@ -616,8 +611,8 @@ msgid "" "``C``. For example::" msgstr "" "Une variable annotée de ``C`` peut accepter une valeur de type ``C``. En " -"revanche, une variable annotée avec ``Type[C]`` peut accepter des valeurs " -"qui sont des classes elles-mêmes -- spécifiquement, elle acceptera l'objet " +"revanche, une variable annotée avec ``Type[C]`` peut accepter des valeurs qui " +"sont des classes elles-mêmes -- spécifiquement, elle acceptera l'objet " "*class* de ``C``. Par exemple ::" #: ../Doc/library/typing.rst:549 @@ -629,8 +624,8 @@ msgid "" "The fact that ``Type[C]`` is covariant implies that all subclasses of ``C`` " "should implement the same constructor signature and class method signatures " "as ``C``. The type checker should flag violations of this, but should also " -"allow constructor calls in subclasses that match the constructor calls in " -"the indicated base class. How the type checker is required to handle this " +"allow constructor calls in subclasses that match the constructor calls in the " +"indicated base class. How the type checker is required to handle this " "particular case may change in future revisions of :pep:`484`." msgstr "" "Le fait que ``Type[C]`` soit covariant implique que toutes les sous-classes " @@ -701,8 +696,8 @@ msgstr "" #: ../Doc/library/typing.rst:621 msgid "" -"An ABC with one abstract method ``__round__`` that is covariant in its " -"return type." +"An ABC with one abstract method ``__round__`` that is covariant in its return " +"type." msgstr "" "Une ABC avec une méthode abstraite ``__round__`` qui est covariante dans son " "type de retour." @@ -757,8 +752,8 @@ msgstr "Une version générique de :class:`collections.abc.ByteString`." #: ../Doc/library/typing.rst:674 msgid "" -"This type represents the types :class:`bytes`, :class:`bytearray`, and :" -"class:`memoryview`." +"This type represents the types :class:`bytes`, :class:`bytearray`, and :class:" +"`memoryview`." msgstr "" "Ce type représente les types :class:`bytes`, :class:`bytearray`, et :class:" "`memoryview`." @@ -768,8 +763,8 @@ msgid "" "As a shorthand for this type, :class:`bytes` can be used to annotate " "arguments of any of the types mentioned above." msgstr "" -"Comme abréviation pour ce type, :class:`bytes` peut être utilisé pour " -"annoter des arguments de n'importe lequel des types mentionnés ci-dessus." +"Comme abréviation pour ce type, :class:`bytes` peut être utilisé pour annoter " +"des arguments de n'importe lequel des types mentionnés ci-dessus." #: ../Doc/library/typing.rst:682 msgid "A generic version of :class:`collections.deque`." @@ -891,8 +886,7 @@ msgstr "" #: ../Doc/library/typing.rst:825 msgid "" "Note that unlike many other generics in the typing module, the ``SendType`` " -"of :class:`Generator` behaves contravariantly, not covariantly or " -"invariantly." +"of :class:`Generator` behaves contravariantly, not covariantly or invariantly." msgstr "" "Notez que contrairement à beaucoup d'autres génériques dans le module " "*typing*, le ``SendType`` de :class:`Generator` se comporte de manière " @@ -924,14 +918,14 @@ msgstr "" #: ../Doc/library/typing.rst:856 msgid "" -"Unlike normal generators, async generators cannot return a value, so there " -"is no ``ReturnType`` type parameter. As with :class:`Generator`, the " +"Unlike normal generators, async generators cannot return a value, so there is " +"no ``ReturnType`` type parameter. As with :class:`Generator`, the " "``SendType`` behaves contravariantly." msgstr "" -"Contrairement aux générateurs normaux, les générateurs asynchrones ne " -"peuvent pas retourner une valeur, il n'y a donc pas de paramètre de type " -"``ReturnType``. Comme avec :class:`Generator`, le ``SendType`` se comporte " -"de manière contrevariante." +"Contrairement aux générateurs normaux, les générateurs asynchrones ne peuvent " +"pas retourner une valeur, il n'y a donc pas de paramètre de type " +"``ReturnType``. Comme avec :class:`Generator`, le ``SendType`` se comporte de " +"manière contrevariante." #: ../Doc/library/typing.rst:860 msgid "" @@ -955,8 +949,8 @@ msgid "" "``unicode``." msgstr "" "``Text`` est un alias pour ``str``. Il est fourni pour fournir un chemin " -"d'accès compatible pour le code Python 2 : en Python 2, ``Text`` est un " -"alias pour ``unicode``." +"d'accès compatible pour le code Python 2 : en Python 2, ``Text`` est un alias " +"pour ``unicode``." #: ../Doc/library/typing.rst:884 msgid "" @@ -973,8 +967,8 @@ msgid "" "by :func:`open`." msgstr "" "Le type générique ``IO[AnyStr]`` et ses sous-classes ``TextIO(IO[str])``et " -"``BinaryIO(IO[bytes])`` représentent les types de flux E/S tels que " -"retournés par :func:`open`." +"``BinaryIO(IO[bytes])`` représentent les types de flux E/S tels que retournés " +"par :func:`open`." #: ../Doc/library/typing.rst:904 msgid "" @@ -983,8 +977,8 @@ msgid "" "generic in ``AnyStr`` and can be made specific by writing ``Pattern[str]``, " "``Pattern[bytes]``, ``Match[str]``, or ``Match[bytes]``." msgstr "" -"Ces alias de type correspondent aux types de retour de :func:`re.compile` " -"et :func:`re.match`. Ces types (et les fonctions correspondantes) sont " +"Ces alias de type correspondent aux types de retour de :func:`re.compile` et :" +"func:`re.match`. Ces types (et les fonctions correspondantes) sont " "génériques dans ``AnyStr`` et peuvent être rendus spécifiques en écrivant " "``Pattern[str]``, ``Pattern[bytes]``, ``Match[str]`` ou ``Match[bytes]``." @@ -1017,11 +1011,10 @@ msgid "" "``_fields`` attribute and the default values are in the ``_field_defaults`` " "attribute both of which are part of the namedtuple API.)" msgstr "" -"La classe résultante a un attribut supplémentaire ``__annotations__`` " -"donnant un dict qui associe les noms des champs aux types de champs. (Les " -"noms des champs sont dans l'attribut ``_fields`` et les valeurs par défaut " -"sont dans l'attribut ``_field_defaults`` qui font partie de l'API " -"*namedtuple*.)" +"La classe résultante a un attribut supplémentaire ``__annotations__`` donnant " +"un dict qui associe les noms des champs aux types de champs. (Les noms des " +"champs sont dans l'attribut ``_fields`` et les valeurs par défaut sont dans " +"l'attribut ``_field_defaults`` qui font partie de l'API *namedtuple*.)" #: ../Doc/library/typing.rst:942 msgid "``NamedTuple`` subclasses can also have docstrings and methods::" @@ -1090,23 +1083,23 @@ msgstr "" "Les informations de type pour l'introspection sont accessibles via ``Point2D." "__annotations__``et ``Point2D.__total__``. Pour permettre l'utilisation de " "cette fonctionnalité avec les anciennes versions de Python qui ne supportent " -"pas :pep:``526``, ``TypedDict`` supporte deux formes syntaxiques " -"équivalentes supplémentaires ::" +"pas :pep:``526``, ``TypedDict`` supporte deux formes syntaxiques équivalentes " +"supplémentaires ::" #: ../Doc/library/typing.rst:999 msgid "" "See :pep:`589` for more examples and detailed rules of using ``TypedDict`` " "with type checkers." msgstr "" -"Voir :pep:`589` pour plus d'exemples et de règles détaillées d'utilisation " -"de ``TypedDict`` avec les vérificateur de type." +"Voir :pep:`589` pour plus d'exemples et de règles détaillées d'utilisation de " +"``TypedDict`` avec les vérificateur de type." #: ../Doc/library/typing.rst:1006 msgid "" -"A class used for internal typing representation of string forward " -"references. For example, ``List[\"SomeClass\"]`` is implicitly transformed " -"into ``List[ForwardRef(\"SomeClass\")]``. This class should not be " -"instantiated by a user, but may be used by introspection tools." +"A class used for internal typing representation of string forward references. " +"For example, ``List[\"SomeClass\"]`` is implicitly transformed into " +"``List[ForwardRef(\"SomeClass\")]``. This class should not be instantiated " +"by a user, but may be used by introspection tools." msgstr "" "Une classe utilisée pour le typage interne de la représentation des " "références directes des chaînes de caractères. Par exemple, " @@ -1121,9 +1114,9 @@ msgid "" "`distinct`. At runtime it returns a function that returns its argument. " "Usage::" msgstr "" -"Une fonction d'aide pour indiquer un type distinct à un vérificateur de " -"type, voir :ref:`distinct`. Lors de l'exécution, il retourne une fonction " -"qui retourne son argument. Utilisation ::" +"Une fonction d'aide pour indiquer un type distinct à un vérificateur de type, " +"voir :ref:`distinct`. Lors de l'exécution, il retourne une fonction qui " +"retourne son argument. Utilisation ::" #: ../Doc/library/typing.rst:1024 msgid "Cast a value to a type." @@ -1145,23 +1138,23 @@ msgid "" "Return a dictionary containing type hints for a function, method, module or " "class object." msgstr "" -"Retourne un dictionnaire contenant des indications de type pour une " -"fonction, une méthode, un module ou un objet de classe." +"Retourne un dictionnaire contenant des indications de type pour une fonction, " +"une méthode, un module ou un objet de classe." #: ../Doc/library/typing.rst:1036 msgid "" "This is often the same as ``obj.__annotations__``. In addition, forward " "references encoded as string literals are handled by evaluating them in " -"``globals`` and ``locals`` namespaces. If necessary, ``Optional[t]`` is " -"added for function and method annotations if a default value equal to " -"``None`` is set. For a class ``C``, return a dictionary constructed by " -"merging all the ``__annotations__`` along ``C.__mro__`` in reverse order." +"``globals`` and ``locals`` namespaces. If necessary, ``Optional[t]`` is added " +"for function and method annotations if a default value equal to ``None`` is " +"set. For a class ``C``, return a dictionary constructed by merging all the " +"``__annotations__`` along ``C.__mro__`` in reverse order." msgstr "" "C'est souvent équivalent à ``obj.__annotations__``. De plus, les références " "directes encodées sous forme de chaîne littérales sont traitées en les " "évaluant dans les espaces de nommage ``globals`` et ``locals``. Si " -"nécessaire, ``Optional[t]`` est ajouté pour les annotations de fonction et " -"de méthode si une valeur par défaut égale à ``None`` est définie. Pour une " +"nécessaire, ``Optional[t]`` est ajouté pour les annotations de fonction et de " +"méthode si une valeur par défaut égale à ``None`` est définie. Pour une " "classe ``C``, retourne un dictionnaire construit en fusionnant toutes les " "``__annotations__``le long de ``C.__mro__``en ordre inverse." @@ -1173,8 +1166,8 @@ msgstr "" #: ../Doc/library/typing.rst:1049 msgid "" -"For a typing object of the form ``X[Y, Z, ...]`` these functions return " -"``X`` and ``(Y, Z, ...)``. If ``X`` is a generic alias for a builtin or :mod:" +"For a typing object of the form ``X[Y, Z, ...]`` these functions return ``X`` " +"and ``(Y, Z, ...)``. If ``X`` is a generic alias for a builtin or :mod:" "`collections` class, it gets normalized to the original class. For " "unsupported objects return ``None`` and ``()`` correspondingly. Examples::" msgstr "" @@ -1204,18 +1197,17 @@ msgstr "" "définition non décorée de ``overload`` (pour la même fonction/méthode). Les " "définitions décorées de ``@overload`` sont pour le vérificateur de type " "seulement, puisqu'elles seront écrasées par la définition non décorée de " -"``@overload``, alors que cette dernière est utilisée au moment de " -"l'exécution mais devrait être ignorée par un vérificateur de type. Lors de " -"l'exécution, l'appel direct d'une fonction décorée avec ``@overload`` " -"lèvera :exc:`NotImplementedError`. Un exemple de surcharge qui donne un type " -"plus précis que celui qui peut être exprimé à l'aide d'une variable union ou " -"type ::" +"``@overload``, alors que cette dernière est utilisée au moment de l'exécution " +"mais devrait être ignorée par un vérificateur de type. Lors de l'exécution, " +"l'appel direct d'une fonction décorée avec ``@overload`` lèvera :exc:" +"`NotImplementedError`. Un exemple de surcharge qui donne un type plus précis " +"que celui qui peut être exprimé à l'aide d'une variable union ou type ::" #: ../Doc/library/typing.rst:1089 msgid "See :pep:`484` for details and comparison with other typing semantics." msgstr "" -"Voir :pep:`484` pour plus de détails et comparaison avec d'autres " -"sémantiques de typage." +"Voir :pep:`484` pour plus de détails et comparaison avec d'autres sémantiques " +"de typage." #: ../Doc/library/typing.rst:1093 msgid "" @@ -1262,8 +1254,8 @@ msgstr "" #: ../Doc/library/typing.rst:1130 msgid "" -"This wraps the decorator with something that wraps the decorated function " -"in :func:`no_type_check`." +"This wraps the decorator with something that wraps the decorated function in :" +"func:`no_type_check`." msgstr "" "Ceci enveloppe le décorateur avec quelque chose qui enveloppe la fonction " "décorée dans :func:`no_type_check`." @@ -1277,8 +1269,8 @@ msgstr "" #: ../Doc/library/typing.rst:1137 msgid "" "This decorator is itself not available at runtime. It is mainly intended to " -"mark classes that are defined in type stub files if an implementation " -"returns an instance of a private class::" +"mark classes that are defined in type stub files if an implementation returns " +"an instance of a private class::" msgstr "" "Ce décorateur n'est pas disponible à l'exécution. Il est principalement " "destiné à marquer les classes qui sont définies dans des fichiers séparés " @@ -1301,8 +1293,8 @@ msgstr "Marquez une classe de protocole comme protocole d'exécution." msgid "" "Such a protocol can be used with :func:`isinstance` and :func:`issubclass`. " "This raises :exc:`TypeError` when applied to a non-protocol class. This " -"allows a simple-minded structural check, very similar to \"one trick ponies" -"\" in :mod:`collections.abc` such as :class:`Iterable`. For example::" +"allows a simple-minded structural check, very similar to \"one trick ponies\" " +"in :mod:`collections.abc` such as :class:`Iterable`. For example::" msgstr "" "Un tel protocole peut être utilisé avec :func:`isinstance` et :func:" "`issubclass`. Cela lève :exc:`TypeError` lorsqu'il est appliqué à une classe " @@ -1345,8 +1337,7 @@ msgstr "" #: ../Doc/library/typing.rst:1197 msgid "The arguments must be types and there must be at least one." -msgstr "" -"Les arguments doivent être des types et il doit y en avoir au moins un." +msgstr "Les arguments doivent être des types et il doit y en avoir au moins un." #: ../Doc/library/typing.rst:1199 msgid "Unions of unions are flattened, e.g.::" @@ -1396,9 +1387,9 @@ msgstr "``Optional[X]`` équivaut à ``Union[X, None]``." #: ../Doc/library/typing.rst:1230 msgid "" "Note that this is not the same concept as an optional argument, which is one " -"that has a default. An optional argument with a default does not require " -"the ``Optional`` qualifier on its type annotation just because it is " -"optional. For example::" +"that has a default. An optional argument with a default does not require the " +"``Optional`` qualifier on its type annotation just because it is optional. " +"For example::" msgstr "" "Notez que ce n'est pas le même concept qu'un argument optionnel, qui est un " "argument par défaut. Un argument optionnel avec une valeur par défaut ne " @@ -1411,8 +1402,8 @@ msgid "" "``Optional`` is appropriate, whether the argument is optional or not. For " "example::" msgstr "" -"Par contre, si une valeur explicite de ``None`` est permise, l'utilisation " -"de ``Optional`` est appropriée, que l'argument soit facultatif ou non. Par " +"Par contre, si une valeur explicite de ``None`` est permise, l'utilisation de " +"``Optional`` est appropriée, que l'argument soit facultatif ou non. Par " "exemple ::" #: ../Doc/library/typing.rst:1247 @@ -1437,8 +1428,8 @@ msgstr "" #: ../Doc/library/typing.rst:1255 msgid "" -"To specify a variable-length tuple of homogeneous type, use literal " -"ellipsis, e.g. ``Tuple[int, ...]``. A plain :data:`Tuple` is equivalent to " +"To specify a variable-length tuple of homogeneous type, use literal ellipsis, " +"e.g. ``Tuple[int, ...]``. A plain :data:`Tuple` is equivalent to " "``Tuple[Any, ...]``, and in turn to :class:`tuple`." msgstr "" "Pour spécifier un tuple de longueur variable et de type homogène, utilisez " @@ -1453,13 +1444,13 @@ msgstr "" #: ../Doc/library/typing.rst:1263 msgid "" "The subscription syntax must always be used with exactly two values: the " -"argument list and the return type. The argument list must be a list of " -"types or an ellipsis; the return type must be a single type." +"argument list and the return type. The argument list must be a list of types " +"or an ellipsis; the return type must be a single type." msgstr "" "La syntaxe de sélection (*subscription*) doit toujours être utilisée avec " -"exactement deux valeurs : la liste d'arguments et le type de retour. La " -"liste d'arguments doit être une liste de types ou une ellipse ; il doit y " -"avoir un seul type de retour." +"exactement deux valeurs : la liste d'arguments et le type de retour. La liste " +"d'arguments doit être une liste de types ou une ellipse ; il doit y avoir un " +"seul type de retour." #: ../Doc/library/typing.rst:1268 msgid "" @@ -1480,8 +1471,8 @@ msgstr "" #: ../Doc/library/typing.rst:1278 msgid "" "A type that can be used to indicate to type checkers that the corresponding " -"variable or function parameter has a value equivalent to the provided " -"literal (or one of several literals). For example::" +"variable or function parameter has a value equivalent to the provided literal " +"(or one of several literals). For example::" msgstr "" "Un type qui peut être utilisé pour indiquer aux vérificateurs de type que la " "variable ou le paramètre de fonction correspondant a une valeur équivalente " @@ -1532,8 +1523,8 @@ msgstr "" #: ../Doc/library/typing.rst:1326 msgid "" -"A special typing construct to indicate to type checkers that a name cannot " -"be re-assigned or overridden in a subclass. For example::" +"A special typing construct to indicate to type checkers that a name cannot be " +"re-assigned or overridden in a subclass. For example::" msgstr "" "Une construction de type spéciale pour indiquer aux vérificateurs de type " "qu'un nom ne peut pas être réassigné ou remplacé dans une sous-classe. Par " @@ -1553,8 +1544,8 @@ msgid "" "without allowing different kinds of strings to mix. For example::" msgstr "" "Cela est destiné à être utilisé pour des fonctions qui peuvent accepter " -"n'importe quel type de chaîne de caractères sans permettre à différents " -"types de chaînes de caractères de se mélanger. Par exemple ::" +"n'importe quel type de chaîne de caractères sans permettre à différents types " +"de chaînes de caractères de se mélanger. Par exemple ::" #: ../Doc/library/typing.rst:1360 msgid "" @@ -1569,12 +1560,11 @@ msgstr "" msgid "" "Note that the first type annotation must be enclosed in quotes, making it a " "\"forward reference\", to hide the ``expensive_mod`` reference from the " -"interpreter runtime. Type annotations for local variables are not " -"evaluated, so the second annotation does not need to be enclosed in quotes." +"interpreter runtime. Type annotations for local variables are not evaluated, " +"so the second annotation does not need to be enclosed in quotes." msgstr "" -"Notez que la première annotation de type doit être entourée de guillemets, " -"ce qui en fait une \" référence avancée\", pour cacher la référence " +"Notez que la première annotation de type doit être entourée de guillemets, ce " +"qui en fait une \" référence avancée\", pour cacher la référence " "``expensive_mod`` au moment de l'exécution par l'interpréteur. Les " -"annotations de type pour les variables locales ne sont pas évaluées, de " -"sorte que la deuxième annotation n'a pas besoin d'être placée entre " -"guillemets." +"annotations de type pour les variables locales ne sont pas évaluées, de sorte " +"que la deuxième annotation n'a pas besoin d'être placée entre guillemets." From 34027c6c49e98ba02156e5dfa52d939d45eb86d9 Mon Sep 17 00:00:00 2001 From: Kydlaw Date: Thu, 5 Dec 2019 19:30:30 -0500 Subject: [PATCH 28/39] Apply suggestions from code review Co-Authored-By: Julien Palard --- library/typing.po | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/library/typing.po b/library/typing.po index f4913ee2b..ff3f0dafc 100644 --- a/library/typing.po +++ b/library/typing.po @@ -124,7 +124,7 @@ msgstr "" "Vous pouvez toujours effectuer toutes les opérations ``int`` sur une " "variable de type ``UserId``, mais le résultat sera toujours de type ``int``. " "Ceci vous permet de passer un ``UserId`` partout où un ``int`` est attendu, " -"mais vous empêche de créer accidentellement un ``UserId``` d'une manière " +"mais vous empêche de créer accidentellement un ``UserId`` d'une manière " "invalide ::" #: ../Doc/library/typing.rst:104 @@ -462,7 +462,7 @@ msgstr "" "telles que :class:`Iterable`. Le problème avec cette approche est qu'une " "classe devait être explicitement marquée pour les supporter, ce qui n'est " "pas *pythonique* et diffère de ce que l'on ferait normalement avec du code " -"Python idiomatique typé dynamiquement. Par exemple, ceci est conforme au :" +"Python idiomatique typé dynamiquement. Par exemple, ceci est conforme à la :" "pep:`484` ::" #: ../Doc/library/typing.rst:417 @@ -473,7 +473,7 @@ msgid "" "``Iterable[int]`` by static type checkers. This is known as *structural " "subtyping* (or static duck-typing)::" msgstr "" -":pep:`544` permet de résoudre ce problème en permettant aux utilisateurs " +"La :pep:`544` permet de résoudre ce problème en permettant aux utilisateurs " "d'écrire le code ci-dessus sans classes de base explicites dans la " "définition de classe, permettant à ``Bucket`` d'être implicitement considéré " "comme un sous-type de ``Sized`` et ``Iterable[int]`` par des vérificateurs " @@ -515,7 +515,7 @@ msgid "" msgstr "" "Les variables de type existent principalement dans l'intérêt des contrôleurs " "de type statiques. Ils servent de paramètres pour les types génériques ainsi " -"que pour les définitions de fonctions génériques. Voir la classe Generic " +"que pour les définitions de fonctions génériques. Voir la classe ``Generic`` " "pour plus d'informations sur les types génériques. Les fonctions génériques " "fonctionnent comme suit ::" @@ -553,7 +553,7 @@ msgstr "" "en passant ``covariant=True`` ou ``contravariant=True``. Voir :pep:`484` " "pour plus de détails. Par défaut, les variables de type sont invariantes. " "Alternativement, une variable de type peut spécifier une limite supérieure " -"en utilisant ``bound=>``. Cela signifie qu'un type réel substitué " +"en utilisant ``bound=``. Cela signifie qu'un type réel substitué " "(explicitement ou implicitement) à la variable type doit être une sous-" "classe du type de frontière, voir :pep:`484`." @@ -616,7 +616,7 @@ msgid "" msgstr "" "Une variable annotée de ``C`` peut accepter une valeur de type ``C``. En " "revanche, une variable annotée avec ``Type[C]`` peut accepter des valeurs " -"qui sont des classes elles-mêmes -- spécifiquement, elle acceptera l'objet " +"qui sont des classes elles-mêmes — spécifiquement, elle acceptera l'objet " "*class* de ``C``. Par exemple ::" #: ../Doc/library/typing.rst:549 @@ -646,7 +646,7 @@ msgid "" "The only legal parameters for :class:`Type` are classes, :data:`Any`, :ref:" "`type variables `, and unions of any of these types. For example::" msgstr "" -"Les seuls paramètres légaux pour :class:`Type` sont les classes, :data:" +"Les seuls paramètres légitimes pour :class:`Type` sont les classes, :data:" "`Any`, :ref:`type variables `, et les unions de ces types. Par " "exemple ::" From 9ae43364079709f6d97f7ade36f71af5afca00bb Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Thu, 30 Apr 2020 18:38:21 +0000 Subject: [PATCH 29/39] Apply suggestions from code review Co-authored-by: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com> Co-authored-by: Vincent Poulailleau --- library/typing.po | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/library/typing.po b/library/typing.po index ff3f0dafc..cc1d826f7 100644 --- a/library/typing.po +++ b/library/typing.po @@ -121,7 +121,7 @@ msgid "" "pass in a ``UserId`` wherever an ``int`` might be expected, but will prevent " "you from accidentally creating a ``UserId`` in an invalid way::" msgstr "" -"Vous pouvez toujours effectuer toutes les opérations ``int`` sur une " +"Vous pouvez toujours effectuer toutes les opérations applicables à un entier (type ``int``) sur une " "variable de type ``UserId``, mais le résultat sera toujours de type ``int``. " "Ceci vous permet de passer un ``UserId`` partout où un ``int`` est attendu, " "mais vous empêche de créer accidentellement un ``UserId`` d'une manière " @@ -215,7 +215,7 @@ msgid "" "hinted using ``Callable[[Arg1Type, Arg2Type], ReturnType]``." msgstr "" "Les cadriciels (*frameworks* en anglais) qui attendent des fonctions de " -"rappel de signatures spécifiques peuvent être typés en utilisant " +"rappel ayant des signatures spécifiques peuvent être typés en utilisant " "``Callable[[Arg1Type, Arg2Type], ReturnType]``." #: ../Doc/library/typing.rst:157 @@ -290,7 +290,7 @@ msgid "" "be constrained::" msgstr "" "Un type générique peut avoir un nombre quelconque de variables de type et " -"les variables de type peuvent être limitées ::" +"vous pouvez fixer des contraintes sur les variables de type ::" #: ../Doc/library/typing.rst:255 msgid "" @@ -346,7 +346,7 @@ msgstr "" "Une classe générique définie par l'utilisateur peut avoir ABC comme classes " "de base sans conflit de métaclasses. Les métaclasses génériques ne sont pas " "prises en charge. Le résultat du paramétrage des génériques est mis en cache " -"et la plupart des types dans le module de typage sont hachables et " +"et la plupart des types dans le module ``typing`` sont hachables et " "comparables pour l'égalité." #: ../Doc/library/typing.rst:320 @@ -437,7 +437,7 @@ msgstr "" #: ../Doc/library/typing.rst:398 msgid "Nominal vs structural subtyping" -msgstr "Sous-typage nominal vs sous-typage structurel" +msgstr "Sous-typage nominal et sous-typage structurel" #: ../Doc/library/typing.rst:400 msgid "" @@ -1335,7 +1335,7 @@ msgstr "Type spécial indiquant qu'une fonction ne renvoit rien. Par exemple :: #: ../Doc/library/typing.rst:1193 msgid "Union type; ``Union[X, Y]`` means either X or Y." -msgstr "Type d'union ; ``Union[X, Y]`` signifie X ou Y." +msgstr "Type d'union ; ``Union[X, Y]`` signifie X ou Y." #: ../Doc/library/typing.rst:1195 msgid "To define a union, use e.g. ``Union[int, str]``. Details:" From 7f615ccf49be3fe835f8532d6bcbbcc15560aa82 Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Thu, 30 Apr 2020 21:30:52 +0000 Subject: [PATCH 30/39] Apply suggestions from code review Co-authored-by: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com> --- library/typing.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/typing.po b/library/typing.po index 49869b5a6..3d9cbe53e 100644 --- a/library/typing.po +++ b/library/typing.po @@ -393,7 +393,7 @@ msgid "" "implicitly default to using :data:`Any`::" msgstr "" "De plus, toutes les fonctions sans type de retour ni type de paramètre sont " -"considérées comme utilisant :data:`Any` implicitement par défaut ::" +"considérées comme utilisant :data:`Any` implicitement par défaut ::" #: ../Doc/library/typing.rst:363 msgid "" @@ -717,7 +717,7 @@ msgstr "Un alias pour :class:`collections.abc.Hashable`" #: ../Doc/library/typing.rst:634 msgid "An alias to :class:`collections.abc.Sized`" -msgstr "Un alias vers :classe:`collections.abc.Sized`" +msgstr "Un alias vers :class:`collections.abc.Sized`" #: ../Doc/library/typing.rst:638 msgid "A generic version of :class:`collections.abc.Collection`" From b19ea65fa0621e02fc07d75514c0fe7e2e724af2 Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Fri, 1 May 2020 10:45:27 +0200 Subject: [PATCH 31/39] =?UTF-8?q?suggestions=20manquantes=20+=20r=C3=A9par?= =?UTF-8?q?ation=20balisage=20+=20wrapping?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/typing.po | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/library/typing.po b/library/typing.po index 3d9cbe53e..70d7066e0 100644 --- a/library/typing.po +++ b/library/typing.po @@ -121,11 +121,11 @@ msgid "" "pass in a ``UserId`` wherever an ``int`` might be expected, but will prevent " "you from accidentally creating a ``UserId`` in an invalid way::" msgstr "" -"Vous pouvez toujours effectuer toutes les opérations applicables à un entier (type ``int``) sur une " -"variable de type ``UserId``, mais le résultat sera toujours de type ``int``. " -"Ceci vous permet de passer un ``UserId`` partout où un ``int`` est attendu, " -"mais vous empêche de créer accidentellement un ``UserId`` d'une manière " -"invalide ::" +"Vous pouvez toujours effectuer toutes les opérations applicables à un entier " +"(type ``int``) sur une variable de type ``UserId``, mais le résultat sera " +"toujours de type ``int``. Ceci vous permet de passer un ``UserId`` partout " +"où un ``int`` est attendu, mais vous empêche de créer accidentellement un " +"``UserId`` d'une manière invalide ::" #: ../Doc/library/typing.rst:104 msgid "" @@ -344,11 +344,11 @@ msgid "" "parameterizing generics is cached, and most types in the typing module are " "hashable and comparable for equality." msgstr "" -"Une classe générique définie par l'utilisateur peut avoir ABC comme classes " -"de base sans conflit de métaclasses. Les métaclasses génériques ne sont pas " -"prises en charge. Le résultat du paramétrage des génériques est mis en cache " -"et la plupart des types dans le module ``typing`` sont hachables et " -"comparables pour l'égalité." +"Une classe générique définie par l'utilisateur peut avoir des CBAs (*Classe " +"de Base Abstraite*) comme classes de base sans conflit de métaclasses. Les " +"métaclasses génériques ne sont pas prises en charge. Le résultat du " +"paramétrage des génériques est mis en cache et la plupart des types dans le " +"module ``typing`` sont hachables et comparables pour l'égalité." #: ../Doc/library/typing.rst:320 msgid "The :data:`Any` type" @@ -1315,7 +1315,7 @@ msgid "" "**Warning:** this will check only the presence of the required methods, not " "their type signatures!" msgstr "" -"**Attention : ** ceci ne vérifiera que la présence des méthodes requises, et " +"**Attention :** ceci ne vérifiera que la présence des méthodes requises, et " "non leur signature de type !" #: ../Doc/library/typing.rst:1173 From 53ea1cf6574052f7f98ca17809a7e5aea6e24dbb Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Fri, 1 May 2020 11:10:00 +0200 Subject: [PATCH 32/39] encore des corrections --- library/typing.po | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/library/typing.po b/library/typing.po index 70d7066e0..9f34b01d5 100644 --- a/library/typing.po +++ b/library/typing.po @@ -137,7 +137,7 @@ msgid "" msgstr "" "Notez que ces contrôles ne sont exécutés que par le vérificateur de type " "statique. À l'exécution, l'instruction ``Derived = NewType('Derived', " -"Base)`` fait de ``Derived``` une fonction qui renvoie immédiatement le " +"Base)`` fait de ``Derived`` une fonction qui renvoie immédiatement le " "paramètre que vous lui passez. Cela signifie que l'expression " "``Derived(some_value)`` ne crée pas une nouvelle classe ou n'introduit pas " "de surcharge au-delà de celle d'un appel de fonction normal." @@ -164,15 +164,14 @@ msgid "" "However, it is possible to create a :func:`NewType` based on a 'derived' " "``NewType``::" msgstr "" -"Cependant, il est possible de créer un :func:`NewType` basé sur un " -"``NewType`` 'derived' ::" +"Cependant, il est possible de créer un :func:`NewType` basé sur un un " +"``NewType`` « dérivé » ::" #: ../Doc/library/typing.rst:131 msgid "and typechecking for ``ProUserId`` will work as expected." msgstr "et la vérification de type pour ``ProUserId`` fonctionne comme prévu." #: ../Doc/library/typing.rst:133 -#, fuzzy msgid "See :pep:`484` for more details." msgstr "Voir la :pep:`484` pour plus de détails." From c29cff409460667bb33b7e6ad82400cd2a71ff66 Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Fri, 1 May 2020 11:12:48 +0200 Subject: [PATCH 33/39] retourne -> renvoie --- library/typing.po | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/library/typing.po b/library/typing.po index 9f34b01d5..4b7a56e9a 100644 --- a/library/typing.po +++ b/library/typing.po @@ -928,7 +928,7 @@ msgid "" "``SendType`` behaves contravariantly." msgstr "" "Contrairement aux générateurs normaux, les générateurs asynchrones ne " -"peuvent pas retourner une valeur, il n'y a donc pas de paramètre de type " +"peuvent pas renvoyer une valeur, il n'y a donc pas de paramètre de type " "``ReturnType``. Comme avec :class:`Generator`, le ``SendType`` se comporte " "de manière contrevariante." @@ -972,8 +972,8 @@ msgid "" "by :func:`open`." msgstr "" "Le type générique ``IO[AnyStr]`` et ses sous-classes ``TextIO(IO[str])`` et " -"``BinaryIO(IO[bytes])`` représentent les types de flux E/S tels que " -"retournés par :func:`open`." +"``BinaryIO(IO[bytes])`` représentent les types de flux E/S tels que renvoyés " +"par :func:`open`." #: ../Doc/library/typing.rst:904 msgid "" @@ -1121,8 +1121,8 @@ msgid "" "Usage::" msgstr "" "Une fonction d'aide pour indiquer un type distinct à un vérificateur de " -"type, voir :ref:`distinct`. Lors de l'exécution, il retourne une fonction " -"qui retourne son argument. Utilisation ::" +"type, voir :ref:`distinct`. Lors de l'exécution, il renvoie une fonction qui " +"renvoie son argument. Utilisation ::" #: ../Doc/library/typing.rst:1024 msgid "Cast a value to a type." @@ -1134,7 +1134,7 @@ msgid "" "return value has the designated type, but at runtime we intentionally don't " "check anything (we want this to be as fast as possible)." msgstr "" -"Ceci retourne la valeur inchangée. Pour le vérificateur de type, cela " +"Ceci renvoie la valeur inchangée. Pour le vérificateur de type, cela " "signifie que la valeur de retour a le type désigné, mais au moment de " "l'exécution, rien n'est vérifié intentionnellement (afin que cela soit aussi " "rapide que possible)." @@ -1144,8 +1144,8 @@ msgid "" "Return a dictionary containing type hints for a function, method, module or " "class object." msgstr "" -"Retourne un dictionnaire contenant des indications de type pour une " -"fonction, une méthode, un module ou un objet de classe." +"renvoie un dictionnaire contenant des indications de type pour une fonction, " +"une méthode, un module ou un objet de classe." #: ../Doc/library/typing.rst:1036 msgid "" @@ -1161,7 +1161,7 @@ msgstr "" "évaluant dans les espaces de nommage ``globals`` et ``locals``. Si " "nécessaire, ``Optional[t]`` est ajouté pour les annotations de fonction et " "de méthode si une valeur par défaut égale à ``None`` est définie. Pour une " -"classe ``C``, retourne un dictionnaire construit en fusionnant toutes les " +"classe ``C``, renvoie un dictionnaire construit en fusionnant toutes les " "``__annotations__`` le long de ``C.__mro__`` en ordre inverse." #: ../Doc/library/typing.rst:1047 @@ -1178,9 +1178,9 @@ msgid "" "unsupported objects return ``None`` and ``()`` correspondingly. Examples::" msgstr "" "Pour un objet de typage de la forme ``X[Y, Z, ....]``, ces fonctions " -"retournent ``X`` et ``(Y, Z,...)``. Si ``X`` est un alias pour une classe " +"renvoient ``X`` et ``(Y, Z,...)``. Si ``X`` est un alias pour une classe " "builtin ou :mod:`collections`, il est normalisé à la classe originale. Pour " -"les objets non supportés, retourne ``None`` et ``()`` en conséquence. " +"les objets non supportés, renvoie ``None`` et ``()`` en conséquence. " "Exemples ::" #: ../Doc/library/typing.rst:1065 @@ -1281,7 +1281,7 @@ msgid "" msgstr "" "Ce décorateur n'est pas disponible à l'exécution. Il est principalement " "destiné à marquer les classes qui sont définies dans des fichiers séparés " -"spécifiqueselli de type si une implémentation retourne une instance d'une " +"spécifiqueselli de type si une implémentation renvoie une instance d'une " "classe privée ::" #: ../Doc/library/typing.rst:1148 @@ -1289,7 +1289,7 @@ msgid "" "Note that returning instances of private classes is not recommended. It is " "usually preferable to make such classes public." msgstr "" -"Notez qu'il n'est pas recommandé de retourner les instances des classes " +"Notez qu'il n'est pas recommandé de renvoyer les instances des classes " "*private*. Il est généralement préférable de rendre ces classes *public*." #: ../Doc/library/typing.rst:1153 From 2d76f2cd0052a6abce2355cff7443d024804e6d6 Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Fri, 1 May 2020 12:05:12 +0200 Subject: [PATCH 34/39] pospell + corrections --- library/typing.po | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/library/typing.po b/library/typing.po index 4b7a56e9a..4e14c3ca1 100644 --- a/library/typing.po +++ b/library/typing.po @@ -963,7 +963,7 @@ msgid "" "manner that is compatible with both Python 2 and Python 3::" msgstr "" "Utilisez ``Text`` pour indiquer qu'une valeur doit contenir une chaîne " -"unicode d'une manière compatible avec Python 2 et Python 3 ::" +"Unicode d'une manière compatible avec Python 2 et Python 3 ::" #: ../Doc/library/typing.rst:896 msgid "" @@ -1017,9 +1017,9 @@ msgid "" "attribute both of which are part of the namedtuple API.)" msgstr "" "La classe résultante a un attribut supplémentaire ``__annotations__`` " -"donnant un dict qui associe les noms des champs aux types de champs. (Les " -"noms des champs sont dans l'attribut ``_fields`` et les valeurs par défaut " -"sont dans l'attribut ``_field_defaults`` qui font partie de l'API " +"donnant un dictionnaire qui associe les noms des champs aux types de champs. " +"(Les noms des champs sont dans l'attribut ``_fields`` et les valeurs par " +"défaut sont dans l'attribut ``_field_defaults`` qui font partie de l'API " "*namedtuple*.)" #: ../Doc/library/typing.rst:942 @@ -1179,8 +1179,8 @@ msgid "" msgstr "" "Pour un objet de typage de la forme ``X[Y, Z, ....]``, ces fonctions " "renvoient ``X`` et ``(Y, Z,...)``. Si ``X`` est un alias pour une classe " -"builtin ou :mod:`collections`, il est normalisé à la classe originale. Pour " -"les objets non supportés, renvoie ``None`` et ``()`` en conséquence. " +"native ou de :mod:`collections`, il est normalisé en la classe originale. " +"Pour les objets non supportés, renvoie ``None`` et ``()`` en conséquence. " "Exemples ::" #: ../Doc/library/typing.rst:1065 @@ -1281,8 +1281,8 @@ msgid "" msgstr "" "Ce décorateur n'est pas disponible à l'exécution. Il est principalement " "destiné à marquer les classes qui sont définies dans des fichiers séparés " -"spécifiqueselli de type si une implémentation renvoie une instance d'une " -"classe privée ::" +"d'annotations de type (*type stub file*, en anglais) si une implémentation " +"renvoie une instance d'une classe privée ::" #: ../Doc/library/typing.rst:1148 msgid "" @@ -1306,8 +1306,8 @@ msgstr "" "Un tel protocole peut être utilisé avec :func:`isinstance` et :func:" "`issubclass`. Cela lève :exc:`TypeError` lorsqu'il est appliqué à une classe " "non protocole. Cela permet un contrôle structurel compréhensible, très " -"similaire à \"one trick poneys\" dans :mod:`collections.abc` tel que :class:" -"`Iterable`. Par exemple ::" +"similaire aux « classes qui ne savent faire qu'une chose » présentes dans :" +"mod:`collections.abc` tel que :class:`Iterable`. Par exemple ::" #: ../Doc/library/typing.rst:1166 msgid "" @@ -1331,7 +1331,7 @@ msgstr ":data:`Any` est compatible avec tous les types." #: ../Doc/library/typing.rst:1180 msgid "Special type indicating that a function never returns. For example::" -msgstr "Type spécial indiquant qu'une fonction ne renvoit rien. Par exemple ::" +msgstr "Type spécial indiquant qu'une fonction ne renvoie rien. Par exemple ::" #: ../Doc/library/typing.rst:1193 msgid "Union type; ``Union[X, Y]`` means either X or Y." @@ -1431,8 +1431,8 @@ msgid "" "float and a string." msgstr "" "Exemple : ``Tuple[T1, T2]`` est un tuple de deux éléments correspondant aux " -"variables de type T1 et T2. ``Tuple[int, float, str]`` est un tuple d'un " -"int, d'un float et d'une chaîne." +"variables de type ``T1`` et ``T2``. ``Tuple[int, float, str]`` est un tuple " +"d'un entier, d'un flottant et d'une chaîne de caractères." #: ../Doc/library/typing.rst:1255 msgid "" @@ -1447,7 +1447,8 @@ msgstr "" #: ../Doc/library/typing.rst:1261 msgid "Callable type; ``Callable[[int], str]`` is a function of (int) -> str." msgstr "" -"Type Appelable ; ``Callable[[int], str]`` est une fonction de (int) -> str." +"Type Appelable. ``Callable[[int], str]`` est une fonction de type ``(int) -> " +"str``." #: ../Doc/library/typing.rst:1263 msgid "" From a7f352399a20e466978e5d78505315b164bcfe05 Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Fri, 1 May 2020 12:14:48 +0200 Subject: [PATCH 35/39] contrevariant(e) -> contravariant(e) --- library/typing.po | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/library/typing.po b/library/typing.po index 4e14c3ca1..435d980f5 100644 --- a/library/typing.po +++ b/library/typing.po @@ -549,7 +549,7 @@ msgid "" "an actual type substituted (explicitly or implicitly) for the type variable " "must be a subclass of the boundary type, see :pep:`484`." msgstr "" -"Les variables de type peuvent être marquées covariantes ou contrevariantes " +"Les variables de type peuvent être marquées covariantes ou contravariantes " "en passant ``covariant=True`` ou ``contravariant=True``. Voir :pep:`484` " "pour plus de détails. Par défaut, les variables de type sont invariantes. " "Alternativement, une variable de type peut spécifier une limite supérieure " @@ -895,7 +895,7 @@ msgid "" msgstr "" "Notez que contrairement à beaucoup d'autres génériques dans le module " "*typing*, le ``SendType`` de :class:`Generator` se comporte de manière " -"contrevariante, pas de manière covariante ou invariante." +"contravariante, pas de manière covariante ou invariante." #: ../Doc/library/typing.rst:829 msgid "" @@ -930,7 +930,7 @@ msgstr "" "Contrairement aux générateurs normaux, les générateurs asynchrones ne " "peuvent pas renvoyer une valeur, il n'y a donc pas de paramètre de type " "``ReturnType``. Comme avec :class:`Generator`, le ``SendType`` se comporte " -"de manière contrevariante." +"de manière contravariante." #: ../Doc/library/typing.rst:860 msgid "" From 1c631f972d051cf7727ee66a7d9ef6ceb755234f Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Fri, 1 May 2020 15:02:21 +0200 Subject: [PATCH 36/39] ajoute "contravariante(s)" au dictionnaire --- dict | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dict b/dict index 8d1efa63c..939542e3b 100644 --- a/dict +++ b/dict @@ -22,6 +22,8 @@ catucci cobjects composabilité concourance +contravariante +contravariantes contribués coroutine coroutines From d72b0aa759065744191ae4f500b03a6ca437f140 Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Sun, 3 May 2020 13:13:13 +0000 Subject: [PATCH 37/39] Apply suggestions from code review Co-authored-by: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com> --- library/typing.po | 142 +++++++++++++++++++++++----------------------- 1 file changed, 71 insertions(+), 71 deletions(-) diff --git a/library/typing.po b/library/typing.po index 435d980f5..c38970ea0 100644 --- a/library/typing.po +++ b/library/typing.po @@ -164,7 +164,7 @@ msgid "" "However, it is possible to create a :func:`NewType` based on a 'derived' " "``NewType``::" msgstr "" -"Cependant, il est possible de créer un :func:`NewType` basé sur un un " +"Cependant, il est possible de créer un :func:`NewType` basé sur un " "``NewType`` « dérivé » ::" #: ../Doc/library/typing.rst:131 @@ -343,7 +343,7 @@ msgid "" "parameterizing generics is cached, and most types in the typing module are " "hashable and comparable for equality." msgstr "" -"Une classe générique définie par l'utilisateur peut avoir des CBAs (*Classe " +"Une classe générique définie par l'utilisateur peut avoir des CBA (*Classe " "de Base Abstraite*) comme classes de base sans conflit de métaclasses. Les " "métaclasses génériques ne sont pas prises en charge. Le résultat du " "paramétrage des génériques est mis en cache et la plupart des types dans le " @@ -359,7 +359,7 @@ msgid "" "every type as being compatible with :data:`Any` and :data:`Any` as being " "compatible with every type." msgstr "" -"Un type spécial de type est :data:`Any`. Un vérificateur de type statique " +"Un type particulier est :data:`Any`. Un vérificateur de type statique " "traite chaque type comme étant compatible avec :data:`Any` et :data:`Any` " "comme étant compatible avec chaque type." @@ -445,7 +445,7 @@ msgid "" "subtyping*. This means that a class ``A`` is allowed where a class ``B`` is " "expected if and only if ``A`` is a subclass of ``B``." msgstr "" -"Initialement :pep:`484` définissait le système de type statique Python comme " +"Initialement la :pep:`484` définissait le système de type statique Python comme " "utilisant *le sous-type nominal*. Cela signifie qu'une classe ``A`` est " "permise lorsqu'une classe ``B`` est prévue si et seulement si ``A`` est une " "sous-classe de ``B``." @@ -514,7 +514,7 @@ msgid "" "types. Generic functions work as follows::" msgstr "" "Les variables de type existent principalement dans l'intérêt des contrôleurs " -"de type statiques. Ils servent de paramètres pour les types génériques ainsi " +"de type statiques. Elles servent de paramètres pour les types génériques ainsi " "que pour les définitions de fonctions génériques. Voir la classe ``Generic`` " "pour plus d'informations sur les types génériques. Les fonctions génériques " "fonctionnent comme suit ::" @@ -550,12 +550,12 @@ msgid "" "must be a subclass of the boundary type, see :pep:`484`." msgstr "" "Les variables de type peuvent être marquées covariantes ou contravariantes " -"en passant ``covariant=True`` ou ``contravariant=True``. Voir :pep:`484` " +"en passant ``covariant=True`` ou ``contravariant=True``. Voir la :pep:`484` " "pour plus de détails. Par défaut, les variables de type sont invariantes. " -"Alternativement, une variable de type peut spécifier une limite supérieure " +"Sinon, une variable de type peut spécifier une limite supérieure " "en utilisant ``bound=``. Cela signifie qu'un type réel substitué " "(explicitement ou implicitement) à la variable type doit être une sous-" -"classe du type de frontière, voir :pep:`484`." +"classe du type frontière (*boundary* en anglais), voir la :pep:`484`." #: ../Doc/library/typing.rst:483 msgid "Abstract base class for generic types." @@ -598,8 +598,8 @@ msgid "" "that check only the presence of given attributes, ignoring their type " "signatures." msgstr "" -"Voir :pep:`544` pour plus de détails. Les classes de protocole décorées " -"avec :func:`runtime_checkable` (décrites plus loin) agissent comme des " +"Voir la :pep:`544` pour plus de détails. Les classes de protocole décorées " +"avec :func:`runtime_checkable` (décrite plus loin) agissent comme des " "protocoles d'exécution simples qui ne vérifient que la présence d'attributs " "donnés, ignorant leurs signatures de type." @@ -616,7 +616,7 @@ msgid "" msgstr "" "Une variable annotée de ``C`` peut accepter une valeur de type ``C``. En " "revanche, une variable annotée avec ``Type[C]`` peut accepter des valeurs " -"qui sont des classes elles-mêmes — spécifiquement, elle acceptera l'objet " +"qui sont elles-mêmes des classes — plus précisément, elle accepte l'objet " "*class* de ``C``. Par exemple ::" #: ../Doc/library/typing.rst:549 @@ -638,7 +638,7 @@ msgstr "" "signaler les manquements à cette règle. Il doit également autoriser les " "appels du constructeur dans les sous-classes qui correspondent aux appels du " "constructeur dans la classe de base indiquée. La façon dont le vérificateur " -"de type est nécessaire pour traiter ce cas particulier peut changer dans les " +"de type est tenu de traiter ce cas particulier peut changer dans les " "futures révisions de :pep:`484`." #: ../Doc/library/typing.rst:569 @@ -716,7 +716,7 @@ msgstr "Un alias pour :class:`collections.abc.Hashable`" #: ../Doc/library/typing.rst:634 msgid "An alias to :class:`collections.abc.Sized`" -msgstr "Un alias vers :class:`collections.abc.Sized`" +msgstr "Un alias pour :class:`collections.abc.Sized`" #: ../Doc/library/typing.rst:638 msgid "A generic version of :class:`collections.abc.Collection`" @@ -759,7 +759,7 @@ msgid "" "This type represents the types :class:`bytes`, :class:`bytearray`, and :" "class:`memoryview`." msgstr "" -"Ce type représente les types :class:`bytes`, :class:`bytearray`, et :class:" +"Ce type représente les types :class:`bytes`, :class:`bytearray` et :class:" "`memoryview`." #: ../Doc/library/typing.rst:677 @@ -953,8 +953,8 @@ msgid "" "compatible path for Python 2 code: in Python 2, ``Text`` is an alias for " "``unicode``." msgstr "" -"``Text`` est un alias pour ``str``. Il est fourni pour fournir un chemin " -"d'accès compatible pour le code Python 2 : en Python 2, ``Text`` est un " +"``Text`` est un alias pour ``str``. Il est fourni pour obtenir une compatibilité " +"ascendante du code Python 2 : en Python 2, ``Text`` est un " "alias pour ``unicode``." #: ../Doc/library/typing.rst:884 @@ -972,7 +972,7 @@ msgid "" "by :func:`open`." msgstr "" "Le type générique ``IO[AnyStr]`` et ses sous-classes ``TextIO(IO[str])`` et " -"``BinaryIO(IO[bytes])`` représentent les types de flux E/S tels que renvoyés " +"``BinaryIO(IO[bytes])`` représentent les types de flux d'entrées-sorties tels que renvoyés " "par :func:`open`." #: ../Doc/library/typing.rst:904 @@ -999,7 +999,7 @@ msgstr "Ce qui est équivalent à ::" msgid "" "To give a field a default value, you can assign to it in the class body::" msgstr "" -"Pour donner une valeur par défaut à une zone, vous pouvez l'affecter dans le " +"Pour assigner une valeur par défaut à un champ, vous pouvez lui donner dans le " "corps de classe ::" #: ../Doc/library/typing.rst:934 @@ -1025,7 +1025,7 @@ msgstr "" #: ../Doc/library/typing.rst:942 msgid "``NamedTuple`` subclasses can also have docstrings and methods::" msgstr "" -"Les sous-classes ``NamedTuple`` peuvent aussi avoir des *docstrings* et des " +"Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et des " "méthodes ::" #: ../Doc/library/typing.rst:952 @@ -1034,7 +1034,7 @@ msgstr "Utilisation rétrocompatible ::" #: ../Doc/library/typing.rst:956 msgid "Added support for :pep:`526` variable annotation syntax." -msgstr "Ajout du support de la syntaxe d'annotation variable :pep:`526`." +msgstr "Ajout de la gestion de la syntaxe d'annotation variable de la :pep:`526`." #: ../Doc/library/typing.rst:959 msgid "Added support for default values, methods, and docstrings." @@ -1047,7 +1047,7 @@ msgid "" "Deprecated the ``_field_types`` attribute in favor of the more standard " "``__annotations__`` attribute which has the same information." msgstr "" -"A déprécié l'attribut ``_field_types`` en faveur de l'attribut plus standard " +"rend l'attribut ``_field_types`` obsolète en faveur de l'attribut plus standard " "``__annotations__`` qui a la même information." #: ../Doc/library/typing.rst:966 @@ -1056,14 +1056,14 @@ msgid "" "dictionaries instead of instances of ``OrderedDict``." msgstr "" "Les attributs ``_field_types`` et ``__annotations__`` sont maintenant des " -"dictionnaires réguliers au lieu des instances de ``OrderedDict``." +"dictionnaires standards au lieu d'instances de ``OrderedDict``." #: ../Doc/library/typing.rst:972 msgid "" "A simple typed namespace. At runtime it is equivalent to a plain :class:" "`dict`." msgstr "" -"Un simple espace de nommage typé. A l'exécution, c'est l'équivalent d'un " +"Un simple espace de nommage typé. À l'exécution, c'est l'équivalent d'un " "simple :class:`dict`." #: ../Doc/library/typing.rst:975 @@ -1075,7 +1075,7 @@ msgid "" msgstr "" "``TypedDict`` crée un type de dictionnaire qui s'attend à ce que toutes ses " "instances aient un certain jeu de clés, où chaque clé est associée à une " -"valeur d'un type cohérent. Cette attente n'est pas vérifiée au moment de " +"valeur d'un type cohérent. Cette vérification n'est pas faite au moment de " "l'exécution mais n'est appliquée que par les vérificateurs de type. " "Utilisation ::" @@ -1088,8 +1088,8 @@ msgid "" msgstr "" "Les informations de type pour l'introspection sont accessibles via ``Point2D." "__annotations__`` et ``Point2D.__total__``. Pour permettre l'utilisation de " -"cette fonctionnalité avec les anciennes versions de Python qui ne supportent " -"pas :pep:`526`, ``TypedDict`` supporte deux formes syntaxiques équivalentes " +"cette fonctionnalité avec les anciennes versions de Python qui ne prennent " +"pas en compte la :pep:`526`, ``TypedDict`` gère deux formes syntaxiques équivalentes " "supplémentaires ::" #: ../Doc/library/typing.rst:999 @@ -1097,7 +1097,7 @@ msgid "" "See :pep:`589` for more examples and detailed rules of using ``TypedDict`` " "with type checkers." msgstr "" -"Voir :pep:`589` pour plus d'exemples et de règles détaillées d'utilisation " +"Voir la :pep:`589` pour plus d'exemples et de règles détaillées d'utilisation " "de ``TypedDict`` avec les vérificateurs de type." #: ../Doc/library/typing.rst:1006 @@ -1120,13 +1120,13 @@ msgid "" "`distinct`. At runtime it returns a function that returns its argument. " "Usage::" msgstr "" -"Une fonction d'aide pour indiquer un type distinct à un vérificateur de " -"type, voir :ref:`distinct`. Lors de l'exécution, il renvoie une fonction qui " +"Une fonction pour faciliter l'indication d'un type distinct à un vérificateur de " +"type, voir :ref:`distinct`. Lors de l'exécution, elle renvoie une fonction qui " "renvoie son argument. Utilisation ::" #: ../Doc/library/typing.rst:1024 msgid "Cast a value to a type." -msgstr "Convertir une valeur en un type." +msgstr "Convertit une valeur en un type." #: ../Doc/library/typing.rst:1026 msgid "" @@ -1135,8 +1135,8 @@ msgid "" "check anything (we want this to be as fast as possible)." msgstr "" "Ceci renvoie la valeur inchangée. Pour le vérificateur de type, cela " -"signifie que la valeur de retour a le type désigné, mais au moment de " -"l'exécution, rien n'est vérifié intentionnellement (afin que cela soit aussi " +"signifie que la valeur de retour a le type désigné mais, à " +"l'exécution, intentionnellement, rien n'est vérifié (afin que cela soit aussi " "rapide que possible)." #: ../Doc/library/typing.rst:1033 @@ -1162,13 +1162,13 @@ msgstr "" "nécessaire, ``Optional[t]`` est ajouté pour les annotations de fonction et " "de méthode si une valeur par défaut égale à ``None`` est définie. Pour une " "classe ``C``, renvoie un dictionnaire construit en fusionnant toutes les " -"``__annotations__`` le long de ``C.__mro__`` en ordre inverse." +"``__annotations__`` en parcourant ``C.__mro__`` en ordre inverse." #: ../Doc/library/typing.rst:1047 msgid "Provide basic introspection for generic types and special typing forms." msgstr "" "Fournit une introspection de base pour les types génériques et les " -"formulaires de typage spéciaux." +"formes spéciales de typage." #: ../Doc/library/typing.rst:1049 msgid "" @@ -1180,7 +1180,7 @@ msgstr "" "Pour un objet de typage de la forme ``X[Y, Z, ....]``, ces fonctions " "renvoient ``X`` et ``(Y, Z,...)``. Si ``X`` est un alias pour une classe " "native ou de :mod:`collections`, il est normalisé en la classe originale. " -"Pour les objets non supportés, renvoie ``None`` et ``()`` en conséquence. " +"Pour les objets non gérés, renvoie la paire ``None`` , ``()``. " "Exemples ::" #: ../Doc/library/typing.rst:1065 @@ -1198,13 +1198,13 @@ msgid "" "variable::" msgstr "" "Le décorateur ``@overload``` permet de décrire des fonctions et des méthodes " -"qui supportent plusieurs combinaisons différentes de types d'arguments. Une " +"qui acceptent plusieurs combinaisons différentes de types d'arguments. Une " "série de définitions décorées avec ``overload`` doit être suivie d'une seule " "définition non décorée de ``overload`` (pour la même fonction/méthode). Les " -"définitions décorées de ``@overload`` sont pour le vérificateur de type " -"seulement, puisqu'elles seront écrasées par la définition non décorée de " -"``@overload``, alors que cette dernière est utilisée au moment de " -"l'exécution mais devrait être ignorée par un vérificateur de type. Lors de " +"définitions décorées de ``@overload`` ne sont destinées qu'au vérificateur de " +"type, puisqu'elles sont écrasées par la définition non décorée de " +"``@overload`` ; cette dernière, en revanche, est utilisée à " +"l'exécution mais qu'il convient que le vérificateur de type l'ignore. Lors de " "l'exécution, l'appel direct d'une fonction décorée avec ``@overload`` " "lèvera :exc:`NotImplementedError`. Un exemple de surcharge qui donne un type " "plus précis que celui qui peut être exprimé à l'aide d'une variable union ou " @@ -1213,7 +1213,7 @@ msgstr "" #: ../Doc/library/typing.rst:1089 msgid "See :pep:`484` for details and comparison with other typing semantics." msgstr "" -"Voir :pep:`484` pour plus de détails et comparaison avec d'autres " +"Voir la :pep:`484` pour plus de détails et la comparaison avec d'autres " "sémantiques de typage." #: ../Doc/library/typing.rst:1093 @@ -1221,7 +1221,7 @@ msgid "" "A decorator to indicate to type checkers that the decorated method cannot be " "overridden, and the decorated class cannot be subclassed. For example::" msgstr "" -"Un décorateur pour indiquer aux contrôleurs de frappe que la méthode décorée " +"Un décorateur pour indiquer aux vérificateurs de types que la méthode décorée " "ne peut pas être remplacée et que la classe décorée ne peut pas être sous-" "classée. Par exemple ::" @@ -1230,7 +1230,7 @@ msgid "" "There is no runtime checking of these properties. See :pep:`591` for more " "details." msgstr "" -"Il n'y a pas de vérification d'exécution de ces propriétés. Voir :pep:`591` " +"Ces propriétés ne sont pas vérifiées à l'exécution. Voir la :pep:`591` " "pour plus de détails." #: ../Doc/library/typing.rst:1118 @@ -1245,7 +1245,7 @@ msgid "" "recursively to all methods defined in that class (but not to methods defined " "in its superclasses or subclasses)." msgstr "" -"Cela fonctionne en tant que classe ou fonction :term:`decorator`. Avec une " +"Cela fonctionne en tant que classe ou fonction :term:`décoratrice `. Avec une " "classe, elle s'applique récursivement à toutes les méthodes définies dans " "cette classe (mais pas aux méthodes définies dans ses superclasses ou sous-" "classes)." @@ -1290,7 +1290,7 @@ msgid "" "usually preferable to make such classes public." msgstr "" "Notez qu'il n'est pas recommandé de renvoyer les instances des classes " -"*private*. Il est généralement préférable de rendre ces classes *public*." +"privées. Il est généralement préférable de rendre ces classes publiques." #: ../Doc/library/typing.rst:1153 msgid "Mark a protocol class as a runtime protocol." @@ -1335,7 +1335,7 @@ msgstr "Type spécial indiquant qu'une fonction ne renvoie rien. Par exemple :: #: ../Doc/library/typing.rst:1193 msgid "Union type; ``Union[X, Y]`` means either X or Y." -msgstr "Type d'union ; ``Union[X, Y]`` signifie X ou Y." +msgstr "Type « union » ; ``Union[X, Y]`` signifie X ou Y." #: ../Doc/library/typing.rst:1195 msgid "To define a union, use e.g. ``Union[int, str]``. Details:" @@ -1349,7 +1349,7 @@ msgstr "" #: ../Doc/library/typing.rst:1199 msgid "Unions of unions are flattened, e.g.::" -msgstr "Les unions d'unions sont aplanis, par exemple ::" +msgstr "Les unions d'unions sont aplanies, par exemple ::" #: ../Doc/library/typing.rst:1203 msgid "Unions of a single argument vanish, e.g.::" @@ -1381,12 +1381,12 @@ msgstr "" #: ../Doc/library/typing.rst:1221 msgid "Don't remove explicit subclasses from unions at runtime." msgstr "" -"Ne supprimez pas les sous-classes explicites des syndicats au moment de " +"Ne supprime pas les sous-classes explicites des unions à " "l'exécution." #: ../Doc/library/typing.rst:1226 msgid "Optional type." -msgstr "Type optionnel." +msgstr "Type « optionnel »." #: ../Doc/library/typing.rst:1228 msgid "``Optional[X]`` is equivalent to ``Union[X, None]``." @@ -1400,9 +1400,9 @@ msgid "" "optional. For example::" msgstr "" "Notez que ce n'est pas le même concept qu'un argument optionnel, qui est un " -"argument par défaut. Un argument optionnel avec une valeur par défaut ne " -"nécessite pas le qualificatif ``Optional`` sur son annotation de type " -"simplement parce qu'il est optionnel. Par exemple ::" +"argument qui possède une valeur par défaut. Un argument optionnel (qui " +"a une valeur par défaut) ne nécessite pas, à ce titre, le qualificatif " +"``Optional`` sur son annotation de type. Par exemple ::" #: ../Doc/library/typing.rst:1238 msgid "" @@ -1420,8 +1420,8 @@ msgid "" "first item of type X and the second of type Y. The type of the empty tuple " "can be written as ``Tuple[()]``." msgstr "" -"Type de tuple ; ``Tuple[X, Y]`` est le type d'un tuple de deux éléments avec " -"le premier élément de type X et le second de type Y. Le type du tuple vide " +"Type « n-uplet » ; ``Tuple[X, Y]`` est le type d'un n-uplet à deux éléments avec " +"le premier élément de type X et le second de type Y. Le type du n-uplet vide " "peut être écrit comme ``Tuple[()]``." #: ../Doc/library/typing.rst:1251 @@ -1430,8 +1430,8 @@ msgid "" "variables T1 and T2. ``Tuple[int, float, str]`` is a tuple of an int, a " "float and a string." msgstr "" -"Exemple : ``Tuple[T1, T2]`` est un tuple de deux éléments correspondant aux " -"variables de type ``T1`` et ``T2``. ``Tuple[int, float, str]`` est un tuple " +"Exemple : ``Tuple[T1, T2]`` est une paire correspondant aux " +"variables de type ``T1`` et ``T2``. ``Tuple[int, float, str]`` est un triplet composé " "d'un entier, d'un flottant et d'une chaîne de caractères." #: ../Doc/library/typing.rst:1255 @@ -1440,9 +1440,9 @@ msgid "" "ellipsis, e.g. ``Tuple[int, ...]``. A plain :data:`Tuple` is equivalent to " "``Tuple[Any, ...]``, and in turn to :class:`tuple`." msgstr "" -"Pour spécifier un tuple de longueur variable et de type homogène, utilisez " -"une ellipse, par exemple ``Tuple[int, ....]``. Un tuple :data:`Tuple` est " -"équivalent à ``Tuple[Any, ....]``, et à son tour à :class:`tuple`." +"Pour spécifier un n-uplet de longueur variable et de type homogène, utilisez " +"une ellipse, par exemple ``Tuple[int, ....]``. Un n-uplet :data:`Tuple` est " +"équivalent à ``Tuple[Any, ....]`` et, à son tour, à :class:`tuple`." #: ../Doc/library/typing.rst:1261 msgid "Callable type; ``Callable[[int], str]`` is a function of (int) -> str." @@ -1456,7 +1456,7 @@ msgid "" "argument list and the return type. The argument list must be a list of " "types or an ellipsis; the return type must be a single type." msgstr "" -"La syntaxe de sélection (*subscription*) doit toujours être utilisée avec " +"La syntaxe de sélection (*subscription* en anglais) doit toujours être utilisée avec " "exactement deux valeurs : la liste d'arguments et le type de retour. La " "liste d'arguments doit être une liste de types ou une ellipse ; il doit y " "avoir un seul type de retour." @@ -1470,12 +1470,12 @@ msgid "" "equivalent to ``Callable[..., Any]``, and in turn to :class:`collections.abc." "Callable`." msgstr "" -"Il n'y a pas de syntaxe pour indiquer les arguments optionnels ou les mots-" +"Il n'y a pas de syntaxe pour indiquer les arguments optionnels ou les arguments par mots-" "clés ; de tels types de fonctions sont rarement utilisés comme types de " "rappel. ``Callable[..., ReturnType]`` (ellipse) peut être utilisé pour " "annoter le type d'un appelable, prenant un nombre quelconque d'arguments et " "renvoyant ``ReturnType``. Un simple :data:`Callable` est équivalent à " -"``Callable[..., Any]``, et à son tour à :class:`collections.abc.Callable`." +"``Callable[..., Any]`` et, à son tour, à :class:`collections.abc.Callable`." #: ../Doc/library/typing.rst:1278 msgid "" @@ -1483,7 +1483,7 @@ msgid "" "variable or function parameter has a value equivalent to the provided " "literal (or one of several literals). For example::" msgstr "" -"Un type qui peut être utilisé pour indiquer aux vérificateurs de type que la " +"Type pour indiquer aux vérificateurs de type que la " "variable ou le paramètre de fonction correspondant a une valeur équivalente " "au littéral fourni (ou un parmi plusieurs littéraux). Par exemple ::" @@ -1495,12 +1495,12 @@ msgid "" msgstr "" "``Literal[...]`` ne peut être sous-classé. Lors de l'exécution, une valeur " "arbitraire est autorisée comme argument de type pour ``Literal[...]``, mais " -"les vérificateurs de type peuvent imposer des restrictions. Voir :pep:`586` " +"les vérificateurs de type peuvent imposer des restrictions. Voir la :pep:`586` " "pour plus de détails sur les types littéraux." #: ../Doc/library/typing.rst:1300 msgid "Special type construct to mark class variables." -msgstr "Construction de type spécial pour marquer les variables de classe." +msgstr "Construction de type particulière pour indiquer les variables de classe." #: ../Doc/library/typing.rst:1302 msgid "" @@ -1508,7 +1508,7 @@ msgid "" "indicates that a given attribute is intended to be used as a class variable " "and should not be set on instances of that class. Usage::" msgstr "" -"Tel qu'introduit dans :pep:`526`, une annotation de variable enveloppée dans " +"Telle qu'introduite dans la :pep:`526`, une annotation de variable enveloppée dans " "ClassVar indique qu'un attribut donné est destiné à être utilisé comme une " "variable de classe et ne doit pas être défini sur des instances de cette " "classe. Utilisation ::" @@ -1516,7 +1516,7 @@ msgstr "" #: ../Doc/library/typing.rst:1310 msgid ":data:`ClassVar` accepts only types and cannot be further subscribed." msgstr "" -":data:`ClassVar` n'accepte que les types et ne peut plus être souscrit." +":data:`ClassVar` n'accepte que les types et ne peut plus être dérivé." #: ../Doc/library/typing.rst:1312 msgid "" @@ -1536,7 +1536,7 @@ msgid "" "A special typing construct to indicate to type checkers that a name cannot " "be re-assigned or overridden in a subclass. For example::" msgstr "" -"Une construction de type spéciale pour indiquer aux vérificateurs de type " +"Construction de type particulière pour indiquer aux vérificateurs de type " "qu'un nom ne peut pas être réassigné ou remplacé dans une sous-classe. Par " "exemple ::" @@ -1562,8 +1562,8 @@ msgid "" "A special constant that is assumed to be ``True`` by 3rd party static type " "checkers. It is ``False`` at runtime. Usage::" msgstr "" -"Une constante spéciale qui est supposée être ``True`` par les vérificateurs " -"de type statiques tiers. C'est ``False`` au moment de l'exécution. " +"Constante spéciale qui vaut ``True`` pour les vérificateurs " +"de type statiques tiers et ``False`` à l'exécution. " "Utilisation ::" #: ../Doc/library/typing.rst:1369 @@ -1574,7 +1574,7 @@ msgid "" "evaluated, so the second annotation does not need to be enclosed in quotes." msgstr "" "Notez que la première annotation de type doit être entourée de guillemets, " -"ce qui en fait une \" référence avancée\", pour cacher la référence " +"ce qui en fait une « référence avant », pour cacher la référence " "``expensive_mod`` au moment de l'exécution par l'interpréteur. Les " "annotations de type pour les variables locales ne sont pas évaluées, de " "sorte que la deuxième annotation n'a pas besoin d'être placée entre " From 74cc93421bbfc06cdb5f12e9ad57e7174704de7d Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Sun, 3 May 2020 15:14:56 +0200 Subject: [PATCH 38/39] wrapping --- library/typing.po | 181 +++++++++++++++++++++++----------------------- 1 file changed, 89 insertions(+), 92 deletions(-) diff --git a/library/typing.po b/library/typing.po index c38970ea0..fbec3c27e 100644 --- a/library/typing.po +++ b/library/typing.po @@ -359,9 +359,9 @@ msgid "" "every type as being compatible with :data:`Any` and :data:`Any` as being " "compatible with every type." msgstr "" -"Un type particulier est :data:`Any`. Un vérificateur de type statique " -"traite chaque type comme étant compatible avec :data:`Any` et :data:`Any` " -"comme étant compatible avec chaque type." +"Un type particulier est :data:`Any`. Un vérificateur de type statique traite " +"chaque type comme étant compatible avec :data:`Any` et :data:`Any` comme " +"étant compatible avec chaque type." #: ../Doc/library/typing.rst:326 msgid "" @@ -445,10 +445,10 @@ msgid "" "subtyping*. This means that a class ``A`` is allowed where a class ``B`` is " "expected if and only if ``A`` is a subclass of ``B``." msgstr "" -"Initialement la :pep:`484` définissait le système de type statique Python comme " -"utilisant *le sous-type nominal*. Cela signifie qu'une classe ``A`` est " -"permise lorsqu'une classe ``B`` est prévue si et seulement si ``A`` est une " -"sous-classe de ``B``." +"Initialement la :pep:`484` définissait le système de type statique Python " +"comme utilisant *le sous-type nominal*. Cela signifie qu'une classe ``A`` " +"est permise lorsqu'une classe ``B`` est prévue si et seulement si ``A`` est " +"une sous-classe de ``B``." #: ../Doc/library/typing.rst:404 msgid "" @@ -514,10 +514,10 @@ msgid "" "types. Generic functions work as follows::" msgstr "" "Les variables de type existent principalement dans l'intérêt des contrôleurs " -"de type statiques. Elles servent de paramètres pour les types génériques ainsi " -"que pour les définitions de fonctions génériques. Voir la classe ``Generic`` " -"pour plus d'informations sur les types génériques. Les fonctions génériques " -"fonctionnent comme suit ::" +"de type statiques. Elles servent de paramètres pour les types génériques " +"ainsi que pour les définitions de fonctions génériques. Voir la classe " +"``Generic`` pour plus d'informations sur les types génériques. Les fonctions " +"génériques fonctionnent comme suit ::" #: ../Doc/library/typing.rst:465 msgid "" @@ -552,8 +552,8 @@ msgstr "" "Les variables de type peuvent être marquées covariantes ou contravariantes " "en passant ``covariant=True`` ou ``contravariant=True``. Voir la :pep:`484` " "pour plus de détails. Par défaut, les variables de type sont invariantes. " -"Sinon, une variable de type peut spécifier une limite supérieure " -"en utilisant ``bound=``. Cela signifie qu'un type réel substitué " +"Sinon, une variable de type peut spécifier une limite supérieure en " +"utilisant ``bound=``. Cela signifie qu'un type réel substitué " "(explicitement ou implicitement) à la variable type doit être une sous-" "classe du type frontière (*boundary* en anglais), voir la :pep:`484`." @@ -638,8 +638,8 @@ msgstr "" "signaler les manquements à cette règle. Il doit également autoriser les " "appels du constructeur dans les sous-classes qui correspondent aux appels du " "constructeur dans la classe de base indiquée. La façon dont le vérificateur " -"de type est tenu de traiter ce cas particulier peut changer dans les " -"futures révisions de :pep:`484`." +"de type est tenu de traiter ce cas particulier peut changer dans les futures " +"révisions de :pep:`484`." #: ../Doc/library/typing.rst:569 msgid "" @@ -953,8 +953,8 @@ msgid "" "compatible path for Python 2 code: in Python 2, ``Text`` is an alias for " "``unicode``." msgstr "" -"``Text`` est un alias pour ``str``. Il est fourni pour obtenir une compatibilité " -"ascendante du code Python 2 : en Python 2, ``Text`` est un " +"``Text`` est un alias pour ``str``. Il est fourni pour obtenir une " +"compatibilité ascendante du code Python 2 : en Python 2, ``Text`` est un " "alias pour ``unicode``." #: ../Doc/library/typing.rst:884 @@ -972,8 +972,8 @@ msgid "" "by :func:`open`." msgstr "" "Le type générique ``IO[AnyStr]`` et ses sous-classes ``TextIO(IO[str])`` et " -"``BinaryIO(IO[bytes])`` représentent les types de flux d'entrées-sorties tels que renvoyés " -"par :func:`open`." +"``BinaryIO(IO[bytes])`` représentent les types de flux d'entrées-sorties " +"tels que renvoyés par :func:`open`." #: ../Doc/library/typing.rst:904 msgid "" @@ -999,8 +999,8 @@ msgstr "Ce qui est équivalent à ::" msgid "" "To give a field a default value, you can assign to it in the class body::" msgstr "" -"Pour assigner une valeur par défaut à un champ, vous pouvez lui donner dans le " -"corps de classe ::" +"Pour assigner une valeur par défaut à un champ, vous pouvez lui donner dans " +"le corps de classe ::" #: ../Doc/library/typing.rst:934 msgid "" @@ -1025,8 +1025,8 @@ msgstr "" #: ../Doc/library/typing.rst:942 msgid "``NamedTuple`` subclasses can also have docstrings and methods::" msgstr "" -"Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et des " -"méthodes ::" +"Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et " +"des méthodes ::" #: ../Doc/library/typing.rst:952 msgid "Backward-compatible usage::" @@ -1034,7 +1034,8 @@ msgstr "Utilisation rétrocompatible ::" #: ../Doc/library/typing.rst:956 msgid "Added support for :pep:`526` variable annotation syntax." -msgstr "Ajout de la gestion de la syntaxe d'annotation variable de la :pep:`526`." +msgstr "" +"Ajout de la gestion de la syntaxe d'annotation variable de la :pep:`526`." #: ../Doc/library/typing.rst:959 msgid "Added support for default values, methods, and docstrings." @@ -1047,8 +1048,8 @@ msgid "" "Deprecated the ``_field_types`` attribute in favor of the more standard " "``__annotations__`` attribute which has the same information." msgstr "" -"rend l'attribut ``_field_types`` obsolète en faveur de l'attribut plus standard " -"``__annotations__`` qui a la même information." +"rend l'attribut ``_field_types`` obsolète en faveur de l'attribut plus " +"standard ``__annotations__`` qui a la même information." #: ../Doc/library/typing.rst:966 msgid "" @@ -1089,16 +1090,16 @@ msgstr "" "Les informations de type pour l'introspection sont accessibles via ``Point2D." "__annotations__`` et ``Point2D.__total__``. Pour permettre l'utilisation de " "cette fonctionnalité avec les anciennes versions de Python qui ne prennent " -"pas en compte la :pep:`526`, ``TypedDict`` gère deux formes syntaxiques équivalentes " -"supplémentaires ::" +"pas en compte la :pep:`526`, ``TypedDict`` gère deux formes syntaxiques " +"équivalentes supplémentaires ::" #: ../Doc/library/typing.rst:999 msgid "" "See :pep:`589` for more examples and detailed rules of using ``TypedDict`` " "with type checkers." msgstr "" -"Voir la :pep:`589` pour plus d'exemples et de règles détaillées d'utilisation " -"de ``TypedDict`` avec les vérificateurs de type." +"Voir la :pep:`589` pour plus d'exemples et de règles détaillées " +"d'utilisation de ``TypedDict`` avec les vérificateurs de type." #: ../Doc/library/typing.rst:1006 msgid "" @@ -1120,9 +1121,9 @@ msgid "" "`distinct`. At runtime it returns a function that returns its argument. " "Usage::" msgstr "" -"Une fonction pour faciliter l'indication d'un type distinct à un vérificateur de " -"type, voir :ref:`distinct`. Lors de l'exécution, elle renvoie une fonction qui " -"renvoie son argument. Utilisation ::" +"Une fonction pour faciliter l'indication d'un type distinct à un " +"vérificateur de type, voir :ref:`distinct`. Lors de l'exécution, elle " +"renvoie une fonction qui renvoie son argument. Utilisation ::" #: ../Doc/library/typing.rst:1024 msgid "Cast a value to a type." @@ -1135,9 +1136,9 @@ msgid "" "check anything (we want this to be as fast as possible)." msgstr "" "Ceci renvoie la valeur inchangée. Pour le vérificateur de type, cela " -"signifie que la valeur de retour a le type désigné mais, à " -"l'exécution, intentionnellement, rien n'est vérifié (afin que cela soit aussi " -"rapide que possible)." +"signifie que la valeur de retour a le type désigné mais, à l'exécution, " +"intentionnellement, rien n'est vérifié (afin que cela soit aussi rapide que " +"possible)." #: ../Doc/library/typing.rst:1033 msgid "" @@ -1167,8 +1168,8 @@ msgstr "" #: ../Doc/library/typing.rst:1047 msgid "Provide basic introspection for generic types and special typing forms." msgstr "" -"Fournit une introspection de base pour les types génériques et les " -"formes spéciales de typage." +"Fournit une introspection de base pour les types génériques et les formes " +"spéciales de typage." #: ../Doc/library/typing.rst:1049 msgid "" @@ -1180,8 +1181,7 @@ msgstr "" "Pour un objet de typage de la forme ``X[Y, Z, ....]``, ces fonctions " "renvoient ``X`` et ``(Y, Z,...)``. Si ``X`` est un alias pour une classe " "native ou de :mod:`collections`, il est normalisé en la classe originale. " -"Pour les objets non gérés, renvoie la paire ``None`` , ``()``. " -"Exemples ::" +"Pour les objets non gérés, renvoie la paire ``None`` , ``()``. Exemples ::" #: ../Doc/library/typing.rst:1065 msgid "" @@ -1201,14 +1201,13 @@ msgstr "" "qui acceptent plusieurs combinaisons différentes de types d'arguments. Une " "série de définitions décorées avec ``overload`` doit être suivie d'une seule " "définition non décorée de ``overload`` (pour la même fonction/méthode). Les " -"définitions décorées de ``@overload`` ne sont destinées qu'au vérificateur de " -"type, puisqu'elles sont écrasées par la définition non décorée de " -"``@overload`` ; cette dernière, en revanche, est utilisée à " -"l'exécution mais qu'il convient que le vérificateur de type l'ignore. Lors de " -"l'exécution, l'appel direct d'une fonction décorée avec ``@overload`` " -"lèvera :exc:`NotImplementedError`. Un exemple de surcharge qui donne un type " -"plus précis que celui qui peut être exprimé à l'aide d'une variable union ou " -"type ::" +"définitions décorées de ``@overload`` ne sont destinées qu'au vérificateur " +"de type, puisqu'elles sont écrasées par la définition non décorée de " +"``@overload`` ; cette dernière, en revanche, est utilisée à l'exécution mais " +"qu'il convient que le vérificateur de type l'ignore. Lors de l'exécution, " +"l'appel direct d'une fonction décorée avec ``@overload`` lèvera :exc:" +"`NotImplementedError`. Un exemple de surcharge qui donne un type plus précis " +"que celui qui peut être exprimé à l'aide d'une variable union ou type ::" #: ../Doc/library/typing.rst:1089 msgid "See :pep:`484` for details and comparison with other typing semantics." @@ -1221,17 +1220,17 @@ msgid "" "A decorator to indicate to type checkers that the decorated method cannot be " "overridden, and the decorated class cannot be subclassed. For example::" msgstr "" -"Un décorateur pour indiquer aux vérificateurs de types que la méthode décorée " -"ne peut pas être remplacée et que la classe décorée ne peut pas être sous-" -"classée. Par exemple ::" +"Un décorateur pour indiquer aux vérificateurs de types que la méthode " +"décorée ne peut pas être remplacée et que la classe décorée ne peut pas être " +"sous-classée. Par exemple ::" #: ../Doc/library/typing.rst:1111 ../Doc/library/typing.rst:1338 msgid "" "There is no runtime checking of these properties. See :pep:`591` for more " "details." msgstr "" -"Ces propriétés ne sont pas vérifiées à l'exécution. Voir la :pep:`591` " -"pour plus de détails." +"Ces propriétés ne sont pas vérifiées à l'exécution. Voir la :pep:`591` pour " +"plus de détails." #: ../Doc/library/typing.rst:1118 msgid "Decorator to indicate that annotations are not type hints." @@ -1245,10 +1244,10 @@ msgid "" "recursively to all methods defined in that class (but not to methods defined " "in its superclasses or subclasses)." msgstr "" -"Cela fonctionne en tant que classe ou fonction :term:`décoratrice `. Avec une " -"classe, elle s'applique récursivement à toutes les méthodes définies dans " -"cette classe (mais pas aux méthodes définies dans ses superclasses ou sous-" -"classes)." +"Cela fonctionne en tant que classe ou fonction :term:`décoratrice " +"`. Avec une classe, elle s'applique récursivement à toutes les " +"méthodes définies dans cette classe (mais pas aux méthodes définies dans ses " +"superclasses ou sous-classes)." #: ../Doc/library/typing.rst:1124 msgid "This mutates the function(s) in place." @@ -1380,9 +1379,7 @@ msgstr "" #: ../Doc/library/typing.rst:1221 msgid "Don't remove explicit subclasses from unions at runtime." -msgstr "" -"Ne supprime pas les sous-classes explicites des unions à " -"l'exécution." +msgstr "Ne supprime pas les sous-classes explicites des unions à l'exécution." #: ../Doc/library/typing.rst:1226 msgid "Optional type." @@ -1400,8 +1397,8 @@ msgid "" "optional. For example::" msgstr "" "Notez que ce n'est pas le même concept qu'un argument optionnel, qui est un " -"argument qui possède une valeur par défaut. Un argument optionnel (qui " -"a une valeur par défaut) ne nécessite pas, à ce titre, le qualificatif " +"argument qui possède une valeur par défaut. Un argument optionnel (qui a une " +"valeur par défaut) ne nécessite pas, à ce titre, le qualificatif " "``Optional`` sur son annotation de type. Par exemple ::" #: ../Doc/library/typing.rst:1238 @@ -1420,9 +1417,9 @@ msgid "" "first item of type X and the second of type Y. The type of the empty tuple " "can be written as ``Tuple[()]``." msgstr "" -"Type « n-uplet » ; ``Tuple[X, Y]`` est le type d'un n-uplet à deux éléments avec " -"le premier élément de type X et le second de type Y. Le type du n-uplet vide " -"peut être écrit comme ``Tuple[()]``." +"Type « n-uplet » ; ``Tuple[X, Y]`` est le type d'un n-uplet à deux éléments " +"avec le premier élément de type X et le second de type Y. Le type du n-uplet " +"vide peut être écrit comme ``Tuple[()]``." #: ../Doc/library/typing.rst:1251 msgid "" @@ -1430,8 +1427,8 @@ msgid "" "variables T1 and T2. ``Tuple[int, float, str]`` is a tuple of an int, a " "float and a string." msgstr "" -"Exemple : ``Tuple[T1, T2]`` est une paire correspondant aux " -"variables de type ``T1`` et ``T2``. ``Tuple[int, float, str]`` est un triplet composé " +"Exemple : ``Tuple[T1, T2]`` est une paire correspondant aux variables de " +"type ``T1`` et ``T2``. ``Tuple[int, float, str]`` est un triplet composé " "d'un entier, d'un flottant et d'une chaîne de caractères." #: ../Doc/library/typing.rst:1255 @@ -1456,10 +1453,10 @@ msgid "" "argument list and the return type. The argument list must be a list of " "types or an ellipsis; the return type must be a single type." msgstr "" -"La syntaxe de sélection (*subscription* en anglais) doit toujours être utilisée avec " -"exactement deux valeurs : la liste d'arguments et le type de retour. La " -"liste d'arguments doit être une liste de types ou une ellipse ; il doit y " -"avoir un seul type de retour." +"La syntaxe de sélection (*subscription* en anglais) doit toujours être " +"utilisée avec exactement deux valeurs : la liste d'arguments et le type de " +"retour. La liste d'arguments doit être une liste de types ou une ellipse ; " +"il doit y avoir un seul type de retour." #: ../Doc/library/typing.rst:1268 msgid "" @@ -1470,12 +1467,13 @@ msgid "" "equivalent to ``Callable[..., Any]``, and in turn to :class:`collections.abc." "Callable`." msgstr "" -"Il n'y a pas de syntaxe pour indiquer les arguments optionnels ou les arguments par mots-" -"clés ; de tels types de fonctions sont rarement utilisés comme types de " -"rappel. ``Callable[..., ReturnType]`` (ellipse) peut être utilisé pour " -"annoter le type d'un appelable, prenant un nombre quelconque d'arguments et " -"renvoyant ``ReturnType``. Un simple :data:`Callable` est équivalent à " -"``Callable[..., Any]`` et, à son tour, à :class:`collections.abc.Callable`." +"Il n'y a pas de syntaxe pour indiquer les arguments optionnels ou les " +"arguments par mots-clés ; de tels types de fonctions sont rarement utilisés " +"comme types de rappel. ``Callable[..., ReturnType]`` (ellipse) peut être " +"utilisé pour annoter le type d'un appelable, prenant un nombre quelconque " +"d'arguments et renvoyant ``ReturnType``. Un simple :data:`Callable` est " +"équivalent à ``Callable[..., Any]`` et, à son tour, à :class:`collections." +"abc.Callable`." #: ../Doc/library/typing.rst:1278 msgid "" @@ -1483,9 +1481,9 @@ msgid "" "variable or function parameter has a value equivalent to the provided " "literal (or one of several literals). For example::" msgstr "" -"Type pour indiquer aux vérificateurs de type que la " -"variable ou le paramètre de fonction correspondant a une valeur équivalente " -"au littéral fourni (ou un parmi plusieurs littéraux). Par exemple ::" +"Type pour indiquer aux vérificateurs de type que la variable ou le paramètre " +"de fonction correspondant a une valeur équivalente au littéral fourni (ou un " +"parmi plusieurs littéraux). Par exemple ::" #: ../Doc/library/typing.rst:1292 msgid "" @@ -1495,12 +1493,13 @@ msgid "" msgstr "" "``Literal[...]`` ne peut être sous-classé. Lors de l'exécution, une valeur " "arbitraire est autorisée comme argument de type pour ``Literal[...]``, mais " -"les vérificateurs de type peuvent imposer des restrictions. Voir la :pep:`586` " -"pour plus de détails sur les types littéraux." +"les vérificateurs de type peuvent imposer des restrictions. Voir la :pep:" +"`586` pour plus de détails sur les types littéraux." #: ../Doc/library/typing.rst:1300 msgid "Special type construct to mark class variables." -msgstr "Construction de type particulière pour indiquer les variables de classe." +msgstr "" +"Construction de type particulière pour indiquer les variables de classe." #: ../Doc/library/typing.rst:1302 msgid "" @@ -1508,15 +1507,14 @@ msgid "" "indicates that a given attribute is intended to be used as a class variable " "and should not be set on instances of that class. Usage::" msgstr "" -"Telle qu'introduite dans la :pep:`526`, une annotation de variable enveloppée dans " -"ClassVar indique qu'un attribut donné est destiné à être utilisé comme une " -"variable de classe et ne doit pas être défini sur des instances de cette " -"classe. Utilisation ::" +"Telle qu'introduite dans la :pep:`526`, une annotation de variable " +"enveloppée dans ClassVar indique qu'un attribut donné est destiné à être " +"utilisé comme une variable de classe et ne doit pas être défini sur des " +"instances de cette classe. Utilisation ::" #: ../Doc/library/typing.rst:1310 msgid ":data:`ClassVar` accepts only types and cannot be further subscribed." -msgstr "" -":data:`ClassVar` n'accepte que les types et ne peut plus être dérivé." +msgstr ":data:`ClassVar` n'accepte que les types et ne peut plus être dérivé." #: ../Doc/library/typing.rst:1312 msgid "" @@ -1562,9 +1560,8 @@ msgid "" "A special constant that is assumed to be ``True`` by 3rd party static type " "checkers. It is ``False`` at runtime. Usage::" msgstr "" -"Constante spéciale qui vaut ``True`` pour les vérificateurs " -"de type statiques tiers et ``False`` à l'exécution. " -"Utilisation ::" +"Constante spéciale qui vaut ``True`` pour les vérificateurs de type " +"statiques tiers et ``False`` à l'exécution. Utilisation ::" #: ../Doc/library/typing.rst:1369 msgid "" From 6b14b0eef2a467951c9bba61dd124a3ad2be88a3 Mon Sep 17 00:00:00 2001 From: Mathieu Dupuy Date: Sun, 3 May 2020 15:56:30 +0200 Subject: [PATCH 39/39] ne pas traduire les :term: --- library/typing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/typing.po b/library/typing.po index fbec3c27e..8226dca80 100644 --- a/library/typing.po +++ b/library/typing.po @@ -1245,7 +1245,7 @@ msgid "" "in its superclasses or subclasses)." msgstr "" "Cela fonctionne en tant que classe ou fonction :term:`décoratrice " -"`. Avec une classe, elle s'applique récursivement à toutes les " +"`. Avec une classe, elle s'applique récursivement à toutes les " "méthodes définies dans cette classe (mais pas aux méthodes définies dans ses " "superclasses ou sous-classes)."