# 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-14 15:50+0100\n"
"Last-Translator: Antoine Wecxsteen\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.0.1\n"

#: library/enum.rst:2
msgid ":mod:`enum` --- Support for enumerations"
msgstr ":mod:`enum` — Énumérations"

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

#: library/enum.rst:18
msgid ""
"This page contains the API reference information. For tutorial information "
"and discussion of more advanced topics, see"
msgstr ""

#: library/enum.rst:21
msgid ":ref:`Basic Tutorial <enum-basic-tutorial>`"
msgstr ""

#: library/enum.rst:22
msgid ":ref:`Advanced Tutorial <enum-advanced-tutorial>`"
msgstr ""

#: library/enum.rst:23
msgid ":ref:`Enum Cookbook <enum-cookbook>`"
msgstr ""

#: library/enum.rst:27
#, fuzzy
msgid "An enumeration:"
msgstr "Énumérations dérivées"

#: library/enum.rst:29
msgid "is a set of symbolic names (members) bound to unique values"
msgstr ""

#: library/enum.rst:30
#, fuzzy
msgid "can be iterated over to return its members in definition order"
msgstr ""
"Les énumérations sont itérables, l'ordre d'itération est celui dans lequel "
"les membres sont déclarés ::"

#: library/enum.rst:31
msgid "uses *call* syntax to return members by value"
msgstr ""

#: library/enum.rst:32
msgid "uses *index* syntax to return members by name"
msgstr ""

#: library/enum.rst:34
msgid ""
"Enumerations are created either by using :keyword:`class` syntax, or by "
"using function-call syntax::"
msgstr ""

#: library/enum.rst:48
#, fuzzy
msgid ""
"Even though we can use :keyword:`class` syntax to create Enums, Enums are "
"not normal Python classes.  See :ref:`How are Enums different? <enum-class-"
"differences>` for more details."
msgstr ""
"Même si on utilise la syntaxe en :keyword:`class` pour créer des "
"énumérations, les *Enums* ne sont pas des vraies classes Python. Voir `En "
"quoi les Enums sont différentes ?`_ pour plus de détails."

#: library/enum.rst:52
msgid "Nomenclature"
msgstr "Nomenclature"

#: library/enum.rst:54
msgid "The class :class:`Color` is an *enumeration* (or *enum*)"
msgstr "La classe :class:`Color` est une *énumération* (ou un *enum*)."

#: library/enum.rst:55
#, fuzzy
msgid ""
"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are "
"*enumeration members* (or *members*) and are functionally constants."
msgstr ""
"Les attributs :attr:`Color.RED`, :attr:`Color.GREEN`, etc., sont les "
"*membres de l'énumération* (ou les *membres de l'enum*) et sont "
"fonctionnellement des constantes."

#: library/enum.rst:57
msgid ""
"The enum members have *names* and *values* (the name of :attr:`Color.RED` is "
"``RED``, the value of :attr:`Color.BLUE` is ``3``, etc.)"
msgstr ""
"Les membres de *l'enum* ont chacun un *nom* et une *valeur* ; le nom de :"
"attr:`Color.RED` est ``RED``, la valeur de :attr:`Color.BLUE` est ``3``, etc."

#: library/enum.rst:64
msgid "Module Contents"
msgstr "Contenu du module"

#: library/enum.rst:66
msgid ":class:`EnumType`"
msgstr ""

#: library/enum.rst:68
msgid "The ``type`` for Enum and its subclasses."
msgstr ""

#: library/enum.rst:70
#, fuzzy
msgid ":class:`Enum`"
msgstr "Avec :class:`auto`"

#: library/enum.rst:72
#, fuzzy
msgid "Base class for creating enumerated constants."
msgstr ""
"Classe de base pour créer une énumération de constantes qui sont également "
"des sous-classes de :class:`int`."

#: library/enum.rst:74
#, fuzzy
msgid ":class:`IntEnum`"
msgstr "IntEnum"

#: library/enum.rst:76
#, fuzzy
msgid ""
"Base class for creating enumerated constants that are also subclasses of :"
"class:`int`. (`Notes`_)"
msgstr ""
"Classe de base pour créer une énumération de constantes qui sont également "
"des sous-classes de :class:`int`."

#: library/enum.rst:79
msgid ":class:`StrEnum`"
msgstr ""

#: library/enum.rst:81
#, fuzzy
msgid ""
"Base class for creating enumerated constants that are also subclasses of :"
"class:`str`. (`Notes`_)"
msgstr ""
"Classe de base pour créer une énumération de constantes qui sont également "
"des sous-classes de :class:`int`."

#: library/enum.rst:84
#, fuzzy
msgid ":class:`Flag`"
msgstr "Avec :class:`auto`"

#: library/enum.rst:86
msgid ""
"Base class for creating enumerated constants that can be combined using the "
"bitwise operations without losing their :class:`Flag` membership."
msgstr ""
"Classe de base pour créer une énumération de constantes pouvant être "
"combinées avec des opérateurs de comparaison bit-à-bit, sans perdre leur "
"qualité de :class:`Flag`."

#: library/enum.rst:89
#, fuzzy
msgid ":class:`IntFlag`"
msgstr "Exemple d'une classe :class:`IntFlag` ::"

#: library/enum.rst:91
#, fuzzy
msgid ""
"Base class for creating enumerated constants that can be combined using the "
"bitwise operators without losing their :class:`IntFlag` membership. :class:"
"`IntFlag` members are also subclasses of :class:`int`. (`Notes`_)"
msgstr ""
"Classe de base pour créer une énumération de constantes pouvant être "
"combinées avec des opérateurs de comparaison bit-à-bit, sans perdre leur "
"qualité de :class:`IntFlag`. Les membres de :class:`IntFlag` sont aussi des "
"sous-classes de :class:`int`."

#: library/enum.rst:95
msgid ":class:`EnumCheck`"
msgstr ""

#: library/enum.rst:97
msgid ""
"An enumeration with the values ``CONTINUOUS``, ``NAMED_FLAGS``, and "
"``UNIQUE``, for use with :func:`verify` to ensure various constraints are "
"met by a given enumeration."
msgstr ""

#: library/enum.rst:101
msgid ":class:`FlagBoundary`"
msgstr ""

#: library/enum.rst:103
msgid ""
"An enumeration with the values ``STRICT``, ``CONFORM``, ``EJECT``, and "
"``KEEP`` which allows for more fine-grained control over how invalid values "
"are dealt with in an enumeration."
msgstr ""

#: library/enum.rst:107
#, fuzzy
msgid ":class:`auto`"
msgstr "Avec :class:`auto`"

#: library/enum.rst:109
#, fuzzy
msgid ""
"Instances are replaced with an appropriate value for Enum members. :class:"
"`StrEnum` defaults to the lower-cased version of the member name, while "
"other Enums default to 1 and increase from there."
msgstr ""
"Les instances sont remplacées par une valeur appropriée pour les membres de "
"l'énumération. Par défaut, la valeur initiale démarre à 1."

#: library/enum.rst:113
msgid ":func:`~enum.property`"
msgstr ""

#: library/enum.rst:115
msgid ""
"Allows :class:`Enum` members to have attributes without conflicting with "
"member names."
msgstr ""

#: library/enum.rst:118
msgid ":func:`unique`"
msgstr ""

#: library/enum.rst:120
msgid ""
"Enum class decorator that ensures only one name is bound to any one value."
msgstr ""
"Décorateur de classe qui garantit qu'une valeur ne puisse être associée qu'à "
"un seul nom."

#: library/enum.rst:122
msgid ":func:`verify`"
msgstr ""

#: library/enum.rst:124
#, fuzzy
msgid ""
"Enum class decorator that checks user-selectable constraints on an "
"enumeration."
msgstr ""
"Décorateur de classe qui garantit qu'une valeur ne puisse être associée qu'à "
"un seul nom."

#: library/enum.rst:127
msgid ":func:`member`"
msgstr ""

#: library/enum.rst:129
msgid "Make ``obj`` a member.  Can be used as a decorator."
msgstr ""

#: library/enum.rst:131
msgid ":func:`nonmember`"
msgstr ""

#: library/enum.rst:133
msgid "Do not make ``obj`` a member.  Can be used as a decorator."
msgstr ""

#: library/enum.rst:136
msgid "``Flag``, ``IntFlag``, ``auto``"
msgstr "``Flag``, ``IntFlag``, ``auto``"

#: library/enum.rst:137
msgid "``StrEnum``, ``EnumCheck``, ``FlagBoundary``, ``property``"
msgstr ""

#: library/enum.rst:138
msgid "``member``, ``nonmember``"
msgstr ""

#: library/enum.rst:143
msgid "Data Types"
msgstr ""

#: library/enum.rst:148
msgid ""
"*EnumType* is the :term:`metaclass` for *enum* enumerations.  It is possible "
"to subclass *EnumType* -- see :ref:`Subclassing EnumType <enumtype-"
"examples>` for details."
msgstr ""

#: library/enum.rst:152
msgid ""
"*EnumType* is responsible for setting the correct :meth:`__repr__`, :meth:"
"`__str__`, :meth:`__format__`, and :meth:`__reduce__` methods on the final "
"*enum*, as well as creating the enum members, properly handling duplicates, "
"providing iteration over the enum class, etc."
msgstr ""

#: library/enum.rst:159
msgid "Returns ``True`` if member belongs to the ``cls``::"
msgstr ""

#: library/enum.rst:167
msgid ""
"In Python 3.12 it will be possible to check for member values and not just "
"members; until then, a ``TypeError`` will be raised if a non-Enum-member is "
"used in a containment check."
msgstr ""

#: library/enum.rst:173
msgid ""
"Returns ``['__class__', '__doc__', '__members__', '__module__']`` and the "
"names of the members in *cls*::"
msgstr ""

