python-docs-fr/library/typing.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-05-22 23:13+0200\n"
"PO-Revision-Date: 2022-11-21 22:01+0100\n"
"Last-Translator: Jean-Michel Laprise <jmichel.dev@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 3.2.1\n"

#: library/typing.rst:3
msgid ":mod:`typing` --- Support for type hints"
msgstr ":mod:`typing` — Prise en charge des annotations de type"

#: library/typing.rst:10
msgid "**Source code:** :source:`Lib/typing.py`"
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."
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."

#: library/typing.rst:20
#, fuzzy
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`."
msgstr ""
"Ce module fournit la gestion des annotations de type à l'exécution "
"conformément à ce qui est spécifié dans les :pep:`484`, :pep:`526`, :pep:"
"`544`, :pep:`586`, :pep:`589` et :pep:`591`. Le support le plus fondamental "
"se compose des types :data:`Any`, :data:`Union`, :data:`Tuple`, :data:"
"`Callable`, :class:`TypeVar` et :class:`Generic`. Pour les spécifications "
"complètes, voir 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 ::"

#: 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."
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."

#: library/typing.rst:35
msgid ""
"New features are frequently added to the ``typing`` module. The "
"`typing_extensions <https://pypi.org/project/typing-extensions/>`_ package "
"provides backports of these new features to older versions of Python."
msgstr ""

#: library/typing.rst:39
msgid ""
"For a summary of deprecated features and a deprecation timeline, please see "
"`Deprecation Timeline of Major Features`_."
msgstr ""

#: library/typing.rst:46
msgid "Relevant PEPs"
msgstr ""

#: library/typing.rst:48
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 ""

#: library/typing.rst:53
msgid ":pep:`526`: Syntax for Variable Annotations"
msgstr ""

#: library/typing.rst:53
msgid ""
"*Introducing* syntax for annotating variables outside of function "
"definitions, and :data:`ClassVar`"
msgstr ""

#: library/typing.rst:56
msgid ":pep:`544`: Protocols: Structural subtyping (static duck typing)"
msgstr ""

#: library/typing.rst:56
msgid ""
"*Introducing* :class:`Protocol` and the :func:"
"`@runtime_checkable<runtime_checkable>` decorator"
msgstr ""

#: library/typing.rst:59
msgid ":pep:`585`: Type Hinting Generics In Standard Collections"
msgstr ""

#: library/typing.rst:59
msgid ""
"*Introducing* :class:`types.GenericAlias` and the ability to use standard "
"library classes as :ref:`generic types<types-genericalias>`"
msgstr ""

#: library/typing.rst:61
msgid ":pep:`586`: Literal Types"
msgstr ""

#: library/typing.rst:62
msgid "*Introducing* :data:`Literal`"
msgstr ""

#: library/typing.rst:63
msgid ""
":pep:`589`: TypedDict: Type Hints for Dictionaries with a Fixed Set of Keys"
msgstr ""

#: library/typing.rst:64
msgid "*Introducing* :class:`TypedDict`"
msgstr ""

#: library/typing.rst:65
msgid ":pep:`591`: Adding a final qualifier to typing"
msgstr ""

#: library/typing.rst:66
msgid "*Introducing* :data:`Final` and the :func:`@final<final>` decorator"
msgstr ""

#: library/typing.rst:67
msgid ":pep:`593`: Flexible function and variable annotations"
msgstr ""

#: library/typing.rst:68
msgid "*Introducing* :data:`Annotated`"
msgstr ""

#: library/typing.rst:71
msgid ":pep:`604`: Allow writing union types as ``X | Y``"
msgstr ""

#: library/typing.rst:70
msgid ""
"*Introducing* :data:`types.UnionType` and the ability to use the binary-or "
"operator ``|`` to signify a :ref:`union of types<types-union>`"
msgstr ""

#: library/typing.rst:73
msgid ":pep:`612`: Parameter Specification Variables"
msgstr ""

#: library/typing.rst:74
msgid "*Introducing* :class:`ParamSpec` and :data:`Concatenate`"
msgstr ""

#: library/typing.rst:75
#, fuzzy
msgid ":pep:`613`: Explicit Type Aliases"
msgstr "Voir la :pep:`484` pour plus de détails."

#: library/typing.rst:76
msgid "*Introducing* :data:`TypeAlias`"
msgstr ""

#: library/typing.rst:77
msgid ":pep:`646`: Variadic Generics"
msgstr ""

#: library/typing.rst:78
msgid "*Introducing* :data:`TypeVarTuple`"
msgstr ""

#: library/typing.rst:79
msgid ":pep:`647`: User-Defined Type Guards"
msgstr ""

#: library/typing.rst:80
msgid "*Introducing* :data:`TypeGuard`"
msgstr ""

#: library/typing.rst:81
msgid ":pep:`673`: Self type"
msgstr ""

#: library/typing.rst:82
msgid "*Introducing* :data:`Self`"
msgstr ""

#: library/typing.rst:84
msgid ":pep:`675`: Arbitrary Literal String Type"
msgstr ""

#: library/typing.rst:84
msgid "*Introducing* :data:`LiteralString`"
msgstr ""

#: library/typing.rst:89
msgid "Type aliases"
msgstr "Alias de type"

#: library/typing.rst:91
#, 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::"
msgstr ""
"Un alias de type est défini en assignant le type à l'alias. Dans cet "
"exemple, ``Vector`` et ``List[float]`` sont traités comme des synonymes "
"interchangeables ::"

#: library/typing.rst:102
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:120
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 "
"remplacé par ``type(None)``."

#: library/typing.rst:126
msgid "NewType"
msgstr "*NewType*"

#: library/typing.rst:128
#, 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 ::"

#: library/typing.rst:135
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 "
"s'agissait d'une sous-classe du type original. C'est utile pour aider à "
"détecter les erreurs logiques ::"

#: library/typing.rst:147
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::"
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 ::"

#: library/typing.rst:155
#, fuzzy
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."
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 ou n'introduit pas "
"de surcharge au-delà de celle d'un appel de fonction normal."

#: library/typing.rst:161
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."

#: library/typing.rst:164
msgid "It is invalid to create a subtype of ``Derived``::"
msgstr ""

#: library/typing.rst:173
#, 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 "
"``NewType`` « dérivé » ::"

#: library/typing.rst:181
msgid "and typechecking for ``ProUserId`` will work as expected."
msgstr "et la vérification de type pour ``ProUserId`` fonctionne comme prévu."

#: library/typing.rst:183
msgid "See :pep:`484` for more details."
msgstr "Voir la :pep:`484` pour plus de détails."

#: library/typing.rst:187
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."
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."

#: library/typing.rst:192
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."
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."

#: library/typing.rst:201
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."
msgstr ""

#: library/typing.rst:208
msgid "Callable"
msgstr "Appelable"

#: library/typing.rst:210
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 "
"``Callable[[Arg1Type, Arg2Type], ReturnType]``."

#: library/typing.rst:1142 library/typing.rst:2695
msgid "For example::"
msgstr "Par exemple ::"

