diff --git a/dict b/dict
index 81246216..1f9054b3 100644
--- a/dict
+++ b/dict
@@ -21,6 +21,8 @@ catucci
 cobjects
 composabilité
 concourance
+contravariante
+contravariantes
 contribués
 coroutine
 coroutines
diff --git a/library/typing.po b/library/typing.po
index 86ed709e..8226dca8 100644
--- a/library/typing.po
+++ b/library/typing.po
@@ -6,17 +6,18 @@ msgstr ""
 "Project-Id-Version: Python 3\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2019-11-15 18:54+0100\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"PO-Revision-Date: 2019-11-26 17:28-0500\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"
+"Last-Translator: \n"
+"X-Generator: Poedit 2.2.4\n"
 
 #: ../Doc/library/typing.rst:2
 msgid ":mod:`typing` --- Support for type hints"
-msgstr ""
+msgstr ":mod:`typing` — Prise en charge des annotations de type"
 
 #: ../Doc/library/typing.rst:9
 msgid "**Source code:** :source:`Lib/typing.py`"
@@ -28,6 +29,9 @@ msgid ""
 "They can be used by third party tools such as type checkers, IDEs, linters, "
 "etc."
 msgstr ""
+"Le moteur d'exécution Python n'applique pas les annotations de type pour les "
+"fonctions et les variables. Elles peuvent être utilisées par des outils "
+"tiers tels que les contrôleurs de type, les IDE, les analyseurs de code, etc."
 
 #: ../Doc/library/typing.rst:19
 msgid ""
@@ -38,11 +42,20 @@ msgid ""
 "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`."
 
 #: ../Doc/library/typing.rst:27
 msgid ""
 "The function below takes and returns a string and is annotated as follows::"
 msgstr ""
+"La fonction ci-dessous prend et renvoie une chaîne de caractères, et est "
+"annotée comme suit ::"
 
 #: ../Doc/library/typing.rst:32
 msgid ""
@@ -50,42 +63,56 @@ msgid ""
 "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."
 
 #: ../Doc/library/typing.rst:37
 msgid "Type aliases"
-msgstr ""
+msgstr "Alias de type"
 
 #: ../Doc/library/typing.rst:39
 msgid ""
 "A type alias is defined by assigning the type to the alias. In this example, "
 "``Vector`` and ``List[float]`` will be treated as interchangeable synonyms::"
 msgstr ""
+"Un alias de type est défini en assignant le type à l'alias. Dans cet "
+"exemple, ``Vector`` et ``List[float]`` sont traités comme des synonymes "
+"interchangeables ::"
 
 #: ../Doc/library/typing.rst:51
 msgid ""
 "Type aliases are useful for simplifying complex type signatures. For "
 "example::"
 msgstr ""
+"Les alias de type sont utiles pour simplifier les signatures complexes. Par "
+"exemple ::"
 
 #: ../Doc/library/typing.rst:69
 msgid ""
 "Note that ``None`` as a type hint is a special case and is replaced by "
 "``type(None)``."
 msgstr ""
+"Notez que ``None`` comme indication de type est un cas particulier et est "
+"remplacé par ``type(None)``."
 
 #: ../Doc/library/typing.rst:75
 msgid "NewType"
-msgstr ""
+msgstr "*NewType*"
 
 #: ../Doc/library/typing.rst:77
 msgid "Use the :func:`NewType` helper function to create distinct types::"
 msgstr ""
+"Aidez-vous de la fonction :func:`NewType` pour créer des types distincts ::"
 
 #: ../Doc/library/typing.rst:84
 msgid ""
 "The static type checker will treat the new type as if it were a subclass of "
 "the original type. This is useful in helping catch logical errors::"
 msgstr ""
+"Le vérificateur de type statique traite le nouveau type comme s'il "
+"s'agissait d'une sous-classe du type original. C'est utile pour aider à "
+"détecter les erreurs logiques ::"
 
 #: ../Doc/library/typing.rst:96
 msgid ""
@@ -94,6 +121,11 @@ msgid ""
 "pass in a ``UserId`` wherever an ``int`` might be expected, but will prevent "
 "you from accidentally creating a ``UserId`` in an invalid way::"
 msgstr ""
+"Vous pouvez toujours effectuer toutes les opérations applicables à un entier "
+"(type ``int``) sur une variable de type ``UserId``, mais le résultat sera "
+"toujours de type ``int``. Ceci vous permet de passer un ``UserId`` partout "
+"où un ``int`` est attendu, mais vous empêche de créer accidentellement un "
+"``UserId`` d'une manière invalide ::"
 
 #: ../Doc/library/typing.rst:104
 msgid ""
@@ -103,33 +135,45 @@ msgid ""
 "it. That means the expression ``Derived(some_value)`` does not create a new "
 "class or introduce any overhead beyond that of a regular function call."
 msgstr ""
+"Notez que ces contrôles ne sont exécutés que par le vérificateur de type "
+"statique. À 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."
 
 #: ../Doc/library/typing.rst:110
 msgid ""
 "More precisely, the expression ``some_value is Derived(some_value)`` is "
 "always true at runtime."
 msgstr ""
+"Plus précisément, l'expression ``some_value is Derived(some_value)`` est "
+"toujours vraie au moment de l'exécution."
 
 #: ../Doc/library/typing.rst:113
 msgid ""
 "This also means that it is not possible to create a subtype of ``Derived`` "
 "since it is an identity function at runtime, not an actual type::"
 msgstr ""
+"Cela signifie également qu'il n'est pas possible de créer un sous-type de "
+"``Derived`` puisqu'il s'agit d'une fonction d'identité au moment de "
+"l'exécution, pas d'un type réel ::"
 
 #: ../Doc/library/typing.rst:123
 msgid ""
 "However, it is possible to create a :func:`NewType` based on a 'derived' "
 "``NewType``::"
 msgstr ""
+"Cependant, il est possible de créer un :func:`NewType` basé sur un "
+"``NewType`` « dérivé » ::"
 
 #: ../Doc/library/typing.rst:131
 msgid "and typechecking for ``ProUserId`` will work as expected."
-msgstr ""
+msgstr "et la vérification de type pour ``ProUserId`` fonctionne comme prévu."
 
 #: ../Doc/library/typing.rst:133
-#, fuzzy
 msgid "See :pep:`484` for more details."
-msgstr "Voir la :pep:`492` pour plus d'informations."
+msgstr "Voir la :pep:`484` pour plus de détails."
 
 #: ../Doc/library/typing.rst:137
 msgid ""
@@ -138,6 +182,11 @@ msgid ""
 "treat ``Alias`` as being *exactly equivalent* to ``Original`` in all cases. "
 "This is useful when you want to simplify complex type signatures."
 msgstr ""
+"Rappelons que l'utilisation d'un alias de type déclare que deux types sont "
+"*équivalents* l'un à l'autre. Écrire ``Alias = Original`` fait que le "
+"vérificateur de type statique traite ``Alias`` comme étant *exactement "
+"équivalent* à ``Original`` dans tous les cas. C'est utile lorsque vous "
+"voulez simplifier des signatures complexes."
 
 #: ../Doc/library/typing.rst:142
 msgid ""
@@ -148,16 +197,26 @@ msgid ""
 "``Derived`` is expected. This is useful when you want to prevent logic "
 "errors with minimal runtime cost."
 msgstr ""
+"En revanche, ``NewType`` déclare qu'un type est un *sous-type* d'un autre. "
+"É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."
 
 #: ../Doc/library/typing.rst:152
 msgid "Callable"
-msgstr ""
+msgstr "Appelable"
 
 #: ../Doc/library/typing.rst:154
 msgid ""
 "Frameworks expecting callback functions of specific signatures might be type "
 "hinted using ``Callable[[Arg1Type, Arg2Type], ReturnType]``."
 msgstr ""
+"Les 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]``."
 
 #: ../Doc/library/typing.rst:157
 msgid "For example::"