#: library/enum.rst:181
msgid ""
"Returns the Enum member in *cls* matching *name*, or raises an :exc:"
"`AttributeError`::"
msgstr ""

#: library/enum.rst:188
msgid ""
"Returns the Enum member in *cls* matching *name*, or raises an :exc:"
"`KeyError`::"
msgstr ""

#: library/enum.rst:195
#, fuzzy
msgid "Returns each member in *cls* in definition order::"
msgstr ""
"Les énumérations sont itérables, l'ordre d'itération est celui dans lequel "
"les membres sont déclarés ::"

#: library/enum.rst:202
msgid "Returns the number of member in *cls*::"
msgstr ""

#: library/enum.rst:209
msgid "Returns each member in *cls* in reverse definition order::"
msgstr ""

#: library/enum.rst:217
msgid "*Enum* is the base class for all *enum* enumerations."
msgstr ""

#: library/enum.rst:221
msgid "The name used to define the ``Enum`` member::"
msgstr ""

#: library/enum.rst:228
msgid "The value given to the ``Enum`` member::"
msgstr ""

#: library/enum.rst:233
msgid "Enum member values"
msgstr "Valeurs des membres d'une *Enum*"

#: library/enum.rst:235
msgid ""
"Member values can be anything: :class:`int`, :class:`str`, etc..  If the "
"exact value is unimportant you may use :class:`auto` instances and an "
"appropriate value will be chosen for you.  Care must be taken if you mix :"
"class:`auto` with other values."
msgstr ""
"La valeur d'un membre peut être de n'importe quel type : :class:`int`, :"
"class:`str`, etc. Si la valeur exacte n'a pas d'importance, utilisez des "
"instances de :class:`auto` et une valeur appropriée sera choisie pour vous. "
"Soyez vigilant si vous mélangez :class:`auto` avec d'autres valeurs."

#: library/enum.rst:242
msgid ""
"``_ignore_`` is only used during creation and is removed from the "
"enumeration once creation is complete."
msgstr ""

#: library/enum.rst:245
msgid ""
"``_ignore_`` is a list of names that will not become members, and whose "
"names will also be removed from the completed enumeration.  See :ref:"
"`TimePeriod <enum-time-period>` for an example."
msgstr ""

#: library/enum.rst:251
msgid "This method is called in two different ways:"
msgstr ""

#: library/enum.rst:253
msgid "to look up an existing member:"
msgstr ""

#: library/enum.rst:0
msgid "cls"
msgstr ""

#: library/enum.rst:260
msgid "The enum class being called."
msgstr ""

#: library/enum.rst:0
msgid "value"
msgstr "value"

#: library/enum.rst:256
msgid "The value to lookup."
msgstr ""

#: library/enum.rst:258
msgid "to use the ``cls`` enum to create a new enum:"
msgstr ""

#: library/enum.rst:261
msgid "The name of the new Enum to create."
msgstr ""

#: library/enum.rst:0
msgid "names"
msgstr "names"

#: library/enum.rst:262
msgid "The names/values of the members for the new Enum."
msgstr ""

#: library/enum.rst:0
msgid "module"
msgstr "module"

#: library/enum.rst:263
#, fuzzy
msgid "The name of the module the new Enum is created in."
msgstr "nom du module dans lequel la classe *Enum* se trouve."

#: library/enum.rst:0
msgid "qualname"
msgstr "qualname"

#: library/enum.rst:264
#, fuzzy
msgid "The actual location in the module where this Enum can be found."
msgstr "nom du module dans lequel la classe *Enum* se trouve."

#: library/enum.rst:0
msgid "type"
msgstr "type"

#: library/enum.rst:265
msgid "A mix-in type for the new Enum."
msgstr ""

#: library/enum.rst:0
msgid "start"
msgstr "start"

#: library/enum.rst:266
msgid "The first integer value for the Enum (used by :class:`auto`)"
msgstr ""

#: library/enum.rst:0
msgid "boundary"
msgstr ""

#: library/enum.rst:267
msgid ""
"How to handle out-of-range values from bit operations (:class:`Flag` only)"
msgstr ""

#: library/enum.rst:271
msgid ""
"Returns ``['__class__', '__doc__', '__module__', 'name', 'value']`` and any "
"public methods defined on *self.__class__*::"
msgstr ""

#: library/enum.rst:0
msgid "name"
msgstr "``name``"

#: library/enum.rst:291
msgid "The name of the member being defined (e.g. 'RED')."
msgstr ""

#: library/enum.rst:292
msgid "The start value for the Enum; the default is 1."
msgstr ""

#: library/enum.rst:0
msgid "count"
msgstr ""

#: library/enum.rst:293
msgid "The number of members currently defined, not including this one."
msgstr ""

#: library/enum.rst:0
msgid "last_values"
msgstr "``last_values``"

#: library/enum.rst:294
msgid "A list of the previous values."
msgstr ""

#: library/enum.rst:296
msgid ""
"A *staticmethod* that is used to determine the next value returned by :class:"
"`auto`::"
msgstr ""

#: library/enum.rst:311
msgid ""
"A *classmethod* that is used to further configure subsequent subclasses. By "
"default, does nothing."
msgstr ""

#: library/enum.rst:316
msgid ""
"A *classmethod* for looking up values not found in *cls*.  By default it "
"does nothing, but can be overridden to implement custom search behavior::"
msgstr ""

#: library/enum.rst:337
msgid ""
"Returns the string used for *repr()* calls.  By default, returns the *Enum* "
"name, member name, and value, but can be overridden::"
msgstr ""

#: library/enum.rst:352
msgid ""
"Returns the string used for *str()* calls.  By default, returns the *Enum* "
"name and member name, but can be overridden::"
msgstr ""

#: library/enum.rst:366
msgid ""
"Returns the string used for *format()* and *f-string* calls.  By default, "
"returns :meth:`__str__` returns, but can be overridden::"
msgstr ""

#: library/enum.rst:380
msgid ""
"Using :class:`auto` with :class:`Enum` results in integers of increasing "
"value, starting with ``1``."
msgstr ""

#: library/enum.rst:386
msgid ""
"*IntEnum* is the same as *Enum*, but its members are also integers and can "
"be used anywhere that an integer can be used.  If any integer operation is "
"performed with an *IntEnum* member, the resulting value loses its "
"enumeration status."
msgstr ""

#: library/enum.rst:406
msgid ""
"Using :class:`auto` with :class:`IntEnum` results in integers of increasing "
"value, starting with ``1``."
msgstr ""

#: library/enum.rst:580
msgid ""
":meth:`__str__` is now :func:`int.__str__` to better support the "
"*replacement of existing constants* use-case. :meth:`__format__` was "
"already :func:`int.__format__` for that same reason."
msgstr ""

#: library/enum.rst:416
msgid ""
"*StrEnum* is the same as *Enum*, but its members are also strings and can be "
"used in most of the same places that a string can be used.  The result of "
"any string operation performed on or with a *StrEnum* member is not part of "
"the enumeration."
msgstr ""

#: library/enum.rst:420
msgid ""
"There are places in the stdlib that check for an exact :class:`str` instead "
"of a :class:`str` subclass (i.e. ``type(unknown) == str`` instead of "
"``isinstance(str, unknown)``), and in those locations you will need to use "
"``str(StrEnum.member)``."
msgstr ""

#: library/enum.rst:427
msgid ""
"Using :class:`auto` with :class:`StrEnum` results in the lower-cased member "
"name as the value."
msgstr ""

#: library/enum.rst:430
msgid ""
":meth:`__str__` is :func:`str.__str__` to better support the *replacement of "
"existing constants* use-case.  :meth:`__format__` is likewise :func:`str."
"__format__` for that same reason."
msgstr ""

#: library/enum.rst:438
msgid ""
"*Flag* members support the bitwise operators ``&`` (*AND*), ``|`` (*OR*), "
"``^`` (*XOR*), and ``~`` (*INVERT*); the results of those operators are "
"members of the enumeration."
msgstr ""

#: library/enum.rst:444
msgid "Returns *True* if value is in self::"
msgstr ""

#: library/enum.rst:464
msgid "Returns all contained members::"
msgstr ""

#: library/enum.rst:473
msgid "Returns number of members in flag::"
msgstr ""

#: library/enum.rst:482
msgid "Returns *True* if any members in flag, *False* otherwise::"
msgstr ""

#: library/enum.rst:494
msgid "Returns current flag binary or'ed with other::"
msgstr ""

#: library/enum.rst:501
msgid "Returns current flag binary and'ed with other::"
msgstr ""

#: library/enum.rst:510
msgid "Returns current flag binary xor'ed with other::"
msgstr ""

#: library/enum.rst:519
msgid "Returns all the flags in *type(self)* that are not in self::"
msgstr ""

#: library/enum.rst:530
msgid ""
"Function used to format any remaining unnamed numeric values.  Default is "
"the value's repr; common choices are :func:`hex` and :func:`oct`."
msgstr ""

#: library/enum.rst:535
msgid ""
"Using :class:`auto` with :class:`Flag` results in integers that are powers "
"of two, starting with ``1``."
msgstr ""

#: library/enum.rst:538
msgid "The *repr()* of zero-valued flags has changed.  It is now::"
msgstr ""

#: library/enum.rst:546
msgid ""
"*IntFlag* is the same as *Flag*, but its members are also integers and can "
"be used anywhere that an integer can be used."
msgstr ""

#: library/enum.rst:559
msgid ""
"If any integer operation is performed with an *IntFlag* member, the result "
"is not an *IntFlag*::"
msgstr ""

#: library/enum.rst:565
msgid "If a *Flag* operation is performed with an *IntFlag* member and:"
msgstr ""

#: library/enum.rst:567
msgid "the result is a valid *IntFlag*: an *IntFlag* is returned"
msgstr ""

#: library/enum.rst:568
msgid ""
"the result is not a valid *IntFlag*: the result depends on the "
"*FlagBoundary* setting"
msgstr ""