#: library/typing.rst:228
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]``."
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]``."

#: library/typing.rst:832
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."
msgstr ""

#: library/typing.rst:844
msgid ""
"``Callable`` now supports :class:`ParamSpec` and :data:`Concatenate`. See :"
"pep:`612` for more information."
msgstr ""

#: library/typing.rst:245
msgid ""
"The documentation for :class:`ParamSpec` and :class:`Concatenate` provides "
"examples of usage in ``Callable``."
msgstr ""

#: library/typing.rst:251
msgid "Generics"
msgstr "Génériques"

#: library/typing.rst:253
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."
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."

#: library/typing.rst:264
#, fuzzy
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`."

#: library/typing.rst:280
msgid "User-defined generic types"
msgstr "Types génériques définis par l'utilisateur"

#: library/typing.rst:282
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."

#: library/typing.rst:308
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."
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."

#: library/typing.rst:312
#, fuzzy
msgid ""
"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 ::"

#: library/typing.rst:321
#, 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::"
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 ::"

#: library/typing.rst:333
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 ::"

#: library/typing.rst:344
msgid "You can use multiple inheritance with :class:`Generic`::"
msgstr "Vous pouvez utiliser l'héritage multiple avec :class:`Generic` ::"

#: library/typing.rst:354
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:364
msgid "In this case ``MyDict`` has a single parameter, ``T``."
msgstr "Dans ce cas, ``MyDict`` a un seul paramètre, ``T``."

#: library/typing.rst:366
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]``::"
msgstr ""
"L'utilisation d'une classe générique sans spécifier de paramètres de type "
"suppose :data:`Any` pour chaque position. Dans l'exemple suivant, "
"``MyIterable`` n'est pas générique mais hérite implicitement de "
"``Iterable[Any]`` ::"

#: library/typing.rst:374
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 ::"

#: library/typing.rst:391
msgid ":class:`Generic` no longer has a custom metaclass."
msgstr ":class:`Generic` n'a plus de métaclasse personnalisée."

#: library/typing.rst:394
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`::"
msgstr ""

#: library/typing.rst:411
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::"
msgstr ""

#: library/typing.rst:423
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."
msgstr ""

#: library/typing.rst:427
msgid ""
":class:`Generic` can now be parameterized over parameter expressions. See :"
"class:`ParamSpec` and :pep:`612` for more details."
msgstr ""

#: library/typing.rst:431
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."
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é."

#: library/typing.rst:438
msgid "The :data:`Any` type"
msgstr "Le type :data:`Any`"

#: library/typing.rst:440
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."
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."

#: library/typing.rst:444
#, 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::"
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 ::"

#: library/typing.rst:462
msgid ""
"Notice that no typechecking is performed when assigning a value of type :"
"data:`Any` to a more precise type. For example, the static type checker did "
"not report an error when assigning ``a`` to ``s`` even though ``s`` was "
"declared to be of type :class:`str` and receives an :class:`int` value at "
"runtime!"
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 !"

#: library/typing.rst:468
msgid ""
"Furthermore, all functions without a return type or parameter types will "
"implicitly default to using :data:`Any`::"
msgstr ""
"De plus, toutes les fonctions sans type de retour ni type de paramètre sont "
"considérées comme utilisant :data:`Any` implicitement par défaut ::"

#: library/typing.rst:481
msgid ""
"This behavior allows :data:`Any` to be used as an *escape hatch* when you "
"need to mix dynamically and statically typed code."
msgstr ""
"Ce comportement permet à :data:`Any` d'être utilisé comme succédané lorsque "
"vous avez besoin de mélanger du code typé dynamiquement et statiquement."

#: library/typing.rst:484
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."
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."

#: library/typing.rst:489
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::"
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 ::"

#: library/typing.rst:511
msgid ""
"Use :class:`object` to indicate that a value could be any type in a typesafe "
"manner. Use :data:`Any` to indicate that a value is dynamically typed."
msgstr ""
"Utilisez :class:`object` pour indiquer qu'une valeur peut être 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:516
msgid "Nominal vs structural subtyping"
msgstr "Sous-typage nominal et sous-typage structurel"

#: library/typing.rst:518
#, 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``."
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``."

#: library/typing.rst:522
#, 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`::"
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` ::"

#: library/typing.rst:535
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)::"
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) ::"

#: library/typing.rst:551
msgid ""
"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)."

#: library/typing.rst:556
msgid "Module contents"
msgstr ""

#: library/typing.rst:558
#, fuzzy
msgid "The module defines the following classes, functions and decorators."
msgstr "Ce module définit les classes, fonctions et décorateurs suivants :"

#: library/typing.rst:562
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 ``[]``."
msgstr ""

#: library/typing.rst:568
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."
msgstr ""

#: library/typing.rst:573
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*."
msgstr ""

#: library/typing.rst:579
msgid "Special typing primitives"
msgstr ""

#: library/typing.rst:582
#, fuzzy
msgid "Special types"
msgstr "Type « optionnel »."

#: library/typing.rst:584
msgid "These can be used as types in annotations and do not support ``[]``."
msgstr ""

#: library/typing.rst:588
msgid "Special type indicating an unconstrained type."
msgstr "Type spécial indiquant un type non contraint."

#: library/typing.rst:590
msgid "Every type is compatible with :data:`Any`."
msgstr "Chaque type est compatible avec :data:`Any`."

#: library/typing.rst:591
msgid ":data:`Any` is compatible with every type."
msgstr ":data:`Any` est compatible avec tous les types."

#: library/typing.rst:593
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."
msgstr ""

#: library/typing.rst:600
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 "
"``LiteralString``-typed objects is also acceptable as a ``LiteralString``."
msgstr ""

#: library/typing.rst:2369
#, fuzzy
msgid "Example::"
msgstr "Par exemple ::"

#: library/typing.rst:620
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."
msgstr ""

#: library/typing.rst:629
msgid ""
"The `bottom type <https://en.wikipedia.org/wiki/Bottom_type>`_, a type that "
"has no members."
msgstr ""

#: library/typing.rst:632
msgid ""
"This can be used to define a function that should never be called, or a "
"function that never returns::"
msgstr ""

#: library/typing.rst:652
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."
msgstr ""

#: library/typing.rst:657
msgid "Special type indicating that a function never returns. For example::"
msgstr "Type spécial indiquant qu'une fonction ne renvoie rien. Par exemple ::"

#: library/typing.rst:665
msgid ""
"``NoReturn`` can also be used as a `bottom type <https://en.wikipedia.org/"
"wiki/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:676
#, fuzzy
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:687
msgid ""
"This annotation is semantically equivalent to the following, albeit in a "
"more succinct fashion::"
msgstr ""

#: library/typing.rst:699
msgid "In general if something currently follows the pattern of::"
msgstr ""

#: library/typing.rst:706
msgid ""
"You should use use :data:`Self` as calls to ``SubclassOfFoo.returns_self`` "
"would have ``Foo`` as the return type and not ``SubclassOfFoo``."
msgstr ""

