abc.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: 2024-10-29 21:40+0100\n"
"PO-Revision-Date: 2022-11-20 22:28+0100\n"
"Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\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 2.4.2\n"

#: library/abc.rst:2
#, fuzzy
msgid ":mod:`!abc` --- Abstract Base Classes"
msgstr ":mod:`abc` — Classes de Base Abstraites"

#: library/abc.rst:11
msgid "**Source code:** :source:`Lib/abc.py`"
msgstr "**Code source:** :source:`Lib/abc.py`"

#: library/abc.rst:15
msgid ""
"This module provides the infrastructure for defining :term:`abstract base "
"classes <abstract base class>` (ABCs) in Python, as outlined in :pep:`3119`; "
"see the PEP for why this was added to Python. (See also :pep:`3141` and the :"
"mod:`numbers` module regarding a type hierarchy for numbers based on ABCs.)"
msgstr ""
"Le module fournit l'infrastructure pour définir les :term:`classes mères "
"abstraites <abstract base class>` (*Abstract Base Class* ou *ABC* en "
"anglais) en Python, tel qu'indiqué dans la :pep:`3119`; voir la PEP pour la "
"raison de son ajout à Python. (Voir également la :pep:`3141` et le module :"
"mod:`numbers` pour ce qui concerne la hiérarchie de types pour les nombres "
"basés sur les classes mères abstraites). Par la suite nous utiliserons "
"l'abréviation ABC (*Abstract Base Class*) pour désigner une classe mère "
"abstraite."

#: library/abc.rst:20
#, fuzzy
msgid ""
"The :mod:`collections` module has some concrete classes that derive from "
"ABCs; these can, of course, be further derived. In addition, the :mod:"
"`collections.abc` submodule has some ABCs that can be used to test whether a "
"class or instance provides a particular interface, for example, if it is :"
"term:`hashable` or if it is a :term:`mapping`."
msgstr ""
"Le module :mod:`collections` possède certaines classes concrètes qui "
"dérivent d'ABC. Celles-ci peuvent, bien sur, être elles-mêmes dérivées. De "
"plus, le sous-module :mod:`collections.abc` possède des ABC qui peuvent être "
"utilisées pour tester si une classe ou une instance fournit une interface "
"spécifique. Par exemple, est-elle hachable ou un tableau associatif "
"(*mapping* en anglais) ?"

#: library/abc.rst:27
msgid ""
"This module provides the metaclass :class:`ABCMeta` for defining ABCs and a "
"helper class :class:`ABC` to alternatively define ABCs through inheritance:"
msgstr ""
"Ce module fournit la métaclasse :class:`ABCMeta` pour définir les ABC ainsi "
"que la classe d'aide :class:`ABC`, cette dernière permettant de définir des "
"ABC en utilisant l'héritage :"

#: library/abc.rst:32
#, fuzzy
msgid ""
"A helper class that has :class:`ABCMeta` as its metaclass.  With this class, "
"an abstract base class can be created by simply deriving from :class:`!ABC` "
"avoiding sometimes confusing metaclass usage, for example::"
msgstr ""
"Classe d'aide qui a :class:`ABCMeta` pour métaclasse. Avec cette classe, une "
"ABC peut être créée simplement en héritant de :class:`ABC` , ce qui permet "
"d'éviter l'utilisation parfois déroutante de métaclasse, par exemple ::"

#: library/abc.rst:36
msgid ""
"from abc import ABC\n"
"\n"
"class MyABC(ABC):\n"
"    pass"
msgstr ""

#: library/abc.rst:41
#, fuzzy
msgid ""
"Note that the type of :class:`!ABC` is still :class:`ABCMeta`, therefore "
"inheriting from :class:`!ABC` requires the usual precautions regarding "
"metaclass usage, as multiple inheritance may lead to metaclass conflicts. "
"One may also define an abstract base class by passing the metaclass keyword "
"and using :class:`!ABCMeta` directly, for example::"
msgstr ""
"Il est à noter que le type de :class:`ABC` reste :class:`ABCMeta`. En "
"conséquence, hériter de :class:`ABC` nécessite les précautions habituelles "
"concernant l'utilisation de métaclasses : l'utilisation d'héritage multiple "
"peut entrainer des conflits de métaclasses. Il est également possible de "
"définir une ABC en passant l'argument nommé *metaclass* et en utilisant :"
"class:`ABCMeta` directement, par exemple ::"