#: library/enum.rst:570
msgid "The *repr()* of unnamed zero-valued flags has changed.  It is now:"
msgstr ""

#: library/enum.rst:577
msgid ""
"Using :class:`auto` with :class:`IntFlag` results in integers that are "
"powers of two, starting with ``1``."
msgstr ""

#: library/enum.rst:587
msgid ""
"*EnumCheck* contains the options used by the :func:`verify` decorator to "
"ensure various constraints; failed constraints result in a :exc:`ValueError`."
msgstr ""

#: library/enum.rst:592
msgid "Ensure that each value has only one name::"
msgstr ""

#: library/enum.rst:608
msgid ""
"Ensure that there are no missing values between the lowest-valued member and "
"the highest-valued member::"
msgstr ""

#: library/enum.rst:623
msgid ""
"Ensure that any flag groups/masks contain only named flags -- useful when "
"values are specified instead of being generated by :func:`auto`"
msgstr ""

#: library/enum.rst:640
msgid ""
"CONTINUOUS and NAMED_FLAGS are designed to work with integer-valued members."
msgstr ""

#: library/enum.rst:646
msgid ""
"*FlagBoundary* controls how out-of-range values are handled in *Flag* and "
"its subclasses."
msgstr ""

#: library/enum.rst:651
msgid ""
"Out-of-range values cause a :exc:`ValueError` to be raised.  This is the "
"default for :class:`Flag`::"
msgstr ""

#: library/enum.rst:668
msgid ""
"Out-of-range values have invalid values removed, leaving a valid *Flag* "
"value::"
msgstr ""

#: library/enum.rst:681
msgid ""
"Out-of-range values lose their *Flag* membership and revert to :class:`int`. "
"This is the default for :class:`IntFlag`::"
msgstr ""

#: library/enum.rst:694
msgid ""
"Out-of-range values are kept, and the *Flag* membership is kept.  This is "
"used for some stdlib flags:"
msgstr ""

#: library/enum.rst:710
msgid "Supported ``__dunder__`` names"
msgstr "Noms de la forme ``__dunder__`` disponibles"

#: library/enum.rst:712
msgid ""
":attr:`__members__` is a read-only ordered mapping of ``member_name``:"
"``member`` items.  It is only available on the class."
msgstr ""
":attr:`__members__` est un dictionnaire en lecture seule ordonné d'éléments "
"``nom_du_membre`` / ``membre``. Il n'est disponible que depuis la classe."

#: library/enum.rst:715
msgid ""
":meth:`__new__`, if specified, must create and return the enum members; it "
"is also a very good idea to set the member's :attr:`_value_` appropriately.  "
"Once all the members are created it is no longer used."
msgstr ""
"La méthode :meth:`__new__`, si elle est définie, doit créer et renvoyer les "
"membres de l'énumération ; affecter correctement l'attribut :attr:`_value_` "
"du membre est également conseillé. Une fois que tous les membres ont été "
"créés, cette méthode n'est plus utilisée."

#: library/enum.rst:721
msgid "Supported ``_sunder_`` names"
msgstr "Noms de la forme ``_sunder_`` disponibles"

#: library/enum.rst:723
msgid "``_name_`` -- name of the member"
msgstr "``_name_`` -- nom du membre"

#: library/enum.rst:724
msgid ""
"``_value_`` -- value of the member; can be set / modified in ``__new__``"
msgstr ""
"``_value_`` -- valeur du membre ; il est possible d'y accéder ou de la muer "
"dans ``__new__``"

#: library/enum.rst:726
msgid ""
"``_missing_`` -- a lookup function used when a value is not found; may be "
"overridden"
msgstr ""
"``_missing_`` -- une fonction de recherche qui est appelée quand la valeur "
"n'est pas trouvée ; elle peut être redéfinie"

#: library/enum.rst:728
msgid ""
"``_ignore_`` -- a list of names, either as a :class:`list` or a :class:"
"`str`, that will not be transformed into members, and will be removed from "
"the final class"
msgstr ""
"``_ignore_`` -- une liste de noms, sous la forme d'une :func:`list` ou "
"d'une :func:`str`, qui ne seront pas convertis en membres et seront "
"supprimés de la classe résultante"

#: library/enum.rst:731
msgid ""
"``_order_`` -- used in Python 2/3 code to ensure member order is consistent "
"(class attribute, removed during class creation)"
msgstr ""
"``_order_`` -- utilisé en Python 2 ou 3 pour s'assurer que l'ordre des "
"membres est cohérent (attribut de classe, supprimé durant la création de la "
"classe)"

#: library/enum.rst:733
#, fuzzy
msgid ""
"``_generate_next_value_`` -- used to get an appropriate value for an enum "
"member; may be overridden"
msgstr ""
"``_generate_next_value_`` -- utilisée par l' `API par fonction`_ et par :"
"class:`auto` pour obtenir une valeur appropriée à affecter à un membre de "
"*l'enum* ; elle peut être redéfinie"

#: library/enum.rst:738
msgid ""
"For standard :class:`Enum` classes the next value chosen is the last value "
"seen incremented by one."
msgstr ""

#: library/enum.rst:741
msgid ""
"For :class:`Flag` classes the next value chosen will be the next highest "
"power-of-two, regardless of the last value seen."
msgstr ""

#: library/enum.rst:744
msgid "``_missing_``, ``_order_``, ``_generate_next_value_``"
msgstr "``_missing_``, ``_order_``, ``_generate_next_value_``"

#: library/enum.rst:745
msgid "``_ignore_``"
msgstr "``_ignore_``"

#: library/enum.rst:750
msgid "Utilities and Decorators"
msgstr ""

#: library/enum.rst:754
msgid ""
"*auto* can be used in place of a value.  If used, the *Enum* machinery will "
"call an *Enum*'s :meth:`_generate_next_value_` to get an appropriate value. "
"For *Enum* and *IntEnum* that appropriate value will be the last value plus "
"one; for *Flag* and *IntFlag* it will be the first power-of-two greater than "
"the last value; for *StrEnum* it will be the lower-cased version of the "
"member's name."
msgstr ""

#: library/enum.rst:761
msgid ""
"``_generate_next_value_`` can be overridden to customize the values used by "
"*auto*."
msgstr ""

#: library/enum.rst:766
msgid ""
"A decorator similar to the built-in *property*, but specifically for "
"enumerations.  It allows member attributes to have the same names as members "
"themselves."
msgstr ""

#: library/enum.rst:770
msgid ""
"the *property* and the member must be defined in separate classes; for "
"example, the *value* and *name* attributes are defined in the *Enum* class, "
"and *Enum* subclasses can define members with the names ``value`` and "
"``name``."
msgstr ""

#: library/enum.rst:779
#, fuzzy
msgid ""
"A :keyword:`class` decorator specifically for enumerations.  It searches an "
"enumeration's :attr:`__members__`, gathering any aliases it finds; if any "
"are found :exc:`ValueError` is raised with the details::"
msgstr ""
"Un décorateur de :keyword:`class` spécifique aux énumérations. Il examine "
"l'attribut :attr:`__members__` d'une énumération et recherche des alias ; "
"s'il en trouve, l'exception :exc:`ValueError` est levée avec des détails ::"

#: library/enum.rst:797
msgid ""
"A :keyword:`class` decorator specifically for enumerations.  Members from :"
"class:`EnumCheck` are used to specify which constraints should be checked on "
"the decorated enumeration."
msgstr ""

#: library/enum.rst:805
msgid "A decorator for use in enums: its target will become a member."
msgstr ""

#: library/enum.rst:811
msgid "A decorator for use in enums: its target will not become a member."
msgstr ""

#: library/enum.rst:818
msgid "Notes"
msgstr ""

#: library/enum.rst:820
msgid ":class:`IntEnum`, :class:`StrEnum`, and :class:`IntFlag`"
msgstr ""

#: library/enum.rst:822
msgid ""
"These three enum types are designed to be drop-in replacements for existing "
"integer- and string-based values; as such, they have extra limitations:"
msgstr ""

#: library/enum.rst:825
msgid "``__str__`` uses the value and not the name of the enum member"
msgstr ""

#: library/enum.rst:827
msgid ""
"``__format__``, because it uses ``__str__``, will also use the value of the "
"enum member instead of its name"
msgstr ""

#: library/enum.rst:830
msgid ""
"If you do not need/want those limitations, you can either create your own "
"base class by mixing in the ``int`` or ``str`` type yourself::"
msgstr ""

#: library/enum.rst:837
msgid "or you can reassign the appropriate :meth:`str`, etc., in your enum::"
msgstr ""

#~ msgid ""
#~ "An enumeration is a set of symbolic names (members) bound to unique, "
#~ "constant values.  Within an enumeration, the members can be compared by "
#~ "identity, and the enumeration itself can be iterated over."
#~ msgstr ""
#~ "Une énumération est un ensemble de noms symboliques, appelés *membres*, "
#~ "liés à des valeurs constantes et uniques. Au sein d'une énumération, les "
#~ "membres peuvent être comparés et il est possible d'itérer sur "
#~ "l'énumération elle-même."

#~ msgid "Case of Enum Members"
#~ msgstr "Convention de nommage pour les membres d'une **Enum**"

#~ msgid ""
#~ "Because Enums are used to represent constants we recommend using "
#~ "UPPER_CASE names for enum members, and will be using that style in our "
#~ "examples."
#~ msgstr ""
#~ "Puisque les **Enums** sont utilisées pour représenter des constantes, il "
#~ "est recommandé d'utiliser des majuscules (format "
#~ "``MAJUSCULE_AVEC_SOULIGNÉS``) pour leurs membres. Cette convention de "
#~ "style sera utilisée dans les exemples."