#: library/typing.rst:709
msgid "Other common use cases include:"
msgstr ""

#: library/typing.rst:711
msgid ""
":class:`classmethod`\\s that are used as alternative constructors and return "
"instances of the ``cls`` parameter."
msgstr ""

#: library/typing.rst:713
msgid "Annotating an :meth:`~object.__enter__` method which returns self."
msgstr ""

#: library/typing.rst:715
msgid "For more information, see :pep:`673`."
msgstr ""

#: library/typing.rst:721
msgid ""
"Special annotation for explicitly declaring a :ref:`type alias <type-"
"aliases>`. For example::"
msgstr ""

#: library/typing.rst:728
#, fuzzy
msgid "See :pep:`613` for more details about explicit type aliases."
msgstr "Voir la :pep:`484` pour plus de détails."

#: library/typing.rst:733
msgid "Special forms"
msgstr ""

#: library/typing.rst:735
msgid ""
"These can be used as types in annotations using ``[]``, each having a unique "
"syntax."
msgstr ""

#: library/typing.rst:739
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[()]``."
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[()]``."

#: library/typing.rst:743
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."
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."

#: library/typing.rst:747
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`."
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`."

#: library/typing.rst:751
msgid ""
":class:`builtins.tuple <tuple>` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`builtins.tuple <tuple>` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:757
#, fuzzy
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:759
#, 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 :"

#: library/typing.rst:761
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."

#: library/typing.rst:763
msgid "Unions of unions are flattened, e.g.::"
msgstr "Les unions d'unions sont aplanies, par exemple ::"

#: library/typing.rst:767
msgid "Unions of a single argument vanish, e.g.::"
msgstr "Les unions d'un seul argument disparaissent, par exemple ::"

#: library/typing.rst:771
msgid "Redundant arguments are skipped, e.g.::"
msgstr "Les arguments redondants sont ignorés, par exemple ::"

#: library/typing.rst:775
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 ::"

#: library/typing.rst:779
#, fuzzy
msgid "You cannot subclass or instantiate a ``Union``."
msgstr "Vous ne pouvez pas sous-classer ou instancier une union."

#: library/typing.rst:781
msgid "You cannot write ``Union[X][Y]``."
msgstr "Vous ne pouvez pas écrire ``Union[X][Y]``."

#: library/typing.rst:783
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:786
msgid ""
"Unions can now be written as ``X | Y``. See :ref:`union type "
"expressions<types-union>`."
msgstr ""

#: library/typing.rst:792
msgid "Optional type."
msgstr "Type « optionnel »."

#: library/typing.rst:794
#, fuzzy
msgid "``Optional[X]`` is equivalent to ``X | None`` (or ``Union[X, None]``)."
msgstr "``Optional[X]`` équivaut à ``Union[X, None]``."

#: library/typing.rst:796
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::"
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 ::"

#: library/typing.rst:804
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::"
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 ::"

#: library/typing.rst:811
msgid ""
"Optional can now be written as ``X | None``. See :ref:`union type "
"expressions<types-union>`."
msgstr ""

#: library/typing.rst:817
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``."

#: library/typing.rst:819
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."
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."

#: library/typing.rst:824
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`."
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`."

#: library/typing.rst:840
msgid ""
":class:`collections.abc.Callable` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Callable` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:849
msgid ""
"The documentation for :class:`ParamSpec` and :class:`Concatenate` provide "
"examples of usage with ``Callable``."
msgstr ""

#: library/typing.rst:854
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 (``...``)."
msgstr ""

#: library/typing.rst:862
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::"
msgstr ""

#: library/typing.rst:1474
msgid ""
":pep:`612` -- Parameter Specification Variables (the PEP which introduced "
"``ParamSpec`` and ``Concatenate``)."
msgstr ""

#: library/typing.rst:903
msgid ":class:`ParamSpec` and :class:`Callable`."
msgstr ""

#: library/typing.rst:908
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::"
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 ::"

#: library/typing.rst:917
msgid "Note that ``Type[C]`` is covariant::"
msgstr "Notez que ``Type[C]`` est covariant ::"

#: library/typing.rst:929
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`."
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 "
"révisions de :pep:`484`."

#: library/typing.rst:937
msgid ""
"The only legal parameters for :class:`Type` are classes, :data:`Any`, :ref:"
"`type variables <generics>`, 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 <generics>`, et les unions de ces types. Par "
"exemple ::"

#: library/typing.rst:943
msgid ""
"``Type[Any]`` is equivalent to ``Type`` which in turn is equivalent to "
"``type``, which is the root of Python's metaclass hierarchy."
msgstr ""
"``Type[Any]`` est équivalent à ``Type`` qui à son tour est équivalent à "
"``type``, qui est la racine de la hiérarchie des métaclasses de Python."

#: library/typing.rst:948
msgid ""
":class:`builtins.type <type>` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`builtins.type <type>` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:954
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::"
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 ::"

#: library/typing.rst:968
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."
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."