#: library/abc.rst:47
msgid ""
"from abc import ABCMeta\n"
"\n"
"class MyABC(metaclass=ABCMeta):\n"
"    pass"
msgstr ""

#: library/abc.rst:57
msgid "Metaclass for defining Abstract Base Classes (ABCs)."
msgstr "Métaclasse pour définir des classes mères abstraites (ABC)."

#: library/abc.rst:59
msgid ""
"Use this metaclass to create an ABC.  An ABC can be subclassed directly, and "
"then acts as a mix-in class.  You can also register unrelated concrete "
"classes (even built-in classes) and unrelated ABCs as \"virtual subclasses\" "
"-- these and their descendants will be considered subclasses of the "
"registering ABC by the built-in :func:`issubclass` function, but the "
"registering ABC won't show up in their MRO (Method Resolution Order) nor "
"will method implementations defined by the registering ABC be callable (not "
"even via :func:`super`). [#]_"
msgstr ""
"Utilisez cette métaclasse pour créer une ABC. Il est possible d'hériter "
"d'une ABC directement, cette classe mère abstraite fonctionne alors comme "
"une classe *mixin*. Vous pouvez également enregistrer une classe concrète "
"sans lien (même une classe native) et des ABC comme \"sous-classes "
"virtuelles\" -- celles-ci et leur descendantes seront considérées comme des "
"sous-classes de la classe mère abstraite par la fonction native :func:"
"`issubclass`, mais les ABC enregistrées n'apparaitront pas dans leur ordre "
"de résolution des méthodes (*MRO* pour *Method Resolution Order* en "
"anglais). Les implémentations de méthodes définies par l'ABC ne seront pas "
"appelable (pas même via :func:`super`). [#]_"

#: library/abc.rst:68
#, fuzzy
msgid ""
"Classes created with a metaclass of :class:`!ABCMeta` have the following "
"method:"
msgstr ""
"Les classes dont la métaclasse est :class:`ABCMeta` possèdent les méthodes "
"suivantes :"

#: library/abc.rst:72
msgid ""
"Register *subclass* as a \"virtual subclass\" of this ABC. For example::"
msgstr ""
"Enregistrer *subclass* en tant que sous-classe virtuelle de cette ABC. Par "
"exemple ::"

#: library/abc.rst:75
msgid ""
"from abc import ABC\n"
"\n"
"class MyABC(ABC):\n"
"    pass\n"
"\n"
"MyABC.register(tuple)\n"
"\n"
"assert issubclass(tuple, MyABC)\n"
"assert isinstance((), MyABC)"
msgstr ""

#: library/abc.rst:85
msgid "Returns the registered subclass, to allow usage as a class decorator."
msgstr ""
"Renvoie la sous-classe enregistrée pour permettre l'utilisation en tant que "
"décorateur de classe."

#: library/abc.rst:88
#, fuzzy
msgid ""
"To detect calls to :meth:`!register`, you can use the :func:"
"`get_cache_token` function."
msgstr ""
"Pour détecter les appels à :meth:`register`, vous pouvez utiliser la "
"fonction :func:`get_cache_token`."

#: library/abc.rst:92
msgid "You can also override this method in an abstract base class:"
msgstr "Vous pouvez également redéfinir cette méthode dans une ABC :"

#: library/abc.rst:96
msgid "(Must be defined as a class method.)"
msgstr "(Doit être définie en tant que méthode de classe.)"

#: library/abc.rst:98
#, fuzzy
msgid ""
"Check whether *subclass* is considered a subclass of this ABC.  This means "
"that you can customize the behavior of :func:`issubclass` further without "
"the need to call :meth:`register` on every class you want to consider a "
"subclass of the ABC.  (This class method is called from the :meth:`~type."
"__subclasscheck__` method of the ABC.)"
msgstr ""
"Vérifie si *subclass* est considérée comme une sous-classe de cette ABC. "
"Cela signifie que vous pouvez personnaliser le comportement de "
"``issubclass`` sans nécessiter d'appeler :meth:`register` pour chacune des "
"classes que vous souhaitez considérer comme sous-classe de l'ABC. (Cette "
"méthode de classe est appelée par la méthode :meth:`__subclasscheck__` de la "
"classe mère abstraite)."