@@ -169,10 +228,13 @@ msgid ""
 "the call signature by substituting a literal ellipsis for the list of "
 "arguments in the type hint: ``Callable[..., ReturnType]``."
 msgstr ""
+"Il est possible de déclarer le type de retour d'un appelable sans spécifier "
+"la signature de l'appel en indiquant des points de suspension à la liste des "
+"arguments dans l'indice de type : ``Callable[..., ReturnType]``."
 
 #: ../Doc/library/typing.rst:175
 msgid "Generics"
-msgstr ""
+msgstr "Génériques"
 
 #: ../Doc/library/typing.rst:177
 msgid ""
@@ -180,20 +242,29 @@ msgid ""
 "inferred in a generic way, abstract base classes have been extended to "
 "support subscription to denote expected types for container elements."
 msgstr ""
+"Comme les informations de type sur les objets conservés dans des conteneurs "
+"ne peuvent pas être déduites statiquement de manière générique, les classes "
+"de base abstraites ont été étendues pour prendre en charge la sélection "
+"(*subscription* en anglais) et indiquer les types attendus pour les éléments "
+"de conteneur."
 
 #: ../Doc/library/typing.rst:188
 msgid ""
 "Generics can be parameterized by using a new factory available in typing "
 "called :class:`TypeVar`."
 msgstr ""
+"Les génériques peuvent être paramétrés en utilisant une nouvelle fabrique "
+"(au sens des patrons de conception) disponible en tapant :class:`TypeVar`."
 
 #: ../Doc/library/typing.rst:202
 msgid "User-defined generic types"
-msgstr ""
+msgstr "Types génériques définis par l'utilisateur"
 
 #: ../Doc/library/typing.rst:204
 msgid "A user-defined class can be defined as a generic class."
 msgstr ""
+"Une classe définie par l'utilisateur peut être définie comme une classe "
+"générique."
 
 #: ../Doc/library/typing.rst:230
 msgid ""
@@ -201,37 +272,48 @@ msgid ""
 "single type parameter ``T`` . This also makes ``T`` valid as a type within "
 "the class body."
 msgstr ""
+"``Generic[T]`` en tant que classe de base définit que la classe "
+"``LoggedVar`` prend un paramètre de type unique ``T``. Ceci rend également "
+"``T`` valide en tant que type dans le corps de la classe."
 
 #: ../Doc/library/typing.rst:234
 msgid ""
 "The :class:`Generic` base class defines :meth:`__class_getitem__` so that "
 "``LoggedVar[t]`` is valid as a type::"
 msgstr ""
+"La classe de base :class:`Generic` définit :meth:`__class_getitem__` de "
+"sorte que ``LoggedVar[t]`` est valide comme type ::"
 
 #: ../Doc/library/typing.rst:243
 msgid ""
 "A generic type can have any number of type variables, and type variables may "
 "be constrained::"
 msgstr ""
+"Un type générique peut avoir un nombre quelconque de variables de type et "
+"vous pouvez fixer des contraintes sur les variables de type ::"
 
 #: ../Doc/library/typing.rst:255
 msgid ""
 "Each type variable argument to :class:`Generic` must be distinct. This is "
 "thus invalid::"
 msgstr ""
+"Chaque argument de variable de type :class:`Generic` doit être distinct. "
+"Ceci n'est donc pas valable ::"
 
 #: ../Doc/library/typing.rst:266
 msgid "You can use multiple inheritance with :class:`Generic`::"
-msgstr ""
+msgstr "Vous pouvez utiliser l'héritage multiple avec :class:`Generic` ::"
 
 #: ../Doc/library/typing.rst:275
 msgid ""
 "When inheriting from generic classes, some type variables could be fixed::"
 msgstr ""
+"Lors de l'héritage de classes génériques, certaines variables de type "
+"peuvent être corrigées ::"
 
 #: ../Doc/library/typing.rst:284
 msgid "In this case ``MyDict`` has a single parameter, ``T``."
-msgstr ""
+msgstr "Dans ce cas, ``MyDict`` a un seul paramètre, ``T``."
 
 #: ../Doc/library/typing.rst:286
 msgid ""
@@ -239,14 +321,20 @@ msgid ""
 "for each position. In the following example, ``MyIterable`` is not generic "
 "but implicitly inherits from ``Iterable[Any]``::"
 msgstr ""
+"L'utilisation d'une classe générique sans spécifier de paramètres de type "
+"suppose :data:`Any` pour chaque position. Dans l'exemple suivant, "
+"``MyIterable`` n'est pas générique mais hérite implicitement de "
+"``Iterable[Any]`` ::"
 
 #: ../Doc/library/typing.rst:294
 msgid "User defined generic type aliases are also supported. Examples::"
 msgstr ""
+"Les alias de type générique définis par l'utilisateur sont également pris en "
+"charge. Exemples ::"
 
 #: ../Doc/library/typing.rst:310
 msgid ":class:`Generic` no longer has a custom metaclass."
-msgstr ""
+msgstr ":class:`Generic` n'a plus de métaclasse personnalisée."
 
 #: ../Doc/library/typing.rst:313
 msgid ""
@@ -255,10 +343,15 @@ msgid ""
 "parameterizing generics is cached, and most types in the typing module are "
 "hashable and comparable for equality."
 msgstr ""
+"Une classe générique définie par l'utilisateur peut avoir des CBA (*Classe "
+"de Base Abstraite*) comme classes de base sans conflit de métaclasses. Les "
+"métaclasses génériques ne sont pas prises en charge. Le résultat du "
+"paramétrage des génériques est mis en cache et la plupart des types dans le "
+"module ``typing`` sont hachables et comparables pour l'égalité."
 
 #: ../Doc/library/typing.rst:320
 msgid "The :data:`Any` type"
-msgstr ""
+msgstr "Le type :data:`Any`"
 
 #: ../Doc/library/typing.rst:322
 msgid ""
@@ -266,12 +359,18 @@ msgid ""
 "every type as being compatible with :data:`Any` and :data:`Any` as being "
 "compatible with every type."
 msgstr ""
+"Un type particulier est :data:`Any`. Un vérificateur de type statique traite "
+"chaque type comme étant compatible avec :data:`Any` et :data:`Any` comme "
+"étant compatible avec chaque type."
 
 #: ../Doc/library/typing.rst:326
 msgid ""
 "This means that it is possible to perform any operation or method call on a "
 "value of type on :data:`Any` and assign it to any variable::"
 msgstr ""
+"Cela signifie qu'il est possible d'effectuer n'importe quelle opération ou "
+"appel de méthode sur une valeur de type :data:`Any` et de l'affecter à "
+"n'importe quelle variable ::"
 
 #: ../Doc/library/typing.rst:344
 msgid ""
@@ -281,18 +380,27 @@ msgid ""
 "declared to be of type :class:`str` and receives an :class:`int` value at "
 "runtime!"
 msgstr ""
+"Notez qu'aucun contrôle de typage n'est effectué lors de l'affectation d'une "
+"valeur de type :data:`Any` à un type plus précis. Par exemple, le "
+"vérificateur de type statique 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 !"
 
 #: ../Doc/library/typing.rst:350
 msgid ""
 "Furthermore, all functions without a return type or parameter types will "
 "implicitly default to using :data:`Any`::"
 msgstr ""
+"De plus, toutes les fonctions sans type de retour ni type de paramètre sont "
+"considérées comme utilisant :data:`Any` implicitement par défaut ::"
 
 #: ../Doc/library/typing.rst:363
 msgid ""
 "This behavior allows :data:`Any` to be used as an *escape hatch* when you "
 "need to mix dynamically and statically typed code."
 msgstr ""
+"Ce comportement permet à :data:`Any` d'être utilisé comme succédané lorsque "
+"vous avez besoin de mélanger du code typé dynamiquement et statiquement."
 
 #: ../Doc/library/typing.rst:366
 msgid ""
@@ -301,6 +409,10 @@ msgid ""
 "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."
 
 #: ../Doc/library/typing.rst:371
 msgid ""