#: library/typing.rst:974
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`."
msgstr ""

#: library/typing.rst:982
msgid "Special type construct to mark class variables."
msgstr ""
"Construction de type particulière pour indiquer les variables de classe."

#: library/typing.rst:984
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::"
msgstr ""
"Telle qu'introduite dans la :pep:`526`, une annotation de variable "
"enveloppée dans ClassVar indique qu'un attribut donné est destiné à être "
"utilisé comme une variable de classe et ne doit pas être défini sur des "
"instances de cette classe. Utilisation ::"

#: library/typing.rst:992
msgid ":data:`ClassVar` accepts only types and cannot be further subscribed."
msgstr ":data:`ClassVar` n'accepte que les types et ne peut plus être dérivé."

#: library/typing.rst:994
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::"
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 ::"

#: library/typing.rst:1008
msgid ""
"A special typing construct to indicate to type checkers that a name cannot "
"be re-assigned or overridden in a subclass. For example::"
msgstr ""
"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:2578
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:1027
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."
msgstr ""

#: library/typing.rst:1041
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()``)."
msgstr ""

#: library/typing.rst:1047
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."
msgstr ""

#: library/typing.rst:1051
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."
msgstr ""

#: library/typing.rst:1055
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::"
msgstr ""

#: library/typing.rst:1064
msgid ""
"Passing ``include_extras=True`` to :func:`get_type_hints` lets one access "
"the extra annotations at runtime."
msgstr ""

#: library/typing.rst:1067
msgid "The details of the syntax:"
msgstr ""

#: library/typing.rst:1069
msgid "The first argument to ``Annotated`` must be a valid type"
msgstr ""

#: library/typing.rst:1071
msgid ""
"Multiple type annotations are supported (``Annotated`` supports variadic "
"arguments)::"
msgstr ""

#: library/typing.rst:1076
msgid ""
"``Annotated`` must be called with at least two arguments "
"( ``Annotated[int]`` is not valid)"
msgstr ""

#: library/typing.rst:1079
msgid ""
"The order of the annotations is preserved and matters for equality checks::"
msgstr ""

#: library/typing.rst:1086
msgid ""
"Nested ``Annotated`` types are flattened, with metadata ordered starting "
"with the innermost annotation::"
msgstr ""

#: library/typing.rst:1093
msgid "Duplicated annotations are not removed::"
msgstr ""

#: library/typing.rst:1099
msgid "``Annotated`` can be used with nested and generic aliases::"
msgstr ""

#: library/typing.rst:1112
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."
msgstr ""

#: library/typing.rst:1116
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\"::"
msgstr ""

#: library/typing.rst:1131
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."
msgstr ""

#: library/typing.rst:1135
msgid ""
"Using  ``-> TypeGuard`` tells the static type checker that for a given "
"function:"
msgstr ""

#: library/typing.rst:1138
msgid "The return value is a boolean."
msgstr ""

#: library/typing.rst:1139
msgid ""
"If the return value is ``True``, the type of its argument is the type inside "
"``TypeGuard``."
msgstr ""

#: library/typing.rst:1156
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``."
msgstr ""

#: library/typing.rst:1160
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``."
msgstr ""

#: library/typing.rst:1166
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."
msgstr ""

#: library/typing.rst:1172
msgid ""
"``TypeGuard`` also works with type variables.  For more information, see :"
"pep:`647` (User-Defined Type Guards)."
msgstr ""

#: library/typing.rst:1179
#, fuzzy
msgid "Building generic types"
msgstr "Types génériques définis par l'utilisateur"

#: library/typing.rst:1181
msgid ""
"These are not used in annotations. They are building blocks for creating "
"generic types."
msgstr ""

#: library/typing.rst:1185
msgid "Abstract base class for generic types."
msgstr "Classe de base abstraite pour les types génériques."

#: library/typing.rst:1187
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::"
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 ::"

#: library/typing.rst:1196
msgid "This class can then be used as follows::"
msgstr "Cette classe peut alors être utilisée comme suit ::"

#: library/typing.rst:1209
msgid "Type variable."
msgstr "Variables de type."

#: library/typing.rst:1403 library/typing.rst:1580
msgid "Usage::"
msgstr "Utilisation ::"

#: library/typing.rst:1217
#, 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::"
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 ::"

#: library/typing.rst:1237
msgid ""
"Note that type variables can be *bound*, *constrained*, or neither, but "
"cannot be both bound *and* constrained."
msgstr ""

#: library/typing.rst:1240
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::"
msgstr ""

#: library/typing.rst:1255
msgid ""
"Type variables can be bound to concrete types, abstract types (ABCs or "
"protocols), and even unions of types::"
msgstr ""

#: library/typing.rst:1261
msgid ""
"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:1272
msgid ""
"At runtime, ``isinstance(x, T)`` will raise :exc:`TypeError`.  In general, :"
"func:`isinstance` and :func:`issubclass` should not be used with types."
msgstr ""
"Au moment de l'exécution, ``isinstance(x, T)`` va lever :exc:`TypeError`. En "
"général, :func:`isinstance` et :func:`issubclass` ne devraient pas être "
"utilisés avec les types."

#: library/typing.rst:1275
#, 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."
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=<type>``. 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:1281
msgid ""
"Type variable tuple. A specialized form of :class:`type variable <TypeVar>` "
"that enables *variadic* generics."
msgstr ""

#: library/typing.rst:1284
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::"
msgstr ""

#: library/typing.rst:1307
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 "
"<Unpack>` instead, as ``Unpack[Ts]``.)"
msgstr ""

#: library/typing.rst:1315
msgid ""
"Type variable tuples must *always* be unpacked. This helps distinguish type "
"variable types from normal type variables::"
msgstr ""

#: library/typing.rst:1322
msgid ""
"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:1331
msgid ""
"Type variable tuples can be happily combined with normal type variables::"
msgstr ""

#: library/typing.rst:1344
msgid ""
"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:1351
msgid ""
"Finally, an unpacked type variable tuple can be used as the type annotation "
"of ``*args``::"
msgstr ""

#: library/typing.rst:1361
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``."
msgstr ""

#: library/typing.rst:1368
msgid "For more details on type variable tuples, see :pep:`646`."
msgstr ""

#: library/typing.rst:1374
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 <TypeVarTuple>` is equivalent to using ``Unpack`` to mark the type "
"variable tuple as having been unpacked::"
msgstr ""

#: library/typing.rst:1384
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::"
msgstr ""

#: library/typing.rst:1400
msgid ""
"Parameter specification variable.  A specialized version of :class:`type "
"variables <TypeVar>`."
msgstr ""

#: library/typing.rst:1407
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."
msgstr ""

#: library/typing.rst:1414
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::"
msgstr ""

#: library/typing.rst:1438
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:"
msgstr ""

#: library/typing.rst:1442
msgid ""
"The type checker can't type check the ``inner`` function because ``*args`` "
"and ``**kwargs`` have to be typed :data:`Any`."
msgstr ""

#: library/typing.rst:1444
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``."
msgstr ""

#: library/typing.rst:1451
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`."
msgstr ""

#: library/typing.rst:1461
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."
msgstr ""

#: library/typing.rst:1470
msgid ""
"Only parameter specification variables defined in global scope can be "
"pickled."
msgstr ""

#: library/typing.rst:1476
msgid ":class:`Callable` and :class:`Concatenate`."
msgstr ""

#: library/typing.rst:1481
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."
msgstr ""

#: library/typing.rst:1486
msgid ""
"Calling :func:`get_origin` on either of these objects will return the "
"original ``ParamSpec``::"
msgstr ""

#: library/typing.rst:1498
#, fuzzy
msgid ""
"``AnyStr`` is a :class:`constrained type variable <TypeVar>` 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:1501
msgid ""
"It is meant to be used for functions that may accept any kind of string "
"without allowing different kinds of strings to mix. For example::"
msgstr ""
"Cela est destiné à être utilisé pour des fonctions qui peuvent accepter "
"n'importe quel type de chaîne de caractères sans permettre à différents "
"types de chaînes de caractères de se mélanger. Par exemple ::"

#: library/typing.rst:1513
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:1519
msgid ""
"Such classes are primarily used with static type checkers that recognize "
"structural subtyping (static duck-typing), for example::"
msgstr ""
"Ces classes sont principalement utilisées avec les vérificateurs statiques "
"de type qui reconnaissent les sous-types structurels (typage canard "
"statique), par exemple ::"

#: library/typing.rst:1531
msgid ""
"See :pep:`544` for 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."

#: library/typing.rst:1536
msgid "Protocol classes can be generic, for example::"
msgstr "Les classes de protocole peuvent être génériques, par exemple ::"

#: library/typing.rst:1546
msgid "Mark a protocol class as a runtime protocol."
msgstr "Marquez une classe de protocole comme protocole d'exécution."

#: library/typing.rst:1548
#, 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::"
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 ::"

#: library/typing.rst:1561
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`."
msgstr ""

#: library/typing.rst:1572
msgid "Other special directives"
msgstr ""

#: library/typing.rst:1574
msgid ""
"These are not used in annotations. They are building blocks for declaring "
"types."
msgstr ""