#: library/abc.rst:104
#, fuzzy
msgid ""
"This method should return ``True``, ``False`` or :data:`NotImplemented`.  If "
"it returns ``True``, the *subclass* is considered a subclass of this ABC. If "
"it returns ``False``, the *subclass* is not considered a subclass of this "
"ABC, even if it would normally be one.  If it returns :data:`!"
"NotImplemented`, the subclass check is continued with the usual mechanism."
msgstr ""
"Cette méthode doit renvoyer ``True``, ``False`` ou ``NotImplemented``. Si "
"elle renvoie ``True``, *subclass* est considérée comme sous-classe de cette "
"ABC. Si elle renvoie ``False``, la *subclass* n'est pas considérée une sous-"
"classe de cette ABC même si elle l'aurait été en temps normal. Si elle "
"renvoie ``NotImplemented``, la vérification d'appartenance à la sous-classe "
"continue via le mécanisme habituel."

#: library/abc.rst:114
msgid ""
"For a demonstration of these concepts, look at this example ABC definition::"
msgstr ""
"Pour une illustration de ces concepts, voir cet exemple de définition de "
"ABC ::"

#: library/abc.rst:116
msgid ""
"class Foo:\n"
"    def __getitem__(self, index):\n"
"        ...\n"
"    def __len__(self):\n"
"        ...\n"
"    def get_iterator(self):\n"
"        return iter(self)\n"
"\n"
"class MyIterable(ABC):\n"
"\n"
"    @abstractmethod\n"
"    def __iter__(self):\n"
"        while False:\n"
"            yield None\n"
"\n"
"    def get_iterator(self):\n"
"        return self.__iter__()\n"
"\n"
"    @classmethod\n"
"    def __subclasshook__(cls, C):\n"
"        if cls is MyIterable:\n"
"            if any(\"__iter__\" in B.__dict__ for B in C.__mro__):\n"
"                return True\n"
"        return NotImplemented\n"
"\n"
"MyIterable.register(Foo)"
msgstr ""

#: library/abc.rst:143
#, fuzzy
msgid ""
"The ABC ``MyIterable`` defines the standard iterable method, :meth:"
"`~iterator.__iter__`, as an abstract method.  The implementation given here "
"can still be called from subclasses.  The :meth:`!get_iterator` method is "
"also part of the ``MyIterable`` abstract base class, but it does not have to "
"be overridden in non-abstract derived classes."
msgstr ""
"L'ABC ``MyIterable`` définit la méthode d'itération :meth:`~iterator."
"__iter__` comme méthode abstraite. L'implémentation qui lui est donnée ici "
"peut être appelée depuis les sous-classes. La méthode :meth:`get_iterator` "
"fait également partie de la classe mère abstraite ``MyIterable``, mais elle "
"n'a pas à être redéfinie dans les classes dérivées non-abstraites."

#: library/abc.rst:149
#, fuzzy
msgid ""
"The :meth:`__subclasshook__` class method defined here says that any class "
"that has an :meth:`~iterator.__iter__` method in its :attr:`~object."
"__dict__` (or in that of one of its base classes, accessed via the :attr:"
"`~type.__mro__` list) is considered a ``MyIterable`` too."
msgstr ""
"La méthode de classe :meth:`__subclasshook__` définie ici dit que toute "
"classe qui possède la méthode :meth:`~iterator.__iter__` dans son :attr:"
"`~object.__dict__` (ou dans une de ses classes mères, accédée via la liste :"
"attr:`~class.__mro__`) est considérée également comme un ``MyIterable``."

#: library/abc.rst:154
#, fuzzy
msgid ""
"Finally, the last line makes ``Foo`` a virtual subclass of ``MyIterable``, "
"even though it does not define an :meth:`~iterator.__iter__` method (it uses "
"the old-style iterable protocol, defined in terms of :meth:`~object.__len__` "
"and :meth:`~object.__getitem__`).  Note that this will not make "
"``get_iterator`` available as a method of ``Foo``, so it is provided "
"separately."
msgstr ""
"Enfin, la dernière ligne fait de ``Foo`` une sous-classe virtuelle de "
"``MyIterable``, même si cette classe ne définit pas de méthode :meth:"
"`~iterator.__iter__` (elle utilise l'ancien protocole d'itération qui se "
"définit en termes de :meth:`__len__` et :meth:`__getitem__`). A noter que "
"cela ne rendra pas le ``get_iterator`` de ``MyIterable`` disponible comme "
"une méthode de ``Foo``, ``get_iterator`` est donc implémenté séparément."

#: library/abc.rst:163
#, fuzzy
msgid "The :mod:`!abc` module also provides the following decorator:"
msgstr "Le module :mod:`abc` fournit aussi le décorateur :"