@@ -309,16 +421,23 @@ msgid ""
 "it as a return value) of a more specialized type is a type error. For "
 "example::"
 msgstr ""
+"Cela signifie que lorsque le type d'une valeur est :class:`object`, un "
+"vérificateur de type 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 ::"
 
 #: ../Doc/library/typing.rst:393
 msgid ""
 "Use :class:`object` to indicate that a value could be any type in a typesafe "
 "manner. Use :data:`Any` to indicate that a value is dynamically typed."
 msgstr ""
+"Utilisez :class:`object` pour indiquer qu'une valeur peut être de n'importe "
+"quel type de manière sûre. Utiliser :data:`Any` pour indiquer qu'une valeur "
+"est typée dynamiquement."
 
 #: ../Doc/library/typing.rst:398
 msgid "Nominal vs structural subtyping"
-msgstr ""
+msgstr "Sous-typage nominal et sous-typage structurel"
 
 #: ../Doc/library/typing.rst:400
 msgid ""
@@ -326,6 +445,10 @@ msgid ""
 "subtyping*. This means that a class ``A`` is allowed where a class ``B`` is "
 "expected if and only if ``A`` is a subclass of ``B``."
 msgstr ""
+"Initialement la :pep:`484` définissait le système de type statique Python "
+"comme utilisant *le sous-type nominal*. Cela signifie qu'une classe ``A`` "
+"est permise lorsqu'une classe ``B`` est prévue si et seulement si ``A`` est "
+"une sous-classe de ``B``."
 
 #: ../Doc/library/typing.rst:404
 msgid ""
@@ -335,6 +458,12 @@ msgid ""
 "would normally do in idiomatic dynamically typed Python code. For example, "
 "this conforms to the :pep:`484`::"
 msgstr ""
+"Ce pré-requis s'appliquait auparavant aussi aux classes de base abstraites, "
+"telles que :class:`Iterable`. Le problème avec cette approche est qu'une "
+"classe devait être explicitement marquée pour les supporter, ce qui n'est "
+"pas *pythonique* et diffère de ce que l'on ferait normalement avec du code "
+"Python idiomatique typé dynamiquement. Par exemple, ceci est conforme à la :"
+"pep:`484` ::"
 
 #: ../Doc/library/typing.rst:417
 msgid ""
@@ -344,6 +473,12 @@ msgid ""
 "``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 de base explicites dans la "
+"définition de classe, permettant à ``Bucket`` d'être implicitement considéré "
+"comme un sous-type de ``Sized`` et ``Iterable[int]`` par des vérificateurs "
+"de type statique. C'est ce qu'on appelle le *sous-typage structurel* (ou "
+"typage canard) ::"
 
 #: ../Doc/library/typing.rst:433
 msgid ""
@@ -351,18 +486,21 @@ msgid ""
 "define new custom protocols to fully enjoy structural subtyping (see "
 "examples below)."
 msgstr ""
+"De plus, en sous-classant une classe spéciale :class:`Protocol`, un "
+"utilisateur peut définir de nouveaux protocoles personnalisés pour profiter "
+"pleinement du sous-typage structurel (voir exemples ci-dessous)."
 
 #: ../Doc/library/typing.rst:439
 msgid "Classes, functions, and decorators"
-msgstr ""
+msgstr "Classes, fonctions et décorateurs"
 
 #: ../Doc/library/typing.rst:441
 msgid "The module defines the following classes, functions and decorators:"
-msgstr ""
+msgstr "Ce module définit les classes, fonctions et décorateurs suivants :"
 
 #: ../Doc/library/typing.rst:445
 msgid "Type variable."
-msgstr ""
+msgstr "Variables de type."
 
 #: ../Doc/library/typing.rst:447 ../Doc/library/typing.rst:915
 msgid "Usage::"
@@ -375,6 +513,11 @@ msgid ""
 "function definitions.  See class Generic for more information on generic "
 "types.  Generic functions work as follows::"
 msgstr ""
+"Les variables de type existent principalement dans l'intérêt des contrôleurs "
+"de type statiques. Elles servent de paramètres pour les types génériques "
+"ainsi que pour les définitions de fonctions génériques. Voir la classe "
+"``Generic`` pour plus d'informations sur les types génériques. Les fonctions "
+"génériques fonctionnent comme suit ::"
 
 #: ../Doc/library/typing.rst:465
 msgid ""
@@ -383,12 +526,19 @@ msgid ""
 "arguments are instances of some subclass of :class:`str`, the return type is "
 "still plain :class:`str`."
 msgstr ""
+"La signature de ce dernier exemple est essentiellement la surcharge de "
+"``(str, str) -> str`` et ``(bytes, bytes) -> bytes``. Notez également que si "
+"les arguments sont des instances d'une sous-classe de la classe :class:"
+"`str`, le type de retour est toujours la classe :class:`str`."
 
 #: ../Doc/library/typing.rst:470
 msgid ""
 "At runtime, ``isinstance(x, T)`` will raise :exc:`TypeError`.  In general, :"
 "func:`isinstance` and :func:`issubclass` should not be used with types."
 msgstr ""
+"Au moment de l'exécution, ``isinstance(x, T)`` va lever :exc:`TypeError`. En "
+"général, :func:`isinstance` et :func:`issubclass` ne devraient pas être "
+"utilisés avec les types."
 
 #: ../Doc/library/typing.rst:473
 msgid ""
@@ -399,10 +549,17 @@ msgid ""
 "an actual type substituted (explicitly or implicitly) for the type variable "
 "must be a subclass of the boundary type, see :pep:`484`."
 msgstr ""
+"Les variables de type peuvent être marquées covariantes ou 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`."
 
 #: ../Doc/library/typing.rst:483
 msgid "Abstract base class for generic types."
-msgstr ""
+msgstr "Classe de base abstraite pour les types génériques."
 
 #: ../Doc/library/typing.rst:485
 msgid ""
@@ -410,21 +567,29 @@ msgid ""
 "this class with one or more type variables. For example, a generic mapping "
 "type might be defined as::"
 msgstr ""
+"Un type générique est généralement déclaré en héritant d'une instanciation "
+"de cette classe avec une ou plusieurs variables de type. Par exemple, un "
+"type de correspondance générique peut être défini comme suit ::"
 
 #: ../Doc/library/typing.rst:494
 msgid "This class can then be used as follows::"
-msgstr ""
+msgstr "Cette classe peut alors être utilisée comme suit ::"
 
 #: ../Doc/library/typing.rst:507
 msgid ""
 "Base class for protocol classes. Protocol classes are defined like this::"
 msgstr ""
+"Classe de base pour les classes de protocole. Les classes de protocole sont "
+"définies comme suit ::"
 
 #: ../Doc/library/typing.rst:513
 msgid ""
 "Such classes are primarily used with static type checkers that recognize "
 "structural subtyping (static duck-typing), for example::"
 msgstr ""
+"Ces classes sont principalement utilisées avec les vérificateurs statiques "
+"de type qui reconnaissent les sous-types structurels (typage canard "
+"statique), par exemple ::"
 
 #: ../Doc/library/typing.rst:525
 msgid ""
@@ -433,10 +598,14 @@ msgid ""
 "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."
 
 #: ../Doc/library/typing.rst:530
 msgid "Protocol classes can be generic, for example::"
-msgstr ""
+msgstr "Les classes de protocole peuvent être génériques, par exemple ::"
 
 #: ../Doc/library/typing.rst:540
 msgid ""
@@ -445,10 +614,14 @@ msgid ""
 "classes themselves -- specifically, it will accept the *class object* of "
 "``C``. For example::"
 msgstr ""
+"Une variable annotée de ``C`` peut accepter une valeur de type ``C``. En "
+"revanche, une variable annotée avec ``Type[C]`` peut accepter des valeurs "
+"qui sont elles-mêmes des classes — plus précisément, elle accepte l'objet "
+"*class* de ``C``. Par exemple ::"
 
 #: ../Doc/library/typing.rst:549
 msgid "Note that ``Type[C]`` is covariant::"