#~ msgid ""
#~ "This module defines four enumeration classes that can be used to define "
#~ "unique sets of names and values: :class:`Enum`, :class:`IntEnum`, :class:"
#~ "`Flag`, and :class:`IntFlag`.  It also defines one decorator, :func:"
#~ "`unique`, and one helper, :class:`auto`."
#~ msgstr ""
#~ "Ce module définit quatre classes d'énumération qui permettent de définir "
#~ "des ensembles uniques de noms et de valeurs : :class:`Enum`, :class:"
#~ "`IntEnum`, :class:`Flag` et :class:`IntFlag`. Il fournit également un "
#~ "décorateur, :func:`unique`, ainsi qu'une classe utilitaire, :class:`auto`."

#~ msgid ""
#~ "Base class for creating enumerated constants.  See section `Functional "
#~ "API`_ for an alternate construction syntax."
#~ msgstr ""
#~ "Classe de base pour créer une énumération de constantes. Voir la section "
#~ "`API par fonction`_ pour une syntaxe alternative de construction."

#~ msgid "Creating an Enum"
#~ msgstr "Création d'une *Enum*"

#~ msgid ""
#~ "Enumerations are created using the :keyword:`class` syntax, which makes "
#~ "them easy to read and write.  An alternative creation method is described "
#~ "in `Functional API`_.  To define an enumeration, subclass :class:`Enum` "
#~ "as follows::"
#~ msgstr ""
#~ "Une énumération est créée comme une :keyword:`class`, ce qui la rend "
#~ "facile à lire et à écrire. Une autre méthode de création est décrite dans "
#~ "`API par fonction`_. Pour définir une énumération, il faut hériter de :"
#~ "class:`Enum` de la manière suivante ::"

#~ msgid "Enumeration members have human readable string representations::"
#~ msgstr ""
#~ "Les membres d'une énumération ont une représentation en chaîne de "
#~ "caractères compréhensible par un humain ::"

#~ msgid "...while their ``repr`` has more information::"
#~ msgstr "… tandis que leur ``repr`` contient plus d'informations ::"

#~ msgid ""
#~ "The *type* of an enumeration member is the enumeration it belongs to::"
#~ msgstr ""
#~ "Le *type* d'un membre est l'énumération auquel ce membre appartient ::"

#~ msgid ""
#~ "Enum members also have a property that contains just their item name::"
#~ msgstr "Les membres ont également un attribut qui contient leur nom ::"

#~ msgid ""
#~ "Enumeration members are hashable, so they can be used in dictionaries and "
#~ "sets::"
#~ msgstr ""
#~ "Les membres d'une énumération sont hachables, ils peuvent ainsi être "
#~ "utilisés dans des dictionnaires ou des ensembles ::"

#~ msgid "Programmatic access to enumeration members and their attributes"
#~ msgstr "Accès dynamique aux membres et à leurs attributs"

#~ msgid ""
#~ "Sometimes it's useful to access members in enumerations programmatically "
#~ "(i.e. situations where ``Color.RED`` won't do because the exact color is "
#~ "not known at program-writing time).  ``Enum`` allows such access::"
#~ msgstr ""
#~ "Il est parfois utile de pouvoir accéder dynamiquement aux membres d'une "
#~ "énumération (p. ex. dans des situations où il ne suffit pas d'utiliser "
#~ "``Color.RED`` car la couleur précise n'est pas connue à l'écriture du "
#~ "programme). ``Enum`` permet de tels accès ::"

#~ msgid "If you want to access enum members by *name*, use item access::"
#~ msgstr ""
#~ "Pour accéder aux membres par leur *nom*, utilisez l'accès par "
#~ "indexation ::"

#~ msgid ""
#~ "If you have an enum member and need its :attr:`name` or :attr:`value`::"
#~ msgstr ""
#~ "Pour obtenir l'attribut :attr:`name` ou :attr:`value` d'un membre ::"

#~ msgid "Duplicating enum members and values"
#~ msgstr "Duplication de membres et de valeurs"

#~ msgid "Having two enum members with the same name is invalid::"
#~ msgstr ""
#~ "Il n'est pas possible d'avoir deux membres du même nom dans un *enum* ::"

#~ msgid ""
#~ "However, two enum members are allowed to have the same value.  Given two "
#~ "members A and B with the same value (and A defined first), B is an alias "
#~ "to A.  By-value lookup of the value of A and B will return A.  By-name "
#~ "lookup of B will also return A::"
#~ msgstr ""
#~ "Cependant deux membres peuvent avoir la même valeur. Si deux membres A et "
#~ "B ont la même valeur (et que A est défini en premier), B sera un alias de "
#~ "A. Un accès par valeur avec la valeur commune à A et B renverra A. Un "
#~ "accès à B par nom renverra aussi A ::"

#~ msgid ""
#~ "Attempting to create a member with the same name as an already defined "
#~ "attribute (another member, a method, etc.) or attempting to create an "
#~ "attribute with the same name as a member is not allowed."
#~ msgstr ""
#~ "Il est interdit de créer un membre avec le même nom qu'un attribut déjà "
#~ "défini (un autre membre, une méthode, etc.) ou de créer un attribut avec "
#~ "le nom d'un membre."

#~ msgid "Ensuring unique enumeration values"
#~ msgstr "Coercition d'unicité des valeurs d'une énumération"

#~ msgid ""
#~ "By default, enumerations allow multiple names as aliases for the same "
#~ "value. When this behavior isn't desired, the following decorator can be "
#~ "used to ensure each value is used only once in the enumeration:"
#~ msgstr ""
#~ "Par défaut, les énumérations autorisent les alias de nom pour une même "
#~ "valeur. Quand ce comportement n'est pas désiré, il faut utiliser le "
#~ "décorateur suivant pour s'assurer que chaque valeur n'est utilisée qu'une "
#~ "seule fois au sein de l'énumération : ::"

#~ msgid "Using automatic values"
#~ msgstr "Valeurs automatiques"

#~ msgid "If the exact value is unimportant you can use :class:`auto`::"
#~ msgstr ""
#~ "Si la valeur exacte n'a pas d'importance, vous pouvez utiliser :class:"
#~ "`auto` ::"

#~ msgid ""
#~ "The values are chosen by :func:`_generate_next_value_`, which can be "
#~ "overridden::"
#~ msgstr ""
#~ "Les valeurs sont déterminées par :func:`_generate_next_value_`, qui peut "
#~ "être redéfinie ::"

#~ msgid ""
#~ "The goal of the default :meth:`_generate_next_value_` method is to "
#~ "provide the next :class:`int` in sequence with the last :class:`int` "
#~ "provided, but the way it does this is an implementation detail and may "
#~ "change."
#~ msgstr ""
#~ "La méthode :meth:`_generate_next_value_` doit renvoyer le prochain :class:"
#~ "`int` de la séquence à partir du dernier :class:`int` fourni, mais "
#~ "l'implémentation de cette fonction peut changer."

#~ msgid ""
#~ "The :meth:`_generate_next_value_` method must be defined before any "
#~ "members."
#~ msgstr ""
#~ "La méthode :meth:`_generate_next_value_` doit être définie avant tout "
#~ "membre."

#~ msgid "Iteration"
#~ msgstr "Itération"

#~ msgid "Iterating over the members of an enum does not provide the aliases::"
#~ msgstr ""
#~ "Itérer sur les membres d'une énumération ne parcourt pas les alias ::"

#~ msgid ""
#~ "The special attribute ``__members__`` is a read-only ordered mapping of "
#~ "names to members.  It includes all names defined in the enumeration, "
#~ "including the aliases::"
#~ msgstr ""
#~ "L'attribut spécial ``__members__`` est un dictionnaire en lecture seule "
#~ "ordonné qui fait correspondre les noms aux membres. Il inclut tous les "
#~ "noms définis dans l'énumération, alias compris ::"

#~ msgid ""
#~ "The ``__members__`` attribute can be used for detailed programmatic "
#~ "access to the enumeration members.  For example, finding all the aliases::"
#~ msgstr ""
#~ "L'attribut ``__members__`` peut servir à accéder dynamiquement aux "
#~ "membres de l'énumération. Par exemple, pour trouver tous les alias ::"

#~ msgid "Comparisons"
#~ msgstr "Comparaisons"

#~ msgid "Enumeration members are compared by identity::"
#~ msgstr "Les membres d'une énumération sont comparés par identité ::"

#~ msgid ""
#~ "Ordered comparisons between enumeration values are *not* supported.  Enum "
#~ "members are not integers (but see `IntEnum`_ below)::"
#~ msgstr ""
#~ "Les comparaisons d'ordre entre les valeurs d'une énumération n'existent "
#~ "*pas* ; les membres d'un *enum* ne sont pas des entiers (voir cependant "
#~ "`IntEnum`_ ci-dessous) ::"

#~ msgid "Equality comparisons are defined though::"
#~ msgstr "A contrario, les comparaisons d'égalité existent ::"

#~ msgid ""
#~ "Comparisons against non-enumeration values will always compare not equal "
#~ "(again, :class:`IntEnum` was explicitly designed to behave differently, "
#~ "see below)::"
#~ msgstr ""
#~ "Les comparaisons avec des valeurs ne provenant pas d'énumérations sont "
#~ "toujours fausses (ici encore, :class:`IntEnum` a été conçue pour "
#~ "fonctionner différemment, voir ci-dessous) ::"

#~ msgid "Allowed members and attributes of enumerations"
#~ msgstr "Membres et attributs autorisés dans une énumération"

#~ msgid ""
#~ "The examples above use integers for enumeration values.  Using integers "
#~ "is short and handy (and provided by default by the `Functional API`_), "
#~ "but not strictly enforced.  In the vast majority of use-cases, one "
#~ "doesn't care what the actual value of an enumeration is.  But if the "
#~ "value *is* important, enumerations can have arbitrary values."
#~ msgstr ""
#~ "Les exemples précédents utilisent des entiers pour énumérer les valeurs. "
#~ "C'est un choix concis et pratique (et implémenté par défaut dans l'`API "
#~ "par fonction`_), mais ce n'est pas une obligation. Dans la majorité des "
#~ "cas, il importe peu de connaître la valeur réelle d'une énumération. Il "
#~ "est toutefois possible de donner une valeur arbitraire aux énumérations, "
#~ "si cette valeur est *vraiment* significative."