#: library/abc.rst:167
msgid "A decorator indicating abstract methods."
msgstr "Un décorateur marquant les méthodes comme abstraites."

#: library/abc.rst:169
#, fuzzy
msgid ""
"Using this decorator requires that the class's metaclass is :class:`ABCMeta` "
"or is derived from it.  A class that has a metaclass derived from :class:`!"
"ABCMeta` cannot be instantiated unless all of its abstract methods and "
"properties are overridden.  The abstract methods can be called using any of "
"the normal 'super' call mechanisms.  :func:`!abstractmethod` may be used to "
"declare abstract methods for properties and descriptors."
msgstr ""
"Utiliser ce décorateur nécessite que la métaclasse de la classe soit :class:"
"`ABCMeta` ou soit dérivée de celle-ci. Une classe qui possède une méta-"
"classe dérivée de :class:`ABCMeta` ne peut pas être instanciée à moins que "
"toutes ses méthodes et propriétés abstraites soient redéfinies. Les méthodes "
"abstraites peuvent être appelées en utilisant n'importe quel des mécanismes "
"d'appel à 'super'. :func:`abstractmethod` peut être utilisée pour déclarer "
"des méthodes abstraites pour les propriétés et descripteurs."

#: library/abc.rst:176
#, fuzzy
msgid ""
"Dynamically adding abstract methods to a class, or attempting to modify the "
"abstraction status of a method or class once it is created, are only "
"supported using the :func:`update_abstractmethods` function.  The :func:`!"
"abstractmethod` only affects subclasses derived using regular inheritance; "
"\"virtual subclasses\" registered with the ABC's :meth:`~ABCMeta.register` "
"method are not affected."
msgstr ""
"L'ajout dynamique de méthodes abstraites à une classe comme la modification "
"de l'état d'abstraction d'une méthode ou d'une classe une fois celle-ci "
"créée sont des opérations à réaliser avec :func:`update_abstractmethods`. En "
"effet, :func:`abstractmethod` n'affecte que les sous-classes dérivées "
"utilisant l'héritage classique. Les \"sous-classes virtuelles\" enregistrées "
"avec la méthode :meth:`register` de l'ABC ne sont pas affectées."

#: library/abc.rst:183
#, fuzzy
msgid ""
"When :func:`!abstractmethod` is applied in combination with other method "
"descriptors, it should be applied as the innermost decorator, as shown in "
"the following usage examples::"
msgstr ""
"Quand le décorateur :func:`abstractmethod` est utilisé en même temps que "
"d'autres descripteurs de méthodes, il doit être appliqué en tant que "
"décorateur le plus interne. Voir les exemples d'utilisation suivants ::"

#: library/abc.rst:187
msgid ""
"class C(ABC):\n"
"    @abstractmethod\n"
"    def my_abstract_method(self, arg1):\n"
"        ...\n"
"    @classmethod\n"
"    @abstractmethod\n"
"    def my_abstract_classmethod(cls, arg2):\n"
"        ...\n"
"    @staticmethod\n"
"    @abstractmethod\n"
"    def my_abstract_staticmethod(arg3):\n"
"        ...\n"
"\n"
"    @property\n"
"    @abstractmethod\n"
"    def my_abstract_property(self):\n"
"        ...\n"
"    @my_abstract_property.setter\n"
"    @abstractmethod\n"
"    def my_abstract_property(self, val):\n"
"        ...\n"
"\n"
"    @abstractmethod\n"
"    def _get_x(self):\n"
"        ...\n"
"    @abstractmethod\n"
"    def _set_x(self, val):\n"
"        ...\n"
"    x = property(_get_x, _set_x)"
msgstr ""

#: library/abc.rst:217
#, fuzzy
msgid ""
"In order to correctly interoperate with the abstract base class machinery, "
"the descriptor must identify itself as abstract using :attr:`!"
"__isabstractmethod__`. In general, this attribute should be ``True`` if any "
"of the methods used to compose the descriptor are abstract. For example, "
"Python's built-in :class:`property` does the equivalent of::"
msgstr ""
"Afin d'interagir correctement avec le mécanisme de classe mère abstraite, un "
"descripteur doit s'identifier comme abstrait en utilisant :attr:"
"`__isabstractmethod__`. En général, cet attribut doit être ``True`` si au "
"moins une des méthodes faisant partie du descripteur est abstraite. Par "
"exemple, la classe native :class:`property` de python fait l'équivalent de ::"