-msgstr ""
+msgstr "Notez que ``Type[C]`` est covariant ::"
 
 #: ../Doc/library/typing.rst:561
 msgid ""
@@ -459,124 +632,147 @@ msgid ""
 "the indicated base class. How the type checker is required to handle this "
 "particular case may change in future revisions of :pep:`484`."
 msgstr ""
+"Le fait que ``Type[C]`` soit covariant implique que toutes les sous-classes "
+"de ``C`` doivent implémenter la même signature de constructeur et les "
+"signatures de méthode de classe que ``C``. Le vérificateur de type doit "
+"signaler les manquements à cette règle. Il doit également autoriser les "
+"appels du constructeur dans les sous-classes qui correspondent aux appels du "
+"constructeur dans la classe de base indiquée. La façon dont le vérificateur "
+"de type est tenu de traiter ce cas particulier peut changer dans les futures "
+"révisions de :pep:`484`."
 
 #: ../Doc/library/typing.rst:569
 msgid ""
 "The only legal parameters for :class:`Type` are classes, :data:`Any`, :ref:"
 "`type variables <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 ::"
 
 #: ../Doc/library/typing.rst:575
 msgid ""
 "``Type[Any]`` is equivalent to ``Type`` which in turn is equivalent to "
 "``type``, which is the root of Python's metaclass hierarchy."
 msgstr ""
+"``Type[Any]`` est équivalent à ``Type`` qui à son tour est équivalent à "
+"``type``, qui est la racine de la hiérarchie des métaclasses de Python."
 
 #: ../Doc/library/typing.rst:582
 msgid "A generic version of :class:`collections.abc.Iterable`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.Iterable`."
 
 #: ../Doc/library/typing.rst:586
 msgid "A generic version of :class:`collections.abc.Iterator`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.Iterator`."
 
 #: ../Doc/library/typing.rst:590
 msgid "A generic version of :class:`collections.abc.Reversible`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.Reversible`."
 
 #: ../Doc/library/typing.rst:594
 msgid "An ABC with one abstract method ``__int__``."
-msgstr ""
+msgstr "Une ABC avec une méthode abstraite ``__int__``."
 
 #: ../Doc/library/typing.rst:598
 msgid "An ABC with one abstract method ``__float__``."
-msgstr ""
+msgstr "Une ABC avec une méthode abstraite ``__float__``."
 
 #: ../Doc/library/typing.rst:602
 msgid "An ABC with one abstract method ``__complex__``."
-msgstr ""
+msgstr "Une ABC avec une méthode abstraite ``__complex__``."
 
 #: ../Doc/library/typing.rst:606
 msgid "An ABC with one abstract method ``__bytes__``."
-msgstr ""
+msgstr "Une ABC avec une méthode abstraite ``__bytes__``."
 
 #: ../Doc/library/typing.rst:610
 msgid "An ABC with one abstract method ``__index__``."
-msgstr ""
+msgstr "Une ABC avec une méthode abstraite ``__index__``."
 
 #: ../Doc/library/typing.rst:616
 msgid ""
 "An ABC with one abstract method ``__abs__`` that is covariant in its return "
 "type."
 msgstr ""
+"Une ABC avec une méthode abstraite ``__abs__`` qui est covariante dans son "
+"type de retour."
 
 #: ../Doc/library/typing.rst:621
 msgid ""
 "An ABC with one abstract method ``__round__`` that is covariant in its "
 "return type."
 msgstr ""
+"Une ABC avec une méthode abstraite ``__round__`` qui est covariante dans son "
+"type de retour."
 
 #: ../Doc/library/typing.rst:626
 msgid "A generic version of :class:`collections.abc.Container`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.Container`."
 
 #: ../Doc/library/typing.rst:630
 msgid "An alias to :class:`collections.abc.Hashable`"
-msgstr ""
+msgstr "Un alias pour :class:`collections.abc.Hashable`"
 
 #: ../Doc/library/typing.rst:634
 msgid "An alias to :class:`collections.abc.Sized`"
-msgstr ""
+msgstr "Un alias pour :class:`collections.abc.Sized`"
 
 #: ../Doc/library/typing.rst:638
 msgid "A generic version of :class:`collections.abc.Collection`"
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.Collection`"
 
 #: ../Doc/library/typing.rst:644
 msgid "A generic version of :class:`collections.abc.Set`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.Set`."
 
 #: ../Doc/library/typing.rst:648
 msgid "A generic version of :class:`collections.abc.MutableSet`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.MutableSet`."
 
 #: ../Doc/library/typing.rst:652
 msgid ""
 "A generic version of :class:`collections.abc.Mapping`. This type can be used "
 "as follows::"
 msgstr ""
+"Une version générique de :class:`collections.abc.Mapping`. Ce type peut être "
+"utilisé comme suit ::"
 
 #: ../Doc/library/typing.rst:660
 msgid "A generic version of :class:`collections.abc.MutableMapping`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.MutableMapping`."
 
 #: ../Doc/library/typing.rst:664
 msgid "A generic version of :class:`collections.abc.Sequence`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.Sequence`."
 
 #: ../Doc/library/typing.rst:668
 msgid "A generic version of :class:`collections.abc.MutableSequence`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.MutableSequence`."
 
 #: ../Doc/library/typing.rst:672
 msgid "A generic version of :class:`collections.abc.ByteString`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.ByteString`."
 
 #: ../Doc/library/typing.rst:674
 msgid ""
 "This type represents the types :class:`bytes`, :class:`bytearray`, and :"
 "class:`memoryview`."
 msgstr ""
+"Ce type représente les types :class:`bytes`, :class:`bytearray` et :class:"
+"`memoryview`."
 
 #: ../Doc/library/typing.rst:677
 msgid ""
 "As a shorthand for this type, :class:`bytes` can be used to annotate "
 "arguments of any of the types mentioned above."
 msgstr ""
+"Comme abréviation pour ce type, :class:`bytes` peut être utilisé pour "
+"annoter des arguments de n'importe quel type mentionné ci-dessus."
 
 #: ../Doc/library/typing.rst:682
 msgid "A generic version of :class:`collections.deque`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.deque`."
 
 #: ../Doc/library/typing.rst:689
 msgid ""
@@ -584,10 +780,13 @@ msgid ""
 "annotate arguments it is preferred to use an abstract collection type such "
 "as :class:`Sequence` or :class:`Iterable`."
 msgstr ""
+"Version générique de :class:`list`. Utile pour annoter les types de retour. "
+"Pour annoter les arguments, il est préférable d'utiliser un type de "
+"collection abstraite tel que :class:`Sequence` ou :class:`Iterable`."
 
 #: ../Doc/library/typing.rst:694
 msgid "This type may be used as follows::"
-msgstr ""
+msgstr "Ce type peut être utilisé comme suit ::"
 
 #: ../Doc/library/typing.rst:706
 msgid ""
@@ -595,30 +794,33 @@ msgid ""
 "return types. To annotate arguments it is preferred to use an abstract "
 "collection type such as :class:`AbstractSet`."
 msgstr ""
+"Une version générique de :class:`builtins.set <set>`. Utile pour annoter les "
+"types de retour. Pour annoter les arguments, il est préférable d'utiliser un "
+"type de collection abstraite tel que :class:`AbstractSet`."
 
 #: ../Doc/library/typing.rst:712
 msgid "A generic version of :class:`builtins.frozenset <frozenset>`."
-msgstr ""
+msgstr "Une version générique de :class:`builtins.frozenset <frozenset>`."
 
 #: ../Doc/library/typing.rst:716
 msgid "A generic version of :class:`collections.abc.MappingView`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.MappingView`."
 
 #: ../Doc/library/typing.rst:720
 msgid "A generic version of :class:`collections.abc.KeysView`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.KeysView`."
 
 #: ../Doc/library/typing.rst:724
 msgid "A generic version of :class:`collections.abc.ItemsView`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.ItemsView`."
 
 #: ../Doc/library/typing.rst:728
 msgid "A generic version of :class:`collections.abc.ValuesView`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.ValuesView`."
 
 #: ../Doc/library/typing.rst:732
 msgid "A generic version of :class:`collections.abc.Awaitable`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.Awaitable`."
 
 #: ../Doc/library/typing.rst:738
 msgid ""