#: library/typing.rst:1578
msgid "Typed version of :func:`collections.namedtuple`."
msgstr "Version typée de :func:`collections.namedtuple`."

#: library/typing.rst:1586
msgid "This is equivalent to::"
msgstr "Ce qui est équivalent à ::"

#: library/typing.rst:1590
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:1599
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:1601
#, 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.)"
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*.)"

#: library/typing.rst:1607
msgid "``NamedTuple`` subclasses can also have docstrings and methods::"
msgstr ""
"Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et "
"des méthodes ::"

#: library/typing.rst:1617
#, fuzzy
msgid "``NamedTuple`` subclasses can be generic::"
msgstr ""
"Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et "
"des méthodes ::"

#: library/typing.rst:1623
msgid "Backward-compatible usage::"
msgstr "Utilisation rétrocompatible ::"

#: library/typing.rst:1627
msgid "Added support for :pep:`526` variable annotation syntax."
msgstr ""
"Ajout de la gestion de la syntaxe d'annotation variable de la :pep:`526`."

#: library/typing.rst:1630
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*."

#: library/typing.rst:1633
msgid ""
"The ``_field_types`` and ``__annotations__`` attributes are now regular "
"dictionaries instead of instances of ``OrderedDict``."
msgstr ""
"Les attributs ``_field_types`` et ``__annotations__`` sont maintenant des "
"dictionnaires standards au lieu d'instances de ``OrderedDict``."

#: library/typing.rst:1637
msgid ""
"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."

#: library/typing.rst:1641
msgid "Added support for generic namedtuples."
msgstr ""

#: library/typing.rst:1646
#, 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::"
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 ::"

#: library/typing.rst:1656
msgid "``NewType`` is now a class rather than a function."
msgstr ""

#: library/typing.rst:1661
#, 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`."

#: library/typing.rst:1664
#, 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::"
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 ::"

#: library/typing.rst:1680
#, 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:"
msgstr ""
"Les informations de type pour l'introspection sont accessibles via ``Point2D."
"__annotations__`` et ``Point2D.__total__``. Pour permettre l'utilisation de "
"cette fonctionnalité avec les anciennes versions de Python qui ne prennent "
"pas en compte la :pep:`526`, ``TypedDict`` gère deux formes syntaxiques "
"équivalentes supplémentaires ::"

#: library/typing.rst:1684
msgid "Using a literal :class:`dict` as the second argument::"
msgstr ""

#: library/typing.rst:1688
msgid "Using keyword arguments::"
msgstr ""

#: library/typing.rst:1695
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."
msgstr ""

#: library/typing.rst:1696
msgid ""
"The functional syntax should also be used when any of the keys are not "
"valid :ref:`identifiers <identifiers>`, for example because they are "
"keywords or contain hyphens. Example::"
msgstr ""

#: library/typing.rst:1708
msgid ""
"By default, all keys must be present in a ``TypedDict``. It is possible to "
"override this by specifying totality. Usage::"
msgstr ""

#: library/typing.rst:1719
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."
msgstr ""

#: library/typing.rst:1724
msgid ""
"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:1731
msgid ""
"``Point3D`` has three items: ``x``, ``y`` and ``z``. It is equivalent to "
"this definition::"
msgstr ""

#: library/typing.rst:1739
msgid ""
"A ``TypedDict`` cannot inherit from a non-\\ ``TypedDict`` class, except "
"for :class:`Generic`. For example::"
msgstr ""

#: library/typing.rst:1757
msgid "A ``TypedDict`` can be generic::"
msgstr ""

#: library/typing.rst:1763
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__`."
msgstr ""

#: library/typing.rst:1769
msgid ""
"``Point2D.__total__`` gives the value of the ``total`` argument. Example::"
msgstr ""

#: library/typing.rst:1786
msgid ""
"``Point2D.__required_keys__`` and ``Point2D.__optional_keys__`` return :"
"class:`frozenset` objects containing required and non-required keys, "
"respectively. Currently the only way to declare both required and non-"
"required keys in the same ``TypedDict`` is mixed inheritance, declaring a "
"``TypedDict`` with one value for the ``total`` argument and then inheriting "
"it from another ``TypedDict`` with a different value for ``total``. Usage::"
msgstr ""

#: library/typing.rst:1806
#, fuzzy
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."

#: library/typing.rst:1810
msgid "Added support for generic ``TypedDict``\\ s."
msgstr ""

#: library/typing.rst:1814
msgid "Generic concrete collections"
msgstr ""

#: library/typing.rst:1817
msgid "Corresponding to built-in types"
msgstr ""

#: library/typing.rst:1821
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`."
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`."

#: library/typing.rst:1825
msgid "This type can be used as follows::"
msgstr "Ce type peut être utilisé comme suit ::"

#: library/typing.rst:1830
msgid ""
":class:`builtins.dict <dict>` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`builtins.dict <dict>` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:1836
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`."
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`."

#: library/typing.rst:1841
msgid "This type may be used as follows::"
msgstr "Ce type peut être utilisé comme suit ::"

#: library/typing.rst:1851
msgid ""
":class:`builtins.list <list>` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`builtins.list <list>` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:1857
msgid ""
"A generic version of :class:`builtins.set <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 <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:1861
msgid ""
":class:`builtins.set <set>` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`builtins.set <set>` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:1867
msgid "A generic version of :class:`builtins.frozenset <frozenset>`."
msgstr "Une version générique de :class:`builtins.frozenset <frozenset>`."

#: library/typing.rst:1869
msgid ""
":class:`builtins.frozenset <frozenset>` now supports ``[]``. See :pep:`585` "
"and :ref:`types-genericalias`."
msgstr ""
":class:`builtins.frozenset <frozenset>` prend désormais en charge ``[]``. "
"Voir :pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:1873
msgid ":data:`Tuple` is a special form."
msgstr ""

#: library/typing.rst:1876
msgid "Corresponding to types in :mod:`collections`"
msgstr ""

#: library/typing.rst:1880
msgid "A generic version of :class:`collections.defaultdict`."
msgstr "Une version générique de :class:`collections.defaultdict`."

#: library/typing.rst:1884
msgid ""
":class:`collections.defaultdict` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.defaultdict` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:1890
msgid "A generic version of :class:`collections.OrderedDict`."
msgstr "Une version générique de :class:`collections.OrderedDict`."

#: library/typing.rst:1894
msgid ""
":class:`collections.OrderedDict` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.OrderedDict` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:1900
msgid "A generic version of :class:`collections.ChainMap`."
msgstr "Une version générique de :class:`collections.ChainMap`."

#: library/typing.rst:1905
msgid ""
":class:`collections.ChainMap` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`collections.ChainMap` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:1911
msgid "A generic version of :class:`collections.Counter`."
msgstr "Une version générique de :class:`collections.Counter`."

#: library/typing.rst:1916
msgid ""
":class:`collections.Counter` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`collections.Counter` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:1922
msgid "A generic version of :class:`collections.deque`."
msgstr "Une version générique de :class:`collections.deque`."