#: library/abc.rst:223
msgid ""
"class Descriptor:\n"
"    ...\n"
"    @property\n"
"    def __isabstractmethod__(self):\n"
"        return any(getattr(f, '__isabstractmethod__', False) for\n"
"                   f in (self._fget, self._fset, self._fdel))"
msgstr ""

#: library/abc.rst:232
msgid ""
"Unlike Java abstract methods, these abstract methods may have an "
"implementation. This implementation can be called via the :func:`super` "
"mechanism from the class that overrides it.  This could be useful as an end-"
"point for a super-call in a framework that uses cooperative multiple-"
"inheritance."
msgstr ""
"Contrairement aux méthodes abstraites Java, ces méthodes abstraites peuvent "
"être implémentées. Cette implémentation peut être appelée via le mécanisme :"
"func:`super` depuis la classe qui la redéfinit. C'est typiquement utile pour "
"y appeler *super* et ainsi coopérer correctement dans un environnement "
"utilisant de l'héritage multiple."

#: library/abc.rst:239
#, fuzzy
msgid "The :mod:`!abc` module also supports the following legacy decorators:"
msgstr ""
"Le module :mod:`abc` gère également les décorateurs historiques suivants :"

#: library/abc.rst:244
msgid ""
"It is now possible to use :class:`classmethod` with :func:`abstractmethod`, "
"making this decorator redundant."
msgstr ""
"Il est désormais possible d'utiliser :class:`classmethod` avec :func:"
"`abstractmethod`, cela rend ce décorateur redondant."

#: library/abc.rst:248
msgid ""
"A subclass of the built-in :func:`classmethod`, indicating an abstract "
"classmethod. Otherwise it is similar to :func:`abstractmethod`."
msgstr ""
"Sous-classe du décorateur natif :func:`classmethod` qui indique une méthode "
"de classe ( ``classmethod`` ) abstraite. En dehors de cela, est similaire à :"
"func:`abstractmethod`."

#: library/abc.rst:251
msgid ""
"This special case is deprecated, as the :func:`classmethod` decorator is now "
"correctly identified as abstract when applied to an abstract method::"
msgstr ""
"Ce cas spécial est obsolète car le décorateur :func:`classmethod` est "
"désormais correctement identifié comme abstrait quand il est appliqué à une "
"méthode abstraite ::"

#: library/abc.rst:255
msgid ""
"class C(ABC):\n"
"    @classmethod\n"
"    @abstractmethod\n"
"    def my_abstract_classmethod(cls, arg):\n"
"        ..."
msgstr ""

#: library/abc.rst:265
msgid ""
"It is now possible to use :class:`staticmethod` with :func:`abstractmethod`, "
"making this decorator redundant."
msgstr ""
"Il est désormais possible d'utiliser :class:`staticmethod` avec :func:"
"`abstractmethod`, cela rend ce décorateur redondant."

#: library/abc.rst:269
msgid ""
"A subclass of the built-in :func:`staticmethod`, indicating an abstract "
"staticmethod. Otherwise it is similar to :func:`abstractmethod`."
msgstr ""
"Sous-classe du décorateur natif :func:`classmethod` qui indique une méthode "
"statique ( ``staticmethod`` ) abstraite. En dehors de cela, est similaire à :"
"func:`abstractmethod`."

#: library/abc.rst:272
msgid ""
"This special case is deprecated, as the :func:`staticmethod` decorator is "
"now correctly identified as abstract when applied to an abstract method::"
msgstr ""
"Ce cas spécial est obsolète car le décorateur :func:`staticmethod` est "
"désormais correctement identifié comme abstrait quand appliqué à une méthode "
"abstraite ::"

#: library/abc.rst:276
msgid ""
"class C(ABC):\n"
"    @staticmethod\n"
"    @abstractmethod\n"
"    def my_abstract_staticmethod(arg):\n"
"        ..."
msgstr ""

#: library/abc.rst:285
msgid ""
"It is now possible to use :class:`property`, :meth:`property.getter`, :meth:"
"`property.setter` and :meth:`property.deleter` with :func:`abstractmethod`, "
"making this decorator redundant."
msgstr ""
"Il est désormais possible d'utiliser :class:`property`, :meth:`property."
"getter`, :meth:`property.setter` et :meth:`property.deleter` avec :func:"
"`abstractmethod`, ce qui rend ce décorateur redondant."

