From 1e94ea06ac2133f48a4f5a6bdf8dcb47a59cf168 Mon Sep 17 00:00:00 2001 From: Nicolas Date: Fri, 17 Feb 2023 16:23:02 +0100 Subject: [PATCH] Add new translations on typing --- library/typing.po | 2697 ++++++++++++++++++++------------------------- 1 file changed, 1177 insertions(+), 1520 deletions(-) diff --git a/library/typing.po b/library/typing.po index 4b492579..74742049 100644 --- a/library/typing.po +++ b/library/typing.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-01-15 22:33+0100\n" -"PO-Revision-Date: 2023-02-17 11:00+0100\n" +"PO-Revision-Date: 2023-02-17 16:13+0100\n" "Last-Translator: Nicolas Gibaud \n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -25,77 +25,65 @@ msgstr "**Code source :** :source:`Lib/typing.py`" #: library/typing.rst:14 msgid "" -"The Python runtime does not enforce function and variable type annotations. " -"They can be used by third party tools such as type checkers, IDEs, linters, " -"etc." +"The Python runtime does not enforce function and variable type annotations. 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 " -"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." +"Le moteur d'exécution Python n'applique pas les annotations de type pour les 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." #: library/typing.rst:20 msgid "" -"This module provides runtime support for type hints. The most fundamental " -"support consists of the types :data:`Any`, :data:`Union`, :data:`Callable`, :" -"class:`TypeVar`, and :class:`Generic`. For a full specification, please see :" -"pep:`484`. For a simplified introduction to type hints, see :pep:`483`." +"This module provides runtime support for type hints. The most fundamental support consists of the types :" +"data:`Any`, :data:`Union`, :data:`Callable`, :class:`TypeVar`, and :class:`Generic`. For a full " +"specification, please see :pep:`484`. For a simplified introduction to type hints, see :pep:`483`." msgstr "" -"Ce module fournit la gestion des annotations de type à l'exécution. La prise " -"en compte de base comprend les types :data:`Any`, :data:`Union`, :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`." +"Ce module fournit la gestion des annotations de type à l'exécution. La prise en compte de base comprend " +"les types :data:`Any`, :data:`Union`, :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`." #: library/typing.rst:26 -msgid "" -"The function below takes and returns a string and is annotated as follows::" -msgstr "" -"La fonction ci-dessous prend et renvoie une chaîne de caractères, et est " -"annotée comme suit ::" +msgid "The function below takes and returns a string and is annotated as follows::" +msgstr "La fonction ci-dessous prend et renvoie une chaîne de caractères, et est annotée comme suit ::" #: library/typing.rst:31 msgid "" -"In the function ``greeting``, the argument ``name`` is expected to be of " -"type :class:`str` and the return type :class:`str`. Subtypes are accepted as " -"arguments." +"In the function ``greeting``, the argument ``name`` is expected to be of type :class:`str` and the return " +"type :class:`str`. Subtypes are accepted as arguments." msgstr "" -"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." +"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." #: library/typing.rst:35 msgid "" -"New features are frequently added to the ``typing`` module. The " -"`typing_extensions `_ package " -"provides backports of these new features to older versions of Python." -msgstr "Le module ``typing`` est fréquemment enrichi de nouvelles " -"fonctionnalités. Le package " -"`typing_extensions `_ fournit " -"des rétroportages de ces fonctionnalités vers les anciennes versions de Python." -"De nouvelles fonctionnalités sont souvent ajoutées au module ``typing``. Le " -"package `typing_extensions `_ " -"fournit des portages de ces nouvelles fonctionnalités aux versions " -"précédentes de Python." +"New features are frequently added to the ``typing`` module. The `typing_extensions `_ package provides backports of these new features to older versions of Python." +msgstr "" +"Le module ``typing`` est fréquemment enrichi de nouvelles fonctionnalités. Le package `typing_extensions " +"`_ fournit des rétroportages de ces fonctionnalités vers les " +"anciennes versions de Python.De nouvelles fonctionnalités sont souvent ajoutées au module ``typing``. Le " +"package `typing_extensions `_ fournit des portages de ces " +"nouvelles fonctionnalités aux versions précédentes de Python." #: library/typing.rst:39 msgid "" -"For a summary of deprecated features and a deprecation timeline, please see " -"`Deprecation Timeline of Major Features`_." -msgstr "Pour un résumé des fonctionnalités obsolètes et leur planification d'obsolescence, " -"consultez les `Etapes d'Obsolescence des Fonctionnalités Majeures`_." -"Pour un résumé des fonctionnalités obsolètes et celles qui vont bientôt " -"l'être, voir ``Deprecation Timeline of Major Features``_." +"For a summary of deprecated features and a deprecation timeline, please see `Deprecation Timeline of Major " +"Features`_." +msgstr "" +"Pour un résumé des fonctionnalités obsolètes et leur planification d'obsolescence, consultez les `Etapes " +"d'Obsolescence des Fonctionnalités Majeures`_.Pour un résumé des fonctionnalités obsolètes et celles qui " +"vont bientôt l'être, voir ``Deprecation Timeline of Major Features``_." #: library/typing.rst:44 msgid "" -"The documentation at https://typing.readthedocs.io/ serves as useful " -"reference for type system features, useful typing related tools and typing " -"best practices." -msgstr "La documentation https://typing.readthedocs.io/ est une référence utile pour " -"les fonctionnalités du système de types, les outils liés au typage et les bonnes pratiques de typage." -"La documentation sur https://typing.readthedocs.io/ sert de référence pour " -"les fonctionnalités, les outils utiles et les meilleures pratiques liés au " -"système de typage." +"The documentation at https://typing.readthedocs.io/ serves as useful reference for type system features, " +"useful typing related tools and typing best practices." +msgstr "" +"La documentation https://typing.readthedocs.io/ est une référence utile pour les fonctionnalités du " +"système de types, les outils liés au typage et les bonnes pratiques de typage.La documentation sur https://" +"typing.readthedocs.io/ sert de référence pour les fonctionnalités, les outils utiles et les meilleures " +"pratiques liés au système de typage." #: library/typing.rst:51 msgid "Relevant PEPs" @@ -103,55 +91,49 @@ msgstr "PEPs pertinentes" #: library/typing.rst:53 msgid "" -"Since the initial introduction of type hints in :pep:`484` and :pep:`483`, a " -"number of PEPs have modified and enhanced Python's framework for type " -"annotations. These include:" -msgstr "Depuis l'ajout des annotations de type dans les :pep:`484` and :pep:`483`, plusieurs " -"PEPs ont été modifiées et améliorées dans le framework des annotations de type de Python, parmi lesquelles:" -"Depuis l'introduction initiale des indications de type dans les :pep:`484` " -"et :pep:`483`, plusieurs PEPs ont modifiés et améliorés le framework " -"d'annotation de type. Cela inclut :" +"Since the initial introduction of type hints in :pep:`484` and :pep:`483`, a number of PEPs have modified " +"and enhanced Python's framework for type annotations. These include:" +msgstr "" +"Depuis l'ajout des annotations de type dans les :pep:`484` and :pep:`483`, plusieurs PEPs ont été " +"modifiées et améliorées dans le framework des annotations de type de Python, parmi lesquelles:Depuis " +"l'introduction initiale des indications de type dans les :pep:`484` et :pep:`483`, plusieurs PEPs ont " +"modifiés et améliorés le framework d'annotation de type. Cela inclut :" #: library/typing.rst:58 msgid ":pep:`526`: Syntax for Variable Annotations" msgstr ":pep:`526`: Syntaxe pour les Annotations de Variables" #: library/typing.rst:58 -msgid "" -"*Introducing* syntax for annotating variables outside of function " -"definitions, and :data:`ClassVar`" -msgstr "*Ajout* de la syntaxe pour l'annotation des variables à l'extérieur des " -"definitions de fonctions, et :data:`ClassVar`" -"*Introduction* d'une syntaxe permettant d'annoter les variables autrement " -"qu'au sein de la définition d'une fonction et de :data:`ClassVar`" +msgid "*Introducing* syntax for annotating variables outside of function definitions, and :data:`ClassVar`" +msgstr "" +"*Ajout* de la syntaxe pour l'annotation des variables à l'extérieur des definitions de fonctions, et :data:" +"`ClassVar`*Introduction* d'une syntaxe permettant d'annoter les variables autrement qu'au sein de la " +"définition d'une fonction et de :data:`ClassVar`" #: library/typing.rst:61 msgid ":pep:`544`: Protocols: Structural subtyping (static duck typing)" msgstr ":pep:`544`: Protocoles : Sous-typage Structurel (*duck-typing* statique)" #: library/typing.rst:61 -msgid "" -"*Introducing* :class:`Protocol` and the :func:" -"`@runtime_checkable` decorator" -msgstr "*Ajout* de :class:`Protocol` et du décorateur :func:" -"`@runtime_checkable`" -"*Introduction* :class:`Protocol` et le décorateur :func:" -"`@runtime_checkable`" +msgid "*Introducing* :class:`Protocol` and the :func:`@runtime_checkable` decorator" +msgstr "" +"*Ajout* de :class:`Protocol` et du décorateur :func:`@runtime_checkable`*Introduction* :" +"class:`Protocol` et le décorateur :func:`@runtime_checkable`" #: library/typing.rst:64 msgid ":pep:`585`: Type Hinting Generics In Standard Collections" -msgstr ":pep:`585`: Annotations de Type Générique dans les Collections Standard" -":pep:`585`: Déclaration générique des types dans les collections natives" +msgstr "" +":pep:`585`: Annotations de Type Générique dans les Collections Standard:pep:`585`: Déclaration générique " +"des types dans les collections natives" #: library/typing.rst:64 msgid "" -"*Introducing* :class:`types.GenericAlias` and the ability to use standard " -"library classes as :ref:`generic types`" -msgstr "*Ajout* de :class:`types.GenericAlias` et de la possibilité d'utiliser" -"less classes de bibliothèques telles que :ref:`generic types`" -"*Introduction* :class:`types.GenericAlias` et la capacité à utiliser les " -"classes des librairies standards comme :ref:`types génériques`" +"*Introducing* :class:`types.GenericAlias` and the ability to use standard library classes as :ref:`generic " +"types`" +msgstr "" +"*Ajout* de :class:`types.GenericAlias` et de la possibilité d'utiliserless classes de bibliothèques telles " +"que :ref:`generic types`*Introduction* :class:`types.GenericAlias` et la capacité à " +"utiliser les classes des librairies standards comme :ref:`types génériques`" #: library/typing.rst:66 msgid ":pep:`586`: Literal Types" @@ -162,10 +144,8 @@ msgid "*Introducing* :data:`Literal`" msgstr "*Ajout* de :data:`Literal`" #: library/typing.rst:68 -msgid "" -":pep:`589`: TypedDict: Type Hints for Dictionaries with a Fixed Set of Keys" -msgstr "" -":pep:`589`: TypedDict: Annotations de Type pour les Dictionnaires ayant un Ensemble Fixe de Clés" +msgid ":pep:`589`: TypedDict: Type Hints for Dictionaries with a Fixed Set of Keys" +msgstr ":pep:`589`: TypedDict: Annotations de Type pour les Dictionnaires ayant un Ensemble Fixe de Clés" #: library/typing.rst:69 msgid "*Introducing* :class:`TypedDict`" @@ -193,10 +173,11 @@ msgstr ":pep:`604`: Permettre l'écriture de types union tels que ``X | Y``" #: library/typing.rst:75 msgid "" -"*Introducing* :data:`types.UnionType` and the ability to use the binary-or " -"operator ``|`` to signify a :ref:`union of types`" -msgstr "*Ajout* de :data:`types.UnionType` et la possibilité d'utiliser l'opérateur" -"binaire ``|`` (*ou*) pour signifier :ref:`union of types`" +"*Introducing* :data:`types.UnionType` and the ability to use the binary-or operator ``|`` to signify a :" +"ref:`union of types`" +msgstr "" +"*Ajout* de :data:`types.UnionType` et la possibilité d'utiliser l'opérateurbinaire ``|`` (*ou*) pour " +"signifier :ref:`union of types`" #: library/typing.rst:78 msgid ":pep:`612`: Parameter Specification Variables" @@ -232,11 +213,8 @@ msgid "*Introducing* :data:`TypeGuard`" msgstr "*Ajout* de :data:`TypeGuard`" #: library/typing.rst:86 -msgid "" -":pep:`655`: Marking individual TypedDict items as required or potentially " -"missing" -msgstr "" -":pep:`655`: Marquer les items individuels TypedDict comme nécessaires ou potentiellement manquants" +msgid ":pep:`655`: Marking individual TypedDict items as required or potentially missing" +msgstr ":pep:`655`: Marquer les items individuels TypedDict comme nécessaires ou potentiellement manquants" #: library/typing.rst:87 msgid "*Introducing* :data:`Required` and :data:`NotRequired`" @@ -263,10 +241,9 @@ msgid ":pep:`681`: Data Class Transforms" msgstr ":pep:`681`: Transformateurs de Classes de Données" #: library/typing.rst:93 -msgid "" -"*Introducing* the :func:`@dataclass_transform` decorator" -msgstr "*Ajout* du décorateur :func:`@dataclass_transform`" -"*Introduction* au décorateur :func:" +msgid "*Introducing* the :func:`@dataclass_transform` decorator" +msgstr "" +"*Ajout* du décorateur :func:`@dataclass_transform`*Introduction* au décorateur :func:" "`@dataclass_transform`" #: library/typing.rst:98 @@ -276,28 +253,20 @@ msgstr "Alias de type" #: library/typing.rst:100 #, fuzzy 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::" +"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 affectant le type à l'alias. Dans cet " -"exemple, ``Vector`` et ``List[float]`` sont traités comme des synonymes " -"interchangeables ::" +"Un alias de type est défini en affectant le type à l'alias. Dans cet exemple, ``Vector`` et " +"``List[float]`` sont traités comme des synonymes interchangeables ::" #: library/typing.rst:111 -msgid "" -"Type aliases are useful for simplifying complex type signatures. For " -"example::" -msgstr "" -"Les alias de type sont utiles pour simplifier les signatures complexes. Par " -"exemple ::" +msgid "Type aliases are useful for simplifying complex type signatures. For example::" +msgstr "Les alias de type sont utiles pour simplifier les signatures complexes. Par exemple ::" #: library/typing.rst:129 -msgid "" -"Note that ``None`` as a type hint is a special case and is replaced by " -"``type(None)``." +msgid "Note that ``None`` as a type hint is a special case and is replaced by ``type(None)``." msgstr "" -"Notez que ``None`` comme annotation de type est un cas particulier et est " -"remplacé par ``type(None)``." +"Notez que ``None`` comme annotation de type est un cas particulier et est remplacé par ``type(None)``." #: library/typing.rst:135 msgid "NewType" @@ -305,65 +274,53 @@ msgstr "*NewType*" #: library/typing.rst:137 msgid "Use the :class:`NewType` helper to create distinct types::" -msgstr "" -"Utilisez la classe :class:`NewType` pour créer des types distincts ::" +msgstr "Utilisez la classe :class:`NewType` pour créer des types distincts ::" #: library/typing.rst:144 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::" +"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 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 ::" +"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 ::" #: library/typing.rst:156 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::" +"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::" 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 ::" #: library/typing.rst:164 msgid "" -"Note that these checks are enforced only by the static type checker. At " -"runtime, the statement ``Derived = NewType('Derived', Base)`` will make " -"``Derived`` a callable that immediately returns whatever parameter you pass " -"it. That means the expression ``Derived(some_value)`` does not create a new " -"class or introduce much overhead beyond that of a regular function call." +"Note that these checks are enforced only by the static type checker. At runtime, the statement ``Derived = " +"NewType('Derived', Base)`` will make ``Derived`` a callable that immediately returns whatever parameter " +"you pass it. That means the expression ``Derived(some_value)`` does not create a new class or introduce " +"much 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. À 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 et n'introduit pas " -"de surcharge au-delà de celle d'un appel de fonction normal." +"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 paramètre que vous lui passez. Cela signifie que l'expression ``Derived(some_value)`` ne " +"crée pas une nouvelle classe et n'introduit pas de surcharge au-delà de celle d'un appel de fonction " +"normal." #: library/typing.rst:170 -msgid "" -"More precisely, the expression ``some_value is Derived(some_value)`` is " -"always true at runtime." +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." +"Plus précisément, l'expression ``some_value is Derived(some_value)`` est toujours vraie au moment de " +"l'exécution." #: library/typing.rst:173 msgid "It is invalid to create a subtype of ``Derived``::" msgstr "La création d'un sous-type de ``Derived`` est invalide:" #: library/typing.rst:182 -msgid "" -"However, it is possible to create a :class:`NewType` based on a 'derived' " -"``NewType``::" -msgstr "" -"Il est néanmoins possible de créer un :class:`NewType` basé sur un " -"``NewType`` « dérivé » ::" +msgid "However, it is possible to create a :class:`NewType` based on a 'derived' ``NewType``::" +msgstr "Il est néanmoins possible de créer un :class:`NewType` basé sur un ``NewType`` « dérivé » ::" #: library/typing.rst:190 msgid "and typechecking for ``ProUserId`` will work as expected." @@ -375,43 +332,35 @@ msgstr "Voir la :pep:`484` pour plus de détails." #: library/typing.rst:196 msgid "" -"Recall that the use of a type alias declares two types to be *equivalent* to " -"one another. Doing ``Alias = Original`` will make the static type checker " -"treat ``Alias`` as being *exactly equivalent* to ``Original`` in all cases. " -"This is useful when you want to simplify complex type signatures." +"Recall that the use of a type alias declares two types to be *equivalent* to one another. Doing ``Alias = " +"Original`` will make the static type checker 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. É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." +"Rappelons que l'utilisation d'un alias de type déclare que deux types sont *é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." #: library/typing.rst:201 msgid "" -"In contrast, ``NewType`` declares one type to be a *subtype* of another. " -"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." +"In contrast, ``NewType`` declares one type to be a *subtype* of another. 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." msgstr "" -"En revanche, ``NewType`` déclare qu'un type est un *sous-type* d'un autre. " -"Écrire ``Derived = NewType('Derived', Original)`` fait 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. C'est utile lorsque vous voulez éviter les erreurs logiques avec un " -"coût d'exécution minimal." +"En revanche, ``NewType`` déclare qu'un type est un *sous-type* d'un autre. Écrire ``Derived = " +"NewType('Derived', Original)`` fait 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. C'est utile lorsque vous voulez éviter les " +"erreurs logiques avec un coût d'exécution minimal." #: library/typing.rst:210 msgid "" -"``NewType`` is now a class rather than a function. There is some additional " -"runtime cost when calling ``NewType`` over a regular function. However, " -"this cost will be reduced in 3.11.0." +"``NewType`` is now a class rather than a function. There is some additional runtime cost when calling " +"``NewType`` over a regular function. However, this cost will be reduced in 3.11.0." msgstr "" -"``NewType`` est maintenant une classe (plutôt qu'une fonction). Cela " -"entraine un coût supplémentaire en temps d'exécution lors d'un appel. " -"Cependant, ce coût sera réduit dans la version 3.11.0." +"``NewType`` est maintenant une classe (plutôt qu'une fonction). Cela entraine un coût supplémentaire en " +"temps d'exécution lors d'un appel. Cependant, ce coût sera réduit dans la version 3.11.0." #: library/typing.rst:217 msgid "Callable" @@ -419,12 +368,11 @@ msgstr "Appelable" #: library/typing.rst:219 msgid "" -"Frameworks expecting callback functions of specific signatures might be type " -"hinted using ``Callable[[Arg1Type, Arg2Type], ReturnType]``." -msgstr "" -"Les cadriciels (*frameworks* en anglais) qui attendent des fonctions de " -"rappel ayant des signatures spécifiques peuvent être typés en utilisant " +"Frameworks expecting callback functions of specific signatures might be type hinted using " "``Callable[[Arg1Type, Arg2Type], ReturnType]``." +msgstr "" +"Les cadriciels (*frameworks* en anglais) qui attendent des fonctions de rappel ayant des signatures " +"spécifiques peuvent être typés en utilisant ``Callable[[Arg1Type, Arg2Type], ReturnType]``." #: library/typing.rst:1164 library/typing.rst:2801 msgid "For example::" @@ -432,46 +380,41 @@ msgstr "Par exemple ::" #: library/typing.rst:237 msgid "" -"It is possible to declare the return type of a callable without specifying " -"the call signature by substituting a literal ellipsis for the list of " -"arguments in the type hint: ``Callable[..., ReturnType]``." +"It is possible to declare the return type of a callable without specifying 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 indiquant des points de suspension à la liste des " -"arguments dans l'indice de type : ``Callable[..., ReturnType]``." +"Il est possible de déclarer le type de retour d'un appelable sans spécifier la signature de l'appel en " +"indiquant des points de suspension à la liste des arguments dans l'indice de type : ``Callable[..., " +"ReturnType]``." #: library/typing.rst:843 msgid "" -"Callables which take other callables as arguments may indicate that their " -"parameter types are dependent on each other using :class:`ParamSpec`. " -"Additionally, if that callable adds or removes arguments from other " -"callables, the :data:`Concatenate` operator may be used. They take the form " -"``Callable[ParamSpecVariable, ReturnType]`` and " -"``Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], " -"ReturnType]`` respectively." +"Callables which take other callables as arguments may indicate that their parameter types are dependent on " +"each other using :class:`ParamSpec`. Additionally, if that callable adds or removes arguments from other " +"callables, the :data:`Concatenate` operator may be used. They take the form ``Callable[ParamSpecVariable, " +"ReturnType]`` and ``Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], ReturnType]`` " +"respectively." msgstr "" -"Les appelables qui prennent en argument d'autres appelables peuvent indiquer que leurs types de paramètres" -"dépendent les uns des autres en utilisant :class:`ParamSpec`. " -"De plus, si un appelable ajoute ou supprime des arguments d'autres" -"callables, l'opérateur :data:`Concatenate` peut être utilisé. Ils prennent la forme " -"``Callable[ParamSpecVariable, ReturnType]`` et " -"``Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], " -"ReturnType]`` respectivement." +"Les appelables qui prennent en argument d'autres appelables peuvent indiquer que leurs types de " +"paramètresdépendent les uns des autres en utilisant :class:`ParamSpec`. De plus, si un appelable ajoute ou " +"supprime des arguments d'autrescallables, l'opérateur :data:`Concatenate` peut être utilisé. Ils prennent " +"la forme ``Callable[ParamSpecVariable, ReturnType]`` et ``Callable[Concatenate[Arg1Type, Arg2Type, ..., " +"ParamSpecVariable], ReturnType]`` respectivement." #: library/typing.rst:855 msgid "" -"``Callable`` now supports :class:`ParamSpec` and :data:`Concatenate`. See :" -"pep:`612` for more details." +"``Callable`` now supports :class:`ParamSpec` and :data:`Concatenate`. See :pep:`612` for more details." msgstr "" -"``Callable`` prend désormais en charge :class:`ParamSpec` et :data:`Concatenate`. See :" -"pep:`612` for more details." +"``Callable`` prend désormais en charge :class:`ParamSpec` et :data:`Concatenate`. See :pep:`612` for more " +"details." #: library/typing.rst:254 msgid "" -"The documentation for :class:`ParamSpec` and :class:`Concatenate` provides " -"examples of usage in ``Callable``." -msgstr "La documentation pour :class:`ParamSpec` et :class:`Concatenate` fournit des " -"exemples d'utilisation dans ``Callable``." +"The documentation for :class:`ParamSpec` and :class:`Concatenate` provides examples of usage in " +"``Callable``." +msgstr "" +"La documentation pour :class:`ParamSpec` et :class:`Concatenate` fournit des exemples d'utilisation dans " +"``Callable``." #: library/typing.rst:260 msgid "Generics" @@ -479,24 +422,20 @@ msgstr "Génériques" #: library/typing.rst:262 msgid "" -"Since type information about objects kept in containers cannot be statically " -"inferred in a generic way, abstract base classes have been extended to " -"support subscription to denote expected types for container elements." +"Since type information about objects kept in containers cannot be statically 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 " -"mères abstraites ont été étendues pour prendre en charge la sélection " -"(*subscription* en anglais) et indiquer les types attendus pour les éléments " -"de conteneur." +"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 mères abstraites ont été étendues pour prendre en charge la " +"sélection (*subscription* en anglais) et indiquer les types attendus pour les éléments de conteneur." #: library/typing.rst:273 #, fuzzy -msgid "" -"Generics can be parameterized by using a factory available in typing called :" -"class:`TypeVar`." +msgid "Generics can be parameterized by using a 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`." #: library/typing.rst:289 msgid "User-defined generic types" @@ -504,56 +443,46 @@ msgstr "Types génériques définis par l'utilisateur" #: library/typing.rst:291 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." +msgstr "Une classe définie par l'utilisateur peut être définie comme une classe générique." #: library/typing.rst:317 msgid "" -"``Generic[T]`` as a base class defines that the class ``LoggedVar`` takes a " -"single type parameter ``T`` . This also makes ``T`` valid as a type within " -"the class body." +"``Generic[T]`` as a base class defines that the class ``LoggedVar`` takes a single type parameter ``T`` . " +"This also makes ``T`` valid as a type within the class body." msgstr "" -"``Generic[T]`` en tant que classe mère 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." +"``Generic[T]`` en tant que classe mère 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." #: library/typing.rst:321 #, fuzzy msgid "" -"The :class:`Generic` base class defines :meth:`~object.__class_getitem__` so " -"that ``LoggedVar[T]`` is valid as a type::" +"The :class:`Generic` base class defines :meth:`~object.__class_getitem__` so that ``LoggedVar[T]`` is " +"valid as a type::" msgstr "" -"La classe mère :class:`Generic` définit :meth:`__class_getitem__` de sorte " -"que ``LoggedVar[t]`` est valide comme type ::" +"La classe mère :class:`Generic` définit :meth:`__class_getitem__` de sorte que ``LoggedVar[t]`` est valide " +"comme type ::" #: library/typing.rst:330 #, fuzzy msgid "" -"A generic type can have any number of type variables. All varieties of :" -"class:`TypeVar` are permissible as parameters for a generic type::" +"A generic type can have any number of type variables. All varieties of :class:`TypeVar` are permissible as " +"parameters for a generic type::" msgstr "" -"Un type générique peut avoir un nombre quelconque de variables de type et " -"vous pouvez fixer des contraintes sur les variables de type ::" +"Un type générique peut avoir un nombre quelconque de variables de type et vous pouvez fixer des " +"contraintes sur les variables de type ::" #: library/typing.rst:342 -msgid "" -"Each type variable argument to :class:`Generic` must be distinct. This is " -"thus invalid::" +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 ::" #: library/typing.rst:353 msgid "You can use multiple inheritance with :class:`Generic`::" msgstr "Vous pouvez utiliser l'héritage multiple avec :class:`Generic` ::" #: library/typing.rst:363 -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 ::" +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 ::" #: library/typing.rst:373 msgid "In this case ``MyDict`` has a single parameter, ``T``." @@ -561,20 +490,16 @@ msgstr "Dans ce cas, ``MyDict`` a un seul paramètre, ``T``." #: library/typing.rst:375 msgid "" -"Using a generic class without specifying type parameters assumes :data:`Any` " -"for each position. In the following example, ``MyIterable`` is not generic " -"but implicitly inherits from ``Iterable[Any]``::" +"Using a generic class without specifying type parameters assumes :data:`Any` 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 " +"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]`` ::" #: library/typing.rst:383 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 ::" +msgstr "Les alias de type générique définis par l'utilisateur sont également pris en charge. Exemples ::" #: library/typing.rst:400 msgid ":class:`Generic` no longer has a custom metaclass." @@ -582,47 +507,41 @@ msgstr ":class:`Generic` n'a plus de métaclasse personnalisée." #: library/typing.rst:403 msgid "" -"User-defined generics for parameter expressions are also supported via " -"parameter specification variables in the form ``Generic[P]``. The behavior " -"is consistent with type variables' described above as parameter " -"specification variables are treated by the typing module as a specialized " -"type variable. The one exception to this is that a list of types can be " -"used to substitute a :class:`ParamSpec`::" +"User-defined generics for parameter expressions are also supported via parameter specification variables " +"in the form ``Generic[P]``. The behavior is consistent with type variables' described above as parameter " +"specification variables are treated by the typing module as a specialized type variable. The one " +"exception to this is that a list of types can be used to substitute a :class:`ParamSpec`::" msgstr "" #: library/typing.rst:420 msgid "" -"Furthermore, a generic with only one parameter specification variable will " -"accept parameter lists in the forms ``X[[Type1, Type2, ...]]`` and also " -"``X[Type1, Type2, ...]`` for aesthetic reasons. Internally, the latter is " -"converted to the former, so the following are equivalent::" +"Furthermore, a generic with only one parameter specification variable will accept parameter lists in the " +"forms ``X[[Type1, Type2, ...]]`` and also ``X[Type1, Type2, ...]`` for aesthetic reasons. Internally, the " +"latter is converted to the former, so the following are equivalent::" msgstr "" #: library/typing.rst:432 msgid "" -"Do note that generics with :class:`ParamSpec` may not have correct " -"``__parameters__`` after substitution in some cases because they are " -"intended primarily for static type checking." +"Do note that generics with :class:`ParamSpec` may not have correct ``__parameters__`` after substitution " +"in some cases because they are intended primarily for static type checking." msgstr "" #: library/typing.rst:436 msgid "" -":class:`Generic` can now be parameterized over parameter expressions. See :" -"class:`ParamSpec` and :pep:`612` for more details." +":class:`Generic` can now be parameterized over parameter expressions. See :class:`ParamSpec` and :pep:" +"`612` for more details." msgstr "" #: library/typing.rst:440 msgid "" -"A user-defined generic class can have ABCs as base classes without a " -"metaclass conflict. Generic metaclasses are not supported. The outcome of " -"parameterizing generics is cached, and most types in the typing module are " -"hashable and comparable for equality." +"A user-defined generic class can have ABCs as base classes without a metaclass conflict. Generic " +"metaclasses are not supported. The outcome of 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 classes mères " -"abstraites (ABC pour *Abstract Base Classes* en anglais) 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 classes mères abstraites (ABC pour *Abstract " +"Base Classes* en anglais) 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é." #: library/typing.rst:447 msgid "The :data:`Any` type" @@ -630,87 +549,76 @@ msgstr "Le type :data:`Any`" #: library/typing.rst:449 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 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." #: library/typing.rst:453 #, fuzzy msgid "" -"This means that it is possible to perform any operation or method call on a " -"value of type :data:`Any` and assign it to any variable::" +"This means that it is possible to perform any operation or method call on a value of type :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 ::" +"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 ::" #: library/typing.rst:471 #, fuzzy msgid "" -"Notice that no type checking 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 type checking 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 " -"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 !" +"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 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 !" #: library/typing.rst:477 msgid "" -"Furthermore, all functions without a return type or parameter types will " -"implicitly default to using :data:`Any`::" +"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 sont " -"considérées comme utilisant :data:`Any` implicitement par défaut ::" +"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 ::" #: library/typing.rst:490 msgid "" -"This behavior allows :data:`Any` to be used as an *escape hatch* when you " -"need to mix dynamically and statically typed code." +"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 succédané lorsque " -"vous avez besoin de mélanger du code typé dynamiquement et statiquement." +"Ce comportement permet à :data:`Any` d'être utilisé comme succédané lorsque vous avez besoin de mélanger " +"du code typé dynamiquement et statiquement." #: library/typing.rst:493 msgid "" -"Contrast the behavior of :data:`Any` with the behavior of :class:`object`. " -"Similar to :data:`Any`, every type is a subtype of :class:`object`. However, " -"unlike :data:`Any`, the reverse is not true: :class:`object` is *not* a " -"subtype of every other type." +"Contrast the behavior of :data:`Any` with the behavior of :class:`object`. Similar to :data:`Any`, every " +"type is a subtype of :class:`object`. However, unlike :data:`Any`, the reverse is not true: :class:" +"`object` is *not* a subtype of every other type." msgstr "" -"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." +"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." #: library/typing.rst:498 msgid "" -"That means when the type of a value is :class:`object`, a type checker will " -"reject almost all operations on it, and assigning it to a variable (or using " -"it as a return value) of a more specialized type is a type error. For " -"example::" +"That means when the type of a value is :class:`object`, a type checker will reject almost all operations " +"on it, and assigning it to a variable (or using 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 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 ::" +"Cela signifie que lorsque le type d'une valeur est :class:`object`, un 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 ::" #: library/typing.rst:520 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." +"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 de n'importe " -"quel type de manière sûre. Utiliser :data:`Any` pour indiquer qu'une valeur " -"est typée dynamiquement." +"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 typée dynamiquement." #: library/typing.rst:525 msgid "Nominal vs structural subtyping" @@ -719,55 +627,45 @@ msgstr "Sous-typage nominal et sous-typage structurel" #: library/typing.rst:527 #, fuzzy msgid "" -"Initially :pep:`484` defined the Python static type system as using *nominal " -"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``." +"Initially :pep:`484` defined the Python static type system as using *nominal 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``." #: library/typing.rst:531 #, fuzzy msgid "" -"This requirement previously also applied to abstract base classes, such as :" -"class:`~collections.abc.Iterable`. The problem with this approach is that a " -"class had to be explicitly marked to support them, which is unpythonic and " -"unlike what one would normally do in idiomatic dynamically typed Python " -"code. For example, this conforms to :pep:`484`::" +"This requirement previously also applied to abstract base classes, such as :class:`~collections.abc." +"Iterable`. The problem with this approach is that a class had to be explicitly marked to support them, " +"which is unpythonic and unlike what one would normally do in idiomatic dynamically typed Python code. For " +"example, this conforms to :pep:`484`::" msgstr "" -"Ce pré-requis s'appliquait auparavant aussi aux classes mères 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 à la :" -"pep:`484` ::" +"Ce pré-requis s'appliquait auparavant aussi aux classes mères 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 à la :pep:`484` ::" #: library/typing.rst:544 msgid "" -":pep:`544` allows to solve this problem by allowing users to write the above " -"code without explicit base classes in the class definition, allowing " -"``Bucket`` to be implicitly considered a subtype of both ``Sized`` and " -"``Iterable[int]`` by static type checkers. This is known as *structural " -"subtyping* (or static duck-typing)::" +":pep:`544` allows to solve this problem by allowing users to write the above code without explicit base " +"classes in the class definition, allowing ``Bucket`` to be implicitly considered a subtype of both " +"``Sized`` and ``Iterable[int]`` by static type checkers. This is known as *structural subtyping* (or " +"static duck-typing)::" msgstr "" -"La :pep:`544` permet de résoudre ce problème en permettant aux utilisateurs " -"d'écrire le code ci-dessus sans classes mères 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) ::" +"La :pep:`544` permet de résoudre ce problème en permettant aux utilisateurs d'écrire le code ci-dessus " +"sans classes mères 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) ::" #: library/typing.rst:560 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 " -"pleinement du sous-typage structurel (voir exemples ci-dessous)." +"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)." #: library/typing.rst:565 msgid "Module contents" @@ -780,25 +678,23 @@ msgstr "Ce module définit les classes, fonctions et décorateurs suivants :" #: library/typing.rst:571 msgid "" -"This module defines several types that are subclasses of pre-existing " -"standard library classes which also extend :class:`Generic` to support type " -"variables inside ``[]``. These types became redundant in Python 3.9 when the " -"corresponding pre-existing classes were enhanced to support ``[]``." +"This module defines several types that are subclasses of pre-existing standard library classes which also " +"extend :class:`Generic` to support type variables inside ``[]``. These types became redundant in Python " +"3.9 when the corresponding pre-existing classes were enhanced to support ``[]``." msgstr "" #: library/typing.rst:577 msgid "" -"The redundant types are deprecated as of Python 3.9 but no deprecation " -"warnings will be issued by the interpreter. It is expected that type " -"checkers will flag the deprecated types when the checked program targets " -"Python 3.9 or newer." +"The redundant types are deprecated as of Python 3.9 but no deprecation warnings will be issued by the " +"interpreter. It is expected that type checkers will flag the deprecated types when the checked program " +"targets Python 3.9 or newer." msgstr "" #: library/typing.rst:582 msgid "" -"The deprecated types will be removed from the :mod:`typing` module in the " -"first Python version released 5 years after the release of Python 3.9.0. See " -"details in :pep:`585`—*Type Hinting Generics In Standard Collections*." +"The deprecated types will be removed from the :mod:`typing` module in the first Python version released 5 " +"years after the release of Python 3.9.0. See details in :pep:`585`—*Type Hinting Generics In Standard " +"Collections*." msgstr "" #: library/typing.rst:588 @@ -828,16 +724,14 @@ msgstr ":data:`Any` est compatible avec tous les types." #: library/typing.rst:602 msgid "" -":data:`Any` can now be used as a base class. This can be useful for avoiding " -"type checker errors with classes that can duck type anywhere or are highly " -"dynamic." +":data:`Any` can now be used as a base class. This can be useful for avoiding type checker errors with " +"classes that can duck type anywhere or are highly dynamic." msgstr "" #: library/typing.rst:609 msgid "" -"Special type that includes only literal strings. A string literal is " -"compatible with ``LiteralString``, as is another ``LiteralString``, but an " -"object typed as just ``str`` is not. A string created by composing " +"Special type that includes only literal strings. A string literal is compatible with ``LiteralString``, as " +"is another ``LiteralString``, but an object typed as just ``str`` is not. A string created by composing " "``LiteralString``-typed objects is also acceptable as a ``LiteralString``." msgstr "" @@ -848,9 +742,9 @@ msgstr "Par exemple ::" #: library/typing.rst:629 msgid "" -"This is useful for sensitive APIs where arbitrary user-generated strings " -"could generate problems. For example, the two cases above that generate type " -"checker errors could be vulnerable to an SQL injection attack." +"This is useful for sensitive APIs where arbitrary user-generated strings could generate problems. For " +"example, the two cases above that generate type checker errors could be vulnerable to an SQL injection " +"attack." msgstr "" #: library/typing.rst:634 @@ -859,21 +753,17 @@ msgid "See :pep:`675` for more details." msgstr "Voir la :pep:`484` pour plus de détails." #: library/typing.rst:640 -msgid "" -"The `bottom type `_, a type that " -"has no members." +msgid "The `bottom type `_, a type that has no members." msgstr "" #: library/typing.rst:643 -msgid "" -"This can be used to define a function that should never be called, or a " -"function that never returns::" +msgid "This can be used to define a function that should never be called, or a function that never returns::" msgstr "" #: library/typing.rst:663 msgid "" -"On older Python versions, :data:`NoReturn` may be used to express the same " -"concept. ``Never`` was added to make the intended meaning more explicit." +"On older Python versions, :data:`NoReturn` may be used to express the same concept. ``Never`` was added to " +"make the intended meaning more explicit." msgstr "" #: library/typing.rst:668 @@ -882,10 +772,9 @@ msgstr "Type spécial indiquant qu'une fonction ne renvoie rien. Par exemple :: #: library/typing.rst:676 msgid "" -"``NoReturn`` can also be used as a `bottom type `_, a type that has no values. Starting in Python 3.11, " -"the :data:`Never` type should be used for this concept instead. Type " -"checkers should treat the two equivalently." +"``NoReturn`` can also be used as a `bottom type `_, a type that " +"has no values. Starting in Python 3.11, the :data:`Never` type should be used for this concept instead. " +"Type checkers should treat the two equivalently." msgstr "" #: library/typing.rst:687 @@ -894,9 +783,7 @@ msgid "Special type to represent the current enclosed class. For example::" msgstr "Type spécial indiquant qu'une fonction ne renvoie rien. Par exemple ::" #: library/typing.rst:698 -msgid "" -"This annotation is semantically equivalent to the following, albeit in a " -"more succinct fashion::" +msgid "This annotation is semantically equivalent to the following, albeit in a more succinct fashion::" msgstr "" #: library/typing.rst:710 @@ -905,8 +792,8 @@ msgstr "" #: library/typing.rst:717 msgid "" -"You should use :data:`Self` as calls to ``SubclassOfFoo.return_self`` would " -"have ``Foo`` as the return type and not ``SubclassOfFoo``." +"You should use :data:`Self` as calls to ``SubclassOfFoo.return_self`` would have ``Foo`` as the return " +"type and not ``SubclassOfFoo``." msgstr "" #: library/typing.rst:720 @@ -915,8 +802,8 @@ msgstr "" #: library/typing.rst:722 msgid "" -":class:`classmethod`\\s that are used as alternative constructors and return " -"instances of the ``cls`` parameter." +":class:`classmethod`\\s that are used as alternative constructors and return instances of the ``cls`` " +"parameter." msgstr "" #: library/typing.rst:724 @@ -929,9 +816,7 @@ msgid "See :pep:`673` for more details." msgstr "Voir la :pep:`484` pour plus de détails." #: library/typing.rst:732 -msgid "" -"Special annotation for explicitly declaring a :ref:`type alias `. For example::" +msgid "Special annotation for explicitly declaring a :ref:`type alias `. For example::" msgstr "" #: library/typing.rst:739 @@ -944,70 +829,58 @@ msgid "Special forms" msgstr "" #: library/typing.rst:746 -msgid "" -"These can be used as types in annotations using ``[]``, each having a unique " -"syntax." +msgid "These can be used as types in annotations using ``[]``, each having a unique syntax." msgstr "" #: library/typing.rst:750 msgid "" -"Tuple type; ``Tuple[X, Y]`` is the type of a tuple of two items with the " -"first item of type X and the second of type Y. The type of the empty tuple " -"can be written as ``Tuple[()]``." +"Tuple type; ``Tuple[X, Y]`` is the type of a tuple of two items with the 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[()]``." #: library/typing.rst:754 msgid "" -"Example: ``Tuple[T1, T2]`` is a tuple of two elements corresponding to type " -"variables T1 and T2. ``Tuple[int, float, str]`` is a tuple of an int, a " -"float and a string." +"Example: ``Tuple[T1, T2]`` is a tuple of two elements corresponding to type 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é " -"d'un entier, d'un flottant et d'une chaîne de caractères." +"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." #: library/typing.rst:758 msgid "" -"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`." +"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 *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`." +"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`." #: library/typing.rst:762 #, fuzzy msgid "" -":class:`builtins.tuple ` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`builtins.tuple ` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`builtins.tuple ` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`builtins.tuple ` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:768 #, fuzzy -msgid "" -"Union type; ``Union[X, Y]`` is equivalent to ``X | Y`` and means either X or " -"Y." +msgid "Union type; ``Union[X, Y]`` is equivalent to ``X | Y`` and means either X or Y." msgstr "Type « union » ; ``Union[X, Y]`` signifie X ou Y." #: library/typing.rst:770 #, fuzzy msgid "" -"To define a union, use e.g. ``Union[int, str]`` or the shorthand ``int | " -"str``. Using that shorthand is recommended. Details:" -msgstr "" -"Pour définir une union, utilisez par exemple ``Union[int, str]``. Détail :" +"To define a union, use e.g. ``Union[int, str]`` or the shorthand ``int | str``. Using that shorthand is " +"recommended. Details:" +msgstr "Pour définir une union, utilisez par exemple ``Union[int, str]``. Détail :" #: library/typing.rst:772 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." #: library/typing.rst:774 msgid "Unions of unions are flattened, e.g.::" @@ -1023,9 +896,7 @@ msgstr "Les arguments redondants sont ignorés, par exemple ::" #: library/typing.rst:786 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 ::" +msgstr "Lors de la comparaison d'unions, l'ordre des arguments est ignoré, par exemple ::" #: library/typing.rst:790 #, fuzzy @@ -1041,9 +912,7 @@ msgid "Don't remove explicit subclasses from unions at runtime." msgstr "Ne supprime pas les sous-classes explicites des unions à l'exécution." #: library/typing.rst:797 -msgid "" -"Unions can now be written as ``X | Y``. See :ref:`union type " -"expressions`." +msgid "Unions can now be written as ``X | Y``. See :ref:`union type expressions`." msgstr "" #: library/typing.rst:803 @@ -1057,106 +926,89 @@ msgstr "``Optional[X]`` équivaut à ``Union[X, None]``." #: library/typing.rst:807 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::" +"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::" 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 " -"``Optional`` sur son annotation de type. Par exemple ::" +"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 ``Optional`` sur son annotation de type. Par exemple ::" #: library/typing.rst:815 msgid "" -"On the other hand, if an explicit value of ``None`` is allowed, the use of " -"``Optional`` is appropriate, whether the argument is optional or not. For " -"example::" +"On the other hand, if an explicit value of ``None`` is allowed, the use of ``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 ::" +"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 ::" #: library/typing.rst:822 -msgid "" -"Optional can now be written as ``X | None``. See :ref:`union type " -"expressions`." +msgid "Optional can now be written as ``X | None``. See :ref:`union type expressions`." msgstr "" #: library/typing.rst:828 msgid "Callable type; ``Callable[[int], str]`` is a function of (int) -> str." -msgstr "" -"Type Appelable. ``Callable[[int], str]`` est une fonction de type ``(int) -> " -"str``." +msgstr "Type Appelable. ``Callable[[int], str]`` est une fonction de type ``(int) -> str``." #: library/typing.rst:830 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." +"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." 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." #: library/typing.rst:835 msgid "" -"There is no syntax to indicate optional or keyword arguments; such function " -"types are rarely used as callback types. ``Callable[..., ReturnType]`` " -"(literal ellipsis) can be used to type hint a callable taking any number of " -"arguments and returning ``ReturnType``. A plain :data:`Callable` is " -"equivalent to ``Callable[..., Any]``, and in turn to :class:`collections.abc." -"Callable`." +"There is no syntax to indicate optional or keyword arguments; such function types are rarely used as " +"callback types. ``Callable[..., ReturnType]`` (literal ellipsis) can be used to type hint a callable " +"taking any number of arguments and returning ``ReturnType``. A plain :data:`Callable` is 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`." #: library/typing.rst:851 #, fuzzy msgid "" -":class:`collections.abc.Callable` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Callable` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Callable` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Callable` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:860 msgid "" -"The documentation for :class:`ParamSpec` and :class:`Concatenate` provide " -"examples of usage with ``Callable``." +"The documentation for :class:`ParamSpec` and :class:`Concatenate` provide examples of usage with " +"``Callable``." msgstr "" #: library/typing.rst:865 msgid "" -"Used with :data:`Callable` and :class:`ParamSpec` to type annotate a higher " -"order callable which adds, removes, or transforms parameters of another " -"callable. Usage is in the form ``Concatenate[Arg1Type, Arg2Type, ..., " -"ParamSpecVariable]``. ``Concatenate`` is currently only valid when used as " -"the first argument to a :data:`Callable`. The last parameter to " -"``Concatenate`` must be a :class:`ParamSpec` or ellipsis (``...``)." +"Used with :data:`Callable` and :class:`ParamSpec` to type annotate a higher order callable which adds, " +"removes, or transforms parameters of another callable. Usage is in the form ``Concatenate[Arg1Type, " +"Arg2Type, ..., ParamSpecVariable]``. ``Concatenate`` is currently only valid when used as the first " +"argument to a :data:`Callable`. The last parameter to ``Concatenate`` must be a :class:`ParamSpec` or " +"ellipsis (``...``)." msgstr "" #: library/typing.rst:873 msgid "" -"For example, to annotate a decorator ``with_lock`` which provides a :class:" -"`threading.Lock` to the decorated function, ``Concatenate`` can be used to " -"indicate that ``with_lock`` expects a callable which takes in a ``Lock`` as " -"the first argument, and returns a callable with a different type signature. " -"In this case, the :class:`ParamSpec` indicates that the returned callable's " -"parameter types are dependent on the parameter types of the callable being " -"passed in::" +"For example, to annotate a decorator ``with_lock`` which provides a :class:`threading.Lock` to the " +"decorated function, ``Concatenate`` can be used to indicate that ``with_lock`` expects a callable which " +"takes in a ``Lock`` as the first argument, and returns a callable with a different type signature. In " +"this case, the :class:`ParamSpec` indicates that the returned callable's parameter types are dependent on " +"the parameter types of the callable being passed in::" msgstr "" #: library/typing.rst:1500 msgid "" -":pep:`612` -- Parameter Specification Variables (the PEP which introduced " -"``ParamSpec`` and ``Concatenate``)." +":pep:`612` -- Parameter Specification Variables (the PEP which introduced ``ParamSpec`` and " +"``Concatenate``)." msgstr "" #: library/typing.rst:914 @@ -1165,15 +1017,13 @@ msgstr "" #: library/typing.rst:919 msgid "" -"A variable annotated with ``C`` may accept a value of type ``C``. In " -"contrast, a variable annotated with ``Type[C]`` may accept values that are " -"classes themselves -- specifically, it will accept the *class object* of " -"``C``. For example::" +"A variable annotated with ``C`` may accept a value of type ``C``. In contrast, a variable annotated with " +"``Type[C]`` may accept values that are 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 elles-mêmes des classes — plus précisément, elle accepte l'objet " -"*class* de ``C``. Par exemple ::" +"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 elles-mêmes des classes — plus précisément, elle " +"accepte l'objet *class* de ``C``. Par exemple ::" #: library/typing.rst:928 msgid "Note that ``Type[C]`` is covariant::" @@ -1181,91 +1031,80 @@ msgstr "Notez que ``Type[C]`` est covariant ::" #: library/typing.rst:940 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 " -"particular case may change in future revisions of :pep:`484`." +"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 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 mère indiquée. La façon dont le vérificateur de " -"type est tenu de traiter ce cas particulier peut changer dans les futures " +"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 mère 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`." #: library/typing.rst:948 msgid "" -"The only legal parameters for :class:`Type` are classes, :data:`Any`, :ref:" -"`type variables `, and unions of any of these types. For example::" +"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égitimes pour :class:`Type` sont les classes, :data:" -"`Any`, :ref:`type variables `, et les unions de ces types. Par " -"exemple ::" +"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 ::" #: library/typing.rst:954 msgid "" -"``Type[Any]`` is equivalent to ``Type`` which in turn is equivalent to " -"``type``, which is the root of Python's metaclass hierarchy." +"``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." +"``Type[Any]`` est équivalent à ``Type`` qui à son tour est équivalent à ``type``, qui est la racine de la " +"hiérarchie des métaclasses de Python." #: library/typing.rst:959 #, fuzzy msgid "" -":class:`builtins.type ` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`builtins.type ` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`builtins.type ` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`builtins.type ` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:965 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::" +"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::" 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 ::" #: library/typing.rst:979 msgid "" -"``Literal[...]`` cannot be subclassed. At runtime, an arbitrary value is " -"allowed as type argument to ``Literal[...]``, but type checkers may impose " -"restrictions. See :pep:`586` for more details about literal types." +"``Literal[...]`` cannot be subclassed. At runtime, an arbitrary value is 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 la :pep:" -"`586` pour plus de détails sur les types littéraux." +"``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." #: library/typing.rst:985 msgid "" -"``Literal`` now de-duplicates parameters. Equality comparisons of " -"``Literal`` objects are no longer order dependent. ``Literal`` objects will " -"now raise a :exc:`TypeError` exception during equality comparisons if one of " -"their parameters are not :term:`hashable`." +"``Literal`` now de-duplicates parameters. Equality comparisons of ``Literal`` objects are no longer order " +"dependent. ``Literal`` objects will now raise a :exc:`TypeError` exception during equality comparisons if " +"one of their parameters are not :term:`hashable`." msgstr "" #: library/typing.rst:993 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." #: library/typing.rst:995 msgid "" -"As introduced in :pep:`526`, a variable annotation wrapped in ClassVar " -"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::" +"As introduced in :pep:`526`, a variable annotation wrapped in ClassVar 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 " +"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 ::" #: library/typing.rst:1003 @@ -1274,38 +1113,31 @@ msgstr ":data:`ClassVar` n'accepte que les types et ne peut plus être dérivé. #: library/typing.rst:1005 msgid "" -":data:`ClassVar` is not a class itself, and should not be used with :func:" -"`isinstance` or :func:`issubclass`. :data:`ClassVar` does not change Python " -"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::" +":data:`ClassVar` is not a class itself, and should not be used with :func:`isinstance` or :func:" +"`issubclass`. :data:`ClassVar` does not change Python 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é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 code suivant comme une erreur ::" +":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 code suivant " +"comme une erreur ::" #: library/typing.rst:1019 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 "" -"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 ::" +"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 ::" #: library/typing.rst:2684 -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." +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." #: library/typing.rst:1040 msgid "" -"Special typing constructs that mark individual keys of a :class:`TypedDict` " -"as either required or non-required respectively." +"Special typing constructs that mark individual keys of a :class:`TypedDict` as either required or non-" +"required respectively." msgstr "" #: library/typing.rst:1043 @@ -1315,56 +1147,46 @@ msgstr "Voir la :pep:`484` pour plus de détails." #: library/typing.rst:1049 msgid "" -"A type, introduced in :pep:`593` (``Flexible function and variable " -"annotations``), to decorate existing types with context-specific metadata " -"(possibly multiple pieces of it, as ``Annotated`` is variadic). " -"Specifically, a type ``T`` can be annotated with metadata ``x`` via the " -"typehint ``Annotated[T, x]``. This metadata can be used for either static " -"analysis or at runtime. If a library (or tool) encounters a typehint " -"``Annotated[T, x]`` and has no special logic for metadata ``x``, it should " -"ignore it and simply treat the type as ``T``. Unlike the ``no_type_check`` " -"functionality that currently exists in the ``typing`` module which " -"completely disables typechecking annotations on a function or a class, the " -"``Annotated`` type allows for both static typechecking of ``T`` (which can " -"safely ignore ``x``) together with runtime access to ``x`` within a specific " -"application." +"A type, introduced in :pep:`593` (``Flexible function and variable annotations``), to decorate existing " +"types with context-specific metadata (possibly multiple pieces of it, as ``Annotated`` is variadic). " +"Specifically, a type ``T`` can be annotated with metadata ``x`` via the typehint ``Annotated[T, x]``. This " +"metadata can be used for either static analysis or at runtime. If a library (or tool) encounters a " +"typehint ``Annotated[T, x]`` and has no special logic for metadata ``x``, it should ignore it and simply " +"treat the type as ``T``. Unlike the ``no_type_check`` functionality that currently exists in the " +"``typing`` module which completely disables typechecking annotations on a function or a class, the " +"``Annotated`` type allows for both static typechecking of ``T`` (which can safely ignore ``x``) together " +"with runtime access to ``x`` within a specific application." msgstr "" #: library/typing.rst:1063 msgid "" -"Ultimately, the responsibility of how to interpret the annotations (if at " -"all) is the responsibility of the tool or library encountering the " -"``Annotated`` type. A tool or library encountering an ``Annotated`` type can " -"scan through the annotations to determine if they are of interest (e.g., " -"using ``isinstance()``)." +"Ultimately, the responsibility of how to interpret the annotations (if at all) is the responsibility of " +"the tool or library encountering the ``Annotated`` type. A tool or library encountering an ``Annotated`` " +"type can scan through the annotations to determine if they are of interest (e.g., using ``isinstance()``)." msgstr "" #: library/typing.rst:1069 msgid "" -"When a tool or a library does not support annotations or encounters an " -"unknown annotation it should just ignore it and treat annotated type as the " -"underlying type." +"When a tool or a library does not support annotations or encounters an unknown annotation it should just " +"ignore it and treat annotated type as the underlying type." msgstr "" #: library/typing.rst:1073 msgid "" -"It's up to the tool consuming the annotations to decide whether the client " -"is allowed to have several annotations on one type and how to merge those " -"annotations." +"It's up to the tool consuming the annotations to decide whether the client is allowed to have several " +"annotations on one type and how to merge those annotations." msgstr "" #: library/typing.rst:1077 msgid "" -"Since the ``Annotated`` type allows you to put several annotations of the " -"same (or different) type(s) on any node, the tools or libraries consuming " -"those annotations are in charge of dealing with potential duplicates. For " -"example, if you are doing value range analysis you might allow this::" +"Since the ``Annotated`` type allows you to put several annotations of the same (or different) type(s) on " +"any node, the tools or libraries consuming those annotations are in charge of dealing with potential " +"duplicates. For example, if you are doing value range analysis you might allow this::" msgstr "" #: library/typing.rst:1086 msgid "" -"Passing ``include_extras=True`` to :func:`get_type_hints` lets one access " -"the extra annotations at runtime." +"Passing ``include_extras=True`` to :func:`get_type_hints` lets one access the extra annotations at runtime." msgstr "" #: library/typing.rst:1089 @@ -1376,26 +1198,20 @@ msgid "The first argument to ``Annotated`` must be a valid type" msgstr "" #: library/typing.rst:1093 -msgid "" -"Multiple type annotations are supported (``Annotated`` supports variadic " -"arguments)::" +msgid "Multiple type annotations are supported (``Annotated`` supports variadic arguments)::" msgstr "" #: library/typing.rst:1098 -msgid "" -"``Annotated`` must be called with at least two arguments " -"( ``Annotated[int]`` is not valid)" +msgid "``Annotated`` must be called with at least two arguments ( ``Annotated[int]`` is not valid)" msgstr "" #: library/typing.rst:1101 -msgid "" -"The order of the annotations is preserved and matters for equality checks::" +msgid "The order of the annotations is preserved and matters for equality checks::" msgstr "" #: library/typing.rst:1108 msgid "" -"Nested ``Annotated`` types are flattened, with metadata ordered starting " -"with the innermost annotation::" +"Nested ``Annotated`` types are flattened, with metadata ordered starting with the innermost annotation::" msgstr "" #: library/typing.rst:1115 @@ -1408,31 +1224,26 @@ msgstr "" #: library/typing.rst:1134 msgid "" -"Special typing form used to annotate the return type of a user-defined type " -"guard function. ``TypeGuard`` only accepts a single type argument. At " -"runtime, functions marked this way should return a boolean." +"Special typing form used to annotate the return type of a user-defined type guard function. ``TypeGuard`` " +"only accepts a single type argument. At runtime, functions marked this way should return a boolean." msgstr "" #: library/typing.rst:1138 msgid "" -"``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static " -"type checkers to determine a more precise type of an expression within a " -"program's code flow. Usually type narrowing is done by analyzing " -"conditional code flow and applying the narrowing to a block of code. The " -"conditional expression here is sometimes referred to as a \"type guard\"::" +"``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static type checkers to determine a " +"more precise type of an expression within a program's code flow. Usually type narrowing is done by " +"analyzing conditional code flow and applying the narrowing to a block of code. The conditional expression " +"here is sometimes referred to as a \"type guard\"::" msgstr "" #: library/typing.rst:1153 msgid "" -"Sometimes it would be convenient to use a user-defined boolean function as a " -"type guard. Such a function should use ``TypeGuard[...]`` as its return " -"type to alert static type checkers to this intention." +"Sometimes it would be convenient to use a user-defined boolean function as a type guard. Such a function " +"should use ``TypeGuard[...]`` as its return type to alert static type checkers to this intention." msgstr "" #: library/typing.rst:1157 -msgid "" -"Using ``-> TypeGuard`` tells the static type checker that for a given " -"function:" +msgid "Using ``-> TypeGuard`` tells the static type checker that for a given function:" msgstr "" #: library/typing.rst:1160 @@ -1440,42 +1251,33 @@ msgid "The return value is a boolean." msgstr "" #: library/typing.rst:1161 -msgid "" -"If the return value is ``True``, the type of its argument is the type inside " -"``TypeGuard``." +msgid "If the return value is ``True``, the type of its argument is the type inside ``TypeGuard``." msgstr "" #: library/typing.rst:1178 msgid "" -"If ``is_str_list`` is a class or instance method, then the type in " -"``TypeGuard`` maps to the type of the second parameter after ``cls`` or " -"``self``." +"If ``is_str_list`` is a class or instance method, then the type in ``TypeGuard`` maps to the type of the " +"second parameter after ``cls`` or ``self``." msgstr "" #: library/typing.rst:1182 msgid "" -"In short, the form ``def foo(arg: TypeA) -> TypeGuard[TypeB]: ...``, means " -"that if ``foo(arg)`` returns ``True``, then ``arg`` narrows from ``TypeA`` " -"to ``TypeB``." +"In short, the form ``def foo(arg: TypeA) -> TypeGuard[TypeB]: ...``, means that if ``foo(arg)`` returns " +"``True``, then ``arg`` narrows from ``TypeA`` to ``TypeB``." msgstr "" #: library/typing.rst:1188 msgid "" -"``TypeB`` need not be a narrower form of ``TypeA`` -- it can even be a wider " -"form. The main reason is to allow for things like narrowing ``list[object]`` " -"to ``list[str]`` even though the latter is not a subtype of the former, " -"since ``list`` is invariant. The responsibility of writing type-safe type " -"guards is left to the user." +"``TypeB`` need not be a narrower form of ``TypeA`` -- it can even be a wider form. The main reason is to " +"allow for things like narrowing ``list[object]`` to ``list[str]`` even though the latter is not a subtype " +"of the former, since ``list`` is invariant. The responsibility of writing type-safe type guards is left to " +"the user." msgstr "" #: library/typing.rst:1194 #, fuzzy -msgid "" -"``TypeGuard`` also works with type variables. See :pep:`647` 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." +msgid "``TypeGuard`` also works with type variables. See :pep:`647` 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." #: library/typing.rst:1200 #, fuzzy @@ -1483,9 +1285,7 @@ msgid "Building generic types" msgstr "Types génériques définis par l'utilisateur" #: library/typing.rst:1202 -msgid "" -"These are not used in annotations. They are building blocks for creating " -"generic types." +msgid "These are not used in annotations. They are building blocks for creating generic types." msgstr "" #: library/typing.rst:1206 @@ -1494,13 +1294,12 @@ msgstr "Classe de base abstraite pour les types génériques." #: library/typing.rst:1208 msgid "" -"A generic type is typically declared by inheriting from an instantiation of " -"this class with one or more type variables. For example, a generic mapping " -"type might be defined as::" +"A generic type is typically declared by inheriting from an instantiation of 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 ::" #: library/typing.rst:1217 msgid "This class can then be used as follows::" @@ -1517,126 +1316,113 @@ msgstr "Utilisation ::" #: library/typing.rst:1238 #, fuzzy 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. 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 ::" +"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 ::" #: library/typing.rst:1258 msgid "" -"Note that type variables can be *bound*, *constrained*, or neither, but " -"cannot be both bound *and* constrained." +"Note that type variables can be *bound*, *constrained*, or neither, but cannot be both bound *and* " +"constrained." msgstr "" #: library/typing.rst:1261 msgid "" -"Bound type variables and constrained type variables have different semantics " -"in several important ways. Using a *bound* type variable means that the " -"``TypeVar`` will be solved using the most specific type possible::" +"Bound type variables and constrained type variables have different semantics in several important ways. " +"Using a *bound* type variable means that the ``TypeVar`` will be solved using the most specific type " +"possible::" msgstr "" #: library/typing.rst:1276 msgid "" -"Type variables can be bound to concrete types, abstract types (ABCs or " -"protocols), and even unions of types::" +"Type variables can be bound to concrete types, abstract types (ABCs or protocols), and even unions of " +"types::" msgstr "" #: library/typing.rst:1282 msgid "" -"Using a *constrained* type variable, however, means that the ``TypeVar`` can " -"only ever be solved as being exactly one of the constraints given::" +"Using a *constrained* type variable, however, means that the ``TypeVar`` can only ever be solved as being " +"exactly one of the constraints given::" msgstr "" #: library/typing.rst:1293 msgid "" -"At runtime, ``isinstance(x, T)`` will raise :exc:`TypeError`. In general, :" -"func:`isinstance` and :func:`issubclass` should not be used with types." +"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." +"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." #: library/typing.rst:1296 #, fuzzy msgid "" -"Type variables may be marked covariant or contravariant by passing " -"``covariant=True`` or ``contravariant=True``. See :pep:`484` for more " -"details. By default, type variables are invariant." +"Type variables may be marked covariant or contravariant by passing ``covariant=True`` or " +"``contravariant=True``. See :pep:`484` for more details. By default, type variables are invariant." 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é " -"(explicitement ou implicitement) à la variable type doit être une sous-" -"classe du type frontière (*boundary* en anglais), voir la :pep:`484`." +"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é (explicitement ou implicitement) à la variable " +"type doit être une sous-classe du type frontière (*boundary* en anglais), voir la :pep:`484`." #: library/typing.rst:1302 msgid "" -"Type variable tuple. A specialized form of :class:`type variable ` " -"that enables *variadic* generics." +"Type variable tuple. A specialized form of :class:`type variable ` that enables *variadic* " +"generics." msgstr "" #: library/typing.rst:1305 msgid "" -"A normal type variable enables parameterization with a single type. A type " -"variable tuple, in contrast, allows parameterization with an *arbitrary* " -"number of types by acting like an *arbitrary* number of type variables " -"wrapped in a tuple. For example::" +"A normal type variable enables parameterization with a single type. A type variable tuple, in contrast, " +"allows parameterization with an *arbitrary* number of types by acting like an *arbitrary* number of type " +"variables wrapped in a tuple. For example::" msgstr "" #: library/typing.rst:1333 msgid "" -"Note the use of the unpacking operator ``*`` in ``tuple[T, *Ts]``. " -"Conceptually, you can think of ``Ts`` as a tuple of type variables ``(T1, " -"T2, ...)``. ``tuple[T, *Ts]`` would then become ``tuple[T, *(T1, " -"T2, ...)]``, which is equivalent to ``tuple[T, T1, T2, ...]``. (Note that in " -"older versions of Python, you might see this written using :data:`Unpack " -"` instead, as ``Unpack[Ts]``.)" +"Note the use of the unpacking operator ``*`` in ``tuple[T, *Ts]``. Conceptually, you can think of ``Ts`` " +"as a tuple of type variables ``(T1, T2, ...)``. ``tuple[T, *Ts]`` would then become ``tuple[T, *(T1, " +"T2, ...)]``, which is equivalent to ``tuple[T, T1, T2, ...]``. (Note that in older versions of Python, you " +"might see this written using :data:`Unpack ` instead, as ``Unpack[Ts]``.)" msgstr "" #: library/typing.rst:1341 msgid "" -"Type variable tuples must *always* be unpacked. This helps distinguish type " -"variable tuples from normal type variables::" +"Type variable tuples must *always* be unpacked. This helps distinguish type variable tuples from normal " +"type variables::" msgstr "" #: library/typing.rst:1348 msgid "" -"Type variable tuples can be used in the same contexts as normal type " -"variables. For example, in class definitions, arguments, and return types::" +"Type variable tuples can be used in the same contexts as normal type variables. For example, in class " +"definitions, arguments, and return types::" msgstr "" #: library/typing.rst:1357 -msgid "" -"Type variable tuples can be happily combined with normal type variables::" +msgid "Type variable tuples can be happily combined with normal type variables::" msgstr "" #: library/typing.rst:1370 msgid "" -"However, note that at most one type variable tuple may appear in a single " -"list of type arguments or type parameters::" +"However, note that at most one type variable tuple may appear in a single list of type arguments or type " +"parameters::" msgstr "" #: library/typing.rst:1377 -msgid "" -"Finally, an unpacked type variable tuple can be used as the type annotation " -"of ``*args``::" +msgid "Finally, an unpacked type variable tuple can be used as the type annotation of ``*args``::" msgstr "" #: library/typing.rst:1387 msgid "" -"In contrast to non-unpacked annotations of ``*args`` - e.g. ``*args: int``, " -"which would specify that *all* arguments are ``int`` - ``*args: *Ts`` " -"enables reference to the types of the *individual* arguments in ``*args``. " -"Here, this allows us to ensure the types of the ``*args`` passed to " -"``call_soon`` match the types of the (positional) arguments of ``callback``." +"In contrast to non-unpacked annotations of ``*args`` - e.g. ``*args: int``, which would specify that *all* " +"arguments are ``int`` - ``*args: *Ts`` enables reference to the types of the *individual* arguments in " +"``*args``. Here, this allows us to ensure the types of the ``*args`` passed to ``call_soon`` match the " +"types of the (positional) arguments of ``callback``." msgstr "" #: library/typing.rst:1394 @@ -1646,89 +1432,75 @@ msgstr "Voir la :pep:`484` pour plus de détails." #: library/typing.rst:1400 msgid "" -"A typing operator that conceptually marks an object as having been unpacked. " -"For example, using the unpack operator ``*`` on a :class:`type variable " -"tuple ` is equivalent to using ``Unpack`` to mark the type " -"variable tuple as having been unpacked::" +"A typing operator that conceptually marks an object as having been unpacked. For example, using the unpack " +"operator ``*`` on a :class:`type variable tuple ` is equivalent to using ``Unpack`` to mark " +"the type variable tuple as having been unpacked::" msgstr "" #: library/typing.rst:1410 msgid "" -"In fact, ``Unpack`` can be used interchangeably with ``*`` in the context of " -"types. You might see ``Unpack`` being used explicitly in older versions of " -"Python, where ``*`` couldn't be used in certain places::" +"In fact, ``Unpack`` can be used interchangeably with ``*`` in the context of types. You might see " +"``Unpack`` being used explicitly in older versions of Python, where ``*`` couldn't be used in certain " +"places::" msgstr "" #: library/typing.rst:1426 -msgid "" -"Parameter specification variable. A specialized version of :class:`type " -"variables `." +msgid "Parameter specification variable. A specialized version of :class:`type variables `." msgstr "" #: library/typing.rst:1433 msgid "" -"Parameter specification variables exist primarily for the benefit of static " -"type checkers. They are used to forward the parameter types of one callable " -"to another callable -- a pattern commonly found in higher order functions " -"and decorators. They are only valid when used in ``Concatenate``, or as the " -"first argument to ``Callable``, or as parameters for user-defined Generics. " -"See :class:`Generic` for more information on generic types." +"Parameter specification variables exist primarily for the benefit of static type checkers. They are used " +"to forward the parameter types of one callable to another callable -- a pattern commonly found in higher " +"order functions and decorators. They are only valid when used in ``Concatenate``, or as the first " +"argument to ``Callable``, or as parameters for user-defined Generics. See :class:`Generic` for more " +"information on generic types." msgstr "" #: library/typing.rst:1440 msgid "" -"For example, to add basic logging to a function, one can create a decorator " -"``add_logging`` to log function calls. The parameter specification variable " -"tells the type checker that the callable passed into the decorator and the " -"new callable returned by it have inter-dependent type parameters::" +"For example, to add basic logging to a function, one can create a decorator ``add_logging`` to log " +"function calls. The parameter specification variable tells the type checker that the callable passed into " +"the decorator and the new callable returned by it have inter-dependent type parameters::" msgstr "" #: library/typing.rst:1464 msgid "" -"Without ``ParamSpec``, the simplest way to annotate this previously was to " -"use a :class:`TypeVar` with bound ``Callable[..., Any]``. However this " -"causes two problems:" +"Without ``ParamSpec``, the simplest way to annotate this previously was to use a :class:`TypeVar` with " +"bound ``Callable[..., Any]``. However this causes two problems:" msgstr "" #: library/typing.rst:1468 msgid "" -"The type checker can't type check the ``inner`` function because ``*args`` " -"and ``**kwargs`` have to be typed :data:`Any`." +"The type checker can't type check the ``inner`` function because ``*args`` and ``**kwargs`` have to be " +"typed :data:`Any`." msgstr "" #: library/typing.rst:1470 msgid "" -":func:`~cast` may be required in the body of the ``add_logging`` decorator " -"when returning the ``inner`` function, or the static type checker must be " -"told to ignore the ``return inner``." +":func:`~cast` may be required in the body of the ``add_logging`` decorator when returning the ``inner`` " +"function, or the static type checker must be told to ignore the ``return inner``." msgstr "" #: library/typing.rst:1477 msgid "" -"Since ``ParamSpec`` captures both positional and keyword parameters, ``P." -"args`` and ``P.kwargs`` can be used to split a ``ParamSpec`` into its " -"components. ``P.args`` represents the tuple of positional parameters in a " -"given call and should only be used to annotate ``*args``. ``P.kwargs`` " -"represents the mapping of keyword parameters to their values in a given " -"call, and should be only be used to annotate ``**kwargs``. Both attributes " -"require the annotated parameter to be in scope. At runtime, ``P.args`` and " -"``P.kwargs`` are instances respectively of :class:`ParamSpecArgs` and :class:" -"`ParamSpecKwargs`." +"Since ``ParamSpec`` captures both positional and keyword parameters, ``P.args`` and ``P.kwargs`` can be " +"used to split a ``ParamSpec`` into its components. ``P.args`` represents the tuple of positional " +"parameters in a given call and should only be used to annotate ``*args``. ``P.kwargs`` represents the " +"mapping of keyword parameters to their values in a given call, and should be only be used to annotate " +"``**kwargs``. Both attributes require the annotated parameter to be in scope. At runtime, ``P.args`` and " +"``P.kwargs`` are instances respectively of :class:`ParamSpecArgs` and :class:`ParamSpecKwargs`." msgstr "" #: library/typing.rst:1487 msgid "" -"Parameter specification variables created with ``covariant=True`` or " -"``contravariant=True`` can be used to declare covariant or contravariant " -"generic types. The ``bound`` argument is also accepted, similar to :class:" -"`TypeVar`. However the actual semantics of these keywords are yet to be " -"decided." +"Parameter specification variables created with ``covariant=True`` or ``contravariant=True`` can be used to " +"declare covariant or contravariant generic types. The ``bound`` argument is also accepted, similar to :" +"class:`TypeVar`. However the actual semantics of these keywords are yet to be decided." msgstr "" #: library/typing.rst:1496 -msgid "" -"Only parameter specification variables defined in global scope can be " -"pickled." +msgid "Only parameter specification variables defined in global scope can be pickled." msgstr "" #: library/typing.rst:1502 @@ -1737,64 +1509,52 @@ msgstr "" #: library/typing.rst:1507 msgid "" -"Arguments and keyword arguments attributes of a :class:`ParamSpec`. The ``P." -"args`` attribute of a ``ParamSpec`` is an instance of ``ParamSpecArgs``, and " -"``P.kwargs`` is an instance of ``ParamSpecKwargs``. They are intended for " -"runtime introspection and have no special meaning to static type checkers." +"Arguments and keyword arguments attributes of a :class:`ParamSpec`. The ``P.args`` attribute of a " +"``ParamSpec`` is an instance of ``ParamSpecArgs``, and ``P.kwargs`` is an instance of ``ParamSpecKwargs``. " +"They are intended for runtime introspection and have no special meaning to static type checkers." msgstr "" #: library/typing.rst:1512 -msgid "" -"Calling :func:`get_origin` on either of these objects will return the " -"original ``ParamSpec``::" +msgid "Calling :func:`get_origin` on either of these objects will return the original ``ParamSpec``::" msgstr "" #: library/typing.rst:1524 #, fuzzy msgid "" -"``AnyStr`` is a :class:`constrained type variable ` defined as " -"``AnyStr = TypeVar('AnyStr', str, bytes)``." -msgstr "" -"``AnyStr`` est une variable de type définie comme ``AnyStr = " -"TypeVar('AnyStr', str, bytes)``." +"``AnyStr`` is a :class:`constrained type variable ` defined as ``AnyStr = TypeVar('AnyStr', str, " +"bytes)``." +msgstr "``AnyStr`` est une variable de type définie comme ``AnyStr = TypeVar('AnyStr', str, bytes)``." #: library/typing.rst:1527 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::" +"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 ::" +"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 ::" #: library/typing.rst:1539 -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 ::" +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 ::" #: library/typing.rst:1545 msgid "" -"Such classes are primarily used with static type checkers that recognize " -"structural subtyping (static duck-typing), for example::" +"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 ::" #: library/typing.rst:1557 #, fuzzy msgid "" -"See :pep:`544` for more details. Protocol classes decorated with :func:" -"`runtime_checkable` (described later) act as simple-minded runtime protocols " -"that check only the presence of given attributes, ignoring their type " -"signatures." +"See :pep:`544` for more details. Protocol classes decorated with :func:`runtime_checkable` (described " +"later) act as simple-minded runtime protocols that check only the presence of given attributes, ignoring " +"their type signatures." msgstr "" -"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." +"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." #: library/typing.rst:1562 msgid "Protocol classes can be generic, for example::" @@ -1807,26 +1567,22 @@ msgstr "Marquez une classe de protocole comme protocole d'exécution." #: library/typing.rst:1574 #, fuzzy 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:`~collections.abc.Iterable`. " -"For example::" +"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:`~collections.abc.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 aux « classes qui ne savent faire qu'une chose » présentes dans :" -"mod:`collections.abc` tel que :class:`Iterable`. Par exemple ::" +"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 aux « classes qui ne savent faire qu'une chose » présentes dans :mod:" +"`collections.abc` tel que :class:`Iterable`. Par exemple ::" #: library/typing.rst:1587 msgid "" -":func:`runtime_checkable` will check only the presence of the required " -"methods, not their type signatures. For example, :class:`ssl.SSLObject` is a " -"class, therefore it passes an :func:`issubclass` check against :data:" -"`Callable`. However, the :meth:`ssl.SSLObject.__init__` method exists only " -"to raise a :exc:`TypeError` with a more informative message, therefore " -"making it impossible to call (instantiate) :class:`ssl.SSLObject`." +":func:`runtime_checkable` will check only the presence of the required methods, not their type signatures. " +"For example, :class:`ssl.SSLObject` is a class, therefore it passes an :func:`issubclass` check against :" +"data:`Callable`. However, the :meth:`ssl.SSLObject.__init__` method exists only to raise a :exc:" +"`TypeError` with a more informative message, therefore making it impossible to call (instantiate) :class:" +"`ssl.SSLObject`." msgstr "" #: library/typing.rst:1598 @@ -1834,9 +1590,7 @@ msgid "Other special directives" msgstr "" #: library/typing.rst:1600 -msgid "" -"These are not used in annotations. They are building blocks for declaring " -"types." +msgid "These are not used in annotations. They are building blocks for declaring types." msgstr "" #: library/typing.rst:1604 @@ -1848,46 +1602,32 @@ msgid "This is equivalent to::" msgstr "Ce qui est équivalent à ::" #: library/typing.rst:1616 -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 ::" +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 ::" #: library/typing.rst:1625 -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." +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." #: library/typing.rst:1627 #, fuzzy msgid "" -"The resulting class has an extra attribute ``__annotations__`` giving a dict " -"that maps the field names to the field types. (The field names are in the " -"``_fields`` attribute and the default values are in the ``_field_defaults`` " -"attribute, both of which are part of the :func:`~collections.namedtuple` " -"API.)" +"The resulting class has an extra attribute ``__annotations__`` giving a dict that maps the field names to " +"the field types. (The field names are in the ``_fields`` attribute and the default values are in the " +"``_field_defaults`` attribute, both of which are part of the :func:`~collections.namedtuple` API.)" msgstr "" -"La classe résultante a un attribut supplémentaire ``__annotations__`` " -"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*.)" +"La classe résultante a un attribut supplémentaire ``__annotations__`` 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*.)" #: library/typing.rst:1633 msgid "``NamedTuple`` subclasses can also have docstrings and methods::" -msgstr "" -"Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et " -"des méthodes ::" +msgstr "Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et des méthodes ::" #: library/typing.rst:1643 #, fuzzy msgid "``NamedTuple`` subclasses can be generic::" -msgstr "" -"Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et " -"des méthodes ::" +msgstr "Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et des méthodes ::" #: library/typing.rst:1649 msgid "Backward-compatible usage::" @@ -1895,30 +1635,28 @@ msgstr "Utilisation rétrocompatible ::" #: library/typing.rst:1653 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`." #: library/typing.rst:1656 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*." +"Ajout de la prise en charge des valeurs par défaut, des méthodes et des chaînes de caractères *docstrings*." #: library/typing.rst:1659 msgid "" -"The ``_field_types`` and ``__annotations__`` attributes are now regular " -"dictionaries instead of instances of ``OrderedDict``." +"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 standards au lieu d'instances de ``OrderedDict``." +"Les attributs ``_field_types`` et ``__annotations__`` sont maintenant des dictionnaires standards au lieu " +"d'instances de ``OrderedDict``." #: library/typing.rst:1663 msgid "" -"Removed the ``_field_types`` attribute in favor of the more standard " -"``__annotations__`` attribute which has the same information." +"Removed 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." #: library/typing.rst:1667 msgid "Added support for generic namedtuples." @@ -1927,13 +1665,11 @@ msgstr "" #: library/typing.rst:1672 #, fuzzy msgid "" -"A helper class to indicate a distinct type to a typechecker, see :ref:" -"`distinct`. At runtime it returns an object that returns its argument when " -"called. Usage::" +"A helper class to indicate a distinct type to a typechecker, see :ref:`distinct`. At runtime it returns an " +"object that returns its argument when called. 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 ::" #: library/typing.rst:1682 msgid "``NewType`` is now a class rather than a function." @@ -1941,38 +1677,29 @@ msgstr "" #: library/typing.rst:1687 #, fuzzy -msgid "" -"Special construct to add type hints to a dictionary. At runtime it is a " -"plain :class:`dict`." -msgstr "" -"Un simple espace de nommage typé. À l'exécution, c'est l'équivalent d'un " -"simple :class:`dict`." +msgid "Special construct to add type hints to a dictionary. At runtime it is a plain :class:`dict`." +msgstr "Un simple espace de nommage typé. À l'exécution, c'est l'équivalent d'un simple :class:`dict`." #: library/typing.rst:1690 #, fuzzy msgid "" -"``TypedDict`` declares a dictionary type that expects all of its instances " -"to have a certain set of keys, where each key is associated with a value of " -"a consistent type. This expectation is not checked at runtime but is only " -"enforced by type checkers. Usage::" +"``TypedDict`` declares a dictionary type that expects all of its instances to have a certain set of keys, " +"where each key is associated with a value of a 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 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 ::" +"``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 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 ::" #: library/typing.rst:1706 #, fuzzy msgid "" -"To allow using this feature with older versions of Python that do not " -"support :pep:`526`, ``TypedDict`` supports two additional equivalent " -"syntactic forms:" +"To allow using this feature 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 prennent " -"pas en compte la :pep:`526`, ``TypedDict`` gère deux formes syntaxiques " +"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 ::" #: library/typing.rst:1710 @@ -1985,65 +1712,56 @@ msgstr "" #: library/typing.rst:1721 msgid "" -"The keyword-argument syntax is deprecated in 3.11 and will be removed in " -"3.13. It may also be unsupported by static type checkers." +"The keyword-argument syntax is deprecated in 3.11 and will be removed in 3.13. It may also be unsupported " +"by static type checkers." msgstr "" #: library/typing.rst:1722 msgid "" -"The functional syntax should also be used when any of the keys are not " -"valid :ref:`identifiers `, for example because they are " -"keywords or contain hyphens. Example::" +"The functional syntax should also be used when any of the keys are not valid :ref:`identifiers " +"`, for example because they are keywords or contain hyphens. Example::" msgstr "" #: library/typing.rst:1734 msgid "" -"By default, all keys must be present in a ``TypedDict``. It is possible to " -"mark individual keys as non-required using :data:`NotRequired`::" +"By default, all keys must be present in a ``TypedDict``. It is possible to mark individual keys as non-" +"required using :data:`NotRequired`::" msgstr "" #: library/typing.rst:1745 -msgid "" -"This means that a ``Point2D`` ``TypedDict`` can have the ``label`` key " -"omitted." +msgid "This means that a ``Point2D`` ``TypedDict`` can have the ``label`` key omitted." msgstr "" #: library/typing.rst:1748 msgid "" -"It is also possible to mark all keys as non-required by default by " -"specifying a totality of ``False``::" +"It is also possible to mark all keys as non-required by default by specifying a totality of ``False``::" msgstr "" #: library/typing.rst:1758 msgid "" -"This means that a ``Point2D`` ``TypedDict`` can have any of the keys " -"omitted. A type checker is only expected to support a literal ``False`` or " -"``True`` as the value of the ``total`` argument. ``True`` is the default, " -"and makes all items defined in the class body required." +"This means that a ``Point2D`` ``TypedDict`` can have any of the keys omitted. A type checker is only " +"expected to support a literal ``False`` or ``True`` as the value of the ``total`` argument. ``True`` is " +"the default, and makes all items defined in the class body required." msgstr "" #: library/typing.rst:1763 -msgid "" -"Individual keys of a ``total=False`` ``TypedDict`` can be marked as required " -"using :data:`Required`::" +msgid "Individual keys of a ``total=False`` ``TypedDict`` can be marked as required using :data:`Required`::" msgstr "" #: library/typing.rst:1778 msgid "" -"It is possible for a ``TypedDict`` type to inherit from one or more other " -"``TypedDict`` types using the class-based syntax. Usage::" +"It is possible for a ``TypedDict`` type to inherit from one or more other ``TypedDict`` types using the " +"class-based syntax. Usage::" msgstr "" #: library/typing.rst:1785 -msgid "" -"``Point3D`` has three items: ``x``, ``y`` and ``z``. It is equivalent to " -"this definition::" +msgid "``Point3D`` has three items: ``x``, ``y`` and ``z``. It is equivalent to this definition::" msgstr "" #: library/typing.rst:1793 msgid "" -"A ``TypedDict`` cannot inherit from a non-\\ ``TypedDict`` class, except " -"for :class:`Generic`. For example::" +"A ``TypedDict`` cannot inherit from a non-\\ ``TypedDict`` class, except for :class:`Generic`. For " +"example::" msgstr "" #: library/typing.rst:1811 @@ -2052,51 +1770,44 @@ msgstr "" #: library/typing.rst:1817 msgid "" -"A ``TypedDict`` can be introspected via annotations dicts (see :ref:" -"`annotations-howto` for more information on annotations best practices), :" -"attr:`__total__`, :attr:`__required_keys__`, and :attr:`__optional_keys__`." +"A ``TypedDict`` can be introspected via annotations dicts (see :ref:`annotations-howto` for more " +"information on annotations best practices), :attr:`__total__`, :attr:`__required_keys__`, and :attr:" +"`__optional_keys__`." msgstr "" #: library/typing.rst:1823 -msgid "" -"``Point2D.__total__`` gives the value of the ``total`` argument. Example::" +msgid "``Point2D.__total__`` gives the value of the ``total`` argument. Example::" msgstr "" #: library/typing.rst:1843 msgid "" -"``Point2D.__required_keys__`` and ``Point2D.__optional_keys__`` return :" -"class:`frozenset` objects containing required and non-required keys, " -"respectively." +"``Point2D.__required_keys__`` and ``Point2D.__optional_keys__`` return :class:`frozenset` objects " +"containing required and non-required keys, respectively." msgstr "" #: library/typing.rst:1846 msgid "" -"Keys marked with :data:`Required` will always appear in " -"``__required_keys__`` and keys marked with :data:`NotRequired` will always " -"appear in ``__optional_keys__``." +"Keys marked with :data:`Required` will always appear in ``__required_keys__`` and keys marked with :data:" +"`NotRequired` will always appear in ``__optional_keys__``." msgstr "" #: library/typing.rst:1849 msgid "" -"For backwards compatibility with Python 3.10 and below, it is also possible " -"to use inheritance to declare both required and non-required keys in the " -"same ``TypedDict`` . This is done by declaring a ``TypedDict`` with one " -"value for the ``total`` argument and then inheriting from it in another " -"``TypedDict`` with a different value for ``total``::" +"For backwards compatibility with Python 3.10 and below, it is also possible to use inheritance to declare " +"both required and non-required keys in the same ``TypedDict`` . This is done by declaring a ``TypedDict`` " +"with one value for the ``total`` argument and then inheriting from it in another ``TypedDict`` with a " +"different value for ``total``::" msgstr "" #: library/typing.rst:1870 #, fuzzy -msgid "" -"See :pep:`589` for more examples and detailed rules of using ``TypedDict``." +msgid "See :pep:`589` for more examples and detailed rules of using ``TypedDict``." 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." #: library/typing.rst:1874 -msgid "" -"Added support for marking individual keys as :data:`Required` or :data:" -"`NotRequired`. See :pep:`655`." +msgid "Added support for marking individual keys as :data:`Required` or :data:`NotRequired`. See :pep:`655`." msgstr "" #: library/typing.rst:1878 @@ -2113,13 +1824,11 @@ msgstr "" #: library/typing.rst:1889 msgid "" -"A generic version of :class:`dict`. Useful for annotating return types. To " -"annotate arguments it is preferred to use an abstract collection type such " -"as :class:`Mapping`." +"A generic version of :class:`dict`. Useful for annotating return types. To 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`." +"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`." #: library/typing.rst:1893 msgid "This type can be used as follows::" @@ -2128,21 +1837,19 @@ msgstr "Ce type peut être utilisé comme suit ::" #: library/typing.rst:1898 #, fuzzy msgid "" -":class:`builtins.dict ` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`builtins.dict ` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`builtins.dict ` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`builtins.dict ` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:1904 msgid "" -"Generic version of :class:`list`. Useful for annotating return types. To " -"annotate arguments it is preferred to use an abstract collection type such " -"as :class:`Sequence` or :class:`Iterable`." +"Generic version of :class:`list`. Useful for annotating return types. To 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`." +"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`." #: library/typing.rst:1909 msgid "This type may be used as follows::" @@ -2151,30 +1858,27 @@ msgstr "Ce type peut être utilisé comme suit ::" #: library/typing.rst:1919 #, fuzzy msgid "" -":class:`builtins.list ` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`builtins.list ` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`builtins.list ` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`builtins.list ` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:1925 msgid "" -"A generic version of :class:`builtins.set `. Useful for annotating " -"return types. To annotate arguments it is preferred to use an abstract " -"collection type such as :class:`AbstractSet`." +"A generic version of :class:`builtins.set `. Useful for annotating 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`." +"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`." #: library/typing.rst:1929 #, fuzzy msgid "" -":class:`builtins.set ` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`builtins.set ` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`builtins.set ` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`builtins.set ` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-genericalias`." #: library/typing.rst:1935 msgid "A generic version of :class:`builtins.frozenset `." @@ -2183,11 +1887,11 @@ msgstr "Une version générique de :class:`builtins.frozenset `." #: library/typing.rst:1937 #, fuzzy msgid "" -":class:`builtins.frozenset ` now supports subscripting (``[]``). " -"See :pep:`585` and :ref:`types-genericalias`." +":class:`builtins.frozenset ` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`builtins.frozenset ` prend désormais en charge ``[]``. " -"Voir :pep:`585` et :ref:`types-genericalias`." +":class:`builtins.frozenset ` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:1942 msgid ":data:`Tuple` is a special form." @@ -2204,11 +1908,11 @@ msgstr "Une version générique de :class:`collections.defaultdict`." #: library/typing.rst:1953 #, fuzzy msgid "" -":class:`collections.defaultdict` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.defaultdict` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.defaultdict` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`collections.defaultdict` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:1959 msgid "A generic version of :class:`collections.OrderedDict`." @@ -2217,11 +1921,11 @@ msgstr "Une version générique de :class:`collections.OrderedDict`." #: library/typing.rst:1963 #, fuzzy msgid "" -":class:`collections.OrderedDict` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.OrderedDict` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.OrderedDict` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`collections.OrderedDict` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:1969 msgid "A generic version of :class:`collections.ChainMap`." @@ -2230,11 +1934,11 @@ msgstr "Une version générique de :class:`collections.ChainMap`." #: library/typing.rst:1974 #, fuzzy msgid "" -":class:`collections.ChainMap` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`collections.ChainMap` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.ChainMap` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`collections.ChainMap` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:1980 msgid "A generic version of :class:`collections.Counter`." @@ -2243,11 +1947,11 @@ msgstr "Une version générique de :class:`collections.Counter`." #: library/typing.rst:1985 #, fuzzy msgid "" -":class:`collections.Counter` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`collections.Counter` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.Counter` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`collections.Counter` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:1991 msgid "A generic version of :class:`collections.deque`." @@ -2256,11 +1960,10 @@ msgstr "Une version générique de :class:`collections.deque`." #: library/typing.rst:1996 #, fuzzy msgid "" -":class:`collections.deque` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`collections.deque` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.deque` prend désormais en charge ``[]``. Voir :pep:`585` " -"et :ref:`types-genericalias`." +":class:`collections.deque` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-genericalias`." #: library/typing.rst:2001 msgid "Other concrete types" @@ -2269,69 +1972,62 @@ msgstr "" #: library/typing.rst:2007 #, fuzzy msgid "" -"Generic type ``IO[AnyStr]`` and its subclasses ``TextIO(IO[str])`` and " -"``BinaryIO(IO[bytes])`` represent the types of I/O streams such as returned " -"by :func:`open`." +"Generic type ``IO[AnyStr]`` and its subclasses ``TextIO(IO[str])`` and ``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 d'entrées-sorties " -"tels que renvoyés par :func:`open`." +"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`." #: library/typing.rst:2014 msgid "" -"The ``typing.io`` namespace is deprecated and will be removed. These types " -"should be directly imported from ``typing`` instead." +"The ``typing.io`` namespace is deprecated and will be removed. These types should be directly imported " +"from ``typing`` instead." msgstr "" #: library/typing.rst:2019 #, fuzzy msgid "" -"These type aliases correspond to the return types from :func:`re.compile` " -"and :func:`re.match`. These types (and the corresponding functions) are " -"generic in ``AnyStr`` and can be made specific by writing ``Pattern[str]``, " -"``Pattern[bytes]``, ``Match[str]``, or ``Match[bytes]``." +"These type aliases correspond to the return types from :func:`re.compile` and :func:`re.match`. These " +"types (and the corresponding functions) are 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]``." +"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]``." #: library/typing.rst:2029 msgid "" -"The ``typing.re`` namespace is deprecated and will be removed. These types " -"should be directly imported from ``typing`` instead." +"The ``typing.re`` namespace is deprecated and will be removed. These types should be directly imported " +"from ``typing`` instead." msgstr "" #: library/typing.rst:2030 msgid "" -"Classes ``Pattern`` and ``Match`` from :mod:`re` now support ``[]``. See :" -"pep:`585` and :ref:`types-genericalias`." +"Classes ``Pattern`` and ``Match`` from :mod:`re` now support ``[]``. See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" #: library/typing.rst:2036 msgid "" -"``Text`` is an alias for ``str``. It is provided to supply a forward " -"compatible path for Python 2 code: in Python 2, ``Text`` is an alias for " -"``unicode``." +"``Text`` is an alias for ``str``. It is provided to supply a forward 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 " -"alias pour ``unicode``." +"``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``." #: library/typing.rst:2040 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::" +"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 ::" +"Utilisez ``Text`` pour indiquer qu'une valeur doit contenir une chaîne Unicode d'une manière compatible " +"avec Python 2 et Python 3 ::" #: library/typing.rst:2048 msgid "" -"Python 2 is no longer supported, and most type checkers also no longer " -"support type checking Python 2 code. Removal of the alias is not currently " -"planned, but users are encouraged to use :class:`str` instead of ``Text`` " -"wherever possible." +"Python 2 is no longer supported, and most type checkers also no longer support type checking Python 2 " +"code. Removal of the alias is not currently planned, but users are encouraged to use :class:`str` instead " +"of ``Text`` wherever possible." msgstr "" #: library/typing.rst:2055 @@ -2341,7 +2037,7 @@ msgstr "Classe de base abstraite pour les types génériques." #: library/typing.rst:2058 msgid "Corresponding to collections in :mod:`collections.abc`" -msgstr "" +msgstr "Correspond aux collections au sein de :mod:`collections.abc`" #: library/typing.rst:2062 msgid "A generic version of :class:`collections.abc.Set`." @@ -2350,11 +2046,11 @@ msgstr "Une version générique de :class:`collections.abc.Set`." #: library/typing.rst:2064 #, fuzzy msgid "" -":class:`collections.abc.Set` now supports subscripting (``[]``). See :pep:" -"`585` and :ref:`types-genericalias`." +":class:`collections.abc.Set` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Set` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`collections.abc.Set` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2070 msgid "A generic version of :class:`collections.abc.ByteString`." @@ -2363,28 +2059,26 @@ msgstr "Une version générique de :class:`collections.abc.ByteString`." #: library/typing.rst:2072 #, fuzzy msgid "" -"This type represents the types :class:`bytes`, :class:`bytearray`, and :" -"class:`memoryview` of byte sequences." -msgstr "" -"Ce type représente les types :class:`bytes`, :class:`bytearray` et :class:" -"`memoryview`." +"This type represents the types :class:`bytes`, :class:`bytearray`, and :class:`memoryview` of byte " +"sequences." +msgstr "Ce type représente les types :class:`bytes`, :class:`bytearray` et :class:`memoryview`." #: library/typing.rst:2075 msgid "" -"As a shorthand for this type, :class:`bytes` can be used to annotate " -"arguments of any of the types mentioned above." +"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 quel type mentionné ci-dessus." +"Comme abréviation pour ce type, :class:`bytes` peut être utilisé pour annoter des arguments de n'importe " +"quel type mentionné ci-dessus." #: library/typing.rst:2078 #, fuzzy msgid "" -":class:`collections.abc.ByteString` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.ByteString` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.ByteString` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.ByteString` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2084 msgid "A generic version of :class:`collections.abc.Collection`" @@ -2393,11 +2087,11 @@ msgstr "Une version générique de :class:`collections.abc.Collection`" #: library/typing.rst:2088 #, fuzzy msgid "" -":class:`collections.abc.Collection` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Collection` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Collection` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Collection` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2094 msgid "A generic version of :class:`collections.abc.Container`." @@ -2406,11 +2100,11 @@ msgstr "Une version générique de :class:`collections.abc.Container`." #: library/typing.rst:2096 #, fuzzy msgid "" -":class:`collections.abc.Container` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Container` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Container` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Container` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2102 msgid "A generic version of :class:`collections.abc.ItemsView`." @@ -2419,11 +2113,11 @@ msgstr "Une version générique de :class:`collections.abc.ItemsView`." #: library/typing.rst:2104 #, fuzzy msgid "" -":class:`collections.abc.ItemsView` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.ItemsView` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.ItemsView` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.ItemsView` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2110 msgid "A generic version of :class:`collections.abc.KeysView`." @@ -2432,28 +2126,24 @@ msgstr "Une version générique de :class:`collections.abc.KeysView`." #: library/typing.rst:2112 #, fuzzy msgid "" -":class:`collections.abc.KeysView` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.KeysView` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.KeysView` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.KeysView` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2118 -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 ::" +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 ::" #: library/typing.rst:2124 #, fuzzy msgid "" -":class:`collections.abc.Mapping` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Mapping` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Mapping` prend désormais en charge ``[]``. Voir :pep:" -"`585` et :ref:`types-genericalias`." +":class:`collections.abc.Mapping` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2130 msgid "A generic version of :class:`collections.abc.MappingView`." @@ -2462,11 +2152,11 @@ msgstr "Une version générique de :class:`collections.abc.MappingView`." #: library/typing.rst:2132 #, fuzzy msgid "" -":class:`collections.abc.MappingView` now supports subscripting (``[]``). " -"See :pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.MappingView` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.MappingView` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.MappingView` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2138 msgid "A generic version of :class:`collections.abc.MutableMapping`." @@ -2475,11 +2165,11 @@ msgstr "Une version générique de :class:`collections.abc.MutableMapping`." #: library/typing.rst:2140 #, fuzzy msgid "" -":class:`collections.abc.MutableMapping` now supports subscripting (``[]``). " -"See :pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.MutableMapping` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.MutableMapping` prend désormais en charge ``[]``. " -"Voir :pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.MutableMapping` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2147 msgid "A generic version of :class:`collections.abc.MutableSequence`." @@ -2488,11 +2178,11 @@ msgstr "Une version générique de :class:`collections.abc.MutableSequence`." #: library/typing.rst:2149 #, fuzzy msgid "" -":class:`collections.abc.MutableSequence` now supports subscripting (``[]``). " -"See :pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.MutableSequence` now supports subscripting (``[]``). See :pep:`585` and :ref:" +"`types-genericalias`." msgstr "" -":class:`collections.abc.MutableSequence` prend désormais en charge ``[]``. " -"Voir :pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.MutableSequence` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2156 msgid "A generic version of :class:`collections.abc.MutableSet`." @@ -2501,11 +2191,11 @@ msgstr "Une version générique de :class:`collections.abc.MutableSet`." #: library/typing.rst:2158 #, fuzzy msgid "" -":class:`collections.abc.MutableSet` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.MutableSet` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.MutableSet` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.MutableSet` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2164 msgid "A generic version of :class:`collections.abc.Sequence`." @@ -2514,11 +2204,11 @@ msgstr "Une version générique de :class:`collections.abc.Sequence`." #: library/typing.rst:2166 #, fuzzy msgid "" -":class:`collections.abc.Sequence` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Sequence` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Sequence` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Sequence` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2172 msgid "A generic version of :class:`collections.abc.ValuesView`." @@ -2527,15 +2217,15 @@ msgstr "Une version générique de :class:`collections.abc.ValuesView`." #: library/typing.rst:2174 #, fuzzy msgid "" -":class:`collections.abc.ValuesView` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.ValuesView` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.ValuesView` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.ValuesView` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2179 msgid "Corresponding to other types in :mod:`collections.abc`" -msgstr "" +msgstr "Correspond aux autres types au sein de :mod:`collections.abc`." #: library/typing.rst:2183 msgid "A generic version of :class:`collections.abc.Iterable`." @@ -2544,11 +2234,11 @@ msgstr "Une version générique de :class:`collections.abc.Iterable`." #: library/typing.rst:2185 #, fuzzy msgid "" -":class:`collections.abc.Iterable` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Iterable` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Iterable` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Iterable` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2191 msgid "A generic version of :class:`collections.abc.Iterator`." @@ -2557,54 +2247,50 @@ msgstr "Une version générique de :class:`collections.abc.Iterator`." #: library/typing.rst:2193 #, fuzzy msgid "" -":class:`collections.abc.Iterator` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Iterator` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Iterator` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Iterator` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2199 msgid "" -"A generator can be annotated by the generic type ``Generator[YieldType, " -"SendType, ReturnType]``. For example::" +"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 ::" +"Un générateur peut être annoté par le type générique ``Generator[YieldType, SendType, ReturnType]``. Par " +"exemple ::" #: library/typing.rst:2208 msgid "" -"Note that unlike many other generics in the typing module, the ``SendType`` " -"of :class:`Generator` behaves contravariantly, not covariantly or " -"invariantly." +"Note that unlike many other generics in the typing module, the ``SendType`` 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 " -"contravariante, pas de manière covariante ou invariante." +"Notez que contrairement à beaucoup d'autres génériques dans le module *typing*, le ``SendType`` de :class:" +"`Generator` se comporte de manière contravariante, pas de manière covariante ou invariante." #: library/typing.rst:2212 -msgid "" -"If your generator will only yield values, set the ``SendType`` and " -"``ReturnType`` to ``None``::" +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`` ::" +"Si votre générateur ne donne que des valeurs, réglez les paramètres ``SendType`` et ``ReturnType`` sur " +"``None`` ::" #: library/typing.rst:2220 msgid "" -"Alternatively, annotate your generator as having a return type of either " -"``Iterable[YieldType]`` or ``Iterator[YieldType]``::" +"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]`` ::" +"Alternativement, annotez votre générateur comme ayant un type de retour soit ``Iterable[YieldType]`` ou " +"``Iterator[YieldType]`` ::" #: library/typing.rst:2228 #, fuzzy msgid "" -":class:`collections.abc.Generator` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Generator` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Generator` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Generator` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2234 #, fuzzy @@ -2618,11 +2304,11 @@ msgstr "Une version générique de :class:`collections.abc.Reversible`." #: library/typing.rst:2240 #, fuzzy msgid "" -":class:`collections.abc.Reversible` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Reversible` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Reversible` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Reversible` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2246 #, fuzzy @@ -2631,69 +2317,62 @@ msgstr "Un alias pour :class:`collections.abc.Sized`" #: library/typing.rst:2249 msgid "Asynchronous programming" -msgstr "" +msgstr "Programmation asynchrone" #: library/typing.rst:2253 msgid "" -"A generic version of :class:`collections.abc.Coroutine`. The variance and " -"order of type variables correspond to those of :class:`Generator`, for " -"example::" +"A generic version of :class:`collections.abc.Coroutine`. The variance and 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 ::" +"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 ::" #: library/typing.rst:2265 #, fuzzy msgid "" -":class:`collections.abc.Coroutine` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Coroutine` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Coroutine` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Coroutine` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2271 msgid "" -"An async generator can be annotated by the generic type " -"``AsyncGenerator[YieldType, SendType]``. For example::" +"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 ::" +"Un générateur asynchrone peut être annoté par le type générique ``AsyncGenerator[YieldType, SendType]``. " +"Par exemple ::" #: library/typing.rst:2280 msgid "" -"Unlike normal generators, async generators cannot return a value, so there " -"is no ``ReturnType`` type parameter. As with :class:`Generator`, the " -"``SendType`` behaves contravariantly." +"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 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 contravariante." +"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 contravariante." #: library/typing.rst:2284 -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`` ::" +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`` ::" #: library/typing.rst:2292 msgid "" -"Alternatively, annotate your generator as having a return type of either " -"``AsyncIterable[YieldType]`` or ``AsyncIterator[YieldType]``::" +"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]`` ::" +"Alternativement, annotez votre générateur comme ayant un type de retour soit ``AsyncIterable[YieldType]`` " +"ou ``AsyncIterator[YieldType]`` ::" #: library/typing.rst:2302 #, fuzzy msgid "" -":class:`collections.abc.AsyncGenerator` now supports subscripting (``[]``). " -"See :pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.AsyncGenerator` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.AsyncGenerator` prend désormais en charge ``[]``. " -"Voir :pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.AsyncGenerator` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2309 msgid "A generic version of :class:`collections.abc.AsyncIterable`." @@ -2702,11 +2381,11 @@ msgstr "Une version générique de :class:`collections.abc.AsyncIterable`." #: library/typing.rst:2313 #, fuzzy msgid "" -":class:`collections.abc.AsyncIterable` now supports subscripting (``[]``). " -"See :pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.AsyncIterable` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.AsyncIterable` prend désormais en charge ``[]``. " -"Voir :pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.AsyncIterable` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2319 msgid "A generic version of :class:`collections.abc.AsyncIterator`." @@ -2715,11 +2394,11 @@ msgstr "Une version générique de :class:`collections.abc.AsyncIterator`." #: library/typing.rst:2323 #, fuzzy msgid "" -":class:`collections.abc.AsyncIterator` now supports subscripting (``[]``). " -"See :pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.AsyncIterator` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.AsyncIterator` prend désormais en charge ``[]``. " -"Voir :pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.AsyncIterator` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2329 msgid "A generic version of :class:`collections.abc.Awaitable`." @@ -2728,15 +2407,15 @@ msgstr "Une version générique de :class:`collections.abc.Awaitable`." #: library/typing.rst:2333 #, fuzzy msgid "" -":class:`collections.abc.Awaitable` now supports subscripting (``[]``). See :" -"pep:`585` and :ref:`types-genericalias`." +":class:`collections.abc.Awaitable` now supports subscripting (``[]``). See :pep:`585` and :ref:`types-" +"genericalias`." msgstr "" -":class:`collections.abc.Awaitable` prend désormais en charge ``[]``. Voir :" -"pep:`585` et :ref:`types-genericalias`." +":class:`collections.abc.Awaitable` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:`types-" +"genericalias`." #: library/typing.rst:2339 msgid "Context manager types" -msgstr "" +msgstr "Types associés aux gestionnaires de contexte" #: library/typing.rst:2343 msgid "A generic version of :class:`contextlib.AbstractContextManager`." @@ -2745,41 +2424,36 @@ msgstr "Une version générique de :class:`contextlib.AbstractContextManager`." #: library/typing.rst:2348 #, fuzzy msgid "" -":class:`contextlib.AbstractContextManager` now supports subscripting " -"(``[]``). See :pep:`585` and :ref:`types-genericalias`." +":class:`contextlib.AbstractContextManager` now supports subscripting (``[]``). See :pep:`585` and :ref:" +"`types-genericalias`." msgstr "" -":class:`contextlib.AbstractContextManager` prend désormais en charge ``[]``. " -"Voir :pep:`585` et :ref:`types-genericalias`." +":class:`contextlib.AbstractContextManager` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:" +"`types-genericalias`." #: library/typing.rst:2355 msgid "A generic version of :class:`contextlib.AbstractAsyncContextManager`." -msgstr "" -"Une version générique de :class:`contextlib.AbstractAsyncContextManager`." +msgstr "Une version générique de :class:`contextlib.AbstractAsyncContextManager`." #: library/typing.rst:2360 #, fuzzy msgid "" -":class:`contextlib.AbstractAsyncContextManager` now supports subscripting " -"(``[]``). See :pep:`585` and :ref:`types-genericalias`." +":class:`contextlib.AbstractAsyncContextManager` now supports subscripting (``[]``). See :pep:`585` and :" +"ref:`types-genericalias`." msgstr "" -":class:`contextlib.AbstractAsyncContextManager` prend désormais en charge " -"``[]``. Voir :pep:`585` et :ref:`types-genericalias`." +":class:`contextlib.AbstractAsyncContextManager` prend désormais en charge ``[]``. Voir :pep:`585` et :ref:" +"`types-genericalias`." #: library/typing.rst:2366 msgid "Protocols" -msgstr "" +msgstr "Protocoles" #: library/typing.rst:2368 msgid "These protocols are decorated with :func:`runtime_checkable`." -msgstr "" +msgstr "Ces protocoles sont décorés par :func:`runtime_checkable`." #: library/typing.rst:2372 -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." +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." #: library/typing.rst:2377 msgid "An ABC with one abstract method ``__bytes__``." @@ -2802,12 +2476,8 @@ msgid "An ABC with one abstract method ``__int__``." msgstr "Une ABC avec une méthode abstraite ``__int__``." #: library/typing.rst:2399 -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." +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." #: library/typing.rst:2403 #, fuzzy @@ -2820,227 +2490,255 @@ msgstr "Convertit une valeur en un type." #: library/typing.rst:2409 msgid "" -"This returns the value unchanged. To the type checker this signals that the " -"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 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 " +"This returns the value unchanged. To the type checker this signals that the 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 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)." #: library/typing.rst:2416 -msgid "" -"Ask a static type checker to confirm that *val* has an inferred type of " -"*typ*." -msgstr "" +msgid "Ask a static type checker to confirm that *val* has an inferred type of *typ*." +msgstr "Vérifie que *val* est bien du type *typ*." #: library/typing.rst:2418 msgid "" -"When the type checker encounters a call to ``assert_type()``, it emits an " -"error if the value is not of the specified type::" +"When the type checker encounters a call to ``assert_type()``, it emits an error if the value is not of the " +"specified type::" msgstr "" +"Lors d'un appel à ``assert_type()``, le vérificateur de type va lever émettre une erreur si la variable " +"n'est pas du type renseigné ::" #: library/typing.rst:2425 -msgid "" -"At runtime this returns the first argument unchanged with no side effects." -msgstr "" +msgid "At runtime this returns the first argument unchanged with no side effects." +msgstr "Renvoie le premier argument inchangé lors de l'exécution." #: library/typing.rst:2427 msgid "" -"This function is useful for ensuring the type checker's understanding of a " -"script is in line with the developer's intentions::" +"This function is useful for ensuring the type checker's understanding of a script is in line with the " +"developer's intentions::" msgstr "" +"Cette fonction permet de s'assurer de la compréhension du vérificateur de type d'un script par rapport aux " +"intentions du développeur ::" #: library/typing.rst:2441 -msgid "" -"Ask a static type checker to confirm that a line of code is unreachable." +msgid "Ask a static type checker to confirm that a line of code is unreachable." msgstr "" +"Demande une confirmation de la part du vérificateur statique de type qu'une ligne de code est inaccessible." #: library/typing.rst:2454 msgid "" -"Here, the annotations allow the type checker to infer that the last case can " -"never execute, because ``arg`` is either an :class:`int` or a :class:`str`, " -"and both options are covered by earlier cases. If a type checker finds that " -"a call to ``assert_never()`` is reachable, it will emit an error. For " -"example, if the type annotation for ``arg`` was instead ``int | str | " -"float``, the type checker would emit an error pointing out that " -"``unreachable`` is of type :class:`float`. For a call to ``assert_never`` to " -"pass type checking, the inferred type of the argument passed in must be the " -"bottom type, :data:`Never`, and nothing else." +"Here, the annotations allow the type checker to infer that the last case can never execute, because " +"``arg`` is either an :class:`int` or a :class:`str`, and both options are covered by earlier cases. If a " +"type checker finds that a call to ``assert_never()`` is reachable, it will emit an error. For example, if " +"the type annotation for ``arg`` was instead ``int | str | float``, the type checker would emit an error " +"pointing out that ``unreachable`` is of type :class:`float`. For a call to ``assert_never`` to pass type " +"checking, the inferred type of the argument passed in must be the bottom type, :data:`Never`, and nothing " +"else." msgstr "" +"Les annotations permettent ici au vérificateur de type de déduire que le dernier cas ne sera jamais " +"exécuté car les seuls cas possibles (qu'``arg`` soit un :class:`int` ou un :class:`str`) sont couverts " +"dans les cas précédents. Une erreur est levée si un appel à ``assert_never()`` est atteignable. Par " +"exemple, si l'annotation de type d'``arg`` est ``int | str | float``, une erreur sera levée indiquant " +"qu'``unreachable`` est de type :class:`float`. Lors d'un appel à ``assert_never``, afin de passer la " +"vérification de type avec succès, le type déduit de l'argument doit être de type :data:`Never`." #: library/typing.rst:2466 msgid "At runtime, this throws an exception when called." -msgstr "" +msgstr "Une erreur est levé si la fonction est appelé lors de l'exécution." #: library/typing.rst:2469 msgid "" -"`Unreachable Code and Exhaustiveness Checking `__ has more information about " -"exhaustiveness checking with static typing." +"`Unreachable Code and Exhaustiveness Checking `__ has more information about exhaustiveness checking with static typing." msgstr "" +"`Unreachable Code and Exhaustiveness Checking `__ pour plus détails sur la vérification exhaustive statique de type." #: library/typing.rst:2477 msgid "Reveal the inferred static type of an expression." -msgstr "" +msgstr "Révèle le type statique déduit d'une expression." #: library/typing.rst:2479 msgid "" -"When a static type checker encounters a call to this function, it emits a " -"diagnostic with the type of the argument. For example::" +"When a static type checker encounters a call to this function, it emits a diagnostic with the type of the " +"argument. For example::" msgstr "" +"Lorsqu'un vérificateur de type rencontre un appel à cette fonction, il va diagnostiquer le type de " +"l'argument. Par exemple ::" #: library/typing.rst:2485 -msgid "" -"This can be useful when you want to debug how your type checker handles a " -"particular piece of code." -msgstr "" +msgid "This can be useful when you want to debug how your type checker handles a particular piece of code." +msgstr "Cela est utile afin de comprendre comment le vérificateur de type va traiter un bout de code précis." #: library/typing.rst:2488 -msgid "" -"The function returns its argument unchanged, which allows using it within an " -"expression::" -msgstr "" +msgid "The function returns its argument unchanged, which allows using it within an expression::" +msgstr "La fonction renvoie l'argument inchangé. Ce qui permet de l'utiliser au sein d'une expression ::" #: library/typing.rst:2493 msgid "" -"Most type checkers support ``reveal_type()`` anywhere, even if the name is " -"not imported from ``typing``. Importing the name from ``typing`` allows your " -"code to run without runtime errors and communicates intent more clearly." +"Most type checkers support ``reveal_type()`` anywhere, even if the name is not imported from ``typing``. " +"Importing the name from ``typing`` allows your code to run without runtime errors and communicates intent " +"more clearly." msgstr "" +"La plupart des vérificateurs de type supportent ``reveal_type()``, même dans le cas ou le nom du type " +"n'est pas importé depuis ``typing``. Cependant, l'import depuis ``typing`` permet d'éviter les erreurs " +"d'exécution et devient plus compréhensible." #: library/typing.rst:2498 msgid "" -"At runtime, this function prints the runtime type of its argument to stderr " -"and returns it unchanged::" +"At runtime, this function prints the runtime type of its argument to stderr and returns it unchanged::" msgstr "" +"Lors de l'exécution, cette fonction affiche le type de son argument dans stderr et le renvoie inchangé ::" #: library/typing.rst:2508 msgid "" -":data:`~typing.dataclass_transform` may be used to decorate a class, " -"metaclass, or a function that is itself a decorator. The presence of " -"``@dataclass_transform()`` tells a static type checker that the decorated " -"object performs runtime \"magic\" that transforms a class, giving it :func:" -"`dataclasses.dataclass`-like behaviors." +":data:`~typing.dataclass_transform` may be used to decorate a class, metaclass, or a function that is " +"itself a decorator. The presence of ``@dataclass_transform()`` tells a static type checker that the " +"decorated object performs runtime \"magic\" that transforms a class, giving it :func:`dataclasses." +"dataclass`-like behaviors." msgstr "" +":data:`~typing.dataclass_transform` permet de décorer une classe, une métaclasse ou une fonction " +"décoratrice. L'utilisation de `@dataclass_transform()`` avertit le vérificateur de type statique que " +"l'objet décoré effectue de la \"magie\" consistant à transformer une classe, lui appliquant un " +"comportement du type de :func:`dataclasses.dataclass`." #: library/typing.rst:2514 msgid "Example usage with a decorator function::" -msgstr "" +msgstr "Exemple d'utilisation avec une fonction décoratrice::" #: library/typing.rst:2528 msgid "On a base class::" -msgstr "" +msgstr "Avec une classe de base :" #: library/typing.rst:2537 msgid "On a metaclass::" -msgstr "" +msgstr "Avec une métaclasse :" #: library/typing.rst:2548 msgid "" -"The ``CustomerModel`` classes defined above will be treated by type checkers " -"similarly to classes created with :func:`@dataclasses.dataclass `. For example, type checkers will assume these classes have " -"``__init__`` methods that accept ``id`` and ``name``." +"The ``CustomerModel`` classes defined above will be treated by type checkers similarly to classes created " +"with :func:`@dataclasses.dataclass `. For example, type checkers will assume these " +"classes have ``__init__`` methods that accept ``id`` and ``name``." msgstr "" +"Les classes ``CustomerModel`` définis ci-dessus sont traitées par les vérificateurs de type de la même que " +"les classes créées avec :func:`@dataclasses.dataclass `. Par exemple, les " +"vérificateurs de type déduisent que ces classes possèdent une méthode ``__init__`` acceptant ``id`` et " +"``name`` comme arguments." #: library/typing.rst:2554 msgid "" -"The decorated class, metaclass, or function may accept the following bool " -"arguments which type checkers will assume have the same effect as they would " -"have on the :func:`@dataclasses.dataclass` decorator: " -"``init``, ``eq``, ``order``, ``unsafe_hash``, ``frozen``, ``match_args``, " -"``kw_only``, and ``slots``. It must be possible for the value of these " -"arguments (``True`` or ``False``) to be statically evaluated." +"The decorated class, metaclass, or function may accept the following bool arguments which type checkers " +"will assume have the same effect as they would have on the :func:`@dataclasses.dataclass` decorator: ``init``, ``eq``, ``order``, ``unsafe_hash``, ``frozen``, ``match_args``, " +"``kw_only``, and ``slots``. It must be possible for the value of these arguments (``True`` or ``False``) " +"to be statically evaluated." msgstr "" +"Les arguments booléens suivants sont acceptés,les vérificateurs de type supposent qu'ils ont le même effet " +"qu'ils auraient eu sur le décorateur :func:`@dataclasses.dataclass` : ``init``, " +"``eq``, ``order``, ``unsafe_hash``, ``frozen``, ``match_args``, ``kw_only``, et ``slots``. Il est possible " +"d'évaluer statiquement les valeurs de ces arguments (`True`` or ``False``)." #: library/typing.rst:2562 msgid "" -"The arguments to the ``dataclass_transform`` decorator can be used to " -"customize the default behaviors of the decorated class, metaclass, or " -"function:" +"The arguments to the ``dataclass_transform`` decorator can be used to customize the default behaviors of " +"the decorated class, metaclass, or function:" msgstr "" +"Les arguments du décorateur ``dataclass_transform`` permettent de personnaliser le comportement par défaut " +"de la classe, métaclasse ou fonction décorée :" #: library/typing.rst:2566 msgid "" -"``eq_default`` indicates whether the ``eq`` parameter is assumed to be " -"``True`` or ``False`` if it is omitted by the caller." +"``eq_default`` indicates whether the ``eq`` parameter is assumed to be ``True`` or ``False`` if it is " +"omitted by the caller." msgstr "" +"``eq_default`` indique la valeur du paramètre ``eq`` (``True`` ou ``False``) si ce ne n'est pas précisé " +"lors de l'appel." #: library/typing.rst:2568 msgid "" -"``order_default`` indicates whether the ``order`` parameter is assumed to be " -"True or False if it is omitted by the caller." +"``order_default`` indicates whether the ``order`` parameter is assumed to be True or False if it is " +"omitted by the caller." msgstr "" +"``order_default`` indique la valeur du paramètre ``order`` (``True`` ou ``False``) si ce n'est pas précisé " +"lors de l'appel." #: library/typing.rst:2570 msgid "" -"``kw_only_default`` indicates whether the ``kw_only`` parameter is assumed " -"to be True or False if it is omitted by the caller." +"``kw_only_default`` indicates whether the ``kw_only`` parameter is assumed to be True or False if it is " +"omitted by the caller." msgstr "" +"``kw_only_default`` indique la valeur du paramètre ``kw_only_default`` (``True`` ou ``False``) si ce ne " +"n'est pas précisé lors de l'appel." #: library/typing.rst:2572 msgid "" -"``field_specifiers`` specifies a static list of supported classes or " -"functions that describe fields, similar to ``dataclasses.field()``." +"``field_specifiers`` specifies a static list of supported classes or functions that describe fields, " +"similar to ``dataclasses.field()``." msgstr "" +"``field_specifiers`` Spécifie une liste statique des classes ou fonctions supportées pour la description " +"des champs, similaire à ``dataclasses.field()``." #: library/typing.rst:2574 -msgid "" -"Arbitrary other keyword arguments are accepted in order to allow for " -"possible future extensions." -msgstr "" +msgid "Arbitrary other keyword arguments are accepted in order to allow for possible future extensions." +msgstr "D'autres arguments sont acceptées afin d'autoriser de futurs possibles extensions." #: library/typing.rst:2577 -msgid "" -"Type checkers recognize the following optional arguments on field specifiers:" -msgstr "" +msgid "Type checkers recognize the following optional arguments on field specifiers:" +msgstr "Les arguments optionnels suivants pour la spécifications des champs sont reconnus :" #: library/typing.rst:2580 msgid "" -"``init`` indicates whether the field should be included in the synthesized " -"``__init__`` method. If unspecified, ``init`` defaults to ``True``." +"``init`` indicates whether the field should be included in the synthesized ``__init__`` method. If " +"unspecified, ``init`` defaults to ``True``." msgstr "" +"``init`` indique si le champ doit être inclut au sein de la méthode ``__init__``. Vaut ``True`` par défaut." #: library/typing.rst:2583 msgid "``default`` provides the default value for the field." -msgstr "" +msgstr "``default`` indique la valeur par défaut du champ." #: library/typing.rst:2584 msgid "" -"``default_factory`` provides a runtime callback that returns the default " -"value for the field. If neither ``default`` nor ``default_factory`` are " -"specified, the field is assumed to have no default value and must be " -"provided a value when the class is instantiated." +"``default_factory`` provides a runtime callback that returns the default value for the field. If neither " +"``default`` nor ``default_factory`` are specified, the field is assumed to have no default value and must " +"be provided a value when the class is instantiated." msgstr "" +"``default_factory`` fournit une fonction de rappel renvoyant la valeur par défaut du champ. Si les " +"arguments ``default` et ``default_factory`` ne sont pas renseignés, le champ n'a pas de valeur pas défaut " +"et il faudra en fournir une lors de l'instanciation de la classe." #: library/typing.rst:2589 msgid "``factory`` is an alias for ``default_factory``." -msgstr "" +msgstr "``factory`` est un alias pour ``default_factory``." #: library/typing.rst:2590 msgid "" -"``kw_only`` indicates whether the field should be marked as keyword-only. If " -"``True``, the field will be keyword-only. If ``False``, it will not be " -"keyword-only. If unspecified, the value of the ``kw_only`` parameter on the " -"object decorated with ``dataclass_transform`` will be used, or if that is " -"unspecified, the value of ``kw_only_default`` on ``dataclass_transform`` " -"will be used." +"``kw_only`` indicates whether the field should be marked as keyword-only. If ``True``, the field will be " +"keyword-only. If ``False``, it will not be keyword-only. If unspecified, the value of the ``kw_only`` " +"parameter on the object decorated with ``dataclass_transform`` will be used, or if that is unspecified, " +"the value of ``kw_only_default`` on ``dataclass_transform`` will be used." msgstr "" +"``kw_only`` indique si le champ est *keyword-only*. Si l'argument n'est pas renseigné, la valeur du " +"paramètre ``kw_only`` de l'objet décoré avec ``dataclass_transform`` est utilisé. Ou si cette valeur n'est " +"pas renseigné non plus, la valeur de ``kw_only_default`` de ``dataclass_transform`` est utilisé." #: library/typing.rst:2596 msgid "" -"``alias`` provides an alternative name for the field. This alternative name " -"is used in the synthesized ``__init__`` method." +"``alias`` provides an alternative name for the field. This alternative name is used in the synthesized " +"``__init__`` method." msgstr "" +"``alias`` indique un nom alternatif pour le champ. Cet alias est utilisé dans le méthode ``__init__`` " +"synthétisée." #: library/typing.rst:2599 msgid "" -"At runtime, this decorator records its arguments in the " -"``__dataclass_transform__`` attribute on the decorated object. It has no " -"other runtime effect." +"At runtime, this decorator records its arguments in the ``__dataclass_transform__`` attribute on the " +"decorated object. It has no other runtime effect." msgstr "" +"Lors de l'exécution, les arguments de ce décorateur sont enregistrés au sein de l'attribut " +"``__dataclass_transform__`` de l'objet décoré. Il n'y pas d'autre effet à l'exécution." #: library/typing.rst:2603 #, fuzzy @@ -3049,103 +2747,93 @@ msgstr "Voir la :pep:`484` pour plus de détails." #: library/typing.rst:2609 msgid "" -"The ``@overload`` decorator allows describing functions and methods that " -"support multiple different combinations of argument types. A series of " -"``@overload``-decorated definitions must be followed by exactly one non-" -"``@overload``-decorated definition (for the same function/method). The " -"``@overload``-decorated definitions are for the benefit of the type checker " -"only, since they will be overwritten by the non-``@overload``-decorated " -"definition, while the latter is used at runtime but should be ignored by a " -"type checker. At runtime, calling a ``@overload``-decorated function " -"directly will raise :exc:`NotImplementedError`. An example of overload that " -"gives a more precise type than can be expressed using a union or a type " -"variable::" +"The ``@overload`` decorator allows describing functions and methods that support multiple different " +"combinations of argument types. A series of ``@overload``-decorated definitions must be followed by " +"exactly one non-``@overload``-decorated definition (for the same function/method). The ``@overload``-" +"decorated definitions are for the benefit of the type checker only, since they will be overwritten by the " +"non-``@overload``-decorated definition, while the latter is used at runtime but should be ignored by a " +"type checker. At runtime, calling a ``@overload``-decorated function directly will raise :exc:" +"`NotImplementedError`. An example of overload that 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 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 ::" +"Le décorateur ``@overload`` permet de décrire des fonctions et des méthodes 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 ::" #: library/typing.rst:2633 #, fuzzy -msgid "" -"See :pep:`484` for more details and comparison with other typing semantics." -msgstr "" -"Voir la :pep:`484` pour plus de détails et la comparaison avec d'autres " -"sémantiques de typage." +msgid "See :pep:`484` for more details and comparison with other typing semantics." +msgstr "Voir la :pep:`484` pour plus de détails et la comparaison avec d'autres sémantiques de typage." #: library/typing.rst:2635 -msgid "" -"Overloaded functions can now be introspected at runtime using :func:" -"`get_overloads`." +msgid "Overloaded functions can now be introspected at runtime using :func:`get_overloads`." msgstr "" +"Les fonctions surchargées peuvent maintenant être inspectées durant l'exécution via :func:`get_overloads`." #: library/typing.rst:2642 msgid "" -"Return a sequence of :func:`@overload `-decorated definitions for " -"*func*. *func* is the function object for the implementation of the " -"overloaded function. For example, given the definition of ``process`` in the " -"documentation for :func:`@overload `, ``get_overloads(process)`` " -"will return a sequence of three function objects for the three defined " -"overloads. If called on a function with no overloads, ``get_overloads()`` " -"returns an empty sequence." +"Return a sequence of :func:`@overload `-decorated definitions for *func*. *func* is the function " +"object for the implementation of the overloaded function. For example, given the definition of ``process`` " +"in the documentation for :func:`@overload `, ``get_overloads(process)`` will return a sequence " +"of three function objects for the three defined overloads. If called on a function with no overloads, " +"``get_overloads()`` returns an empty sequence." msgstr "" +"Renvoie la séquence des définitions des fonctions décorées comme :func:`@overload ` associées à " +"*func*. *func* est l'objet de la fonction implémenté de base. Par exemple, en reprenant le définition de " +"``process`` dans la documentation pour :func:`@overload `, ``get_overloads(process)`` renvoie " +"une séquence composée de trois objets de fonction associés aux trois fonctions surchargées définies. En " +"cas d'appel à ``get_overloads()`` sur une fonction non surchargés, une séquence vide est retournée." #: library/typing.rst:2650 -msgid "" -"``get_overloads()`` can be used for introspecting an overloaded function at " -"runtime." -msgstr "" +msgid "``get_overloads()`` can be used for introspecting an overloaded function at runtime." +msgstr "``get_overloads()`` peut être utilisé afin d'inspecter une fonction surchargée durant l'exécution." #: library/typing.rst:2658 msgid "" -"Clear all registered overloads in the internal registry. This can be used to " -"reclaim the memory used by the registry." +"Clear all registered overloads in the internal registry. This can be used to reclaim the memory used by " +"the registry." msgstr "" +"Suppression de toutes les surcharges enregistrées au sein du registre interne. Cela peut être utilisé afin " +"de récupérer la mémoire utilisé par le registre." #: library/typing.rst:2666 msgid "" -"A decorator to indicate to type checkers that the decorated method cannot be " -"overridden, and the decorated class cannot be subclassed. For example::" +"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 ::" #: library/typing.rst:2689 msgid "" -"The decorator will now set the ``__final__`` attribute to ``True`` on the " -"decorated object. Thus, a check like ``if getattr(obj, \"__final__\", " -"False)`` can be used at runtime to determine whether an object ``obj`` has " -"been marked as final. If the decorated object does not support setting " -"attributes, the decorator returns the object unchanged without raising an " -"exception." +"The decorator will now set the ``__final__`` attribute to ``True`` on the decorated object. Thus, a check " +"like ``if getattr(obj, \"__final__\", False)`` can be used at runtime to determine whether an object " +"``obj`` has been marked as final. If the decorated object does not support setting attributes, the " +"decorator returns the object unchanged without raising an exception." msgstr "" +"Le décorateur met l'attribut ``__final__`` à ``True`` de l'objet décoré. Cela permet d'utiliser une " +"vérification comme ``if getattr(obj, \"__final__\", False)`` durant l'exécution afin de vérifier si un " +"objet ``obj`` est décoré comme ``final``. Dans le cas où l'objet décoré ne supporte pas la modification " +"d'attributs, le décorateur retournera l'objet de base sans lever d'exception." #: library/typing.rst:2700 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." +msgstr "Décorateur pour indiquer que les annotations ne sont pas des indications de type." #: library/typing.rst:2702 #, fuzzy msgid "" -"This works as class or function :term:`decorator`. With a class, it applies " -"recursively to all methods and classes defined in that class (but not to " -"methods defined in its superclasses or subclasses)." +"This works as class or function :term:`decorator`. With a class, it applies recursively to all methods " +"and classes 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)." #: library/typing.rst:2706 msgid "This mutates the function(s) in place." @@ -3153,146 +2841,131 @@ msgstr "Cela fait muter la ou les fonctions en place." #: library/typing.rst:2710 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`." +msgstr "Décorateur pour donner à un autre décorateur l'effet :func:`no_type_check`." #: library/typing.rst:2712 -msgid "" -"This wraps the decorator with something that wraps the decorated function " -"in :func:`no_type_check`." +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`." +"Ceci enveloppe le décorateur avec quelque chose qui enveloppe la fonction décorée dans :func:" +"`no_type_check`." #: library/typing.rst:2717 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." +"Décorateur pour marquer une classe ou une fonction comme étant indisponible au moment de l'exécution." #: library/typing.rst:2719 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::" +"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::" 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 " -"d'annotations de type (*type stub file*, en anglais) si une implémentation " -"renvoie une instance d'une classe privée ::" +"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 d'annotations de type (*type stub file*, en anglais) si une " +"implémentation renvoie une instance d'une classe privée ::" #: library/typing.rst:2730 msgid "" -"Note that returning instances of private classes is not recommended. It is " -"usually preferable to make such classes public." +"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 renvoyer les instances des classes " -"privées. Il est généralement préférable de rendre ces classes publiques." +"Notez qu'il n'est pas recommandé de renvoyer les instances des classes privées. Il est généralement " +"préférable de rendre ces classes publiques." #: library/typing.rst:2734 msgid "Introspection helpers" -msgstr "" +msgstr "Utilitaires d'introspection" #: library/typing.rst:2738 -msgid "" -"Return a dictionary containing type hints for a function, method, module or " -"class object." +msgid "Return a dictionary containing type hints for a function, method, module or class object." msgstr "" -"renvoie 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." #: library/typing.rst:2741 #, fuzzy 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. For a class ``C``, return a " -"dictionary constructed by merging all the ``__annotations__`` along ``C." -"__mro__`` in reverse order." +"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. 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``, renvoie un dictionnaire construit en fusionnant toutes les " -"``__annotations__`` en parcourant ``C.__mro__`` en ordre inverse." +"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``, renvoie un dictionnaire construit en " +"fusionnant toutes les ``__annotations__`` en parcourant ``C.__mro__`` en ordre inverse." #: library/typing.rst:2747 msgid "" -"The function recursively replaces all ``Annotated[T, ...]`` with ``T``, " -"unless ``include_extras`` is set to ``True`` (see :class:`Annotated` for " -"more information). For example::" +"The function recursively replaces all ``Annotated[T, ...]`` with ``T``, unless ``include_extras`` is set " +"to ``True`` (see :class:`Annotated` for more information). For example::" msgstr "" +"La fonction remplace de manière récursive, tous les ``Annotated[T, ...]`` par ``T`` sauf dans le cas où " +"``include_extras`` est égale à ``True`` (voir `Annotated` pour plus de détails). Par exemple :" #: library/typing.rst:2762 +#, fuzzy msgid "" -":func:`get_type_hints` does not work with imported :ref:`type aliases ` that include forward references. Enabling postponed evaluation of " -"annotations (:pep:`563`) may remove the need for most forward references." +":func:`get_type_hints` does not work with imported :ref:`type aliases ` that include forward " +"references. Enabling postponed evaluation of annotations (:pep:`563`) may remove the need for most forward " +"references." msgstr "" +":func:`get_type_hints` ne fonctionne pas avec les :ref:`alias de type ` importés contenant " +"des références directes. L'activation d'évaluation différée des annotations (:pep:`563`) permet de " +"supprimer le besoin de références directes supplémentaires." #: library/typing.rst:2767 msgid "Added ``include_extras`` parameter as part of :pep:`593`." -msgstr "" +msgstr "Ajout du paramètre ``include_extras`` au sein de la :pep:`593`." #: library/typing.rst:2770 msgid "" -"Previously, ``Optional[t]`` was added for function and method annotations if " -"a default value equal to ``None`` was set. Now the annotation is returned " -"unchanged." +"Previously, ``Optional[t]`` was added for function and method annotations if a default value equal to " +"``None`` was set. Now the annotation is returned unchanged." msgstr "" +"Avant, ``Optional[t]`` était ajouté pour les annotations de fonctions et de méthodes dans le cas où une " +"valeur par défaut était égal à ``None``. Maintenant, les annotations sont renvoyées inchangés." #: library/typing.rst:2778 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." +msgstr "Fournit une introspection de base pour les types génériques et les formes spéciales de typage." #: library/typing.rst:2780 #, fuzzy 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:" -"`collections` class, it gets normalized to the original class. If ``X`` is a " -"union or :class:`Literal` contained in another generic type, the order of " -"``(Y, Z, ...)`` may be different from the order of the original arguments " -"``[Y, Z, ...]`` due to type caching. For unsupported objects return ``None`` " -"and ``()`` correspondingly. Examples::" +"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. If ``X`` is a union or :class:`Literal` contained in another generic type, the order of ``(Y, " +"Z, ...)`` may be different from the order of the original arguments ``[Y, Z, ...]`` due to type caching. " +"For unsupported objects return ``None`` and ``()`` correspondingly. Examples::" 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 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 ::" #: library/typing.rst:2799 msgid "Check if a type is a :class:`TypedDict`." -msgstr "" +msgstr "Vérifie si le type est un :class:`TypedDict`." #: library/typing.rst:2814 #, fuzzy 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, " -"``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." +"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." #: library/typing.rst:2820 msgid "" -":pep:`585` generic types such as ``list[\"SomeClass\"]`` will not be " -"implicitly transformed into ``list[ForwardRef(\"SomeClass\")]`` and thus " -"will not automatically resolve to ``list[SomeClass]``." +":pep:`585` generic types such as ``list[\"SomeClass\"]`` will not be implicitly transformed into " +"``list[ForwardRef(\"SomeClass\")]`` and thus will not automatically resolve to ``list[SomeClass]``." msgstr "" -":pep:`585` les types tels que ``list[\"SomeClass\"]`` ne seront pas" -"implicitement transformés en ``list[ForwardRef(\"SomeClass\")]`` et " -"ne seront donc pas automatiquement résolus en ``list[SomeClass]``." +":pep:`585` les types tels que ``list[\"SomeClass\"]`` ne seront pasimplicitement transformés en " +"``list[ForwardRef(\"SomeClass\")]`` et ne seront donc pas automatiquement résolus en ``list[SomeClass]``." #: library/typing.rst:2827 msgid "Constant" @@ -3300,39 +2973,33 @@ msgstr "Constante" #: library/typing.rst:2831 msgid "" -"A special constant that is assumed to be ``True`` by 3rd party static type " -"checkers. It is ``False`` at runtime. Usage::" +"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 ::" #: library/typing.rst:2840 #, fuzzy msgid "" -"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." +"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." msgstr "" -"Notez que la première annotation de type doit être entourée de guillemets, " -"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 " -"guillemets." +"Notez que la première annotation de type doit être entourée de guillemets, 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 guillemets." #: library/typing.rst:2847 msgid "" -"If ``from __future__ import annotations`` is used, annotations are not " -"evaluated at function definition time. Instead, they are stored as strings " -"in ``__annotations__``. This makes it unnecessary to use quotes around the " -"annotation (see :pep:`563`)." +"If ``from __future__ import annotations`` is used, annotations are not evaluated at function definition " +"time. Instead, they are stored as strings in ``__annotations__``. This makes it unnecessary to use quotes " +"around the annotation (see :pep:`563`)." msgstr "" -"Si ``from __future__ import annotations`` est utilisé, les annotations ne sont " -"pas evaluées au moment de la définition de fonction. " -"Elles sont alors stockées comme des chaînes de caractères " -"dans ``__annotations__``, ce qui rend inutile l'utilisation de quotes autour de " -"l'annotation (see :pep:`563`)." +"Si ``from __future__ import annotations`` est utilisé, les annotations ne sont pas evaluées au moment de " +"la définition de fonction. Elles sont alors stockées comme des chaînes de caractères dans " +"``__annotations__``, ce qui rend inutile l'utilisation de quotes autour de l'annotation (see :pep:`563`)." #: library/typing.rst:2856 msgid "Deprecation Timeline of Major Features" @@ -3340,14 +3007,13 @@ msgstr "Etapes d'Obsolescence des Fonctionnalités Majeures" #: library/typing.rst:2858 msgid "" -"Certain features in ``typing`` are deprecated and may be removed in a future " -"version of Python. The following table summarizes major deprecations for " -"your convenience. This is subject to change, and not all deprecations are " -"listed." +"Certain features in ``typing`` are deprecated and may be removed in a future version of Python. The " +"following table summarizes major deprecations for your convenience. This is subject to change, and not all " +"deprecations are listed." msgstr "" "Certaines fonctionnalités dans ``typing`` sont obsolètes et peuvent être supprimées dans une future " -"version de Python. Le tableau suivant résume les principales dépréciations." -" Celui-ci peut changer et toutes les dépréciations ne sont pas listées." +"version de Python. Le tableau suivant résume les principales dépréciations. Celui-ci peut changer et " +"toutes les dépréciations ne sont pas listées." #: library/typing.rst:2863 msgid "Feature" @@ -3383,7 +3049,7 @@ msgstr "" #: library/typing.rst:2868 msgid "``typing`` versions of standard collections" -msgstr "" +msgstr "Versions de typing des collections standards" #: library/typing.rst:2868 msgid "3.9" @@ -3391,7 +3057,7 @@ msgstr "" #: library/typing.rst:2871 msgid "Undecided" -msgstr "" +msgstr "Non défini" #: library/typing.rst:2868 msgid ":pep:`585`" @@ -3410,33 +3076,24 @@ msgid ":gh:`92332`" msgstr "" #~ 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`." +#~ "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`." #~ 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::" +#~ "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 ::" +#~ "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 ::" #~ 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]``." +#~ msgstr "Vous pouvez utiliser l'abréviation ``Optional[X]`` pour ``Union[X, None]``." -#~ msgid "" -#~ "**Warning:** this will check only the presence of the required methods, " -#~ "not their type signatures!" +#~ 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 !" +#~ "**Attention :** ceci ne vérifiera que la présence des méthodes requises, et non leur signature de type !"