From 92e43cb2cbcd47ad2a308512aa2e3ae12745c62e Mon Sep 17 00:00:00 2001 From: NicolasGibaud Date: Fri, 17 Feb 2023 16:53:03 +0000 Subject: [PATCH] library-typing (#84) Closes #49 Co-authored-by: Zoe Drey Co-authored-by: Nicolas Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/84 Co-authored-by: NicolasGibaud Co-committed-by: NicolasGibaud --- library/typing.po | 365 +++++++++++++++++++++++++++++++++------------- 1 file changed, 262 insertions(+), 103 deletions(-) diff --git a/library/typing.po b/library/typing.po index a0a6fda5..9306b0b9 100644 --- a/library/typing.po +++ b/library/typing.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-01-15 22:33+0100\n" -"PO-Revision-Date: 2022-11-21 22:01+0100\n" -"Last-Translator: Jean-Michel Laprise \n" +"PO-Revision-Date: 2023-02-17 16:13+0100\n" +"Last-Translator: Nicolas Gibaud \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -"X-Generator: Poedit 2.4.3\n" +"X-Generator: Poedit 2.3\n" #: library/typing.rst:3 msgid ":mod:`typing` --- Support for type hints" @@ -69,12 +69,19 @@ msgid "" "`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étro-portages de ces fonctionnalités vers les anciennes " +"versions 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`_." #: library/typing.rst:44 msgid "" @@ -82,10 +89,15 @@ msgid "" "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" -msgstr "" +msgstr "PEPs pertinentes" #: library/typing.rst:53 msgid "" @@ -93,147 +105,165 @@ msgid "" "number of PEPs have modified and enhanced Python's framework for type " "annotations. These include:" msgstr "" +"Depuis l'introduction initiale des annotations de type dans les :pep:`484` " +"et :pep:`483`, plusieurs PEPs ont modifié et amélioré le framework " +"d'annotation de type. Cela inclut :" #: library/typing.rst:58 msgid ":pep:`526`: Syntax for Variable Annotations" -msgstr "" +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 "" +"*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`" #: library/typing.rst:64 msgid ":pep:`585`: Type Hinting Generics In Standard Collections" -msgstr "" +msgstr ":pep:`585`: Annotations de Type Générique 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 les " +"classes de bibliothèques natives comme les :ref:`types génériques`" #: library/typing.rst:66 msgid ":pep:`586`: Literal Types" -msgstr "" +msgstr ":pep:`586`: Types Littéraux" #: library/typing.rst:67 msgid "*Introducing* :data:`Literal`" -msgstr "" +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" #: library/typing.rst:69 msgid "*Introducing* :class:`TypedDict`" -msgstr "" +msgstr "*Ajout* de :class:`TypedDict`" #: library/typing.rst:70 msgid ":pep:`591`: Adding a final qualifier to typing" -msgstr "" +msgstr ":pep:`591`: Ajout d'un qualificatif final au typage" #: library/typing.rst:71 msgid "*Introducing* :data:`Final` and the :func:`@final` decorator" -msgstr "" +msgstr "*Ajout* de :data:`Final` et du décorateur :func:`@final`" #: library/typing.rst:72 msgid ":pep:`593`: Flexible function and variable annotations" -msgstr "" +msgstr ":pep:`593`: fonction Flexible et annotations de variables" #: library/typing.rst:73 msgid "*Introducing* :data:`Annotated`" -msgstr "" +msgstr "*Ajout* de :data:`Annotated`" #: library/typing.rst:76 msgid ":pep:`604`: Allow writing union types as ``X | Y``" -msgstr "" +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`" #: library/typing.rst:78 msgid ":pep:`612`: Parameter Specification Variables" -msgstr "" +msgstr ":pep:`612`: Variables de Spécification de Paramètre" #: library/typing.rst:79 msgid "*Introducing* :class:`ParamSpec` and :data:`Concatenate`" -msgstr "" +msgstr "*Ajout* de :class:`ParamSpec` et de :data:`Concatenate`" #: library/typing.rst:80 #, fuzzy msgid ":pep:`613`: Explicit Type Aliases" -msgstr "Voir la :pep:`484` pour plus de détails." +msgstr ":pep:`613`: Alias de Type Explicites" #: library/typing.rst:81 msgid "*Introducing* :data:`TypeAlias`" -msgstr "" +msgstr "*Ajout* de :data:`TypeAlias`" #: library/typing.rst:82 msgid ":pep:`646`: Variadic Generics" -msgstr "" +msgstr ":pep:`646`: Génériques Variadiques" #: library/typing.rst:83 msgid "*Introducing* :data:`TypeVarTuple`" -msgstr "" +msgstr "*Ajout* de :data:`TypeVarTuple`" #: library/typing.rst:84 msgid ":pep:`647`: User-Defined Type Guards" -msgstr "" +msgstr ":pep:`647`: Gardes de Types Définies par l'Utilisateur" #: library/typing.rst:85 msgid "*Introducing* :data:`TypeGuard`" -msgstr "" +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" #: library/typing.rst:87 msgid "*Introducing* :data:`Required` and :data:`NotRequired`" -msgstr "" +msgstr "*Ajout* de :data:`Required` et de :data:`NotRequired`" #: library/typing.rst:88 msgid ":pep:`673`: Self type" -msgstr "" +msgstr ":pep:`673`: Type self" #: library/typing.rst:89 msgid "*Introducing* :data:`Self`" -msgstr "" +msgstr "*Ajout* de :data:`Self`" #: library/typing.rst:90 msgid ":pep:`675`: Arbitrary Literal String Type" -msgstr "" +msgstr ":pep:`675`: Type String Littéral Arbitraire" #: library/typing.rst:91 msgid "*Introducing* :data:`LiteralString`" -msgstr "" +msgstr "*Ajout* de :data:`LiteralString`" #: library/typing.rst:93 msgid ":pep:`681`: Data Class Transforms" -msgstr "" +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`" #: library/typing.rst:98 msgid "Type aliases" @@ -245,7 +275,7 @@ msgid "" "A type alias is defined by assigning the type to the alias. In this example, " "``Vector`` and ``list[float]`` will be treated as interchangeable synonyms::" msgstr "" -"Un alias de type est défini en assignant le type à l'alias. Dans cet " +"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 ::" @@ -262,7 +292,7 @@ msgid "" "Note that ``None`` as a type hint is a special case and is replaced by " "``type(None)``." msgstr "" -"Notez que ``None`` comme indication de type est un cas particulier et est " +"Notez que ``None`` comme annotation de type est un cas particulier et est " "remplacé par ``type(None)``." #: library/typing.rst:135 @@ -270,17 +300,15 @@ msgid "NewType" msgstr "*NewType*" #: library/typing.rst:137 -#, fuzzy msgid "Use the :class:`NewType` helper to create distinct types::" -msgstr "" -"Aidez-vous de la fonction :func:`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::" msgstr "" -"Le vérificateur de type statique traite le nouveau type comme s'il " +"Le vérificateur de types statiques 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 ::" @@ -298,7 +326,6 @@ msgstr "" "``UserId`` d'une manière invalide ::" #: library/typing.rst:164 -#, fuzzy msgid "" "Note that these checks are enforced only by the static type checker. At " "runtime, the statement ``Derived = NewType('Derived', Base)`` will make " @@ -306,11 +333,11 @@ msgid "" "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 " +"Notez que ces contrôles ne sont exécutés que par le vérificateur de types " "statique. À l'exécution, l'instruction ``Derived = NewType('Derived', " "Base)`` fait de ``Derived`` une fonction qui renvoie immédiatement le " "paramètre que vous lui passez. Cela signifie que l'expression " -"``Derived(some_value)`` ne crée pas une nouvelle classe ou n'introduit pas " +"``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 @@ -323,15 +350,14 @@ msgstr "" #: library/typing.rst:173 msgid "It is invalid to create a subtype of ``Derived``::" -msgstr "" +msgstr "La création d'un sous-type de ``Derived`` est invalide:" #: library/typing.rst:182 -#, fuzzy msgid "" "However, it is possible to create a :class:`NewType` based on a 'derived' " "``NewType``::" msgstr "" -"Cependant, il est possible de créer un :func:`NewType` basé sur un " +"Il est néanmoins possible de créer un :class:`NewType` basé sur un " "``NewType`` « dérivé » ::" #: library/typing.rst:190 @@ -351,7 +377,7 @@ msgid "" 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 " +"vérificateur de types statiques traite ``Alias`` comme étant *exactement " "équivalent* à ``Original`` dans tous les cas. C'est utile lorsque vous " "voulez simplifier des signatures complexes." @@ -365,12 +391,12 @@ msgid "" "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 en sorte que le " -"vérificateur de type statique traite ``Derived`` comme une *sous-classe* de " -"``Original``, ce qui signifie qu'une valeur de type ``Original`` ne peut " -"être utilisée dans les endroits où une valeur de type ``Derived`` est " -"prévue. C'est utile lorsque vous voulez éviter les erreurs logiques avec un " -"coût d'exécution minimal." +"É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 "" @@ -378,6 +404,9 @@ msgid "" "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." #: library/typing.rst:217 msgid "Callable" @@ -416,18 +445,29 @@ msgid "" "``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 appelables, 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." msgstr "" +"``Callable`` prend désormais en charge :class:`ParamSpec` et :data:" +"`Concatenate`. Voir :pep:`612` pour plus de détails." #: 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``." #: library/typing.rst:260 msgid "Generics" @@ -590,9 +630,9 @@ msgid "" "every type as being compatible with :data:`Any` and :data:`Any` as being " "compatible with every type." msgstr "" -"Un type particulier est :data:`Any`. Un vérificateur de type statique traite " -"chaque type comme étant compatible avec :data:`Any` et :data:`Any` comme " -"étant compatible avec chaque type." +"Un type particulier est :data:`Any`. Un vérificateur de types statiques " +"traite chaque type comme étant compatible avec :data:`Any` et :data:`Any` " +"comme étant compatible avec chaque type." #: library/typing.rst:453 #, fuzzy @@ -615,9 +655,9 @@ msgid "" msgstr "" "Notez qu'aucun contrôle de typage n'est effectué lors de l'affectation d'une " "valeur de type :data:`Any` à un type plus précis. Par exemple, le " -"vérificateur de type statique 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 !" +"vérificateur de types statiques 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 "" @@ -655,7 +695,7 @@ msgid "" "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 " +"vérificateur de types 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 ::" @@ -1146,7 +1186,7 @@ msgid "" 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 " +"signatures de méthode de classe que ``C``. Le vérificateur de types 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 " @@ -1238,7 +1278,7 @@ 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 " +"par des vérificateurs tiers. Par exemple, un vérificateur de types peut " "marquer le code suivant comme une erreur ::" #: library/typing.rst:1019 @@ -1765,9 +1805,9 @@ msgstr "Marquez une classe de protocole comme protocole d'exécution." msgid "" "Such a protocol can be used with :func:`isinstance` and :func:`issubclass`. " "This raises :exc:`TypeError` when applied to a non-protocol class. This " -"allows a simple-minded structural check, very similar to \"one trick " -"ponies\" in :mod:`collections.abc` such as :class:`~collections.abc." -"Iterable`. For example::" +"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 " @@ -1888,7 +1928,7 @@ msgid "" "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 " +"vérificateur de types, voir :ref:`distinct`. Lors de l'exécution, elle " "renvoie une fonction qui renvoie son argument. Utilisation ::" #: library/typing.rst:1682 @@ -2297,7 +2337,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`." @@ -2491,7 +2531,7 @@ msgstr "" #: 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`." @@ -2587,7 +2627,7 @@ msgstr "Un alias pour :class:`collections.abc.Sized`" #: library/typing.rst:2249 msgid "Asynchronous programming" -msgstr "" +msgstr "Programmation asynchrone" #: library/typing.rst:2253 msgid "" @@ -2692,7 +2732,7 @@ msgstr "" #: 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`." @@ -2723,11 +2763,11 @@ msgstr "" #: 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 "" @@ -2780,7 +2820,7 @@ msgid "" "return value has the designated type, but at runtime we intentionally don't " "check anything (we want this to be as fast as possible)." msgstr "" -"Ceci renvoie la valeur inchangée. Pour le vérificateur de type, cela " +"Ceci renvoie la valeur inchangée. Pour le vérificateur de types, 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)." @@ -2789,29 +2829,35 @@ msgstr "" msgid "" "Ask a static type checker to confirm that *val* has an inferred type of " "*typ*." -msgstr "" +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::" msgstr "" +"Lors d'un appel à ``assert_type()``, le vérificateur de types 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 "" +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::" 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." 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 "" @@ -2825,10 +2871,19 @@ msgid "" "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 types 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 "" @@ -2836,28 +2891,37 @@ msgid "" "en/latest/source/unreachable.html>`__ 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::" msgstr "" +"Lorsqu'un vérificateur de types 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 "" +"Cela est utile afin de comprendre comment le vérificateur de types 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 "" +"La fonction renvoie l'argument inchangé. Ce qui permet de l'utiliser au sein " +"d'une expression ::" #: library/typing.rst:2493 msgid "" @@ -2865,12 +2929,18 @@ msgid "" "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::" 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 "" @@ -2880,18 +2950,23 @@ msgid "" "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 types statiques 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 "" @@ -2900,6 +2975,11 @@ msgid "" "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 "" @@ -2910,6 +2990,12 @@ msgid "" "``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 "" @@ -2917,51 +3003,69 @@ msgid "" "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." 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." 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." 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()``." msgstr "" +"``field_specifiers`` spécifie une liste statique des classes ou fonctions " +"prises en charge 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 "" +"D'autres arguments sont acceptés afin d'autoriser de futurs possibles " +"extensions." #: library/typing.rst:2577 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``." 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 "" @@ -2970,10 +3074,14 @@ msgid "" "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 "" @@ -2984,12 +3092,19 @@ msgid "" "unspecified, the value of ``kw_only_default`` on ``dataclass_transform`` " "will be used." msgstr "" +"``kw_only`` indique si le champ est uniquement par mot-clé. 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." 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 "" @@ -2997,6 +3112,9 @@ msgid "" "``__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 @@ -3024,7 +3142,7 @@ msgstr "" "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, " +"qu'il convient que le vérificateur de types 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 ::" @@ -3042,6 +3160,8 @@ 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 "" @@ -3053,18 +3173,31 @@ msgid "" "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 "" +"``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." 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 "" @@ -3084,6 +3217,12 @@ msgid "" "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." @@ -3147,18 +3286,17 @@ msgstr "" #: 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." msgstr "" -"renvoie un dictionnaire contenant des indications de type pour une fonction, " +"Renvoie un dictionnaire contenant des annotations 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 " @@ -3167,11 +3305,9 @@ msgid "" "__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 " +"postérieures encodées sous forme de chaîne de caractères sont évaluées dans " +"les espaces de nommage ``globals`` et ``locals``. Pour une classe ``C``, " +"elle renvoie un dictionnaire construit en fusionnant toutes les " "``__annotations__`` en parcourant ``C.__mro__`` en ordre inverse." #: library/typing.rst:2747 @@ -3180,6 +3316,9 @@ msgid "" "unless ``include_extras`` is set to ``True`` (see :class:`Annotated` for " "more information). For example::" msgstr "" +"La fonction remplace récursivement tous les ``Annotated[T, ...]`` avec " +"``T``, sauf si la valeur de ``include_extras`` est définie à ``True`` (voir :" +"class:`Annotated` pour plus d'information). Par exemple ::" #: library/typing.rst:2762 msgid "" @@ -3187,10 +3326,14 @@ msgid "" "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 postérieures. L'activation " +"d'évaluation différée des annotations (:pep:`563`) permet de supprimer le " +"besoin de références postérieures supplémentaires." #: library/typing.rst:2767 msgid "Added ``include_extras`` parameter as part of :pep:`593`." -msgstr "" +msgstr "Ajout du paramètre ``include_extras`` comme énoncé dans la :pep:`593`." #: library/typing.rst:2770 msgid "" @@ -3198,6 +3341,9 @@ msgid "" "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ées." #: library/typing.rst:2778 msgid "Provide basic introspection for generic types and special typing forms." @@ -3206,7 +3352,6 @@ msgstr "" "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:" @@ -3218,15 +3363,17 @@ msgid "" msgstr "" "Pour un objet de typage de la forme ``X[Y, Z, ....]``, ces fonctions " "renvoient ``X`` et ``(Y, Z,...)``. Si ``X`` est un alias pour une classe " -"native ou de :mod:`collections`, il est normalisé en la classe originale. " -"Pour les objets non gérés, renvoie la paire ``None`` , ``()``. Exemples ::" +"native ou de :mod:`collections`, il est normalisé vers la classe originale. " +"Si ``X`` est une union or un :class:`Literal` contenu dans un autre type " +"générique, l'ordre de ``(Y, Z, ...)`` peut différer de l'ordre des arguments " +"originels ``[Y, Z, ...]`` à cause du cache de types.Pour les objets non " +"gérés, renvoient ``None`` et ``()`` respectivement. Exemples ::" #: library/typing.rst:2799 msgid "Check if a type is a :class:`TypedDict`." -msgstr "" +msgstr "Vérifier si un 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 " @@ -3234,9 +3381,9 @@ msgid "" "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 " +"références postérieures des chaînes de caractères. Par exemple, " +"``List[\"SomeClass\"]`` est implicitement transformé en " +"``List[ForwardRef(\"SomeClass\")]``. Cette classe ne doit pas être " "instanciée par un utilisateur, mais peut être utilisée par des outils " "d'introspection." @@ -3246,6 +3393,9 @@ msgid "" "implicitly transformed into ``list[ForwardRef(\"SomeClass\")]`` and thus " "will not automatically resolve to ``list[SomeClass]``." msgstr "" +"Les types :pep:`585` 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]``." #: library/typing.rst:2827 msgid "Constant" @@ -3256,8 +3406,8 @@ msgid "" "A special constant that is assumed to be ``True`` by 3rd party static type " "checkers. It is ``False`` at runtime. Usage::" msgstr "" -"Constante spéciale qui vaut ``True`` pour les vérificateurs de type " -"statiques tiers et ``False`` à l'exécution. Utilisation ::" +"Constante spéciale qui vaut ``True`` pour les vérificateurs de types " +"statique tiers et ``False`` à l'exécution. Utilisation ::" #: library/typing.rst:2840 #, fuzzy @@ -3281,10 +3431,15 @@ msgid "" "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 évalué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 guillemets autour de l'annotation (Voir :pep:" +"`563`)." #: library/typing.rst:2856 msgid "Deprecation Timeline of Major Features" -msgstr "" +msgstr "Étapes d'Obsolescence des Fonctionnalités Majeures" #: library/typing.rst:2858 msgid "" @@ -3293,18 +3448,22 @@ msgid "" "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." #: library/typing.rst:2863 msgid "Feature" -msgstr "" +msgstr "Fonctionnalité" #: library/typing.rst:2863 msgid "Deprecated in" -msgstr "" +msgstr "Obsolète en" #: library/typing.rst:2863 msgid "Projected removal" -msgstr "" +msgstr "Suppression prévue" #: library/typing.rst:2863 msgid "PEP/issue" @@ -3312,7 +3471,7 @@ msgstr "" #: library/typing.rst:2865 msgid "``typing.io`` and ``typing.re`` submodules" -msgstr "" +msgstr "sous-modules ``typing.io`` et ``typing.re``" #: library/typing.rst:2865 msgid "3.8" @@ -3328,7 +3487,7 @@ msgstr "" #: library/typing.rst:2868 msgid "``typing`` versions of standard collections" -msgstr "" +msgstr "Versions de typage des collections standards" #: library/typing.rst:2868 msgid "3.9" @@ -3336,7 +3495,7 @@ msgstr "" #: library/typing.rst:2871 msgid "Undecided" -msgstr "" +msgstr "Non défini" #: library/typing.rst:2868 msgid ":pep:`585`"