#~ msgid ""
#~ "Enumerations are Python classes, and can have methods and special methods "
#~ "as usual.  If we have this enumeration::"
#~ msgstr ""
#~ "Les énumérations sont des classes Python et peuvent donc avoir des "
#~ "méthodes et des méthodes spéciales. L'énumération suivante ::"

#~ msgid "Then::"
#~ msgstr "Amène ::"

#~ msgid ""
#~ "The rules for what is allowed are as follows: names that start and end "
#~ "with a single underscore are reserved by enum and cannot be used; all "
#~ "other attributes defined within an enumeration will become members of "
#~ "this enumeration, with the exception of special methods (:meth:"
#~ "`__str__`, :meth:`__add__`, etc.), descriptors (methods are also "
#~ "descriptors), and variable names listed in :attr:`_ignore_`."
#~ msgstr ""
#~ "Les règles pour ce qui est autorisé sont les suivantes : les noms qui "
#~ "commencent et finissent avec un seul tiret bas sont réservés par *enum* "
#~ "et ne peuvent pas être utilisés ; tous les autres attributs définis dans "
#~ "l'énumération en deviendront des membres, à l'exception des méthodes "
#~ "spéciales (:meth:`__str__`, :meth:`__add__`, etc.), des descripteurs (les "
#~ "méthodes sont aussi des descripteurs) et des noms de variable listés "
#~ "dans :attr:`_ignore_`."

#~ msgid ""
#~ "Note:  if your enumeration defines :meth:`__new__` and/or :meth:"
#~ "`__init__` then any value(s) given to the enum member will be passed into "
#~ "those methods. See `Planet`_ for an example."
#~ msgstr ""
#~ "Remarque : si votre énumération définit :meth:`__new__` ou :meth:"
#~ "`__init__`, alors les valeurs affectées aux membres seront passées à ces "
#~ "méthodes. Voir `Planet`_ pour exemple."

#~ msgid "Restricted Enum subclassing"
#~ msgstr "Restrictions sur l'héritage"

#~ msgid ""
#~ "A new :class:`Enum` class must have one base Enum class, up to one "
#~ "concrete data type, and as many :class:`object`-based mixin classes as "
#~ "needed.  The order of these base classes is::"
#~ msgstr ""
#~ "Une nouvelle classe :class:`Enum` doit avoir une classe *Enum* de base, "
#~ "au plus un type de données concret et autant de classes de mélange "
#~ "(basées sur :class:`object`) que nécessaire. L'ordre de ces classes de "
#~ "base est le suivant ::"

#~ msgid ""
#~ "Also, subclassing an enumeration is allowed only if the enumeration does "
#~ "not define any members.  So this is forbidden::"
#~ msgstr ""
#~ "Hériter d'une énumération n'est permis que si cette énumération ne "
#~ "définit aucun membre. Le code suivant n'est pas autorisé ::"

#~ msgid "But this is allowed::"
#~ msgstr "Mais celui-ci est correct ::"

#~ msgid ""
#~ "Allowing subclassing of enums that define members would lead to a "
#~ "violation of some important invariants of types and instances.  On the "
#~ "other hand, it makes sense to allow sharing some common behavior between "
#~ "a group of enumerations. (See `OrderedEnum`_ for an example.)"
#~ msgstr ""
#~ "Autoriser l'héritage d'*enums* définissant des membres violerait des "
#~ "invariants sur les types et les instances. D'un autre côté, il est "
#~ "logique d'autoriser un groupe d'énumérations à partager un comportement "
#~ "commun (voir par exemple `OrderedEnum`_)."

#~ msgid "Pickling"
#~ msgstr "Sérialisation"

#~ msgid "Enumerations can be pickled and unpickled::"
#~ msgstr "Les énumérations peuvent être sérialisées et déserialisées ::"

#~ msgid ""
#~ "The usual restrictions for pickling apply: picklable enums must be "
#~ "defined in the top level of a module, since unpickling requires them to "
#~ "be importable from that module."
#~ msgstr ""
#~ "Les restrictions habituelles de sérialisation s'appliquent : les *enums* "
#~ "à sérialiser doivent être déclarés dans l'espace de nom de haut niveau du "
#~ "module, car la déserialisation nécessite que ces *enums* puissent être "
#~ "importés depuis ce module."

#~ msgid ""
#~ "With pickle protocol version 4 it is possible to easily pickle enums "
#~ "nested in other classes."
#~ msgstr ""
#~ "Depuis la version 4 du protocole de *pickle*, il est possible de "
#~ "sérialiser facilement des *enums* imbriqués dans d'autres classes."

#~ msgid ""
#~ "It is possible to modify how Enum members are pickled/unpickled by "
#~ "defining :meth:`__reduce_ex__` in the enumeration class."
#~ msgstr ""
#~ "Redéfinir la méthode :meth:`__reduce_ex__` permet de modifier la "
#~ "sérialisation ou la dé-sérialisation des membres d'une énumération."

#~ msgid "Functional API"
#~ msgstr "API par fonction"

#~ msgid ""
#~ "The :class:`Enum` class is callable, providing the following functional "
#~ "API::"
#~ msgstr ""
#~ "La :class:`Enum` est appelable et implémente l'API par fonction "
#~ "suivante ::"

#~ msgid ""
#~ "The semantics of this API resemble :class:`~collections.namedtuple`. The "
#~ "first argument of the call to :class:`Enum` is the name of the "
#~ "enumeration."
#~ msgstr ""
#~ "La sémantique de cette API est similaire à :class:`~collections."
#~ "namedtuple`. Le premier argument de l'appel à :class:`Enum` est le nom de "
#~ "l'énumération."

#~ msgid ""
#~ "The second argument is the *source* of enumeration member names.  It can "
#~ "be a whitespace-separated string of names, a sequence of names, a "
#~ "sequence of 2-tuples with key/value pairs, or a mapping (e.g. dictionary) "
#~ "of names to values.  The last two options enable assigning arbitrary "
#~ "values to enumerations; the others auto-assign increasing integers "
#~ "starting with 1 (use the ``start`` parameter to specify a different "
#~ "starting value).  A new class derived from :class:`Enum` is returned.  In "
#~ "other words, the above assignment to :class:`Animal` is equivalent to::"
#~ msgstr ""
#~ "Le second argument est la *source* des noms des membres de l'énumération. "
#~ "Il peut être une chaîne de caractères contenant les noms séparés par des "
#~ "espaces, une séquence de noms, une séquence de couples clé / valeur ou un "
#~ "dictionnaire (p. ex. un *dict*) de valeurs indexées par des noms. Les "
#~ "deux dernières options permettent d'affecter des valeurs arbitraires aux "
#~ "énumérations ; les autres affectent automatiquement des entiers en "
#~ "commençant par 1 (le paramètre ``start`` permet de changer la valeur de "
#~ "départ). Ceci renvoie une nouvelle classe dérivée de :class:`Enum`. En "
#~ "d'autres termes, la déclaration de :class:`Animal` ci-dessus équivaut à ::"

#~ msgid ""
#~ "The reason for defaulting to ``1`` as the starting number and not ``0`` "
#~ "is that ``0`` is ``False`` in a boolean sense, but enum members all "
#~ "evaluate to ``True``."
#~ msgstr ""
#~ "La valeur de départ par défaut est ``1`` et non ``0`` car ``0`` au sens "
#~ "booléen vaut ``False`` alors que tous les membres d'une *enum* valent "
#~ "``True``."

#~ msgid ""
#~ "Pickling enums created with the functional API can be tricky as frame "
#~ "stack implementation details are used to try and figure out which module "
#~ "the enumeration is being created in (e.g. it will fail if you use a "
#~ "utility function in separate module, and also may not work on IronPython "
#~ "or Jython). The solution is to specify the module name explicitly as "
#~ "follows::"
#~ msgstr ""
#~ "La sérialisation d'énumérations créées avec l'API en fonction peut être "
#~ "source de problèmes, car celle-ci repose sur des détails d'implémentation "
#~ "de l'affichage de la pile d'appel pour tenter de déterminer dans quel "
#~ "module l'énumération est créée (p. ex. elle échouera avec les fonctions "
#~ "utilitaires provenant d'un module séparé et peut ne pas fonctionner avec "
#~ "IronPython ou Jython). La solution consiste à préciser explicitement le "
#~ "nom du module comme ceci ::"

#~ msgid ""
#~ "If ``module`` is not supplied, and Enum cannot determine what it is, the "
#~ "new Enum members will not be unpicklable; to keep errors closer to the "
#~ "source, pickling will be disabled."
#~ msgstr ""
#~ "Si ``module`` n'est pas fourni et que *Enum* ne peut pas le deviner, les "
#~ "nouveaux membres de *l'Enum* ne seront pas déserialisables ; pour garder "
#~ "les erreurs au plus près de leur origine, la sérialisation sera "
#~ "désactivée."

#~ msgid ""
#~ "The new pickle protocol 4 also, in some circumstances, relies on :attr:"
#~ "`~definition.__qualname__` being set to the location where pickle will be "
#~ "able to find the class.  For example, if the class was made available in "
#~ "class SomeData in the global scope::"
#~ msgstr ""
#~ "Le nouveau protocole version 4 de *pickle* se base lui aussi, dans "
#~ "certains cas, sur le fait que :attr:`~definition.__qualname__` pointe sur "
#~ "l'endroit où *pickle* peut trouver la classe. Par exemple, si la classe "
#~ "était disponible depuis la classe *SomeData* dans l'espace de nom de plus "
#~ "haut niveau ::"