#: library/abc.rst:290
msgid ""
"A subclass of the built-in :func:`property`, indicating an abstract property."
msgstr "Sous-classe de :func:`property`, qui indique une propriété abstraite."

#: library/abc.rst:293
msgid ""
"This special case is deprecated, as the :func:`property` decorator is now "
"correctly identified as abstract when applied to an abstract method::"
msgstr ""
"Ce cas spécial est obsolète car le décorateur :func:`property` est désormais "
"correctement identifié comme abstrait quand appliqué à une méthode "
"abstraite ::"

#: library/abc.rst:297
msgid ""
"class C(ABC):\n"
"    @property\n"
"    @abstractmethod\n"
"    def my_abstract_property(self):\n"
"        ..."
msgstr ""

#: library/abc.rst:303
msgid ""
"The above example defines a read-only property; you can also define a read-"
"write abstract property by appropriately marking one or more of the "
"underlying methods as abstract::"
msgstr ""
"L'exemple ci-dessus définit une propriété en lecture seule. Vous pouvez "
"également définir une propriété en lecture-écriture abstraite en indiquant "
"une ou plusieurs des méthodes sous-jacentes comme abstraite ::"

#: library/abc.rst:307
msgid ""
"class C(ABC):\n"
"    @property\n"
"    def x(self):\n"
"        ...\n"
"\n"
"    @x.setter\n"
"    @abstractmethod\n"
"    def x(self, val):\n"
"        ..."
msgstr ""

#: library/abc.rst:317
msgid ""
"If only some components are abstract, only those components need to be "
"updated to create a concrete property in a subclass::"
msgstr ""
"Si seuls certains composants sont abstraits, seuls ces composants abstraits "
"nécessitent d'être mis à jour pour créer une propriété concrète dans une "
"sous-classe ::"

#: library/abc.rst:320
msgid ""
"class D(C):\n"
"    @C.x.setter\n"
"    def x(self, val):\n"
"        ..."
msgstr ""

#: library/abc.rst:326
#, fuzzy
msgid "The :mod:`!abc` module also provides the following functions:"
msgstr "Le module :mod:`abc` fournit également la fonction suivante :"

#: library/abc.rst:330
msgid "Returns the current abstract base class cache token."
msgstr "Renvoie le jeton de cache ( *cache token*) de l'ABC."

#: library/abc.rst:332
msgid ""
"The token is an opaque object (that supports equality testing) identifying "
"the current version of the abstract base class cache for virtual subclasses. "
"The token changes with every call to :meth:`ABCMeta.register` on any ABC."
msgstr ""
"Le jeton est un objet opaque (qui implémente le test d'égalité) qui "
"identifie la version actuelle du cache de l'ABC pour les sous-classes "
"virtuelles. Le jeton change avec chaque appel à :meth:`ABCMeta.register` sur "
"n'importe quelle ABC."

#: library/abc.rst:340
msgid ""
"A function to recalculate an abstract class's abstraction status. This "
"function should be called if a class's abstract methods have been "
"implemented or changed after it was created. Usually, this function should "
"be called from within a class decorator."
msgstr ""
"Recalcule l'état d'abstraction de la classe. Il est nécessaire d'appeler "
"cette fonction si les méthodes abstraites d'une classe sont ajoutées ou "
"modifiées après la création de la classe. C'est notamment le cas dans les "
"décorateurs de classe."

#: library/abc.rst:345
msgid "Returns *cls*, to allow usage as a class decorator."
msgstr ""
"Pour permettre une utilisation en tant que décorateur, cette fonction "
"renvoie *cls*."

#: library/abc.rst:347
msgid "If *cls* is not an instance of :class:`ABCMeta`, does nothing."
msgstr "Ne fait rien si *cls* n'est pas une instance de :class:`ABCMeta`."

#: library/abc.rst:351
msgid ""
"This function assumes that *cls*'s superclasses are already updated. It does "
"not update any subclasses."
msgstr ""
"Cette fonction suppose que les classes mères de *cls* ont vu leur état "
"recalculé, et ne fait rien pour recalculer celui des classes filles."

#: library/abc.rst:357
msgid "Footnotes"
msgstr "Notes"

#: library/abc.rst:358
msgid ""
"C++ programmers should note that Python's virtual base class concept is not "
"the same as C++'s."
msgstr ""
"Les développeurs C++ noteront que le concept Python de classe mère virtuelle "
"( *virtual base class* ) n'est pas le même que celui de C++."