@@ -626,22 +828,26 @@ msgid ""
 "order of type variables correspond to those of :class:`Generator`, for "
 "example::"
 msgstr ""
+"Une version générique de :class:`collections.abc.Coroutine`. La variance et "
+"l'ordre des variables de type correspondent à ceux de la classe :class:"
+"`Generator`, par exemple ::"
 
 #: ../Doc/library/typing.rst:753
 msgid "A generic version of :class:`collections.abc.AsyncIterable`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.AsyncIterable`."
 
 #: ../Doc/library/typing.rst:759
 msgid "A generic version of :class:`collections.abc.AsyncIterator`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.abc.AsyncIterator`."
 
 #: ../Doc/library/typing.rst:765
 msgid "A generic version of :class:`contextlib.AbstractContextManager`."
-msgstr ""
+msgstr "Une version générique de :class:`contextlib.AbstractContextManager`."
 
 #: ../Doc/library/typing.rst:772
 msgid "A generic version of :class:`contextlib.AbstractAsyncContextManager`."
 msgstr ""
+"Une version générique de :class:`contextlib.AbstractAsyncContextManager`."
 
 #: ../Doc/library/typing.rst:779
 msgid ""
@@ -649,32 +855,37 @@ msgid ""
 "annotate arguments it is preferred to use an abstract collection type such "
 "as :class:`Mapping`."
 msgstr ""
+"Une version générique de :class:`dict`. Utile pour annoter les types de "
+"retour. Pour annoter les arguments, il est préférable d'utiliser un type de "
+"collection abstraite tel que :class:`Mapping`."
 
 #: ../Doc/library/typing.rst:783
 msgid "This type can be used as follows::"
-msgstr ""
+msgstr "Ce type peut être utilisé comme suit ::"
 
 #: ../Doc/library/typing.rst:790
 msgid "A generic version of :class:`collections.defaultdict`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.defaultdict`."
 
 #: ../Doc/library/typing.rst:796
 msgid "A generic version of :class:`collections.OrderedDict`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.OrderedDict`."
 
 #: ../Doc/library/typing.rst:802
 msgid "A generic version of :class:`collections.Counter`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.Counter`."
 
 #: ../Doc/library/typing.rst:809
 msgid "A generic version of :class:`collections.ChainMap`."
-msgstr ""
+msgstr "Une version générique de :class:`collections.ChainMap`."
 
 #: ../Doc/library/typing.rst:816
 msgid ""
 "A generator can be annotated by the generic type ``Generator[YieldType, "
 "SendType, ReturnType]``. For example::"
 msgstr ""
+"Un générateur peut être annoté par le type générique ``Generator[YieldType, "
+"SendType, ReturnType]``. Par exemple ::"
 
 #: ../Doc/library/typing.rst:825
 msgid ""
@@ -682,24 +893,33 @@ msgid ""
 "of :class:`Generator` behaves contravariantly, not covariantly or "
 "invariantly."
 msgstr ""
+"Notez que contrairement à beaucoup d'autres génériques dans le module "
+"*typing*, le ``SendType`` de :class:`Generator` se comporte de manière "
+"contravariante, pas de manière covariante ou invariante."
 
 #: ../Doc/library/typing.rst:829
 msgid ""
 "If your generator will only yield values, set the ``SendType`` and "
 "``ReturnType`` to ``None``::"
 msgstr ""
+"Si votre générateur ne donne que des valeurs, réglez les paramètres "
+"``SendType`` et ``ReturnType`` sur ``None`` ::"
 
 #: ../Doc/library/typing.rst:837
 msgid ""
 "Alternatively, annotate your generator as having a return type of either "
 "``Iterable[YieldType]`` or ``Iterator[YieldType]``::"
 msgstr ""
+"Alternativement, annotez votre générateur comme ayant un type de retour soit "
+"``Iterable[YieldType]`` ou ``Iterator[YieldType]`` ::"
 
 #: ../Doc/library/typing.rst:847
 msgid ""
 "An async generator can be annotated by the generic type "
 "``AsyncGenerator[YieldType, SendType]``. For example::"
 msgstr ""
+"Un générateur asynchrone peut être annoté par le type générique "
+"``AsyncGenerator[YieldType, SendType]``. Par exemple ::"
 
 #: ../Doc/library/typing.rst:856
 msgid ""
@@ -707,17 +927,25 @@ msgid ""
 "is no ``ReturnType`` type parameter. As with :class:`Generator`, the "
 "``SendType`` behaves contravariantly."
 msgstr ""
+"Contrairement aux générateurs normaux, les générateurs asynchrones ne "
+"peuvent pas 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."
 
 #: ../Doc/library/typing.rst:860
 msgid ""
 "If your generator will only yield values, set the ``SendType`` to ``None``::"
 msgstr ""
+"Si votre générateur ne donne que des valeurs, réglez le paramètre "
+"``SendType`` sur ``None`` ::"
 
 #: ../Doc/library/typing.rst:868
 msgid ""
 "Alternatively, annotate your generator as having a return type of either "
 "``AsyncIterable[YieldType]`` or ``AsyncIterator[YieldType]``::"
 msgstr ""
+"Alternativement, annotez votre générateur comme ayant un type de retour soit "
+"``AsyncIterable[YieldType]`` ou ``AsyncIterator[YieldType]`` ::"
 
 #: ../Doc/library/typing.rst:880
 msgid ""
@@ -725,12 +953,17 @@ msgid ""
 "compatible path for Python 2 code: in Python 2, ``Text`` is an alias for "
 "``unicode``."
 msgstr ""
+"``Text`` est un alias pour ``str``. Il est fourni pour obtenir une "
+"compatibilité ascendante du code Python 2 : en Python 2, ``Text`` est un "
+"alias pour ``unicode``."
 
 #: ../Doc/library/typing.rst:884
 msgid ""
 "Use ``Text`` to indicate that a value must contain a unicode string in a "
 "manner that is compatible with both Python 2 and Python 3::"
 msgstr ""
+"Utilisez ``Text`` pour indiquer qu'une valeur doit contenir une chaîne "
+"Unicode d'une manière compatible avec Python 2 et Python 3 ::"
 
 #: ../Doc/library/typing.rst:896
 msgid ""
@@ -738,6 +971,9 @@ msgid ""
 "``BinaryIO(IO[bytes])`` represent the types of I/O streams such as returned "
 "by :func:`open`."
 msgstr ""
+"Le type générique ``IO[AnyStr]`` et ses sous-classes ``TextIO(IO[str])`` et "
+"``BinaryIO(IO[bytes])`` représentent les types de flux d'entrées-sorties "
+"tels que renvoyés par :func:`open`."
 
 #: ../Doc/library/typing.rst:904
 msgid ""
@@ -746,24 +982,32 @@ msgid ""
 "generic in ``AnyStr`` and can be made specific by writing ``Pattern[str]``, "
 "``Pattern[bytes]``, ``Match[str]``, or ``Match[bytes]``."
 msgstr ""
+"Ces alias de type correspondent aux types de retour de :func:`re.compile` "
+"et :func:`re.match`. Ces types (et les fonctions correspondantes) sont "
+"génériques dans ``AnyStr`` et peuvent être rendus spécifiques en écrivant "
+"``Pattern[str]``, ``Pattern[bytes]``, ``Match[str]`` ou ``Match[bytes]``."
 
 #: ../Doc/library/typing.rst:913
 msgid "Typed version of :func:`collections.namedtuple`."
-msgstr ""
+msgstr "Version typée de :func:`collections.namedtuple`."
 
 #: ../Doc/library/typing.rst:921
 msgid "This is equivalent to::"
-msgstr "C’est équivalent à ::"
+msgstr "Ce qui est équivalent à ::"
 
 #: ../Doc/library/typing.rst:925
 msgid ""
 "To give a field a default value, you can assign to it in the class body::"
 msgstr ""