#: library/typing.rst:1927
msgid ""
":class:`collections.deque` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`collections.deque` prend désormais en charge ``[]``. Voir :pep:`585` "
"et :ref:`types-genericalias`."

#: library/typing.rst:1932
msgid "Other concrete types"
msgstr ""

#: library/typing.rst:1938
#, 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`."
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`."

#: library/typing.rst:1945
msgid ""
"The ``typing.io`` namespace is deprecated and will be removed. These types "
"should be directly imported from ``typing`` instead."
msgstr ""

#: library/typing.rst:1950
#, 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]``."
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]``."

#: library/typing.rst:1960
msgid ""
"The ``typing.re`` namespace is deprecated and will be removed. These types "
"should be directly imported from ``typing`` instead."
msgstr ""

#: library/typing.rst:1961
msgid ""
"Classes ``Pattern`` and ``Match`` from :mod:`re` now support ``[]``. See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: library/typing.rst:1967
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``."
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``."

#: library/typing.rst:1971
msgid ""
"Use ``Text`` to indicate that a value must contain a unicode string in a "
"manner that is compatible with both Python 2 and Python 3::"
msgstr ""
"Utilisez ``Text`` pour indiquer qu'une valeur doit contenir une chaîne "
"Unicode d'une manière compatible avec Python 2 et Python 3 ::"

#: library/typing.rst:1979
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."
msgstr ""

#: library/typing.rst:1986
#, fuzzy
msgid "Abstract Base Classes"
msgstr "Classe de base abstraite pour les types génériques."

#: library/typing.rst:1989
msgid "Corresponding to collections in :mod:`collections.abc`"
msgstr ""

#: library/typing.rst:1993
msgid "A generic version of :class:`collections.abc.Set`."
msgstr "Une version générique de :class:`collections.abc.Set`."

#: library/typing.rst:1995
msgid ""
":class:`collections.abc.Set` now supports ``[]``. See :pep:`585` and :ref:"
"`types-genericalias`."
msgstr ""
":class:`collections.abc.Set` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:2001
msgid "A generic version of :class:`collections.abc.ByteString`."
msgstr "Une version générique de :class:`collections.abc.ByteString`."

#: library/typing.rst:2003
#, 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`."

#: library/typing.rst:2006
msgid ""
"As a shorthand for this type, :class:`bytes` can be used to annotate "
"arguments of any of the types mentioned above."
msgstr ""
"Comme abréviation pour ce type, :class:`bytes` peut être utilisé pour "
"annoter des arguments de n'importe quel type mentionné ci-dessus."

#: library/typing.rst:2009
msgid ""
":class:`collections.abc.ByteString` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.ByteString` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2015
msgid "A generic version of :class:`collections.abc.Collection`"
msgstr "Une version générique de :class:`collections.abc.Collection`"

#: library/typing.rst:2019
msgid ""
":class:`collections.abc.Collection` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Collection` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2025
msgid "A generic version of :class:`collections.abc.Container`."
msgstr "Une version générique de :class:`collections.abc.Container`."

#: library/typing.rst:2027
msgid ""
":class:`collections.abc.Container` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Container` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2033
msgid "A generic version of :class:`collections.abc.ItemsView`."
msgstr "Une version générique de :class:`collections.abc.ItemsView`."

#: library/typing.rst:2035
msgid ""
":class:`collections.abc.ItemsView` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.ItemsView` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2041
msgid "A generic version of :class:`collections.abc.KeysView`."
msgstr "Une version générique de :class:`collections.abc.KeysView`."

#: library/typing.rst:2043
msgid ""
":class:`collections.abc.KeysView` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.KeysView` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2049
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:2055
msgid ""
":class:`collections.abc.Mapping` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Mapping` prend désormais en charge ``[]``. Voir :pep:"
"`585` et :ref:`types-genericalias`."

#: library/typing.rst:2061
msgid "A generic version of :class:`collections.abc.MappingView`."
msgstr "Une version générique de :class:`collections.abc.MappingView`."

#: library/typing.rst:2063
msgid ""
":class:`collections.abc.MappingView` now supports ``[]``. See :pep:`585` "
"and :ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.MappingView` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2069
msgid "A generic version of :class:`collections.abc.MutableMapping`."
msgstr "Une version générique de :class:`collections.abc.MutableMapping`."

#: library/typing.rst:2071
msgid ""
":class:`collections.abc.MutableMapping` now supports ``[]``. See :pep:`585` "
"and :ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.MutableMapping` prend désormais en charge ``[]``. "
"Voir :pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2077
msgid "A generic version of :class:`collections.abc.MutableSequence`."
msgstr "Une version générique de :class:`collections.abc.MutableSequence`."

#: library/typing.rst:2079
msgid ""
":class:`collections.abc.MutableSequence` now supports ``[]``. See :pep:`585` "
"and :ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.MutableSequence` prend désormais en charge ``[]``. "
"Voir :pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2085
msgid "A generic version of :class:`collections.abc.MutableSet`."
msgstr "Une version générique de :class:`collections.abc.MutableSet`."

#: library/typing.rst:2087
msgid ""
":class:`collections.abc.MutableSet` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.MutableSet` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2093
msgid "A generic version of :class:`collections.abc.Sequence`."
msgstr "Une version générique de :class:`collections.abc.Sequence`."

#: library/typing.rst:2095
msgid ""
":class:`collections.abc.Sequence` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Sequence` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2101
msgid "A generic version of :class:`collections.abc.ValuesView`."
msgstr "Une version générique de :class:`collections.abc.ValuesView`."

#: library/typing.rst:2103
msgid ""
":class:`collections.abc.ValuesView` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.ValuesView` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2108
msgid "Corresponding to other types in :mod:`collections.abc`"
msgstr ""

#: library/typing.rst:2112
msgid "A generic version of :class:`collections.abc.Iterable`."
msgstr "Une version générique de :class:`collections.abc.Iterable`."

#: library/typing.rst:2114
msgid ""
":class:`collections.abc.Iterable` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Iterable` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2120
msgid "A generic version of :class:`collections.abc.Iterator`."
msgstr "Une version générique de :class:`collections.abc.Iterator`."

#: library/typing.rst:2122
msgid ""
":class:`collections.abc.Iterator` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Iterator` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2128
msgid ""
"A generator can be annotated by the generic type ``Generator[YieldType, "
"SendType, ReturnType]``. For example::"
msgstr ""
"Un générateur peut être annoté par le type générique ``Generator[YieldType, "
"SendType, ReturnType]``. Par exemple ::"

#: library/typing.rst:2137
msgid ""
"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."

#: library/typing.rst:2141
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`` ::"

#: library/typing.rst:2149
msgid ""
"Alternatively, annotate your generator as having a return type of either "
"``Iterable[YieldType]`` or ``Iterator[YieldType]``::"
msgstr ""
"Alternativement, annotez votre générateur comme ayant un type de retour soit "
"``Iterable[YieldType]`` ou ``Iterator[YieldType]`` ::"