#~ msgid "The complete signature is::"
#~ msgstr "La signature complète est la suivante ::"

#~ msgid "What the new Enum class will record as its name."
#~ msgstr "Le nom de la la nouvelle classe *Enum*."

#~ msgid ""
#~ "The Enum members.  This can be a whitespace or comma separated string "
#~ "(values will start at 1 unless otherwise specified)::"
#~ msgstr ""
#~ "Les membres de l'énumération. Une chaîne de caractères séparés par des "
#~ "espaces ou des virgules (la valeur de départ est fixée à 1, sauf si "
#~ "spécifiée autrement) ::"

#~ msgid "or an iterator of names::"
#~ msgstr "ou un itérateur sur les noms ::"

#~ msgid "or an iterator of (name, value) pairs::"
#~ msgstr "ou un itérateur sur les *n*-uplets (nom, valeur) ::"

#~ msgid "or a mapping::"
#~ msgstr "ou une correspondance ::"

#~ msgid "where in module new Enum class can be found."
#~ msgstr "localisation de la nouvelle classe *Enum* dans le module."

#~ msgid "type to mix in to new Enum class."
#~ msgstr "le type à mélanger dans la nouvelle classe *Enum*."

#~ msgid "number to start counting at if only names are passed in."
#~ msgstr "index de départ si uniquement des noms sont passés."

#~ msgid "The *start* parameter was added."
#~ msgstr "Ajout du paramètre *start*."

#~ msgid ""
#~ "The first variation of :class:`Enum` that is provided is also a subclass "
#~ "of :class:`int`.  Members of an :class:`IntEnum` can be compared to "
#~ "integers; by extension, integer enumerations of different types can also "
#~ "be compared to each other::"
#~ msgstr ""
#~ "La première version dérivée de :class:`Enum` qui existe est aussi une "
#~ "sous-classe de :class:`int`. Les membres de :class:`IntEnum` peuvent être "
#~ "comparés à des entiers et, par extension, les comparaisons entre des "
#~ "énumérations entières de type différent sont possibles ::"

#~ msgid ""
#~ "However, they still can't be compared to standard :class:`Enum` "
#~ "enumerations::"
#~ msgstr ""
#~ "Elles ne peuvent cependant toujours pas être comparées à des énumérations "
#~ "standards de :class:`Enum` ::"

#~ msgid ""
#~ ":class:`IntEnum` values behave like integers in other ways you'd expect::"
#~ msgstr ""
#~ "Les valeurs de :class:`IntEnum` se comportent comme des entiers, comme on "
#~ "pouvait s'y attendre ::"

#~ msgid "IntFlag"
#~ msgstr "IntFlag"

#~ msgid ""
#~ "The next variation of :class:`Enum` provided, :class:`IntFlag`, is also "
#~ "based on :class:`int`.  The difference being :class:`IntFlag` members can "
#~ "be combined using the bitwise operators (&, \\|, ^, ~) and the result is "
#~ "still an :class:`IntFlag` member.  However, as the name implies, :class:"
#~ "`IntFlag` members also subclass :class:`int` and can be used wherever an :"
#~ "class:`int` is used.  Any operation on an :class:`IntFlag` member besides "
#~ "the bit-wise operations will lose the :class:`IntFlag` membership."
#~ msgstr ""
#~ "La version dérivée suivante de :class:`Enum` est :class:`IntFlag`. Elle "
#~ "est aussi basée sur :class:`int`, à la différence près que les membres "
#~ "de :class:`IntFlag` peuvent être combinés en utilisant les opérateurs bit-"
#~ "à-bit (&, \\|, ^, ~) et que le résultat reste un membre de :class:"
#~ "`IntFlag`. Cependant, comme le nom l'indique, les membres d'une classe :"
#~ "class:`IntFlag` héritent aussi de :class:`int` et peuvent être utilisés "
#~ "là où un :class:`int` est utilisé. Toute opération sur un membre d'une "
#~ "classe :class:`IntFlag`, autre qu'un opérateur bit-à-bit lui fait perdre "
#~ "sa qualité de :class:`IntFlag`."

#~ msgid "It is also possible to name the combinations::"
#~ msgstr "Il est aussi possible de nommer les combinaisons ::"

#~ msgid ""
#~ "Another important difference between :class:`IntFlag` and :class:`Enum` "
#~ "is that if no flags are set (the value is 0), its boolean evaluation is :"
#~ "data:`False`::"
#~ msgstr ""
#~ "Une autre différence importante entre :class:`IntFlag` et :class:`Enum` "
#~ "est que, si aucune option n'est activée (la valeur vaut 0), son "
#~ "évaluation booléenne est :data:`False` ::"

#~ msgid ""
#~ "Because :class:`IntFlag` members are also subclasses of :class:`int` they "
#~ "can be combined with them::"
#~ msgstr ""
#~ "Comme les membres d'une classe :class:`IntFlag` héritent aussi de :class:"
#~ "`int`, ils peuvent être combinés avec eux ::"

#~ msgid "Flag"
#~ msgstr "Option"

#~ msgid ""
#~ "The last variation is :class:`Flag`.  Like :class:`IntFlag`, :class:"
#~ "`Flag` members can be combined using the bitwise operators (&, \\|, ^, "
#~ "~).  Unlike :class:`IntFlag`, they cannot be combined with, nor compared "
#~ "against, any other :class:`Flag` enumeration, nor :class:`int`.  While it "
#~ "is possible to specify the values directly it is recommended to use :"
#~ "class:`auto` as the value and let :class:`Flag` select an appropriate "
#~ "value."
#~ msgstr ""
#~ "La dernière version dérivée est la classe :class:`Flag`.  Comme :class:"
#~ "`IntFlag`, les membres d'une classe :class:`Flag` peuvent être combinés "
#~ "en utilisant les opérateurs de comparaison bit-à-bit. Cependant, à la "
#~ "différence de :class:`IntFlag`, ils ne peuvent ni être combinés, ni être "
#~ "comparés avec une autre énumération :class:`Flag`, ni avec :class:`int`. "
#~ "Bien qu'il soit possible de définir directement les valeurs, il est "
#~ "recommandé d'utiliser :class:`auto` comme valeur et de laisser :class:"
#~ "`Flag` choisir une valeur appropriée."

#~ msgid ""
#~ "Like :class:`IntFlag`, if a combination of :class:`Flag` members results "
#~ "in no flags being set, the boolean evaluation is :data:`False`::"
#~ msgstr ""
#~ "Comme avec :class:`IntFlag`, si une combinaison de membres d'une classe :"
#~ "class:`Flag` n'active aucune option, l'évaluation booléenne de la "
#~ "comparaison est :data:`False` ::"

#~ msgid ""
#~ "Individual flags should have values that are powers of two (1, 2, 4, "
#~ "8, ...), while combinations of flags won't::"
#~ msgstr ""
#~ "Les options de base doivent avoir des puissances de deux pour valeurs (1, "
#~ "2, 4, 8, ...) mais pas les combinaisons ::"

#~ msgid ""
#~ "Giving a name to the \"no flags set\" condition does not change its "
#~ "boolean value::"
#~ msgstr ""
#~ "Donner un nom à la valeur « aucune option activée » ne change pas sa "
#~ "valeur booléenne ::"

#~ msgid ""
#~ "For the majority of new code, :class:`Enum` and :class:`Flag` are "
#~ "strongly recommended, since :class:`IntEnum` and :class:`IntFlag` break "
#~ "some semantic promises of an enumeration (by being comparable to "
#~ "integers, and thus by transitivity to other unrelated enumerations).  :"
#~ "class:`IntEnum` and :class:`IntFlag` should be used only in cases where :"
#~ "class:`Enum` and :class:`Flag` will not do; for example, when integer "
#~ "constants are replaced with enumerations, or for interoperability with "
#~ "other systems."
#~ msgstr ""
#~ "Dans la plupart des cas, il est fortement recommandé d'utiliser :class:"
#~ "`Enum` et :class:`Flag` pour écrire du code nouveau, car :class:`IntEnum` "
#~ "et :class:`IntFlag` violent certains principes sémantiques d'une "
#~ "énumération (en pouvant être comparées à des entiers et donc, par "
#~ "transitivité, à d'autres énumérations). :class:`IntEnum` et :class:"
#~ "`IntFlag` ne doivent être utilisées que dans les cas où :class:`Enum` et :"
#~ "class:`Flag` ne suffisent pas ; par exemple quand des constantes entières "
#~ "sont remplacées par des énumérations, ou pour l’interopérabilité avec "
#~ "d'autres systèmes."

#~ msgid "Others"
#~ msgstr "Autres"

#~ msgid ""
#~ "While :class:`IntEnum` is part of the :mod:`enum` module, it would be "
#~ "very simple to implement independently::"
#~ msgstr ""
#~ "Bien que :class:`IntEnum` fasse partie du module :mod:`enum`, elle serait "
#~ "très simple à implémenter hors de ce module ::"

#~ msgid ""
#~ "This demonstrates how similar derived enumerations can be defined; for "
#~ "example a :class:`StrEnum` that mixes in :class:`str` instead of :class:"
#~ "`int`."
#~ msgstr ""
#~ "Ceci montre comment définir des énumérations dérivées similaires ; par "
#~ "exemple une classe :class:`StrEnum` qui dériverait de :class:`str` au "
#~ "lieu de :class:`int`."

#~ msgid "Some rules:"
#~ msgstr "Quelques règles :"

#~ msgid ""
#~ "When subclassing :class:`Enum`, mix-in types must appear before :class:"
#~ "`Enum` itself in the sequence of bases, as in the :class:`IntEnum` "
#~ "example above."
#~ msgstr ""
#~ "Pour hériter de :class:`Enum`, les types de mélange doivent être placés "
#~ "avant la classe :class:`Enum` elle-même dans la liste des classes de "
#~ "base, comme dans l'exemple de :class:`IntEnum` ci-dessus."