+"Pour assigner une valeur par défaut à un champ, vous pouvez lui donner dans "
+"le corps de classe ::"
 
 #: ../Doc/library/typing.rst:934
 msgid ""
 "Fields with a default value must come after any fields without a default."
 msgstr ""
+"Les champs avec une valeur par défaut doivent venir après tous les champs "
+"sans valeur par défaut."
 
 #: ../Doc/library/typing.rst:936
 msgid ""
@@ -772,40 +1016,56 @@ msgid ""
 "``_fields`` attribute and the default values are in the ``_field_defaults`` "
 "attribute both of which are part of the namedtuple API.)"
 msgstr ""
+"La classe résultante a un attribut supplémentaire ``__annotations__`` "
+"donnant un dictionnaire qui associe les noms des champs aux types de champs. "
+"(Les noms des champs sont dans l'attribut ``_fields`` et les valeurs par "
+"défaut sont dans l'attribut ``_field_defaults`` qui font partie de l'API "
+"*namedtuple*.)"
 
 #: ../Doc/library/typing.rst:942
 msgid "``NamedTuple`` subclasses can also have docstrings and methods::"
 msgstr ""
+"Les sous-classes de ``NamedTuple`` peuvent aussi avoir des *docstrings* et "
+"des méthodes ::"
 
 #: ../Doc/library/typing.rst:952
 msgid "Backward-compatible usage::"
-msgstr ""
+msgstr "Utilisation rétrocompatible ::"
 
 #: ../Doc/library/typing.rst:956
 msgid "Added support for :pep:`526` variable annotation syntax."
 msgstr ""
+"Ajout de la gestion de la syntaxe d'annotation variable de la :pep:`526`."
 
 #: ../Doc/library/typing.rst:959
 msgid "Added support for default values, methods, and docstrings."
 msgstr ""
+"Ajout de la prise en charge des valeurs par défaut, des méthodes et des "
+"chaînes de caractères *docstrings*."
 
 #: ../Doc/library/typing.rst:962
 msgid ""
 "Deprecated the ``_field_types`` attribute in favor of the more standard "
 "``__annotations__`` attribute which has the same information."
 msgstr ""
+"rend l'attribut ``_field_types`` obsolète en faveur de l'attribut plus "
+"standard ``__annotations__`` qui a la même information."
 
 #: ../Doc/library/typing.rst:966
 msgid ""
 "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``."
 
 #: ../Doc/library/typing.rst:972
 msgid ""
 "A simple typed namespace. At runtime it is equivalent to a plain :class:"
 "`dict`."
 msgstr ""
+"Un simple espace de nommage typé. À l'exécution, c'est l'équivalent d'un "
+"simple :class:`dict`."
 
 #: ../Doc/library/typing.rst:975
 msgid ""
@@ -814,6 +1074,11 @@ msgid ""
 "consistent type. This expectation is not checked at runtime but is only "
 "enforced by type checkers. Usage::"
 msgstr ""
+"``TypedDict`` crée un type de dictionnaire qui s'attend à ce que toutes ses "
+"instances aient un certain jeu de clés, où chaque clé est associée à une "
+"valeur d'un type cohérent. Cette 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 ::"
 
 #: ../Doc/library/typing.rst:991
 msgid ""
@@ -822,12 +1087,19 @@ msgid ""
 "with older versions of Python that do not support :pep:`526`, ``TypedDict`` "
 "supports two additional equivalent syntactic forms::"
 msgstr ""
+"Les informations de type pour l'introspection sont accessibles via ``Point2D."
+"__annotations__`` et ``Point2D.__total__``. Pour permettre l'utilisation de "
+"cette fonctionnalité avec les anciennes versions de Python qui ne prennent "
+"pas en compte la :pep:`526`, ``TypedDict`` gère deux formes syntaxiques "
+"équivalentes supplémentaires ::"
 
 #: ../Doc/library/typing.rst:999
 msgid ""
 "See :pep:`589` for more examples and detailed rules of using ``TypedDict`` "
 "with type checkers."
 msgstr ""
+"Voir la :pep:`589` pour plus d'exemples et de règles détaillées "
+"d'utilisation de ``TypedDict`` avec les vérificateurs de type."
 
 #: ../Doc/library/typing.rst:1006
 msgid ""
@@ -836,6 +1108,12 @@ msgid ""
 "into ``List[ForwardRef(\"SomeClass\")]``.  This class should not be "
 "instantiated by a user, but may be used by introspection tools."
 msgstr ""
+"Une classe utilisée pour le typage interne de la représentation des "
+"références directes des chaînes de caractères. Par exemple, "
+"``Liste[\"SomeClass\"]`` est implicitement transformé en "
+"``Liste[ForwardRef(\"SomeClass\")]``. Cette classe ne doit pas être "
+"instanciée par un utilisateur, mais peut être utilisée par des outils "
+"d'introspection."
 
 #: ../Doc/library/typing.rst:1013
 msgid ""
@@ -843,10 +1121,13 @@ msgid ""
 "`distinct`. At runtime it returns a function that returns its argument. "
 "Usage::"
 msgstr ""
+"Une fonction pour faciliter l'indication d'un type distinct à un "
+"vérificateur de type, voir :ref:`distinct`. Lors de l'exécution, elle "
+"renvoie une fonction qui renvoie son argument. Utilisation ::"
 
 #: ../Doc/library/typing.rst:1024
 msgid "Cast a value to a type."
-msgstr ""
+msgstr "Convertit une valeur en un type."
 
 #: ../Doc/library/typing.rst:1026
 msgid ""
@@ -854,12 +1135,18 @@ msgid ""
 "return value has the designated type, but at runtime we intentionally don't "
 "check anything (we want this to be as fast as possible)."
 msgstr ""
+"Ceci 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)."
 
 #: ../Doc/library/typing.rst:1033
 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."
 
 #: ../Doc/library/typing.rst:1036
 msgid ""
@@ -870,10 +1157,19 @@ msgid ""
 "``None`` is set. For a class ``C``, return a dictionary constructed by "
 "merging all the ``__annotations__`` along ``C.__mro__`` in reverse order."
 msgstr ""
+"C'est souvent équivalent à ``obj.__annotations__``. De plus, les références "
+"directes encodées sous forme de chaîne littérales sont traitées en les "
+"évaluant dans les espaces de nommage ``globals`` et ``locals``. Si "
+"nécessaire, ``Optional[t]`` est ajouté pour les annotations de fonction et "
+"de méthode si une valeur par défaut égale à ``None`` est définie. Pour une "
+"classe ``C``, renvoie un dictionnaire construit en fusionnant toutes les "
+"``__annotations__`` en parcourant ``C.__mro__`` en ordre inverse."
 
 #: ../Doc/library/typing.rst:1047
 msgid "Provide basic introspection for generic types and special typing forms."
 msgstr ""
+"Fournit une introspection de base pour les types génériques et les formes "
+"spéciales de typage."
 
 #: ../Doc/library/typing.rst:1049
 msgid ""
@@ -882,6 +1178,10 @@ msgid ""
 "`collections` class, it gets normalized to the original class. For "
 "unsupported objects return ``None`` and ``()`` correspondingly. Examples::"
 msgstr ""
+"Pour un objet de typage de la forme ``X[Y, Z, ....]``, ces fonctions "
+"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 ::"
 
 #: ../Doc/library/typing.rst:1065
 msgid ""
@@ -897,26 +1197,46 @@ msgid ""
 "gives a more precise type than can be expressed using a union or a type "
 "variable::"
 msgstr ""
+"Le décorateur ``@overload``` permet de décrire des fonctions et des méthodes "
+"qui 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 ::"
 
 #: ../Doc/library/typing.rst:1089
 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."
 
 #: ../Doc/library/typing.rst:1093
 msgid ""
 "A decorator to indicate to type checkers that the decorated method cannot be "
 "overridden, and the decorated class cannot be subclassed. For example::"
 msgstr ""