#: library/typing.rst:2157
msgid ""
":class:`collections.abc.Generator` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Generator` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2163
#, fuzzy
msgid "An alias to :class:`collections.abc.Hashable`."
msgstr "Un alias pour :class:`collections.abc.Hashable`"

#: library/typing.rst:2167
msgid "A generic version of :class:`collections.abc.Reversible`."
msgstr "Une version générique de :class:`collections.abc.Reversible`."

#: library/typing.rst:2169
msgid ""
":class:`collections.abc.Reversible` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Reversible` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2175
#, fuzzy
msgid "An alias to :class:`collections.abc.Sized`."
msgstr "Un alias pour :class:`collections.abc.Sized`"

#: library/typing.rst:2178
msgid "Asynchronous programming"
msgstr ""

#: library/typing.rst:2182
msgid ""
"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 ::"

#: library/typing.rst:2194
msgid ""
":class:`collections.abc.Coroutine` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Coroutine` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2200
msgid ""
"An async generator can be annotated by the generic type "
"``AsyncGenerator[YieldType, SendType]``. For example::"
msgstr ""
"Un générateur asynchrone peut être annoté par le type générique "
"``AsyncGenerator[YieldType, SendType]``. Par exemple ::"

#: library/typing.rst:2209
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."
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."

#: library/typing.rst:2213
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:2221
msgid ""
"Alternatively, annotate your generator as having a return type of either "
"``AsyncIterable[YieldType]`` or ``AsyncIterator[YieldType]``::"
msgstr ""
"Alternativement, annotez votre générateur comme ayant un type de retour soit "
"``AsyncIterable[YieldType]`` ou ``AsyncIterator[YieldType]`` ::"

#: library/typing.rst:2231
msgid ""
":class:`collections.abc.AsyncGenerator` now supports ``[]``. See :pep:`585` "
"and :ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.AsyncGenerator` prend désormais en charge ``[]``. "
"Voir :pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2237
msgid "A generic version of :class:`collections.abc.AsyncIterable`."
msgstr "Une version générique de :class:`collections.abc.AsyncIterable`."

#: library/typing.rst:2241
msgid ""
":class:`collections.abc.AsyncIterable` now supports ``[]``. See :pep:`585` "
"and :ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.AsyncIterable` prend désormais en charge ``[]``. "
"Voir :pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2247
msgid "A generic version of :class:`collections.abc.AsyncIterator`."
msgstr "Une version générique de :class:`collections.abc.AsyncIterator`."

#: library/typing.rst:2251
msgid ""
":class:`collections.abc.AsyncIterator` now supports ``[]``. See :pep:`585` "
"and :ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.AsyncIterator` prend désormais en charge ``[]``. "
"Voir :pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2257
msgid "A generic version of :class:`collections.abc.Awaitable`."
msgstr "Une version générique de :class:`collections.abc.Awaitable`."

#: library/typing.rst:2261
msgid ""
":class:`collections.abc.Awaitable` now supports ``[]``. See :pep:`585` and :"
"ref:`types-genericalias`."
msgstr ""
":class:`collections.abc.Awaitable` prend désormais en charge ``[]``. Voir :"
"pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2267
msgid "Context manager types"
msgstr ""

#: library/typing.rst:2271
msgid "A generic version of :class:`contextlib.AbstractContextManager`."
msgstr "Une version générique de :class:`contextlib.AbstractContextManager`."

#: library/typing.rst:2276
msgid ""
":class:`contextlib.AbstractContextManager` now supports ``[]``. See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""
":class:`contextlib.AbstractContextManager` prend désormais en charge ``[]``. "
"Voir :pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2282
msgid "A generic version of :class:`contextlib.AbstractAsyncContextManager`."
msgstr ""
"Une version générique de :class:`contextlib.AbstractAsyncContextManager`."

#: library/typing.rst:2287
msgid ""
":class:`contextlib.AbstractAsyncContextManager` now supports ``[]``. See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""
":class:`contextlib.AbstractAsyncContextManager` prend désormais en charge "
"``[]``. Voir :pep:`585` et :ref:`types-genericalias`."

#: library/typing.rst:2292
msgid "Protocols"
msgstr ""

#: library/typing.rst:2294
msgid "These protocols are decorated with :func:`runtime_checkable`."
msgstr ""

#: library/typing.rst:2298
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:2303
msgid "An ABC with one abstract method ``__bytes__``."
msgstr "Une ABC avec une méthode abstraite ``__bytes__``."

#: library/typing.rst:2307
msgid "An ABC with one abstract method ``__complex__``."
msgstr "Une ABC avec une méthode abstraite ``__complex__``."

#: library/typing.rst:2311
msgid "An ABC with one abstract method ``__float__``."
msgstr "Une ABC avec une méthode abstraite ``__float__``."

#: library/typing.rst:2315
msgid "An ABC with one abstract method ``__index__``."
msgstr "Une ABC avec une méthode abstraite ``__index__``."

#: library/typing.rst:2321
msgid "An ABC with one abstract method ``__int__``."
msgstr "Une ABC avec une méthode abstraite ``__int__``."

#: library/typing.rst:2325
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:2329
#, fuzzy
msgid "Functions and decorators"
msgstr "Classes, fonctions et décorateurs"

#: library/typing.rst:2333
msgid "Cast a value to a type."
msgstr "Convertit une valeur en un type."

#: library/typing.rst:2335
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 "
"possible)."

#: library/typing.rst:2342
msgid ""
"Ask a static type checker to confirm that *val* has an inferred type of "
"*typ*."
msgstr ""

#: library/typing.rst:2344
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 ""

#: library/typing.rst:2351
msgid ""
"At runtime this returns the first argument unchanged with no side effects."
msgstr ""

#: library/typing.rst:2353
msgid ""
"This function is useful for ensuring the type checker's understanding of a "
"script is in line with the developer's intentions::"
msgstr ""

#: library/typing.rst:2367
msgid ""
"Ask a static type checker to confirm that a line of code is unreachable."
msgstr ""

#: library/typing.rst:2380
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."
msgstr ""

#: library/typing.rst:2392
msgid "At runtime, this throws an exception when called."
msgstr ""

#: library/typing.rst:2395
msgid ""
"`Unreachable Code and Exhaustiveness Checking <https://typing.readthedocs.io/"
"en/latest/source/unreachable.html>`__ has more information about "
"exhaustiveness checking with static typing."
msgstr ""

#: library/typing.rst:2403
msgid "Reveal the inferred static type of an expression."
msgstr ""

#: library/typing.rst:2405
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 ""

#: library/typing.rst:2411
msgid ""
"This can be useful when you want to debug how your type checker handles a "
"particular piece of code."
msgstr ""

#: library/typing.rst:2414
msgid ""
"The function returns its argument unchanged, which allows using it within an "
"expression::"
msgstr ""

#: library/typing.rst:2419
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."
msgstr ""

#: library/typing.rst:2424
msgid ""
"At runtime, this function prints the runtime type of its argument to stderr "
"and returns it unchanged::"
msgstr ""

#: library/typing.rst:2434
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."
msgstr ""