#~ msgid ""
#~ "While :class:`Enum` can have members of any type, once you mix in an "
#~ "additional type, all the members must have values of that type, e.g. :"
#~ "class:`int` above.  This restriction does not apply to mix-ins which only "
#~ "add methods and don't specify another type."
#~ msgstr ""
#~ "Même si une classe :class:`Enum` peut avoir des membres de n'importe quel "
#~ "type, dès qu'un type est spécifié à la déclaration de la classe, alors "
#~ "tous les membres doivent être de ce type, p. ex. :class:`int` ci-dessus. "
#~ "Cette restriction ne s'applique pas aux classes dérivées qui n'ajoutent "
#~ "que des méthodes supplémentaires sans spécifier un type de données."

#~ msgid ""
#~ "When another data type is mixed in, the :attr:`value` attribute is *not "
#~ "the same* as the enum member itself, although it is equivalent and will "
#~ "compare equal."
#~ msgstr ""
#~ "Quand un autre type de données est mélangé, l'attribut :attr:`value` "
#~ "n'est *pas* identique au membre de l'énumération lui-même, bien qu'ils "
#~ "soient équivalents et égaux en comparaison."

#~ msgid ""
#~ "%-style formatting:  `%s` and `%r` call the :class:`Enum` class's :meth:"
#~ "`__str__` and :meth:`__repr__` respectively; other codes (such as `%i` or "
#~ "`%h` for IntEnum) treat the enum member as its mixed-in type."
#~ msgstr ""
#~ "Formatage de style *%* : `%s` et `%r` appellent respectivement les "
#~ "méthodes :meth:`__str__` et :meth:`__repr__` de la classe :class:`Enum` ; "
#~ "les autres codes, comme `%i` ou `%h` pour *IntEnum*, s'appliquent au "
#~ "membre comme si celui-ci était converti en son type de mélange."

#~ msgid ""
#~ ":ref:`Formatted string literals <f-strings>`, :meth:`str.format`, and :"
#~ "func:`format` will use the mixed-in type's :meth:`__format__` unless :"
#~ "meth:`__str__` or :meth:`__format__` is overridden in the subclass, in "
#~ "which case the overridden methods or :class:`Enum` methods will be used. "
#~ "Use the !s and !r format codes to force usage of the :class:`Enum` "
#~ "class's :meth:`__str__` and :meth:`__repr__` methods."
#~ msgstr ""
#~ "Les :ref:`chaînes littérales formatées <f-strings>` : :meth:`str.format` "
#~ "et :func:`format` appellent la méthode :meth:`__format__` du type dérivé "
#~ "à moins que :meth:`__str__` ou :meth:`__format__` soit surchargée dans la "
#~ "sous-classe, auquel cas les méthodes surchargées ou celles de la classe :"
#~ "class:`Enum`  seront utilisées. Pour appeler les méthodes :meth:`__str__` "
#~ "ou :meth:`__repr__` de la classe :class:`Enum`, il faut utiliser les "
#~ "codes de formatage ``!s`` ou ``!r``."

#~ msgid "When to use :meth:`__new__` vs. :meth:`__init__`"
#~ msgstr "Quand utiliser :meth:`__new__` ou :meth:`__init__`"

#~ msgid ""
#~ ":meth:`__new__` must be used whenever you want to customize the actual "
#~ "value of the :class:`Enum` member.  Any other modifications may go in "
#~ "either :meth:`__new__` or :meth:`__init__`, with :meth:`__init__` being "
#~ "preferred."
#~ msgstr ""
#~ ":meth:`__new__` doit être utilisé dès que vous souhaitez personnaliser la "
#~ "valeur effective des membres d'un :class:`Enum`. Tout autre modification "
#~ "peut autant aller dans :meth:`__new__` que dans :meth:`__init__`, mais "
#~ "l'usage de :meth:`__init__` est recommandé."

#~ msgid ""
#~ "For example, if you want to pass several items to the constructor, but "
#~ "only want one of them to be the value::"
#~ msgstr ""
#~ "Par exemple, si vous voulez passer plusieurs éléments au constructeur, "
#~ "mais qu'un seul d'entre eux soit la valeur ::"

#~ msgid "Interesting examples"
#~ msgstr "Exemples intéressants"

#~ msgid ""
#~ "While :class:`Enum`, :class:`IntEnum`, :class:`IntFlag`, and :class:"
#~ "`Flag` are expected to cover the majority of use-cases, they cannot cover "
#~ "them all.  Here are recipes for some different types of enumerations that "
#~ "can be used directly, or as examples for creating one's own."
#~ msgstr ""
#~ "Bien que :class:`Enum`, :class:`IntEnum`, :class:`IntFlag` et :class:"
#~ "`Flag` soient conçues pour répondre à la majorité des besoins, elles ne "
#~ "peuvent répondre à tous. Voici quelques recettes d'énumération qui "
#~ "peuvent être réutilisées telles quelles, ou peuvent servir d'exemple pour "
#~ "développer vos propres énumérations."

#~ msgid "Omitting values"
#~ msgstr "Omettre les valeurs"

#~ msgid ""
#~ "In many use-cases one doesn't care what the actual value of an "
#~ "enumeration is. There are several ways to define this type of simple "
#~ "enumeration:"
#~ msgstr ""
#~ "Dans de nombreux cas, la valeur réelle de l'énumération n'a pas "
#~ "d'importance. Il y a plusieurs façons de définir ce type d'énumération "
#~ "simple :"

#~ msgid "use instances of :class:`auto` for the value"
#~ msgstr "affecter des instances de :class:`auto` aux valeurs"

#~ msgid "use instances of :class:`object` as the value"
#~ msgstr "affecter des instances de :class:`object` aux valeurs"

#~ msgid "use a descriptive string as the value"
#~ msgstr "affecter des chaînes de caractères aux valeurs pour les décrire"

#~ msgid ""
#~ "use a tuple as the value and a custom :meth:`__new__` to replace the "
#~ "tuple with an :class:`int` value"
#~ msgstr ""
#~ "affecter un *n*-uplet aux valeurs et définir une méthode :meth:`__new__` "
#~ "pour remplacer les *n*-uplets avec un :class:`int`"

#~ msgid ""
#~ "Using any of these methods signifies to the user that these values are "
#~ "not important, and also enables one to add, remove, or reorder members "
#~ "without having to renumber the remaining members."
#~ msgstr ""
#~ "Utiliser une de ces méthodes indique à l'utilisateur que les valeurs "
#~ "n'ont pas d'importance. Cela permet aussi d'ajouter, de supprimer ou de "
#~ "ré-ordonner les membres sans avoir à ré-énumérer les membres existants."

#~ msgid ""
#~ "Whichever method you choose, you should provide a :meth:`repr` that also "
#~ "hides the (unimportant) value::"
#~ msgstr ""
#~ "Quelle que soit la méthode choisie, il faut fournir une méthode :meth:"
#~ "`repr` qui masque les valeurs (pas importantes de toute façon) ::"

#~ msgid "Using :class:`auto` would look like::"
#~ msgstr "On utilise :class:`auto` de la manière suivante ::"

#~ msgid "Using :class:`object`"
#~ msgstr "Avec :class:`object`"

#~ msgid "Using :class:`object` would look like::"
#~ msgstr "On utilise :class:`object` de la manière suivante ::"

#~ msgid "Using a descriptive string"
#~ msgstr "Avec une chaîne de caractères de description"

#~ msgid "Using a string as the value would look like::"
#~ msgstr "On utilise une chaîne de caractères de la manière suivante ::"

#~ msgid "Using a custom :meth:`__new__`"
#~ msgstr "Avec une méthode ad-hoc :meth:`__new__`"

#~ msgid "Using an auto-numbering :meth:`__new__` would look like::"
#~ msgstr ""
#~ "On utilise une méthode :meth:`__new__` d'énumération de la manière "
#~ "suivante ::"

#~ msgid ""
#~ "To make a more general purpose ``AutoNumber``, add ``*args`` to the "
#~ "signature::"
#~ msgstr ""
#~ "Pour définir un ``AutoNumber`` plus générique, ajoutez ``*args`` à la "
#~ "signature ::"

#~ msgid ""
#~ "Then when you inherit from ``AutoNumber`` you can write your own "
#~ "``__init__`` to handle any extra arguments::"
#~ msgstr ""
#~ "Ainsi, quand vous héritez d'``AutoNumber``, vous pouvez définir "
#~ "``__init__`` pour gérer tout argument supplémentaire ::"

#~ msgid ""
#~ "The :meth:`__new__` method, if defined, is used during creation of the "
#~ "Enum members; it is then replaced by Enum's :meth:`__new__` which is used "
#~ "after class creation for lookup of existing members."
#~ msgstr ""
#~ "La méthode :meth:`__new__`, si définie, est appelée à la création des "
#~ "membres de l'énumération ; elle est ensuite remplacée par la méthode :"
#~ "meth:`__new__` de *Enum*, qui est utilisée après la création de la classe "
#~ "pour la recherche des membres existants."

#~ msgid "OrderedEnum"
#~ msgstr "OrderedEnum"

#~ msgid ""
#~ "An ordered enumeration that is not based on :class:`IntEnum` and so "
#~ "maintains the normal :class:`Enum` invariants (such as not being "
#~ "comparable to other enumerations)::"
#~ msgstr ""
#~ "Une énumération ordonnée qui n'est pas basée sur :class:`IntEnum` et qui, "
#~ "par conséquent, respecte les invariants classiques de :class:`Enum` "
#~ "(comme par exemple l'impossibilité de pouvoir être comparée à d'autres "
#~ "énumérations) ::"

#~ msgid "DuplicateFreeEnum"
#~ msgstr "DuplicateFreeEnum"