+"Un décorateur pour indiquer aux vérificateurs de types que la méthode "
+"décorée ne peut pas être remplacée et que la classe décorée ne peut pas être "
+"sous-classée. Par exemple ::"
 
 #: ../Doc/library/typing.rst:1111 ../Doc/library/typing.rst:1338
 msgid ""
 "There is no runtime checking of these properties. See :pep:`591` for more "
 "details."
 msgstr ""
+"Ces propriétés ne sont pas vérifiées à l'exécution. Voir la :pep:`591` pour "
+"plus de détails."
 
 #: ../Doc/library/typing.rst:1118
 msgid "Decorator to indicate that annotations are not type hints."
 msgstr ""
+"Décorateur pour indiquer que les annotations ne sont pas des indications de "
+"type."
 
 #: ../Doc/library/typing.rst:1120
 msgid ""
@@ -924,24 +1244,33 @@ msgid ""
 "recursively to all methods defined in that class (but not to methods defined "
 "in its superclasses or subclasses)."
 msgstr ""
+"Cela fonctionne en tant que classe ou fonction :term:`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)."
 
 #: ../Doc/library/typing.rst:1124
 msgid "This mutates the function(s) in place."
-msgstr ""
+msgstr "Cela fait muter la ou les fonctions en place."
 
 #: ../Doc/library/typing.rst:1128
 msgid "Decorator to give another decorator the :func:`no_type_check` effect."
 msgstr ""
+"Décorateur pour donner à un autre décorateur l'effet :func:`no_type_check`."
 
 #: ../Doc/library/typing.rst:1130
 msgid ""
 "This wraps the decorator with something that wraps the decorated function "
 "in :func:`no_type_check`."
 msgstr ""
+"Ceci enveloppe le décorateur avec quelque chose qui enveloppe la fonction "
+"décorée dans :func:`no_type_check`."
 
 #: ../Doc/library/typing.rst:1135
 msgid "Decorator to mark a class or function to be unavailable at runtime."
 msgstr ""
+"Décorateur pour marquer une classe ou une fonction comme étant indisponible "
+"au moment de l'exécution."
 
 #: ../Doc/library/typing.rst:1137
 msgid ""
@@ -949,16 +1278,22 @@ msgid ""
 "mark classes that are defined in type stub files if an implementation "
 "returns an instance of a private class::"
 msgstr ""
+"Ce décorateur n'est pas disponible à l'exécution. Il est principalement "
+"destiné à marquer les classes qui sont définies dans des fichiers séparés "
+"d'annotations de type (*type stub file*, en anglais) si une implémentation "
+"renvoie une instance d'une classe privée ::"
 
 #: ../Doc/library/typing.rst:1148
 msgid ""
 "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."
 
 #: ../Doc/library/typing.rst:1153
 msgid "Mark a protocol class as a runtime protocol."
-msgstr ""
+msgstr "Marquez une classe de protocole comme protocole d'exécution."
 
 #: ../Doc/library/typing.rst:1155
 msgid ""
@@ -967,80 +1302,92 @@ msgid ""
 "allows a simple-minded structural check, very similar to \"one trick ponies"
 "\" in :mod:`collections.abc` such as :class:`Iterable`.  For example::"
 msgstr ""
+"Un tel protocole peut être utilisé avec :func:`isinstance` et :func:"
+"`issubclass`. Cela lève :exc:`TypeError` lorsqu'il est appliqué à une classe "
+"non protocole. Cela permet un contrôle structurel compréhensible, très "
+"similaire aux « classes qui ne savent faire qu'une chose » présentes dans :"
+"mod:`collections.abc` tel que :class:`Iterable`. Par exemple ::"
 
 #: ../Doc/library/typing.rst:1166
 msgid ""
 "**Warning:** this will check only the presence of the required methods, not "
 "their type signatures!"
 msgstr ""
+"**Attention :** ceci ne vérifiera que la présence des méthodes requises, et "
+"non leur signature de type !"
 
 #: ../Doc/library/typing.rst:1173
 msgid "Special type indicating an unconstrained type."
-msgstr ""
+msgstr "Type spécial indiquant un type non contraint."
 
 #: ../Doc/library/typing.rst:1175
 msgid "Every type is compatible with :data:`Any`."
-msgstr ""
+msgstr "Chaque type est compatible avec :data:`Any`."
 
 #: ../Doc/library/typing.rst:1176
 msgid ":data:`Any` is compatible with every type."
-msgstr ""
+msgstr ":data:`Any` est compatible avec tous les types."
 
 #: ../Doc/library/typing.rst:1180
 msgid "Special type indicating that a function never returns. For example::"
-msgstr ""
+msgstr "Type spécial indiquant qu'une fonction ne renvoie rien. Par exemple ::"
 
 #: ../Doc/library/typing.rst:1193
 msgid "Union type; ``Union[X, Y]`` means either X or Y."
-msgstr ""
+msgstr "Type « union » ; ``Union[X, Y]`` signifie X ou Y."
 
 #: ../Doc/library/typing.rst:1195
 msgid "To define a union, use e.g. ``Union[int, str]``.  Details:"
 msgstr ""
+"Pour définir une union, utilisez par exemple ``Union[int, str]``. Détail :"
 
 #: ../Doc/library/typing.rst:1197
 msgid "The arguments must be types and there must be at least one."
 msgstr ""
+"Les arguments doivent être des types et il doit y en avoir au moins un."
 
 #: ../Doc/library/typing.rst:1199
 msgid "Unions of unions are flattened, e.g.::"
-msgstr ""
+msgstr "Les unions d'unions sont aplanies, par exemple ::"
 
 #: ../Doc/library/typing.rst:1203
 msgid "Unions of a single argument vanish, e.g.::"
-msgstr ""
+msgstr "Les unions d'un seul argument disparaissent, par exemple ::"
 
 #: ../Doc/library/typing.rst:1207
 msgid "Redundant arguments are skipped, e.g.::"
-msgstr ""
+msgstr "Les arguments redondants sont ignorés, par exemple ::"
 
 #: ../Doc/library/typing.rst:1211
 msgid "When comparing unions, the argument order is ignored, e.g.::"
 msgstr ""
+"Lors de la comparaison d'unions, l'ordre des arguments est ignoré, par "
+"exemple ::"
 
 #: ../Doc/library/typing.rst:1215
 msgid "You cannot subclass or instantiate a union."
-msgstr ""
+msgstr "Vous ne pouvez pas sous-classer ou instancier une union."
 
 #: ../Doc/library/typing.rst:1217
 msgid "You cannot write ``Union[X][Y]``."
-msgstr ""
+msgstr "Vous ne pouvez pas écrire ``Union[X][Y]``."
 
 #: ../Doc/library/typing.rst:1219
 msgid "You can use ``Optional[X]`` as a shorthand for ``Union[X, None]``."
 msgstr ""
+"Vous pouvez utiliser l'abréviation ``Optional[X]`` pour ``Union[X, None]``."
 
 #: ../Doc/library/typing.rst:1221
 msgid "Don't remove explicit subclasses from unions at runtime."
-msgstr ""
+msgstr "Ne supprime pas les sous-classes explicites des unions à l'exécution."
 
 #: ../Doc/library/typing.rst:1226
 msgid "Optional type."
-msgstr ""
+msgstr "Type « optionnel »."
 
 #: ../Doc/library/typing.rst:1228
 msgid "``Optional[X]`` is equivalent to ``Union[X, None]``."
-msgstr ""
+msgstr "``Optional[X]`` équivaut à ``Union[X, None]``."
 
 #: ../Doc/library/typing.rst:1230
 msgid ""
@@ -1049,6 +1396,10 @@ msgid ""
 "the ``Optional`` qualifier on its type annotation just because it is "
 "optional. For example::"
 msgstr ""
+"Notez que ce n'est pas le même concept qu'un argument optionnel, qui est un "
+"argument qui possède une valeur par défaut. Un argument optionnel (qui a une "
+"valeur par défaut) ne nécessite pas, à ce titre, le qualificatif "
+"``Optional`` sur son annotation de type. Par exemple ::"
 
 #: ../Doc/library/typing.rst:1238
 msgid ""