#: library/typing.rst:2440
msgid "Example usage with a decorator function::"
msgstr ""

#: library/typing.rst:2454
msgid "On a base class::"
msgstr ""

#: library/typing.rst:2463
msgid "On a metaclass::"
msgstr ""

#: library/typing.rst:2474
msgid ""
"The ``CustomerModel`` classes defined above will be treated by type checkers "
"similarly to classes created with :func:`@dataclasses.dataclass <dataclasses."
"dataclass>`. For example, type checkers will assume these classes have "
"``__init__`` methods that accept ``id`` and ``name``."
msgstr ""

#: library/typing.rst:2480
msgid "The arguments to this decorator can be used to customize this behavior:"
msgstr ""

#: library/typing.rst:2482
msgid ""
"``eq_default`` indicates whether the ``eq`` parameter is assumed to be "
"``True`` or ``False`` if it is omitted by the caller."
msgstr ""

#: library/typing.rst:2484
msgid ""
"``order_default`` indicates whether the ``order`` parameter is assumed to be "
"True or False if it is omitted by the caller."
msgstr ""

#: library/typing.rst:2486
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 ""

#: library/typing.rst:2488
msgid ""
"``field_specifiers`` specifies a static list of supported classes or "
"functions that describe fields, similar to ``dataclasses.field()``."
msgstr ""

#: library/typing.rst:2490
msgid ""
"Arbitrary other keyword arguments are accepted in order to allow for "
"possible future extensions."
msgstr ""

#: library/typing.rst:2493
msgid ""
"At runtime, this decorator records its arguments in the "
"``__dataclass_transform__`` attribute on the decorated object. It has no "
"other runtime effect."
msgstr ""

#: library/typing.rst:2497
#, fuzzy
msgid "See :pep:`681` for more details."
msgstr "Voir la :pep:`484` pour plus de détails."

#: library/typing.rst:2503
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::"
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 ::"

#: library/typing.rst:2527
msgid "See :pep:`484` for 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:2529
msgid ""
"Overloaded functions can now be introspected at runtime using :func:"
"`get_overloads`."
msgstr ""

#: library/typing.rst:2536
msgid ""
"Return a sequence of :func:`@overload <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 <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 ""

#: library/typing.rst:2544
msgid ""
"``get_overloads()`` can be used for introspecting an overloaded function at "
"runtime."
msgstr ""

#: library/typing.rst:2552
msgid ""
"Clear all registered overloads in the internal registry. This can be used to "
"reclaim the memory used by the registry."
msgstr ""

#: library/typing.rst:2560
msgid ""
"A decorator to indicate to type checkers that the decorated method cannot be "
"overridden, and the decorated class cannot be subclassed. For example::"
msgstr ""
"Un décorateur pour indiquer aux vérificateurs de types que la méthode "
"décorée ne peut pas être remplacée et que la classe décorée ne peut pas être "
"sous-classée. Par exemple ::"

#: library/typing.rst:2583
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."
msgstr ""

#: library/typing.rst:2594
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."

#: library/typing.rst:2596
#, 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)."
msgstr ""
"Cela fonctionne en tant que classe ou fonction :term:`décoratrice "
"<decorator>`. Avec une classe, elle s'applique récursivement à toutes les "
"méthodes définies dans cette classe (mais pas aux méthodes définies dans ses "
"superclasses ou sous-classes)."

#: library/typing.rst:2600
msgid "This mutates the function(s) in place."
msgstr "Cela fait muter la ou les fonctions en place."

#: library/typing.rst:2604
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`."

#: library/typing.rst:2606
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`."

#: library/typing.rst:2611
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."

#: library/typing.rst:2613
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::"
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 ::"

#: library/typing.rst:2624
msgid ""
"Note that returning instances of private classes is not recommended. It is "
"usually preferable to make such classes public."
msgstr ""
"Notez qu'il n'est pas recommandé de renvoyer les instances des classes "
"privées. Il est généralement préférable de rendre ces classes publiques."

#: library/typing.rst:2628
msgid "Introspection helpers"
msgstr ""

#: library/typing.rst:2632
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."

#: library/typing.rst:2635
#, 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."
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."

#: library/typing.rst:2641
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::"
msgstr ""

#: library/typing.rst:2656
msgid ""
":func:`get_type_hints` does not work with imported :ref:`type aliases <type-"
"aliases>` that include forward references. Enabling postponed evaluation of "
"annotations (:pep:`563`) may remove the need for most forward references."
msgstr ""

#: library/typing.rst:2661
msgid "Added ``include_extras`` parameter as part of :pep:`593`."
msgstr ""

#: library/typing.rst:2664
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."
msgstr ""

#: library/typing.rst:2672
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."

#: library/typing.rst:2674
#, 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::"
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 ::"

#: library/typing.rst:2693
msgid "Check if a type is a :class:`TypedDict`."
msgstr ""

#: library/typing.rst:2708
#, 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."
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."

#: library/typing.rst:2714
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]``."
msgstr ""

#: library/typing.rst:2721
msgid "Constant"
msgstr "Constante"

#: library/typing.rst:2725
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 ::"

#: library/typing.rst:2734
#, 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."
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."

#: library/typing.rst:2741
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`)."
msgstr ""

#: library/typing.rst:2750
msgid "Deprecation Timeline of Major Features"
msgstr ""

#: library/typing.rst:2752
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."
msgstr ""

#: library/typing.rst:2757
msgid "Feature"
msgstr ""

#: library/typing.rst:2757
msgid "Deprecated in"
msgstr ""

#: library/typing.rst:2757
msgid "Projected removal"
msgstr ""

#: library/typing.rst:2757
msgid "PEP/issue"
msgstr ""

#: library/typing.rst:2759
msgid "``typing.io`` and ``typing.re`` submodules"
msgstr ""

#: library/typing.rst:2759
msgid "3.8"
msgstr ""

#: library/typing.rst:2759
msgid "3.12"
msgstr ""

#: library/typing.rst:2759
msgid ":issue:`38291`"
msgstr ""

#: library/typing.rst:2762
msgid "``typing`` versions of standard collections"
msgstr ""

#: library/typing.rst:2762
msgid "3.9"
msgstr ""

#: library/typing.rst:2765
msgid "Undecided"
msgstr ""

#: library/typing.rst:2762
msgid ":pep:`585`"
msgstr ""

#: library/typing.rst:2765
msgid "``typing.Text``"
msgstr ""

#: library/typing.rst:2765
msgid "3.11"
msgstr ""

#: library/typing.rst:2765
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`."
#~ 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`."

#~ msgid ""
#~ "This also means that it is not possible to create a subtype of "
#~ "``Derived`` since it is an identity function at runtime, not an actual "
#~ "type::"
#~ msgstr ""
#~ "Cela signifie également qu'il n'est pas possible de créer un sous-type de "
#~ "``Derived`` puisqu'il s'agit d'une fonction d'identité au moment de "
#~ "l'exécution, pas d'un type réel ::"

#~ 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]``."

#~ 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 !"