#~ msgid ""
#~ "Raises an error if a duplicate member name is found instead of creating "
#~ "an alias::"
#~ msgstr ""
#~ "Lève une erreur si un membre est dupliqué, plutôt que de créer un alias ::"

#~ msgid ""
#~ "This is a useful example for subclassing Enum to add or change other "
#~ "behaviors as well as disallowing aliases.  If the only desired change is "
#~ "disallowing aliases, the :func:`unique` decorator can be used instead."
#~ msgstr ""
#~ "Cet exemple d'héritage de *Enum* est intéressant pour ajouter ou modifier "
#~ "des comportements comme interdire les alias. Si vous ne souhaitez "
#~ "qu'interdire les alias, il suffit d'utiliser le décorateur :func:`unique`."

#~ msgid "Planet"
#~ msgstr "Planet"

#~ msgid ""
#~ "If :meth:`__new__` or :meth:`__init__` is defined the value of the enum "
#~ "member will be passed to those methods::"
#~ msgstr ""
#~ "Si :meth:`__new__` ou :meth:`__init__` sont définies, la valeur du membre "
#~ "de l'énumération sera passée à ces méthodes ::"

#~ msgid "TimePeriod"
#~ msgstr "TimePeriod"

#~ msgid "An example to show the :attr:`_ignore_` attribute in use::"
#~ msgstr "Exemple d'utilisation de l'attribut :attr:`_ignore_` ::"

#~ msgid "How are Enums different?"
#~ msgstr "En quoi les *Enums* sont différentes ?"

#~ msgid ""
#~ "Enums have a custom metaclass that affects many aspects of both derived "
#~ "Enum classes and their instances (members)."
#~ msgstr ""
#~ "Les *enums* ont une métaclasse spéciale qui affecte de nombreux aspects "
#~ "des classes dérivées de *Enum* et de leurs instances (membres)."

#~ msgid "Enum Classes"
#~ msgstr "Classes *Enum*"

#~ msgid ""
#~ "The :class:`EnumMeta` metaclass is responsible for providing the :meth:"
#~ "`__contains__`, :meth:`__dir__`, :meth:`__iter__` and other methods that "
#~ "allow one to do things with an :class:`Enum` class that fail on a typical "
#~ "class, such as `list(Color)` or `some_enum_var in Color`.  :class:"
#~ "`EnumMeta` is responsible for ensuring that various other methods on the "
#~ "final :class:`Enum` class are correct (such as :meth:`__new__`, :meth:"
#~ "`__getnewargs__`, :meth:`__str__` and :meth:`__repr__`)."
#~ msgstr ""
#~ "La métaclasse :class:`EnumMeta` se charge de fournir les méthodes :meth:"
#~ "`__contains__`, :meth:`__dir__`, :meth:`__iter__` etc. qui permettent de "
#~ "faire des opérations sur une classe :class:`Enum` qui ne fonctionneraient "
#~ "pas sur une classe standard, comme `list(Color)` ou `some_enum_var in "
#~ "Color`. :class:`EnumMeta` garantit que les autres méthodes de la classe "
#~ "finale :class:`Enum` sont correctes (comme :meth:`__new__`, :meth:"
#~ "`__getnewargs__`, :meth:`__str__` et :meth:`__repr__`)."

#~ msgid "Enum Members (aka instances)"
#~ msgstr "Membres d'Enum (c.-à-d. instances)"

#~ msgid ""
#~ "The most interesting thing about Enum members is that they are "
#~ "singletons. :class:`EnumMeta` creates them all while it is creating the :"
#~ "class:`Enum` class itself, and then puts a custom :meth:`__new__` in "
#~ "place to ensure that no new ones are ever instantiated by returning only "
#~ "the existing member instances."
#~ msgstr ""
#~ "Il est intéressant de souligner que les membres d'une *Enum* sont des "
#~ "singletons.  La classe :class:`EnumMeta` les crée tous au moment de la "
#~ "création de la classe :class:`Enum` elle-même et implémente une méthode :"
#~ "meth:`__new__` spécifique. Cette méthode renvoie toujours les instances "
#~ "de membres déjà existantes pour être sûr de ne jamais en instancier de "
#~ "nouvelles."

#~ msgid "Finer Points"
#~ msgstr "Aspects approfondis"

#~ msgid ""
#~ "To help keep Python 2 / Python 3 code in sync an :attr:`_order_` "
#~ "attribute can be provided.  It will be checked against the actual order "
#~ "of the enumeration and raise an error if the two do not match::"
#~ msgstr ""
#~ "Pour faciliter la transition de Python 2 en Python 3, l'attribut :attr:"
#~ "`_order_` peut être défini. Il sera comparé au véritable ordre de "
#~ "l'énumération et lève une erreur si les deux ne correspondent pas ::"

#~ msgid ""
#~ "In Python 2 code the :attr:`_order_` attribute is necessary as definition "
#~ "order is lost before it can be recorded."
#~ msgstr ""
#~ "En Python 2, l'attribut :attr:`_order_` est indispensable car l'ordre de "
#~ "la définition est perdu avant de pouvoir être enregistré."

#~ msgid "_Private__names"
#~ msgstr "_Noms__privés"

#~ msgid ""
#~ ":ref:`Private names <private-name-mangling>` will be normal attributes in "
#~ "Python 3.11 instead of either an error or a member (depending on if the "
#~ "name ends with an underscore). Using these names in 3.10 will issue a :"
#~ "exc:`DeprecationWarning`."
#~ msgstr ""
#~ "Les :ref:`noms privés <private-name-mangling>` seront des attributs "
#~ "habituels avec Python 3.11 et non plus des erreurs ou membres (selon si "
#~ "le nom termine par tiret bas ou non). Utiliser ces noms avec Python 3.10 "
#~ "lèvera un :exc:`DeprecationWarning`."

#~ msgid "``Enum`` member type"
#~ msgstr "Type des membres de ``Enum``"

#~ msgid ""
#~ ":class:`Enum` members are instances of their :class:`Enum` class, and are "
#~ "normally accessed as ``EnumClass.member``.  Under certain circumstances "
#~ "they can also be accessed as ``EnumClass.member.member``, but you should "
#~ "never do this as that lookup may fail or, worse, return something besides "
#~ "the :class:`Enum` member you are looking for (this is another good reason "
#~ "to use all-uppercase names for members)::"
#~ msgstr ""
#~ "Les membres de :class:`Enum` sont des instances de leur classe :class:"
#~ "`Enum`. On y accède normalement par ``ClasseEnum.membre``.  Dans certains "
#~ "cas, on peut également y accéder par ``ClasseEnum.membre.membre``, mais "
#~ "ceci est fortement déconseillé car cette indirection est susceptible "
#~ "d'échouer, ou pire, de ne pas renvoyer le membre de la classe :class:"
#~ "`Enum` désiré (c'est une autre bonne raison pour définir tous les noms "
#~ "des membres en majuscules) ::"

#~ msgid "This behavior is deprecated and will be removed in 3.11."
#~ msgstr "Ce comportement est obsolète et sera retiré en 3.11."

#~ msgid "Boolean value of ``Enum`` classes and members"
#~ msgstr "Valeur booléenne des classes ``Enum`` et de leurs membres"

#~ msgid ""
#~ ":class:`Enum` members that are mixed with non-:class:`Enum` types (such "
#~ "as :class:`int`, :class:`str`, etc.) are evaluated according to the mixed-"
#~ "in type's rules; otherwise, all members evaluate as :data:`True`.  To "
#~ "make your own Enum's boolean evaluation depend on the member's value add "
#~ "the following to your class::"
#~ msgstr ""
#~ "Les membres d'une classe :class:`Enum` mélangée avec un type non dérivé "
#~ "de :class:`Enum` (comme :class:`int`, :class:`str`, etc.) sont évalués "
#~ "selon les règles du type de mélange. Sinon, tous les membres valent :data:"
#~ "`True`. Pour faire dépendre l'évaluation booléenne de votre propre *Enum* "
#~ "de la valeur du membre, il faut ajouter le code suivant à votre classe ::"

#~ msgid ":class:`Enum` classes always evaluate as :data:`True`."
#~ msgstr "Les classes :class:`Enum` valent toujours :data:`True`."

#~ msgid "``Enum`` classes with methods"
#~ msgstr "Classes ``Enum`` avec des méthodes"

#~ msgid ""
#~ "If you give your :class:`Enum` subclass extra methods, like the `Planet`_ "
#~ "class above, those methods will show up in a :func:`dir` of the member, "
#~ "but not of the class::"
#~ msgstr ""
#~ "Si votre classe :class:`Enum` contient des méthodes supplémentaires, "
#~ "comme la classe `Planet`_ ci-dessus, elles s'afficheront avec un appel à :"
#~ "func:`dir` sur le membre, mais pas avec un appel sur la classe ::"

#~ msgid "Combining members of ``Flag``"
#~ msgstr "Combinaison de membres de ``Flag``"

#~ msgid ""
#~ "If a combination of Flag members is not named, the :func:`repr` will "
#~ "include all named flags and all named combinations of flags that are in "
#~ "the value::"
#~ msgstr ""
#~ "Si une valeur issue de la combinaison de membres de *Flag* n'est pas "
#~ "associée explicitement à un membre, la fonction :func:`repr` inclut tous "
#~ "les membres et toutes les combinaisons de membres présents dans cette "
#~ "valeur ::"

#~ msgid ""
#~ "In 3.11 unnamed combinations of flags will only produce the canonical "
#~ "flag members (aka single-value flags).  So ``Color(7)`` will produce "
#~ "something like ``<Color.BLUE|GREEN|RED: 7>``."
#~ msgstr ""
#~ "En 3.11, les combinaisons non-nommées de ``Flag`` ne renverront que les "
#~ "*flags* canoniques (*flags* associés à une unique valeur). Donc "
#~ "``Color(7)`` renverra ``<Color.BLUE|GREE|RED: 7>``."