@@ -1056,6 +1407,9 @@ msgid ""
 "``Optional`` is appropriate, whether the argument is optional or not. For "
 "example::"
 msgstr ""
+"Par contre, si une valeur explicite de ``None`` est permise, l'utilisation "
+"de ``Optional`` est appropriée, que l'argument soit facultatif ou non. Par "
+"exemple ::"
 
 #: ../Doc/library/typing.rst:1247
 msgid ""
@@ -1063,6 +1417,9 @@ msgid ""
 "first item of type X and the second of type Y. The type of the empty tuple "
 "can be written as ``Tuple[()]``."
 msgstr ""
+"Type « n-uplet » ; ``Tuple[X, Y]`` est le type d'un n-uplet à deux éléments "
+"avec le premier élément de type X et le second de type Y. Le type du n-uplet "
+"vide peut être écrit comme ``Tuple[()]``."
 
 #: ../Doc/library/typing.rst:1251
 msgid ""
@@ -1070,6 +1427,9 @@ msgid ""
 "variables T1 and T2.  ``Tuple[int, float, str]`` is a tuple of an int, a "
 "float and a string."
 msgstr ""
+"Exemple : ``Tuple[T1, T2]`` est une paire correspondant aux variables de "
+"type ``T1`` et ``T2``. ``Tuple[int, float, str]`` est un triplet composé "
+"d'un entier, d'un flottant et d'une chaîne de caractères."
 
 #: ../Doc/library/typing.rst:1255
 msgid ""
@@ -1077,10 +1437,15 @@ msgid ""
 "ellipsis, e.g. ``Tuple[int, ...]``. A plain :data:`Tuple` is equivalent to "
 "``Tuple[Any, ...]``, and in turn to :class:`tuple`."
 msgstr ""
+"Pour spécifier un n-uplet de longueur variable et de type homogène, utilisez "
+"une ellipse, par exemple ``Tuple[int, ....]``. Un n-uplet :data:`Tuple` est "
+"équivalent à ``Tuple[Any, ....]`` et, à son tour, à :class:`tuple`."
 
 #: ../Doc/library/typing.rst:1261
 msgid "Callable type; ``Callable[[int], str]`` is a function of (int) -> str."
 msgstr ""
+"Type Appelable. ``Callable[[int], str]`` est une fonction de type ``(int) -> "
+"str``."
 
 #: ../Doc/library/typing.rst:1263
 msgid ""
@@ -1088,6 +1453,10 @@ msgid ""
 "argument list and the return type.  The argument list must be a list of "
 "types or an ellipsis; the return type must be a single type."
 msgstr ""
+"La syntaxe de sélection (*subscription* en anglais) doit toujours être "
+"utilisée avec exactement deux valeurs : la liste d'arguments et le type de "
+"retour. La liste d'arguments doit être une liste de types ou une ellipse ; "
+"il doit y avoir un seul type de retour."
 
 #: ../Doc/library/typing.rst:1268
 msgid ""
@@ -1098,6 +1467,13 @@ msgid ""
 "equivalent to ``Callable[..., Any]``, and in turn to :class:`collections.abc."
 "Callable`."
 msgstr ""
+"Il n'y a pas de syntaxe pour indiquer les arguments optionnels ou les "
+"arguments par mots-clés ; de tels types de fonctions sont rarement utilisés "
+"comme types de rappel. ``Callable[..., ReturnType]`` (ellipse) peut être "
+"utilisé pour annoter le type d'un appelable, prenant un nombre quelconque "
+"d'arguments et renvoyant ``ReturnType``. Un simple :data:`Callable` est "
+"équivalent à ``Callable[..., Any]`` et, à son tour, à :class:`collections."
+"abc.Callable`."
 
 #: ../Doc/library/typing.rst:1278
 msgid ""
@@ -1105,6 +1481,9 @@ msgid ""
 "variable or function parameter has a value equivalent to the provided "
 "literal (or one of several literals). For example::"
 msgstr ""
+"Type pour indiquer aux vérificateurs de type que la variable ou le paramètre "
+"de fonction correspondant a une valeur équivalente au littéral fourni (ou un "
+"parmi plusieurs littéraux). Par exemple ::"
 
 #: ../Doc/library/typing.rst:1292
 msgid ""
@@ -1112,10 +1491,15 @@ msgid ""
 "allowed as type argument to ``Literal[...]``, but type checkers may impose "
 "restrictions. See :pep:`586` for more details about literal types."
 msgstr ""
+"``Literal[...]`` ne peut être sous-classé. Lors de l'exécution, une valeur "
+"arbitraire est autorisée comme argument de type pour ``Literal[...]``, mais "
+"les vérificateurs de type peuvent imposer des restrictions. Voir la :pep:"
+"`586` pour plus de détails sur les types littéraux."
 
 #: ../Doc/library/typing.rst:1300
 msgid "Special type construct to mark class variables."
 msgstr ""
+"Construction de type particulière pour indiquer les variables de classe."
 
 #: ../Doc/library/typing.rst:1302
 msgid ""
@@ -1123,10 +1507,14 @@ msgid ""
 "indicates that a given attribute is intended to be used as a class variable "
 "and should not be set on instances of that class. Usage::"
 msgstr ""
+"Telle qu'introduite dans la :pep:`526`, une annotation de variable "
+"enveloppée dans ClassVar indique qu'un attribut donné est destiné à être "
+"utilisé comme une variable de classe et ne doit pas être défini sur des "
+"instances de cette classe. Utilisation ::"
 
 #: ../Doc/library/typing.rst:1310
 msgid ":data:`ClassVar` accepts only types and cannot be further subscribed."
-msgstr ""
+msgstr ":data:`ClassVar` n'accepte que les types et ne peut plus être dérivé."
 
 #: ../Doc/library/typing.rst:1312
 msgid ""
@@ -1135,30 +1523,45 @@ msgid ""
 "runtime behavior, but it can be used by third-party type checkers. For "
 "example, a type checker might flag the following code as an error::"
 msgstr ""
+":data:`ClassVar` n'est pas une classe en soi, et ne devrait pas être "
+"utilisé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 ::"
 
 #: ../Doc/library/typing.rst:1326
 msgid ""
 "A special typing construct to indicate to type checkers that a name cannot "
 "be re-assigned or overridden in a subclass. For example::"
 msgstr ""
+"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 ::"
 
 #: ../Doc/library/typing.rst:1345
 msgid ""
 "``AnyStr`` is a type variable defined as ``AnyStr = TypeVar('AnyStr', str, "
 "bytes)``."
 msgstr ""
+"``AnyStr`` est une variable de type définie comme ``AnyStr = "
+"TypeVar('AnyStr', str, bytes)``."
 
 #: ../Doc/library/typing.rst:1348
 msgid ""
 "It is meant to be used for functions that may accept any kind of string "
 "without allowing different kinds of strings to mix. For example::"
 msgstr ""
+"Cela est destiné à être utilisé pour des fonctions qui peuvent accepter "
+"n'importe quel type de chaîne de caractères sans permettre à différents "
+"types de chaînes de caractères de se mélanger. Par exemple ::"
 
 #: ../Doc/library/typing.rst:1360
 msgid ""
 "A special constant that is assumed to be ``True`` by 3rd party static type "
 "checkers. It is ``False`` at runtime. Usage::"
 msgstr ""
+"Constante spéciale qui vaut ``True`` pour les vérificateurs de type "
+"statiques tiers et ``False`` à l'exécution. Utilisation ::"
 
 #: ../Doc/library/typing.rst:1369
 msgid ""
@@ -1167,3 +1570,9 @@ msgid ""
 "interpreter runtime.  Type annotations for local variables are not "
 "evaluated, so the second annotation does not need to be enclosed in quotes."
 msgstr ""
+"Notez que la première annotation de type doit être entourée de guillemets, "
+"ce qui en fait une « référence 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."