From d75cd7aede9a34fe8da4dd488f146813c7cb2302 Mon Sep 17 00:00:00 2001 From: awecx Date: Sat, 20 Jul 2019 18:08:46 +0200 Subject: [PATCH 01/12] 50% --- library/enum.po | 807 ++++++++++++++++++++++++++++-------------------- 1 file changed, 471 insertions(+), 336 deletions(-) diff --git a/library/enum.po b/library/enum.po index d834af4d9..0e63fb548 100644 --- a/library/enum.po +++ b/library/enum.po @@ -6,17 +6,18 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-10-12 18:59+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2019-07-15 14:54+0200\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" +"Last-Translator: Antoine Wecxsteen\n" +"X-Generator: Poedit 2.0.6\n" #: ../Doc/library/enum.rst:2 msgid ":mod:`enum` --- Support for enumerations" -msgstr "" +msgstr ":mod:`enum` --- Support for enumerations" #: ../Doc/library/enum.rst:14 msgid "**Source code:** :source:`Lib/enum.py`" @@ -24,10 +25,13 @@ msgstr "**Code source :** :source:`Lib/enum.py`" #: ../Doc/library/enum.rst:18 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." +"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 entre eux et il est possible d'itérer sur l'énumération elle-même." #: ../Doc/library/enum.rst:24 msgid "Module Contents" @@ -35,41 +39,53 @@ msgstr "Contenu du module" #: ../Doc/library/enum.rst:26 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`." +"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 peuvent être utilisées pour 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`." #: ../Doc/library/enum.rst:33 msgid "" -"Base class for creating enumerated constants. See section `Functional API`_ " -"for an alternate construction syntax." +"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." #: ../Doc/library/enum.rst:38 msgid "" -"Base class for creating enumerated constants that are also subclasses of :" -"class:`int`." +"Base class for creating enumerated constants that are also subclasses of :class:`int`." msgstr "" +"Classe de base pour créer une énumération de constantes qui seront également des sous-" +"classes de :class:`int`." #: ../Doc/library/enum.rst:43 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`." +"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`." 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 nature de :class:`IntFlag`. Les " +"membres de :class:`IntFlag` sont aussi des sous-classes de :class:`int`." #: ../Doc/library/enum.rst:49 msgid "" -"Base class for creating enumerated constants that can be combined using the " -"bitwise operations without losing their :class:`Flag` membership." +"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 nature de :class:`Flag`." #: ../Doc/library/enum.rst:54 -msgid "" -"Enum class decorator that ensures only one name is bound to any one value." +msgid "Enum class decorator that ensures only one name is bound to any one value." msgstr "" +"Décorateur de classe qui garantissant qu'un seul nom ne puisse être associé qu'à une " +"seule valeur." #: ../Doc/library/enum.rst:58 msgid "Instances are replaced with an appropriate value for Enum members." @@ -77,185 +93,218 @@ msgstr "" #: ../Doc/library/enum.rst:60 msgid "``Flag``, ``IntFlag``, ``auto``" -msgstr "" +msgstr "``Flag``, ``IntFlag``, ``auto``" #: ../Doc/library/enum.rst:64 msgid "Creating an Enum" -msgstr "" +msgstr "Création d'un Enum" #: ../Doc/library/enum.rst:66 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::" +"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 méthode alternative de création est décrite dans `Functional API`_. Pour " +"définir, une énumération, il faut sous-classer :class:`Enum` de la manière suivante ::" #: ../Doc/library/enum.rst:78 msgid "Enum member values" -msgstr "" +msgstr "Valeurs des membres d'un Enum" #: ../Doc/library/enum.rst:80 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." +"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'est pas importante, il est possible d'utiliser des instances de :" +"class:`auto` et une valeur appropriée sera choisie. Soyez vigilant si vous mélangez :" +"class:`auto` avec d'autres valeurs." #: ../Doc/library/enum.rst:85 msgid "Nomenclature" -msgstr "" +msgstr "Nomenclature" #: ../Doc/library/enum.rst:87 msgid "The class :class:`Color` is an *enumeration* (or *enum*)" -msgstr "" +msgstr "La classe :class:`Color` est une *énumeration* (ou un *enum*)" #: ../Doc/library/enum.rst:88 msgid "" -"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are " -"*enumeration members* (or *enum members*) and are functionally constants." +"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are *enumeration members* " +"(or *enum 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." #: ../Doc/library/enum.rst:90 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.)" +"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.)" #: ../Doc/library/enum.rst:96 msgid "" -"Even though we use the :keyword:`class` syntax to create Enums, Enums are " -"not normal Python classes. See `How are Enums different?`_ for more details." +"Even though we use the :keyword:`class` syntax to create Enums, Enums are not normal " +"Python classes. See `How are Enums different?`_ for more details." msgstr "" +"Même si on utilise la syntaxe en :keyword:`class` pour crééer des enums, les *Enums* ne " +"sont pas des vraies classes Python. Voir `How are Enums different?`_ pour plus de détails." #: ../Doc/library/enum.rst:100 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 ::" #: ../Doc/library/enum.rst:105 msgid "...while their ``repr`` has more information::" -msgstr "" +msgstr "... tandis que leur ``repr`` contient plus d'informations ::" #: ../Doc/library/enum.rst:110 msgid "The *type* of an enumeration member is the enumeration it belongs to::" -msgstr "" +msgstr "Le *type* d'un membre est l'énumération auquel ce membre appartient ::" #: ../Doc/library/enum.rst:118 msgid "Enum members also have a property that contains just their item name::" -msgstr "" +msgstr "Les membres ont également un attribut qui contient leur nom ::" #: ../Doc/library/enum.rst:123 msgid "Enumerations support iteration, 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 ::" #: ../Doc/library/enum.rst:139 -msgid "" -"Enumeration members are hashable, so they can be used in dictionaries and " -"sets::" +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 ::" #: ../Doc/library/enum.rst:149 msgid "Programmatic access to enumeration members and their attributes" -msgstr "" +msgstr "Accès dynamique aux membres et à leurs attributs" #: ../Doc/library/enum.rst:151 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::" +"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 (par " +"exemple 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 ::" #: ../Doc/library/enum.rst:160 msgid "If you want to access enum members by *name*, use item access::" -msgstr "" +msgstr "Pour accéder au membres par leur *nom*, utilisez l'accès par indexation ::" #: ../Doc/library/enum.rst:167 msgid "If you have an enum member and need its :attr:`name` or :attr:`value`::" -msgstr "" +msgstr "Pour obtenir le :attr:`name` ou la :attr:`value` d'un membre ::" #: ../Doc/library/enum.rst:177 msgid "Duplicating enum members and values" -msgstr "" +msgstr "Duplication de membres et de valeurs" #: ../Doc/library/enum.rst:179 msgid "Having two enum members with the same name is invalid::" -msgstr "" +msgstr "Il n'est pas possible d'avoir deux membres du même nom dans une enum ::" #: ../Doc/library/enum.rst:189 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::" +"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 de la " +"valeur commune à A et B renverra A. Un accès à B par nom renverra aussi A ::" #: ../Doc/library/enum.rst:209 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." +"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 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." #: ../Doc/library/enum.rst:215 msgid "Ensuring unique enumeration values" -msgstr "" +msgstr "Coercition d'unicité des valeurs d'un enum" #: ../Doc/library/enum.rst:217 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:" +"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é, le décorateur ci-dessous peut être utilisé pour s'assurer " +"que chaque valeur n'est utilisée qu'une seule fois au sein de l'énumération ::" #: ../Doc/library/enum.rst:223 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::" +"enumeration's :attr:`__members__` gathering any aliases it finds; if any are found :exc:" +"`ValueError` is raised with the details::" msgstr "" +"Un :keyword:`class` décorateur spécifique aux énumérations. Il examine :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 ::" #: ../Doc/library/enum.rst:241 msgid "Using automatic values" -msgstr "" +msgstr "Valeurs automatiques" #: ../Doc/library/enum.rst:243 msgid "If the exact value is unimportant you can use :class:`auto`::" -msgstr "" +msgstr "Si la valeur exacte n'a pas d'importance, vous pouvez utiliser :class:`auto` ::" #: ../Doc/library/enum.rst:254 -msgid "" -"The values are chosen by :func:`_generate_next_value_`, which can be " -"overridden::" +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 ::" #: ../Doc/library/enum.rst:272 msgid "" -"The goal of the default :meth:`_generate_next_value_` methods 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." +"The goal of the default :meth:`_generate_next_value_` methods 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 "" +"Le but de la méthode par défaut :meth:`_generate_next_value_` est de fournir la :class:" +"`int` suivante de la séquence en fonction de la dernière :class:`int` fournie, mais son " +"comportement dépend de l'implémentation Python." #: ../Doc/library/enum.rst:277 msgid "Iteration" -msgstr "" +msgstr "Itération" #: ../Doc/library/enum.rst:279 msgid "Iterating over the members of an enum does not provide the aliases::" -msgstr "" +msgstr "Itérer sur les membres d'une enum ne parcourt pas les alias ::" #: ../Doc/library/enum.rst:284 msgid "" -"The special attribute ``__members__`` is an ordered dictionary mapping names " -"to members. It includes all names defined in the enumeration, including the " -"aliases::" +"The special attribute ``__members__`` is an ordered dictionary mapping names to members. " +"It includes all names defined in the enumeration, including the aliases::" msgstr "" +"L'attribut spécial ``__members__`` est un dictionnaire ordonné qui fait correspondre les " +"noms aux membres. Il inclut tous les noms définis dans l'énumération, alias compris ::" #: ../Doc/library/enum.rst:296 msgid "" -"The ``__members__`` attribute can be used for detailed programmatic access " -"to the enumeration members. For example, finding all the aliases::" +"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 ::" #: ../Doc/library/enum.rst:304 msgid "Comparisons" @@ -267,20 +316,24 @@ msgstr "" #: ../Doc/library/enum.rst:315 msgid "" -"Ordered comparisons between enumeration values are *not* supported. Enum " -"members are not integers (but see `IntEnum`_ below)::" +"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'une enum ne sont pas des entiers (voir cependant `IntEnum`_ ci-dessous) ::" #: ../Doc/library/enum.rst:323 msgid "Equality comparisons are defined though::" -msgstr "" +msgstr "A contrario, les comparaisons d'égalité existent :" #: ../Doc/library/enum.rst:332 msgid "" -"Comparisons against non-enumeration values will always compare not equal " -"(again, :class:`IntEnum` was explicitly designed to behave differently, see " -"below)::" +"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 " +"(encore une, fois :class:`IntEnum` a été conçue pour fonctionner différemment, voir ci-" +"dessous)::" #: ../Doc/library/enum.rst:341 msgid "Allowed members and attributes of enumerations" @@ -288,187 +341,228 @@ msgstr "" #: ../Doc/library/enum.rst:343 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." +"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 la `Functional API`_), 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." #: ../Doc/library/enum.rst:349 msgid "" -"Enumerations are Python classes, and can have methods and special methods as " -"usual. If we have this enumeration::" +"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 ::" #: ../Doc/library/enum.rst:369 msgid "Then::" -msgstr "" +msgstr "Amène ::" #: ../Doc/library/enum.rst:378 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_`." +"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_`." #: ../Doc/library/enum.rst:385 msgid "" -"Note: if your enumeration defines :meth:`__new__` and/or :meth:`__init__` " -"then whatever value(s) were given to the enum member will be passed into " -"those methods. See `Planet`_ for an example." +"Note: if your enumeration defines :meth:`__new__` and/or :meth:`__init__` then whatever " +"value(s) were given to the enum member will be passed into those methods. See `Planet`_ " +"for an example." msgstr "" +"Remarque : si l'énumération définit :meth:`__new__` and/or :meth:`__init__`, alors (????) " +"la (ou les) valeur affectée au membre sera passée à ces méthodes. Voir l'exemple de " +"`Planet`_." #: ../Doc/library/enum.rst:391 msgid "Restricted Enum subclassing" -msgstr "" +msgstr "Restrictions sur l'héritage" #: ../Doc/library/enum.rst:393 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::" +"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ée sur :class:`object`) que " +"nécessaire. L'ordre de ces classes de base est le suivant ::" #: ../Doc/library/enum.rst:400 msgid "" -"Also, subclassing an enumeration is allowed only if the enumeration does not " -"define any members. So this is forbidden::" +"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é ::" #: ../Doc/library/enum.rst:410 msgid "But this is allowed::" -msgstr "" +msgstr "Mais celui-ci est correct ::" #: ../Doc/library/enum.rst:421 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.)" +"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 `OrderedEnum`_ pour exemple)." #: ../Doc/library/enum.rst:428 msgid "Pickling" -msgstr "" +msgstr "Sérialisation" #: ../Doc/library/enum.rst:430 msgid "Enumerations can be pickled and unpickled::" -msgstr "" +msgstr "Les énumérations peuvent être sérialisées et dé-sérialisées ::" #: ../Doc/library/enum.rst:437 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." +"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ées dans l'espace de nom de haut niveau du module car la dé-" +"sérialisation nécessite que ces enums puissent être importées depuis ce module." #: ../Doc/library/enum.rst:443 msgid "" -"With pickle protocol version 4 it is possible to easily pickle enums nested " -"in other classes." +"With pickle protocol version 4 it is possible to easily pickle enums nested in other " +"classes." msgstr "" +"Depuis la version numéro 4 du protocole de pickle, il est possible de sérialiser " +"facilement des enums imbriquées dans d'autres classes." #: ../Doc/library/enum.rst:446 msgid "" -"It is possible to modify how Enum members are pickled/unpickled by defining :" -"meth:`__reduce_ex__` in the enumeration class." +"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 / dé-" +"sérialisation des membres d'une enum." #: ../Doc/library/enum.rst:451 msgid "Functional API" -msgstr "" +msgstr "API par fonction" #: ../Doc/library/enum.rst:453 -msgid "" -"The :class:`Enum` class is callable, providing the following functional API::" +msgid "The :class:`Enum` class is callable, providing the following functional API::" msgstr "" +"La :class:`Enum` est appelable et implémente l'API pproviding the following functional " +"API::" #: ../Doc/library/enum.rst:465 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." +"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." #: ../Doc/library/enum.rst:468 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 "" +"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 des noms séparés par des espaces, une séquence de noms, une " +"séquence de duets clé/valeur ou une correspondance (par exemple un dictionnaire) entre " +"noms et valeurs. 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 à ::" #: ../Doc/library/enum.rst:484 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``." +"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``." #: ../Doc/library/enum.rst:488 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::" +"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 "" #: ../Doc/library/enum.rst:498 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." +"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 non-sérialisables (?????) ; ." #: ../Doc/library/enum.rst:502 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::" +"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 "" #: ../Doc/library/enum.rst:509 msgid "The complete signature is::" -msgstr "" +msgstr "La signature complète est la suivante ::" #: ../Doc/library/enum.rst:0 msgid "value" -msgstr "valeur" +msgstr "value" #: ../Doc/library/enum.rst:513 msgid "What the new Enum class will record as its name." -msgstr "" +msgstr "Le nom de la la nouvelle classe Enum." #: ../Doc/library/enum.rst:0 msgid "names" -msgstr "" +msgstr "names" #: ../Doc/library/enum.rst:515 msgid "" -"The Enum members. This can be a whitespace or comma separated string " -"(values will start at 1 unless otherwise specified)::" +"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'Enum. 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) ::" #: ../Doc/library/enum.rst:520 msgid "or an iterator of names::" -msgstr "" +msgstr "ou un itérateur sur les noms ::" #: ../Doc/library/enum.rst:524 msgid "or an iterator of (name, value) pairs::" -msgstr "" +msgstr "ou un itérateur sur les tuples (nom, valeur) ::" #: ../Doc/library/enum.rst:528 msgid "or a mapping::" -msgstr "" +msgstr "ou une correspondance ::" #: ../Doc/library/enum.rst:0 msgid "module" @@ -476,15 +570,15 @@ msgstr "module" #: ../Doc/library/enum.rst:532 msgid "name of module where new Enum class can be found." -msgstr "" +msgstr "nom du module dans lequel la classe Enum se trouve." #: ../Doc/library/enum.rst:0 msgid "qualname" -msgstr "" +msgstr "qualname" #: ../Doc/library/enum.rst:534 msgid "where in module new Enum class can be found." -msgstr "" +msgstr "localisation de la nouvelle classe Enum dans le module." #: ../Doc/library/enum.rst:0 msgid "type" @@ -496,19 +590,19 @@ msgstr "" #: ../Doc/library/enum.rst:0 msgid "start" -msgstr "" +msgstr "start" #: ../Doc/library/enum.rst:538 msgid "number to start counting at if only names are passed in." -msgstr "" +msgstr "index de départ si uniquement des noms sont passés." #: ../Doc/library/enum.rst:540 msgid "The *start* parameter was added." -msgstr "" +msgstr "Ajout du paramètre *start*." #: ../Doc/library/enum.rst:545 msgid "Derived Enumerations" -msgstr "" +msgstr "Énumérations dérivées" #: ../Doc/library/enum.rst:548 msgid "IntEnum" @@ -516,58 +610,73 @@ msgstr "IntEnum" #: ../Doc/library/enum.rst:550 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::" +"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ération entières de type différent sont " +"possibles ::" #: ../Doc/library/enum.rst:571 -msgid "" -"However, they still can't be compared to standard :class:`Enum` " -"enumerations::" +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` ::" #: ../Doc/library/enum.rst:584 -msgid "" -":class:`IntEnum` values behave like integers in other ways you'd expect::" +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 peut s'y " +"attendre ::" #: ../Doc/library/enum.rst:595 msgid "IntFlag" -msgstr "" +msgstr "IntFlag" #: ../Doc/library/enum.rst:597 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 "" +"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 (??? une instance) de type :class:`IntFlag`. Cependant, comme le nom l'indique, " +"les membres d'une :class:`IntFlag` sont aussi des sous-classes de :class:`int` et peuvent " +"être utilisés là où une :class:`int` est utilisée. Toute opération sur un membre d'une :" +"class:`IntFlag`, autre qu'un opérateur bit-à-bit lui fait perdre sa qualité de :class:" +"`IntFlag`." #: ../Doc/library/enum.rst:607 msgid "Sample :class:`IntFlag` class::" -msgstr "" +msgstr "Exemple d'une classe :class:`IntFlag` ::" #: ../Doc/library/enum.rst:623 msgid "It is also possible to name the combinations::" -msgstr "" +msgstr "Il est aussi possible de nommer les combinaisons ::" #: ../Doc/library/enum.rst:635 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`::" +"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` ::" #: ../Doc/library/enum.rst:643 msgid "" -"Because :class:`IntFlag` members are also subclasses of :class:`int` they " -"can be combined with them::" +"Because :class:`IntFlag` members are also subclasses of :class:`int` they can be combined " +"with them::" msgstr "" +"Comme les membres d'une :class:`IntFlag` sont aussi des sous-classes de :class:`int`, ils " +"peuvent être combinés avec eux ::" #: ../Doc/library/enum.rst:651 msgid "Flag" @@ -575,42 +684,57 @@ msgstr "Option" #: ../Doc/library/enum.rst:653 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." +"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 :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 la valeur " +"appropriée." #: ../Doc/library/enum.rst:662 msgid "" -"Like :class:`IntFlag`, if a combination of :class:`Flag` members results in " -"no flags being set, the boolean evaluation is :data:`False`::" +"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 de :class:`Flag` n'active " +"aucune option, l'évaluation booléenne de la comparaison est :data:`False`::" #: ../Doc/library/enum.rst:676 msgid "" -"Individual flags should have values that are powers of two (1, 2, 4, " -"8, ...), while combinations of flags won't::" +"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 ::" #: ../Doc/library/enum.rst:688 -msgid "" -"Giving a name to the \"no flags set\" condition does not change its boolean " -"value::" +msgid "Giving a name to the \"no flags set\" condition does not change its boolean value::" msgstr "" +"Donner un nom à la valeur \"aucun option activée\" ne change pas sa valeur booléenne ::" #: ../Doc/library/enum.rst:704 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 "" +"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` and :class:" +"`Flag` pour écrire du code nouveau, car :class:`IntEnum` and :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` and :class:" +"`IntFlag` ne doivent être utilisées que dans les cas où :class:`Enum` and :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." #: ../Doc/library/enum.rst:714 msgid "Others" @@ -618,150 +742,165 @@ msgstr "Autres" #: ../Doc/library/enum.rst:716 msgid "" -"While :class:`IntEnum` is part of the :mod:`enum` module, it would be very " -"simple to implement independently::" +"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` module, it would be very " +"simple to implement independently::" #: ../Doc/library/enum.rst:722 msgid "" -"This demonstrates how similar derived enumerations can be defined; for " -"example a :class:`StrEnum` that mixes in :class:`str` instead of :class:" -"`int`." +"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 class:" +"`StrEnum` qui dérive de :class:`str` au lieu d':class:`int`." #: ../Doc/library/enum.rst:725 msgid "Some rules:" -msgstr "" +msgstr "Quelques règles :" #: ../Doc/library/enum.rst:727 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." +"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 "" #: ../Doc/library/enum.rst:730 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 data type such as :class:`int` or :class:" -"`str`." +"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 data type such " +"as :class:`int` or :class:`str`." msgstr "" #: ../Doc/library/enum.rst:735 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." +"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 "" #: ../Doc/library/enum.rst:738 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." +"%-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 "" #: ../Doc/library/enum.rst:741 msgid "" -":ref:`Formatted string literals `, :meth:`str.format`, and :func:" -"`format` will use the mixed-in type's :meth:`__format__`. If the :class:" -"`Enum` class's :func:`str` or :func:`repr` is desired, use the `!s` or `!r` " -"format codes." +":ref:`Formatted string literals `, :meth:`str.format`, and :func:`format` will " +"use the mixed-in type's :meth:`__format__`. If the :class:`Enum` class's :func:`str` or :" +"func:`repr` is desired, use the `!s` or `!r` format codes." msgstr "" #: ../Doc/library/enum.rst:748 msgid "Interesting examples" -msgstr "" +msgstr "Exemples intéressants" #: ../Doc/library/enum.rst:750 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." +"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." #: ../Doc/library/enum.rst:757 msgid "Omitting values" -msgstr "" +msgstr "Omettre les valeurs" #: ../Doc/library/enum.rst:759 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:" +"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, simple, d'énumération :" #: ../Doc/library/enum.rst:762 msgid "use instances of :class:`auto` for the value" -msgstr "" +msgstr "affecter des instances de :class:`auto` aux valeurs" #: ../Doc/library/enum.rst:763 msgid "use instances of :class:`object` as the value" -msgstr "" +msgstr "affecter des instances de :class:`object` aux valeurs" #: ../Doc/library/enum.rst:764 msgid "use a descriptive string as the value" -msgstr "" +msgstr "affecter des chaînes de caractères aux valeurs pour les décrire" #: ../Doc/library/enum.rst:765 msgid "" -"use a tuple as the value and a custom :meth:`__new__` to replace the tuple " -"with an :class:`int` value" +"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`" #: ../Doc/library/enum.rst:768 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." +"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." #: ../Doc/library/enum.rst:772 msgid "" -"Whichever method you choose, you should provide a :meth:`repr` that also " -"hides the (unimportant) value::" +"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) ::" #: ../Doc/library/enum.rst:782 msgid "Using :class:`auto`" -msgstr "" +msgstr "Utiliser :class:`auto`" #: ../Doc/library/enum.rst:784 msgid "Using :class:`auto` would look like::" -msgstr "" +msgstr "On utilise :class:`auto` de la manière suivante ::" #: ../Doc/library/enum.rst:796 msgid "Using :class:`object`" -msgstr "" +msgstr "Utiliser :class:`object`" #: ../Doc/library/enum.rst:798 msgid "Using :class:`object` would look like::" -msgstr "" +msgstr "On utilise :class:`object` de la manière suivante ::" #: ../Doc/library/enum.rst:810 msgid "Using a descriptive string" -msgstr "" +msgstr "Utiliser une chaîne de caractères de description" #: ../Doc/library/enum.rst:812 msgid "Using a string as the value would look like::" -msgstr "" +msgstr "On utilise une chaîne de caractères de la manière suivante ::" #: ../Doc/library/enum.rst:826 msgid "Using a custom :meth:`__new__`" -msgstr "" +msgstr "Utiliser une méthode ad-hoc :meth:`__new__`" #: ../Doc/library/enum.rst:828 msgid "Using an auto-numbering :meth:`__new__` would look like::" -msgstr "" +msgstr "On utilise une méthode :meth:`__new__` d'énumération de la manière suivante ::" #: ../Doc/library/enum.rst:850 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." +"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'enum ; " +"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." #: ../Doc/library/enum.rst:856 msgid "OrderedEnum" @@ -769,54 +908,59 @@ msgstr "OrderedEnum" #: ../Doc/library/enum.rst:858 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)::" +"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 respecte les " +"invariants standards de :class:`Enum` (par exemple interdire les comparaisons avec " +"d'autre énumérations) ::" #: ../Doc/library/enum.rst:892 msgid "DuplicateFreeEnum" msgstr "DuplicateFreeEnum" #: ../Doc/library/enum.rst:894 -msgid "" -"Raises an error if a duplicate member name is found instead of creating an " -"alias::" -msgstr "" +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 ::" #: ../Doc/library/enum.rst:919 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." +"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 "" +"C'est une exemple utile d'héritage de Enum pour ajouter ou modifier des comportements, en " +"plus d'interdire les alias. Pour uniquement interdire les alias, il suffit d'utiliser le " +"décorateur :func:`unique`." #: ../Doc/library/enum.rst:925 msgid "Planet" -msgstr "" +msgstr "Planet" #: ../Doc/library/enum.rst:927 msgid "" -"If :meth:`__new__` or :meth:`__init__` is defined the value of the enum " -"member will be passed to those methods::" +"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'enum sera " +"passée à ces méthodes ::" #: ../Doc/library/enum.rst:955 msgid "TimePeriod" -msgstr "" +msgstr "TimePeriod" #: ../Doc/library/enum.rst:957 msgid "An example to show the :attr:`_ignore_` attribute in use::" -msgstr "" +msgstr "Exemple d'utilisation de l'attribut :attr:`_ignore_` ::" #: ../Doc/library/enum.rst:974 msgid "How are Enums different?" -msgstr "" +msgstr "Pourquoi les Enums sont différentes ?" #: ../Doc/library/enum.rst:976 msgid "" -"Enums have a custom metaclass that affects many aspects of both derived Enum " -"classes and their instances (members)." +"Enums have a custom metaclass that affects many aspects of both derived Enum classes and " +"their instances (members)." msgstr "" #: ../Doc/library/enum.rst:981 @@ -825,13 +969,12 @@ msgstr "" #: ../Doc/library/enum.rst:983 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__`)." +"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 "" #: ../Doc/library/enum.rst:993 @@ -840,11 +983,10 @@ msgstr "" #: ../Doc/library/enum.rst:995 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." +"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 "" #: ../Doc/library/enum.rst:1003 @@ -857,15 +999,15 @@ msgstr "" #: ../Doc/library/enum.rst:1008 msgid "" -":attr:`__members__` is an :class:`OrderedDict` of ``member_name``:``member`` " -"items. It is only available on the class." +":attr:`__members__` is an :class:`OrderedDict` of ``member_name``:``member`` items. It " +"is only available on the class." msgstr "" #: ../Doc/library/enum.rst:1011 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." +":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 "" #: ../Doc/library/enum.rst:1017 @@ -877,33 +1019,29 @@ msgid "``_name_`` -- name of the member" msgstr "" #: ../Doc/library/enum.rst:1020 -msgid "" -"``_value_`` -- value of the member; can be set / modified in ``__new__``" +msgid "``_value_`` -- value of the member; can be set / modified in ``__new__``" msgstr "" #: ../Doc/library/enum.rst:1022 -msgid "" -"``_missing_`` -- a lookup function used when a value is not found; may be " -"overridden" +msgid "``_missing_`` -- a lookup function used when a value is not found; may be overridden" msgstr "" #: ../Doc/library/enum.rst:1024 msgid "" -"``_ignore_`` -- a list of names, either as a :func:`list` or a :func:`str`, " -"that will not be transformed into members, and will be removed from the " -"final class" +"``_ignore_`` -- a list of names, either as a :func:`list` or a :func:`str`, that will not " +"be transformed into members, and will be removed from the final class" msgstr "" #: ../Doc/library/enum.rst:1027 msgid "" -"``_order_`` -- used in Python 2/3 code to ensure member order is consistent " -"(class attribute, removed during class creation)" +"``_order_`` -- used in Python 2/3 code to ensure member order is consistent (class " +"attribute, removed during class creation)" msgstr "" #: ../Doc/library/enum.rst:1029 msgid "" -"``_generate_next_value_`` -- used by the `Functional API`_ and by :class:" -"`auto` to get an appropriate value for an enum member; may be overridden" +"``_generate_next_value_`` -- used by the `Functional API`_ and by :class:`auto` to get an " +"appropriate value for an enum member; may be overridden" msgstr "" #: ../Doc/library/enum.rst:1033 @@ -916,15 +1054,15 @@ msgstr "" #: ../Doc/library/enum.rst:1036 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::" +"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 "" #: ../Doc/library/enum.rst:1052 msgid "" -"In Python 2 code the :attr:`_order_` attribute is necessary as definition " -"order is lost before it can be recorded." +"In Python 2 code the :attr:`_order_` attribute is necessary as definition order is lost " +"before it can be recorded." msgstr "" #: ../Doc/library/enum.rst:1056 @@ -933,12 +1071,11 @@ msgstr "" #: ../Doc/library/enum.rst:1058 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)::" +":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 "" #: ../Doc/library/enum.rst:1079 @@ -947,11 +1084,10 @@ msgstr "" #: ../Doc/library/enum.rst:1081 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::" +":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 "" #: ../Doc/library/enum.rst:1090 @@ -964,9 +1100,8 @@ msgstr "" #: ../Doc/library/enum.rst:1096 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::" +"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 "" #: ../Doc/library/enum.rst:1107 @@ -975,6 +1110,6 @@ msgstr "" #: ../Doc/library/enum.rst:1109 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::" +"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 "" From 42132c4a05193ad7252ffada12b4953aa34cf356 Mon Sep 17 00:00:00 2001 From: awecx Date: Wed, 24 Jul 2019 07:56:01 +0200 Subject: [PATCH 02/12] 100% --- library/enum.po | 536 +++++++++++++++++++++++++++--------------------- 1 file changed, 307 insertions(+), 229 deletions(-) diff --git a/library/enum.po b/library/enum.po index 0e63fb548..0f9ef9942 100644 --- a/library/enum.po +++ b/library/enum.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-10-12 18:59+0200\n" -"PO-Revision-Date: 2019-07-15 14:54+0200\n" +"PO-Revision-Date: 2019-07-24 07:53+0200\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -17,21 +17,21 @@ msgstr "" #: ../Doc/library/enum.rst:2 msgid ":mod:`enum` --- Support for enumerations" -msgstr ":mod:`enum` --- Support for enumerations" +msgstr ":mod:`enum` — Énumerations" #: ../Doc/library/enum.rst:14 msgid "**Source code:** :source:`Lib/enum.py`" -msgstr "**Code source :** :source:`Lib/enum.py`" +msgstr "**Code source :** :source:`Lib/enum.py`" #: ../Doc/library/enum.rst:18 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." +"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 entre eux et il est possible d'itérer sur l'énumération elle-même." +"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 entre " +"eux et il est possible d'itérer sur l'énumération elle-même." #: ../Doc/library/enum.rst:24 msgid "Module Contents" @@ -43,10 +43,10 @@ msgid "" "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 peuvent être utilisées pour 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`." +"Ce module définit quatre classes d'énumération qui permettend 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`." #: ../Doc/library/enum.rst:33 msgid "" @@ -60,7 +60,7 @@ msgstr "" msgid "" "Base class for creating enumerated constants that are also subclasses of :class:`int`." msgstr "" -"Classe de base pour créer une énumération de constantes qui seront également des sous-" +"Classe de base pour créer une énumération de constantes qui sont également des sous-" "classes de :class:`int`." #: ../Doc/library/enum.rst:43 @@ -70,7 +70,7 @@ msgid "" "also subclasses of :class:`int`." 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 nature de :class:`IntFlag`. Les " +"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`." #: ../Doc/library/enum.rst:49 @@ -79,17 +79,18 @@ msgid "" "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 nature de :class:`Flag`." +"opérateurs de comparaison bit-à-bit, sans perdre leur qualité de :class:`Flag`." #: ../Doc/library/enum.rst:54 msgid "Enum class decorator that ensures only one name is bound to any one value." msgstr "" -"Décorateur de classe qui garantissant qu'un seul nom ne puisse être associé qu'à une " -"seule valeur." +"Décorateur de classe qui garantit qu'une valeur ne puisse être associée qu'à un seul nom." #: ../Doc/library/enum.rst:58 msgid "Instances are replaced with an appropriate value for Enum members." msgstr "" +"Les instances de cette classe remplacent les membres d'une *Enum* par une valeur " +"appropriée." #: ../Doc/library/enum.rst:60 msgid "``Flag``, ``IntFlag``, ``auto``" @@ -97,7 +98,7 @@ msgstr "``Flag``, ``IntFlag``, ``auto``" #: ../Doc/library/enum.rst:64 msgid "Creating an Enum" -msgstr "Création d'un Enum" +msgstr "Création d'une *Enum*" #: ../Doc/library/enum.rst:66 msgid "" @@ -106,12 +107,12 @@ msgid "" "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 méthode alternative de création est décrite dans `Functional API`_. Pour " -"définir, une énumération, il faut sous-classer :class:`Enum` de la manière suivante ::" +"écrire. Une autre méthode de création est décrite dans `API par fonction`_. Pour définir " +"une énumération, il faut sous-classer :class:`Enum` de la manière suivante : ::" #: ../Doc/library/enum.rst:78 msgid "Enum member values" -msgstr "Valeurs des membres d'un Enum" +msgstr "Valeurs des membres d'une *Enum*" #: ../Doc/library/enum.rst:80 msgid "" @@ -120,9 +121,9 @@ msgid "" "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'est pas importante, il est possible d'utiliser des instances de :" -"class:`auto` et une valeur appropriée sera choisie. Soyez vigilant si vous mélangez :" -"class:`auto` avec d'autres valeurs." +"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." #: ../Doc/library/enum.rst:85 msgid "Nomenclature" @@ -130,55 +131,56 @@ msgstr "Nomenclature" #: ../Doc/library/enum.rst:87 msgid "The class :class:`Color` is an *enumeration* (or *enum*)" -msgstr "La classe :class:`Color` est une *énumeration* (ou un *enum*)" +msgstr "La classe :class:`Color` est une *énumeration* (ou un *enum*)." #: ../Doc/library/enum.rst:88 msgid "" -"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are *enumeration members* " -"(or *enum members*) and are functionally constants." +"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are *enumeration members* (or " +"*enum 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." +"l'énumération* (ou les *membres de l'enum*) et sont fonctionnellement des constantes." #: ../Doc/library/enum.rst:90 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.)" +"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." #: ../Doc/library/enum.rst:96 msgid "" "Even though we use the :keyword:`class` syntax to create Enums, Enums are not normal " "Python classes. See `How are Enums different?`_ for more details." msgstr "" -"Même si on utilise la syntaxe en :keyword:`class` pour crééer des enums, les *Enums* ne " -"sont pas des vraies classes Python. Voir `How are Enums different?`_ pour plus de détails." +"Même si on utilise la syntaxe en :keyword:`class` pour créer des enums, les *Enums* ne " +"sont pas des vraies classes Python. Voir `En quoi les Enums sont différentes ?`_ pour plus " +"de détails." #: ../Doc/library/enum.rst:100 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 ::" +"compréhensible par un humain : ::" #: ../Doc/library/enum.rst:105 msgid "...while their ``repr`` has more information::" -msgstr "... tandis que leur ``repr`` contient plus d'informations ::" +msgstr "… tandis que leur ``repr`` contient plus d'informations : ::" #: ../Doc/library/enum.rst:110 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 ::" +msgstr "Le *type* d'un membre est l'énumération auquel ce membre appartient : ::" #: ../Doc/library/enum.rst:118 msgid "Enum members also have a property that contains just their item name::" -msgstr "Les membres ont également un attribut qui contient leur nom ::" +msgstr "Les membres ont également un attribut qui contient leur nom : ::" #: ../Doc/library/enum.rst:123 msgid "Enumerations support iteration, 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 ::" +"sont déclarés : ::" #: ../Doc/library/enum.rst:139 msgid "Enumeration members are hashable, so they can be used in dictionaries and sets::" @@ -196,17 +198,17 @@ msgid "" "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 (par " -"exemple 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 ::" +"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 : ::" #: ../Doc/library/enum.rst:160 msgid "If you want to access enum members by *name*, use item access::" -msgstr "Pour accéder au membres par leur *nom*, utilisez l'accès par indexation ::" +msgstr "Pour accéder aux membres par leur *nom*, utilisez l'accès par indexation : ::" #: ../Doc/library/enum.rst:167 msgid "If you have an enum member and need its :attr:`name` or :attr:`value`::" -msgstr "Pour obtenir le :attr:`name` ou la :attr:`value` d'un membre ::" +msgstr "Pour obtenir l'attribut :attr:`name` ou :attr:`value` d'un membre : ::" #: ../Doc/library/enum.rst:177 msgid "Duplicating enum members and values" @@ -214,7 +216,7 @@ msgstr "Duplication de membres et de valeurs" #: ../Doc/library/enum.rst:179 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 une enum ::" +msgstr "Il n'est pas possible d'avoir deux membres du même nom dans une *enum* : ::" #: ../Doc/library/enum.rst:189 msgid "" @@ -222,9 +224,9 @@ msgid "" "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 de la " -"valeur commune à A et B renverra A. Un accès à B par nom renverra aussi A ::" +"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 : ::" #: ../Doc/library/enum.rst:209 msgid "" @@ -232,12 +234,12 @@ msgid "" "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 nom qu'un attribut déjà défini (un autre " +"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." #: ../Doc/library/enum.rst:215 msgid "Ensuring unique enumeration values" -msgstr "Coercition d'unicité des valeurs d'un enum" +msgstr "Coercition d'unicité des valeurs d'une énumération" #: ../Doc/library/enum.rst:217 msgid "" @@ -246,18 +248,18 @@ msgid "" "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é, le décorateur ci-dessous peut être utilisé pour s'assurer " -"que chaque valeur n'est utilisée qu'une seule fois au sein de l'énumération ::" +"comportement n'est pas désiré, il faut utiliser le décorateur pour s'assurer que chaque " +"valeur n'est utilisée qu'une seule fois au sein de l'énumération : ::" #: ../Doc/library/enum.rst:223 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::" +"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 :keyword:`class` décorateur spécifique aux énumérations. Il examine :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 ::" +"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 : ::" #: ../Doc/library/enum.rst:241 msgid "Using automatic values" @@ -265,12 +267,13 @@ msgstr "Valeurs automatiques" #: ../Doc/library/enum.rst:243 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` ::" +msgstr "Si la valeur exacte n'a pas d'importance, vous pouvez utiliser :class:`auto` : ::" #: ../Doc/library/enum.rst:254 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 ::" +"Les valeurs sont déterminées par :func:`_generate_next_value_`, qui peut être " +"redéfinie : ::" #: ../Doc/library/enum.rst:272 msgid "" @@ -278,9 +281,9 @@ msgid "" "class:`int` in sequence with the last :class:`int` provided, but the way it does this is " "an implementation detail and may change." msgstr "" -"Le but de la méthode par défaut :meth:`_generate_next_value_` est de fournir la :class:" -"`int` suivante de la séquence en fonction de la dernière :class:`int` fournie, mais son " -"comportement dépend de l'implémentation Python." +"La méthode par défaut :meth:`_generate_next_value_` doit fournir le :class:`int` suivant " +"de la séquence en fonction du dernier :class:`int` fourni, mais la séquence générée dépend " +"de l'implémentation Python." #: ../Doc/library/enum.rst:277 msgid "Iteration" @@ -288,7 +291,7 @@ msgstr "Itération" #: ../Doc/library/enum.rst:279 msgid "Iterating over the members of an enum does not provide the aliases::" -msgstr "Itérer sur les membres d'une enum ne parcourt pas les alias ::" +msgstr "Itérer sur les membres d'une énumération ne parcourt pas les alias : ::" #: ../Doc/library/enum.rst:284 msgid "" @@ -296,7 +299,7 @@ msgid "" "It includes all names defined in the enumeration, including the aliases::" msgstr "" "L'attribut spécial ``__members__`` est un dictionnaire ordonné qui fait correspondre les " -"noms aux membres. Il inclut tous les noms définis dans l'énumération, alias compris ::" +"noms aux membres. Il inclut tous les noms définis dans l'énumération, alias compris : ::" #: ../Doc/library/enum.rst:296 msgid "" @@ -304,7 +307,7 @@ msgid "" "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 ::" +"l'énumération. Par exemple, pour trouver tous les alias : ::" #: ../Doc/library/enum.rst:304 msgid "Comparisons" @@ -312,19 +315,19 @@ msgstr "Comparaisons" #: ../Doc/library/enum.rst:306 msgid "Enumeration members are compared by identity::" -msgstr "" +msgstr "Les membres d'une énumération sont comparés par identité : ::" #: ../Doc/library/enum.rst:315 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'une enum ne sont pas des entiers (voir cependant `IntEnum`_ ci-dessous) ::" +"Les comparaisons d'ordre entre les valeurs d'une énumération n'existent *pas* ; les " +"membres d'une *enum* ne sont pas des entiers (voir cependant `IntEnum`_ ci-dessous) : ::" #: ../Doc/library/enum.rst:323 msgid "Equality comparisons are defined though::" -msgstr "A contrario, les comparaisons d'égalité existent :" +msgstr "A contrario, les comparaisons d'égalité existent : ::" #: ../Doc/library/enum.rst:332 msgid "" @@ -332,51 +335,51 @@ msgid "" "`IntEnum` was explicitly designed to behave differently, see below)::" msgstr "" "Les comparaisons avec des valeurs ne provenant pas d'énumérations sont toujours fausses " -"(encore une, fois :class:`IntEnum` a été conçue pour fonctionner différemment, voir ci-" -"dessous)::" +"(ici encore, :class:`IntEnum` a été conçue pour fonctionner différemment, voir ci-" +"dessous) : ::" #: ../Doc/library/enum.rst:341 msgid "Allowed members and attributes of enumerations" -msgstr "" +msgstr "Membres et attributs autorisés dans une énumération" #: ../Doc/library/enum.rst:343 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." +"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 la `Functional API`_), 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 " +"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." #: ../Doc/library/enum.rst:349 msgid "" -"Enumerations are Python classes, and can have methods and special methods as usual. If " -"we have this enumeration::" +"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 ::" +"méthodes et des méthodes spéciales. L'énumération suivante : ::" #: ../Doc/library/enum.rst:369 msgid "Then::" -msgstr "Amène ::" +msgstr "amène : ::" #: ../Doc/library/enum.rst:378 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 " +"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_`." #: ../Doc/library/enum.rst:385 @@ -385,9 +388,9 @@ msgid "" "value(s) were given to the enum member will be passed into those methods. See `Planet`_ " "for an example." msgstr "" -"Remarque : si l'énumération définit :meth:`__new__` and/or :meth:`__init__`, alors (????) " -"la (ou les) valeur affectée au membre sera passée à ces méthodes. Voir l'exemple de " -"`Planet`_." +"Remarque : si l'énumération définit :meth:`__new__` and/or :meth:`__init__`, alors " +"(double ????) la (ou les) valeur affectée au membre sera passée à ces méthodes. Voir " +"l'exemple de `Planet`_." #: ../Doc/library/enum.rst:391 msgid "Restricted Enum subclassing" @@ -395,13 +398,13 @@ msgstr "Restrictions sur l'héritage" #: ../Doc/library/enum.rst:393 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::" +"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ée sur :class:`object`) que " -"nécessaire. L'ordre de ces classes de base est le suivant ::" +"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 : ::" #: ../Doc/library/enum.rst:400 msgid "" @@ -409,11 +412,11 @@ msgid "" "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é ::" +"Le code suivant n'est pas autorisé : ::" #: ../Doc/library/enum.rst:410 msgid "But this is allowed::" -msgstr "Mais celui-ci est correct ::" +msgstr "Mais celui-ci est correct : ::" #: ../Doc/library/enum.rst:421 msgid "" @@ -422,7 +425,7 @@ msgid "" "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 " +"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 `OrderedEnum`_ pour exemple)." @@ -432,32 +435,32 @@ msgstr "Sérialisation" #: ../Doc/library/enum.rst:430 msgid "Enumerations can be pickled and unpickled::" -msgstr "Les énumérations peuvent être sérialisées et dé-sérialisées ::" +msgstr "Les énumérations peuvent être sérialisées et dé-sérialisées : ::" #: ../Doc/library/enum.rst:437 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 " +"Les restrictions habituelles de sérialisation s'appliquent : les *enums* à sérialiser " "doivent être déclarées dans l'espace de nom de haut niveau du module car la dé-" -"sérialisation nécessite que ces enums puissent être importées depuis ce module." +"sérialisation nécessite que ces *enums* puissent être importées depuis ce module." #: ../Doc/library/enum.rst:443 msgid "" "With pickle protocol version 4 it is possible to easily pickle enums nested in other " "classes." msgstr "" -"Depuis la version numéro 4 du protocole de pickle, il est possible de sérialiser " -"facilement des enums imbriquées dans d'autres classes." +"Depuis la version 4 du protocole de *pickle*, il est possible de sérialiser facilement des " +"*enums* imbriquées dans d'autres classes." #: ../Doc/library/enum.rst:446 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 / dé-" -"sérialisation des membres d'une enum." +"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." #: ../Doc/library/enum.rst:451 msgid "Functional API" @@ -465,14 +468,12 @@ msgstr "API par fonction" #: ../Doc/library/enum.rst:453 msgid "The :class:`Enum` class is callable, providing the following functional API::" -msgstr "" -"La :class:`Enum` est appelable et implémente l'API pproviding the following functional " -"API::" +msgstr "La :class:`Enum` est appelable et implémente l'API par fonction suivante : ::" #: ../Doc/library/enum.rst:465 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." +"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." @@ -487,14 +488,14 @@ msgid "" "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 des noms séparés par des espaces, une séquence de noms, une " -"séquence de duets clé/valeur ou une correspondance (par exemple un dictionnaire) entre " -"noms et valeurs. 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 " +"Le second argument est la *source* des noms des membres de l'énumération. Il peut être une " +"chaîne de caractères des noms séparés par des espaces, une séquence de noms, une séquence " +"de duets clé / valeur ou une correspondance (p. ex. un dictionnaire) entre noms et " +"valeurs. 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 à ::" +"dessus équivaut à : ::" #: ../Doc/library/enum.rst:484 msgid "" @@ -506,20 +507,25 @@ msgstr "" #: ../Doc/library/enum.rst:488 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::" +"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éés 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 oy Jython). La solution consiste à préciser explicitement le nom du module " +"comme ceci : ::" #: ../Doc/library/enum.rst:498 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 non-sérialisables (?????) ; ." +"Si ``module`` n'est pas fourni et que *Enum* ne peut pas le deviner, les nouveaux membres " +"de l' *Enum* ne seront pas non-sérialisables (?????) ; ." #: ../Doc/library/enum.rst:502 msgid "" @@ -527,10 +533,14 @@ msgid "" "__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 : ::" #: ../Doc/library/enum.rst:509 msgid "The complete signature is::" -msgstr "La signature complète est la suivante ::" +msgstr "La signature complète est la suivante : ::" #: ../Doc/library/enum.rst:0 msgid "value" @@ -538,7 +548,7 @@ msgstr "value" #: ../Doc/library/enum.rst:513 msgid "What the new Enum class will record as its name." -msgstr "Le nom de la la nouvelle classe Enum." +msgstr "Le nom de la la nouvelle classe *Enum*." #: ../Doc/library/enum.rst:0 msgid "names" @@ -549,20 +559,20 @@ 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'Enum. 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) ::" +"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) : ::" #: ../Doc/library/enum.rst:520 msgid "or an iterator of names::" -msgstr "ou un itérateur sur les noms ::" +msgstr "ou un itérateur sur les noms : ::" #: ../Doc/library/enum.rst:524 msgid "or an iterator of (name, value) pairs::" -msgstr "ou un itérateur sur les tuples (nom, valeur) ::" +msgstr "ou un itérateur sur les tuples (nom, valeur) : ::" #: ../Doc/library/enum.rst:528 msgid "or a mapping::" -msgstr "ou une correspondance ::" +msgstr "ou une correspondance : ::" #: ../Doc/library/enum.rst:0 msgid "module" @@ -570,7 +580,7 @@ msgstr "module" #: ../Doc/library/enum.rst:532 msgid "name of module where new Enum class can be found." -msgstr "nom du module dans lequel la classe Enum se trouve." +msgstr "nom du module dans lequel la classe *Enum* se trouve." #: ../Doc/library/enum.rst:0 msgid "qualname" @@ -578,7 +588,7 @@ msgstr "qualname" #: ../Doc/library/enum.rst:534 msgid "where in module new Enum class can be found." -msgstr "localisation de la nouvelle classe Enum dans le module." +msgstr "localisation de la nouvelle classe *Enum* dans le module." #: ../Doc/library/enum.rst:0 msgid "type" @@ -586,7 +596,7 @@ msgstr "type" #: ../Doc/library/enum.rst:536 msgid "type to mix in to new Enum class." -msgstr "" +msgstr "le type à mélanger dans la nouvelle classe *Enum*." #: ../Doc/library/enum.rst:0 msgid "start" @@ -610,26 +620,26 @@ msgstr "IntEnum" #: ../Doc/library/enum.rst:550 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 " +"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ération entières de type différent sont " -"possibles ::" +"possibles : ::" #: ../Doc/library/enum.rst:571 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` ::" +"class:`Enum` : ::" #: ../Doc/library/enum.rst:584 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 peut s'y " -"attendre ::" +"Les valeurs de :class:`IntEnum` se comportent comme des entiers, comme on pouvait s'y " +"attendre : ::" #: ../Doc/library/enum.rst:595 msgid "IntFlag" @@ -641,34 +651,32 @@ msgid "" "`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." +"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 (??? une instance) de type :class:`IntFlag`. Cependant, comme le nom l'indique, " -"les membres d'une :class:`IntFlag` sont aussi des sous-classes de :class:`int` et peuvent " -"être utilisés là où une :class:`int` est utilisée. Toute opération sur un membre d'une :" -"class:`IntFlag`, autre qu'un opérateur bit-à-bit lui fait perdre sa qualité de :class:" -"`IntFlag`." +"membre de :class:`IntFlag`. Cependant, comme le nom l'indique, les membres d'une :class:" +"`IntFlag` sont aussi des sous-classes de :class:`int` et peuvent être utilisés là où un :" +"class:`int` est utilisé. Toute opération sur un membre d'une :class:`IntFlag`, autre qu'un " +"opérateur bit-à-bit lui fait perdre sa qualité de :class:`IntFlag`." #: ../Doc/library/enum.rst:607 msgid "Sample :class:`IntFlag` class::" -msgstr "Exemple d'une classe :class:`IntFlag` ::" +msgstr "Exemple d'une classe :class:`IntFlag` : ::" #: ../Doc/library/enum.rst:623 msgid "It is also possible to name the combinations::" -msgstr "Il est aussi possible de nommer les combinaisons ::" +msgstr "Il est aussi possible de nommer les combinaisons : ::" #: ../Doc/library/enum.rst:635 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` ::" +"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` : ::" #: ../Doc/library/enum.rst:643 msgid "" @@ -676,7 +684,7 @@ msgid "" "with them::" msgstr "" "Comme les membres d'une :class:`IntFlag` sont aussi des sous-classes de :class:`int`, ils " -"peuvent être combinés avec eux ::" +"peuvent être combinés avec eux : ::" #: ../Doc/library/enum.rst:651 msgid "Flag" @@ -685,26 +693,26 @@ msgstr "Option" #: ../Doc/library/enum.rst:653 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." +"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 :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 la valeur " +"d'utiliser :class:`auto` comme valeur et de laisser :class:`Flag` choisir une valeur " "appropriée." #: ../Doc/library/enum.rst:662 msgid "" -"Like :class:`IntFlag`, if a combination of :class:`Flag` members results in no flags " -"being set, the boolean evaluation is :data:`False`::" +"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 de :class:`Flag` n'active " -"aucune option, l'évaluation booléenne de la comparaison est :data:`False`::" +"aucune option, l'évaluation booléenne de la comparaison est :data:`False` : ::" #: ../Doc/library/enum.rst:676 msgid "" @@ -712,7 +720,7 @@ msgid "" "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 ::" +"mais pas les combinaisons : ::" #: ../Doc/library/enum.rst:688 msgid "Giving a name to the \"no flags set\" condition does not change its boolean value::" @@ -722,19 +730,19 @@ msgstr "" #: ../Doc/library/enum.rst:704 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 " +"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` and :class:" "`Flag` pour écrire du code nouveau, car :class:`IntEnum` and :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` and :class:" -"`IntFlag` ne doivent être utilisées que dans les cas où :class:`Enum` and :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." +"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` and :class:`IntFlag` " +"ne doivent être utilisées que dans les cas où :class:`Enum` and :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." #: ../Doc/library/enum.rst:714 msgid "Others" @@ -745,40 +753,51 @@ 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` module, it would be very " -"simple to implement independently::" +"Bien que :class:`IntEnum` fasse partie du module :mod:`enum`, elle serait très simple à " +"implémenter hors de ce module : ::" #: ../Doc/library/enum.rst:722 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 class:" -"`StrEnum` qui dérive de :class:`str` au lieu d':class:`int`." +"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`." #: ../Doc/library/enum.rst:725 msgid "Some rules:" -msgstr "Quelques règles :" +msgstr "Quelques règles :" #: ../Doc/library/enum.rst:727 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." #: ../Doc/library/enum.rst:730 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 data type such " -"as :class:`int` or :class:`str`." +"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 data type such as :" +"class:`int` or :class:`str`." msgstr "" +"Même si une classe :class:`Enum` peut avoir des membres de n'importe quel type, dès lors " +"qu'un type de mélange est ajouté, tous les membres doivent être de ce type, p. ex. :class:" +"`int` ci-dessus. Cette restriction ne s'applique pas aux types de mélange qui ne font " +"qu'ajouter des méthodes et ne définissent pas de type de données, tels :class:`int` ou :" +"class:`str`. (???)." #: ../Doc/library/enum.rst:735 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." #: ../Doc/library/enum.rst:738 msgid "" @@ -786,6 +805,10 @@ msgid "" "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." #: ../Doc/library/enum.rst:741 msgid "" @@ -793,6 +816,10 @@ msgid "" "use the mixed-in type's :meth:`__format__`. If the :class:`Enum` class's :func:`str` or :" "func:`repr` is desired, use the `!s` or `!r` format codes." msgstr "" +":ref:`Chaînes de caractères formatées littérales ` : (???) :meth:`str.format`, " +"et :func:`format` appellent la méthode :meth:`__format__` du type de mélange. Pour " +"appeler les fonctions :func:`str` ou :func:`repr` de la classe :class:`Enum`, il faut " +"utiliser les codes de formatage `!s` ou `!r`." #: ../Doc/library/enum.rst:748 msgid "Interesting examples" @@ -800,10 +827,10 @@ msgstr "Exemples intéressants" #: ../Doc/library/enum.rst:750 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." +"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 " @@ -820,7 +847,7 @@ msgid "" "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, simple, d'énumération :" +"plusieurs façons de définir ce type, d'énumération simple :" #: ../Doc/library/enum.rst:762 msgid "use instances of :class:`auto` for the value" @@ -849,8 +876,8 @@ msgid "" "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." +"d'importance. Cela permet aussi d'ajouter, de supprimer ou de ré-ordonner les membres sans " +"avoir à ré-énumérer les membres existants." #: ../Doc/library/enum.rst:772 msgid "" @@ -858,7 +885,7 @@ msgid "" "(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) ::" +"les valeurs (pas importantes de toute façon) : ::" #: ../Doc/library/enum.rst:782 msgid "Using :class:`auto`" @@ -866,7 +893,7 @@ msgstr "Utiliser :class:`auto`" #: ../Doc/library/enum.rst:784 msgid "Using :class:`auto` would look like::" -msgstr "On utilise :class:`auto` de la manière suivante ::" +msgstr "On utilise :class:`auto` de la manière suivante : ::" #: ../Doc/library/enum.rst:796 msgid "Using :class:`object`" @@ -874,7 +901,7 @@ msgstr "Utiliser :class:`object`" #: ../Doc/library/enum.rst:798 msgid "Using :class:`object` would look like::" -msgstr "On utilise :class:`object` de la manière suivante ::" +msgstr "On utilise :class:`object` de la manière suivante : ::" #: ../Doc/library/enum.rst:810 msgid "Using a descriptive string" @@ -882,7 +909,7 @@ msgstr "Utiliser une chaîne de caractères de description" #: ../Doc/library/enum.rst:812 msgid "Using a string as the value would look like::" -msgstr "On utilise une chaîne de caractères de la manière suivante ::" +msgstr "On utilise une chaîne de caractères de la manière suivante : ::" #: ../Doc/library/enum.rst:826 msgid "Using a custom :meth:`__new__`" @@ -890,17 +917,17 @@ msgstr "Utiliser une méthode ad-hoc :meth:`__new__`" #: ../Doc/library/enum.rst:828 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 ::" +msgstr "On utilise une méthode :meth:`__new__` d'énumération de la manière suivante : ::" #: ../Doc/library/enum.rst:850 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." +"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'enum ; " -"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." +"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." #: ../Doc/library/enum.rst:856 msgid "OrderedEnum" @@ -911,9 +938,9 @@ 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 respecte les " -"invariants standards de :class:`Enum` (par exemple interdire les comparaisons avec " -"d'autre énumérations) ::" +"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) ::" #: ../Doc/library/enum.rst:892 msgid "DuplicateFreeEnum" @@ -921,7 +948,7 @@ msgstr "DuplicateFreeEnum" #: ../Doc/library/enum.rst:894 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 ::" +msgstr "Lève une erreur si un membre est dupliqué, plutôt que de créer un alias : ::" #: ../Doc/library/enum.rst:919 msgid "" @@ -929,9 +956,9 @@ msgid "" "disallowing aliases. If the only desired change is disallowing aliases, the :func:" "`unique` decorator can be used instead." msgstr "" -"C'est une exemple utile d'héritage de Enum pour ajouter ou modifier des comportements, en " -"plus d'interdire les alias. Pour uniquement interdire les alias, il suffit d'utiliser le " -"décorateur :func:`unique`." +"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`." #: ../Doc/library/enum.rst:925 msgid "Planet" @@ -942,8 +969,8 @@ 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'enum sera " -"passée à ces méthodes ::" +"Si :meth:`__new__` ou :meth:`__init__` sont définies, la valeur du membre de l'énumération " +"sera passée à ces méthodes : ::" #: ../Doc/library/enum.rst:955 msgid "TimePeriod" @@ -951,21 +978,23 @@ msgstr "TimePeriod" #: ../Doc/library/enum.rst:957 msgid "An example to show the :attr:`_ignore_` attribute in use::" -msgstr "Exemple d'utilisation de l'attribut :attr:`_ignore_` ::" +msgstr "Exemple d'utilisation de l'attribut :attr:`_ignore_` : ::" #: ../Doc/library/enum.rst:974 msgid "How are Enums different?" -msgstr "Pourquoi les Enums sont différentes ?" +msgstr "En quoi les *Enums* sont différentes ?" #: ../Doc/library/enum.rst:976 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 leur instances (membres)." #: ../Doc/library/enum.rst:981 msgid "Enum Classes" -msgstr "" +msgstr "Classes *Enum*" #: ../Doc/library/enum.rst:983 msgid "" @@ -976,32 +1005,45 @@ msgid "" "the final :class:`Enum` class are correct (such as :meth:`__new__`, :meth:" "`__getnewargs__`, :meth:`__str__` and :meth:`__repr__`)." msgstr "" +"La métaclass :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__`)." #: ../Doc/library/enum.rst:993 msgid "Enum Members (aka instances)" -msgstr "" +msgstr "Membres d'Enum (c.-à-d. instances)" #: ../Doc/library/enum.rst:995 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." +"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." #: ../Doc/library/enum.rst:1003 msgid "Finer Points" -msgstr "" +msgstr "Aspects approfondis" #: ../Doc/library/enum.rst:1006 msgid "Supported ``__dunder__`` names" -msgstr "" +msgstr "Noms de la forme ``__dunder__`` disponibles" #: ../Doc/library/enum.rst:1008 msgid "" -":attr:`__members__` is an :class:`OrderedDict` of ``member_name``:``member`` items. It " -"is only available on the class." +":attr:`__members__` is an :class:`OrderedDict` of ``member_name``:``member`` items. It is " +"only available on the class." msgstr "" +":attr:`__members__` est une :class:`OrderedDict` de correspondances " +"``nom_du_membre`` / ``membre``. Elle n'est disponible que depuis la classe." #: ../Doc/library/enum.rst:1011 msgid "" @@ -1009,48 +1051,61 @@ msgid "" "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." #: ../Doc/library/enum.rst:1017 msgid "Supported ``_sunder_`` names" -msgstr "" +msgstr "Noms de la forme ``_sunder_`` disponibles" #: ../Doc/library/enum.rst:1019 msgid "``_name_`` -- name of the member" -msgstr "" +msgstr "``_name_`` -- nom du membre" #: ../Doc/library/enum.rst:1020 msgid "``_value_`` -- value of the member; can be set / modified in ``__new__``" -msgstr "" +msgstr "``_value_`` -- valeur du membre ; peut être accédé ou mué dans ``__new__``" #: ../Doc/library/enum.rst:1022 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" #: ../Doc/library/enum.rst:1024 msgid "" "``_ignore_`` -- a list of names, either as a :func:`list` or a :func:`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 de :func:`list` ou de :func:`str`, " +"(func ?????) qui ne seront pas transformés en membres, et seront supprimés de la classe " +"résultante" #: ../Doc/library/enum.rst:1027 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)" #: ../Doc/library/enum.rst:1029 msgid "" "``_generate_next_value_`` -- used by the `Functional API`_ and by :class:`auto` to get an " "appropriate value for an enum member; may be overridden" msgstr "" +"``_generate_next_value_`` -- (??? une fonction) 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" #: ../Doc/library/enum.rst:1033 msgid "``_missing_``, ``_order_``, ``_generate_next_value_``" -msgstr "" +msgstr "``_missing_``, ``_order_``, ``_generate_next_value_``" #: ../Doc/library/enum.rst:1034 msgid "``_ignore_``" -msgstr "" +msgstr "``_ignore_``" #: ../Doc/library/enum.rst:1036 msgid "" @@ -1058,16 +1113,22 @@ msgid "" "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 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 : ::" #: ../Doc/library/enum.rst:1052 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 \n" +"être enregistré." #: ../Doc/library/enum.rst:1056 msgid "``Enum`` member type" -msgstr "" +msgstr "Type des membres de ``Enum``" #: ../Doc/library/enum.rst:1058 msgid "" @@ -1077,10 +1138,16 @@ msgid "" "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) : ::" #: ../Doc/library/enum.rst:1079 msgid "Boolean value of ``Enum`` classes and members" -msgstr "" +msgstr "Valeur booléenne des classes ``Enum`` et de leurs membres" #: ../Doc/library/enum.rst:1081 msgid "" @@ -1089,27 +1156,38 @@ msgid "" "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és 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 : ::" #: ../Doc/library/enum.rst:1090 msgid ":class:`Enum` classes always evaluate as :data:`True`." -msgstr "" +msgstr "Les classes :class:`Enum` valent toujours :data:`True`." #: ../Doc/library/enum.rst:1094 msgid "``Enum`` classes with methods" -msgstr "" +msgstr "Classes ``Enum`` avec des méthodes" #: ../Doc/library/enum.rst:1096 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 : ::" #: ../Doc/library/enum.rst:1107 msgid "Combining members of ``Flag``" -msgstr "" +msgstr "Combinaison de membres de ``Flag``" #: ../Doc/library/enum.rst:1109 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 : ::" From eeef49a39bf84b49e890fe8abc9bb04bc2bd0cee Mon Sep 17 00:00:00 2001 From: awecx Date: Wed, 24 Jul 2019 09:06:13 +0200 Subject: [PATCH 03/12] Corrige indentation --- library/enum.po | 1086 ++++++++++++++++++++++++++--------------------- 1 file changed, 594 insertions(+), 492 deletions(-) diff --git a/library/enum.po b/library/enum.po index 0f9ef9942..d600584fa 100644 --- a/library/enum.po +++ b/library/enum.po @@ -25,13 +25,14 @@ msgstr "**Code source :** :source:`Lib/enum.py`" #: ../Doc/library/enum.rst:18 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." +"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 entre " -"eux et il est possible d'itérer sur l'énumération elle-même." +"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 entre eux et il est possible d'itérer sur " +"l'énumération elle-même." #: ../Doc/library/enum.rst:24 msgid "Module Contents" @@ -39,58 +40,64 @@ msgstr "Contenu du module" #: ../Doc/library/enum.rst:26 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`." +"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 permettend 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`." +"Ce module définit quatre classes d'énumération qui permettend 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`." #: ../Doc/library/enum.rst:33 msgid "" -"Base class for creating enumerated constants. See section `Functional API`_ for an " -"alternate construction syntax." +"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." +"Classe de base pour créer une énumération de constantes. Voir la section " +"`API par fonction`_ pour une syntaxe alternative de construction." #: ../Doc/library/enum.rst:38 msgid "" -"Base class for creating enumerated constants that are also subclasses of :class:`int`." +"Base class for creating enumerated constants that are also subclasses of :" +"class:`int`." msgstr "" -"Classe de base pour créer une énumération de constantes qui sont également des sous-" -"classes de :class:`int`." +"Classe de base pour créer une énumération de constantes qui sont également " +"des sous-classes de :class:`int`." #: ../Doc/library/enum.rst:43 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`." +"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`." 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`." +"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`." #: ../Doc/library/enum.rst:49 msgid "" -"Base class for creating enumerated constants that can be combined using the bitwise " -"operations without losing their :class:`Flag` membership." +"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`." +"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`." #: ../Doc/library/enum.rst:54 -msgid "Enum class decorator that ensures only one name is bound to any one value." +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." +"Décorateur de classe qui garantit qu'une valeur ne puisse être associée qu'à " +"un seul nom." #: ../Doc/library/enum.rst:58 msgid "Instances are replaced with an appropriate value for Enum members." msgstr "" -"Les instances de cette classe remplacent les membres d'une *Enum* par une valeur " -"appropriée." +"Les instances de cette classe remplacent les membres d'une *Enum* par une " +"valeur appropriée." #: ../Doc/library/enum.rst:60 msgid "``Flag``, ``IntFlag``, ``auto``" @@ -102,13 +109,15 @@ msgstr "Création d'une *Enum*" #: ../Doc/library/enum.rst:66 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::" +"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 sous-classer :class:`Enum` de la manière suivante : ::" +"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 sous-classer :class:`Enum` " +"de la manière suivante : ::" #: ../Doc/library/enum.rst:78 msgid "Enum member values" @@ -116,14 +125,15 @@ msgstr "Valeurs des membres d'une *Enum*" #: ../Doc/library/enum.rst:80 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." +"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." +"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." #: ../Doc/library/enum.rst:85 msgid "Nomenclature" @@ -135,28 +145,29 @@ msgstr "La classe :class:`Color` est une *énumeration* (ou un *enum*)." #: ../Doc/library/enum.rst:88 msgid "" -"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are *enumeration members* (or " -"*enum members*) and are functionally constants." +"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are " +"*enumeration members* (or *enum 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." +"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." #: ../Doc/library/enum.rst:90 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.)" +"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." +"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." #: ../Doc/library/enum.rst:96 msgid "" -"Even though we use the :keyword:`class` syntax to create Enums, Enums are not normal " -"Python classes. See `How are Enums different?`_ for more details." +"Even though we use the :keyword:`class` syntax to create Enums, Enums are " +"not normal Python classes. See `How are Enums different?`_ for more details." msgstr "" -"Même si on utilise la syntaxe en :keyword:`class` pour créer des enums, les *Enums* ne " -"sont pas des vraies classes Python. Voir `En quoi les Enums sont différentes ?`_ pour plus " -"de détails." +"Même si on utilise la syntaxe en :keyword:`class` pour créer des enums, les " +"*Enums* ne sont pas des vraies classes Python. Voir `En quoi les Enums sont " +"différentes ?`_ pour plus de détails." #: ../Doc/library/enum.rst:100 msgid "Enumeration members have human readable string representations::" @@ -170,7 +181,8 @@ msgstr "… tandis que leur ``repr`` contient plus d'informations : ::" #: ../Doc/library/enum.rst:110 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 : ::" +msgstr "" +"Le *type* d'un membre est l'énumération auquel ce membre appartient : ::" #: ../Doc/library/enum.rst:118 msgid "Enum members also have a property that contains just their item name::" @@ -179,14 +191,16 @@ msgstr "Les membres ont également un attribut qui contient leur nom : ::" #: ../Doc/library/enum.rst:123 msgid "Enumerations support iteration, 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 : ::" +"Les énumérations sont itérables, l'ordre d'itération est celui dans lequel " +"les membres sont déclarés : ::" #: ../Doc/library/enum.rst:139 -msgid "Enumeration members are hashable, so they can be used in dictionaries and sets::" +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 ::" +"Les membres d'une énumération sont hachables, ils peuvent ainsi être " +"utilisés dans des dictionnaires ou des ensembles ::" #: ../Doc/library/enum.rst:149 msgid "Programmatic access to enumeration members and their attributes" @@ -194,17 +208,19 @@ msgstr "Accès dynamique aux membres et à leurs attributs" #: ../Doc/library/enum.rst:151 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::" +"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 : ::" +"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 : ::" #: ../Doc/library/enum.rst:160 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 : ::" +msgstr "" +"Pour accéder aux membres par leur *nom*, utilisez l'accès par indexation : ::" #: ../Doc/library/enum.rst:167 msgid "If you have an enum member and need its :attr:`name` or :attr:`value`::" @@ -216,26 +232,30 @@ msgstr "Duplication de membres et de valeurs" #: ../Doc/library/enum.rst:179 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 une *enum* : ::" +msgstr "" +"Il n'est pas possible d'avoir deux membres du même nom dans une *enum* : ::" #: ../Doc/library/enum.rst:189 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::" +"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 : ::" +"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 : ::" #: ../Doc/library/enum.rst:209 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." +"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." +"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." #: ../Doc/library/enum.rst:215 msgid "Ensuring unique enumeration values" @@ -243,23 +263,24 @@ msgstr "Coercition d'unicité des valeurs d'une énumération" #: ../Doc/library/enum.rst:217 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:" +"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 pour s'assurer que chaque " -"valeur n'est utilisée qu'une seule fois au sein de l'énumération : ::" +"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 pour s'assurer que chaque valeur n'est utilisée qu'une seule fois " +"au sein de l'énumération : ::" #: ../Doc/library/enum.rst:223 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::" +"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 : ::" +"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 : ::" #: ../Doc/library/enum.rst:241 msgid "Using automatic values" @@ -267,23 +288,27 @@ msgstr "Valeurs automatiques" #: ../Doc/library/enum.rst:243 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` : ::" +msgstr "" +"Si la valeur exacte n'a pas d'importance, vous pouvez utiliser :class:" +"`auto` : ::" #: ../Doc/library/enum.rst:254 -msgid "The values are chosen by :func:`_generate_next_value_`, which can be overridden::" +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 : ::" +"Les valeurs sont déterminées par :func:`_generate_next_value_`, qui peut " +"être redéfinie : ::" #: ../Doc/library/enum.rst:272 msgid "" -"The goal of the default :meth:`_generate_next_value_` methods 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." +"The goal of the default :meth:`_generate_next_value_` methods 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 par défaut :meth:`_generate_next_value_` doit fournir le :class:`int` suivant " -"de la séquence en fonction du dernier :class:`int` fourni, mais la séquence générée dépend " -"de l'implémentation Python." +"La méthode par défaut :meth:`_generate_next_value_` doit fournir le :class:" +"`int` suivant de la séquence en fonction du dernier :class:`int` fourni, " +"mais la séquence générée dépend de l'implémentation Python." #: ../Doc/library/enum.rst:277 msgid "Iteration" @@ -291,23 +316,26 @@ msgstr "Itération" #: ../Doc/library/enum.rst:279 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 : ::" +msgstr "" +"Itérer sur les membres d'une énumération ne parcourt pas les alias : ::" #: ../Doc/library/enum.rst:284 msgid "" -"The special attribute ``__members__`` is an ordered dictionary mapping names to members. " -"It includes all names defined in the enumeration, including the aliases::" +"The special attribute ``__members__`` is an ordered dictionary mapping names " +"to members. It includes all names defined in the enumeration, including the " +"aliases::" msgstr "" -"L'attribut spécial ``__members__`` est un dictionnaire ordonné qui fait correspondre les " -"noms aux membres. Il inclut tous les noms définis dans l'énumération, alias compris : ::" +"L'attribut spécial ``__members__`` est un dictionnaire ordonné qui fait " +"correspondre les noms aux membres. Il inclut tous les noms définis dans " +"l'énumération, alias compris : ::" #: ../Doc/library/enum.rst:296 msgid "" -"The ``__members__`` attribute can be used for detailed programmatic access to the " -"enumeration members. For example, finding all the aliases::" +"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 : ::" +"L'attribut ``__members__`` peut servir à accéder dynamiquement aux membres " +"de l'énumération. Par exemple, pour trouver tous les alias : ::" #: ../Doc/library/enum.rst:304 msgid "Comparisons" @@ -319,11 +347,12 @@ msgstr "Les membres d'une énumération sont comparés par identité : ::" #: ../Doc/library/enum.rst:315 msgid "" -"Ordered comparisons between enumeration values are *not* supported. Enum members are not " -"integers (but see `IntEnum`_ below)::" +"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'une *enum* ne sont pas des entiers (voir cependant `IntEnum`_ ci-dessous) : ::" +"Les comparaisons d'ordre entre les valeurs d'une énumération n'existent " +"*pas* ; les membres d'une *enum* ne sont pas des entiers (voir cependant " +"`IntEnum`_ ci-dessous) : ::" #: ../Doc/library/enum.rst:323 msgid "Equality comparisons are defined though::" @@ -331,12 +360,13 @@ msgstr "A contrario, les comparaisons d'égalité existent : ::" #: ../Doc/library/enum.rst:332 msgid "" -"Comparisons against non-enumeration values will always compare not equal (again, :class:" -"`IntEnum` was explicitly designed to behave differently, see below)::" +"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) : ::" +"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) : ::" #: ../Doc/library/enum.rst:341 msgid "Allowed members and attributes of enumerations" @@ -344,24 +374,27 @@ msgstr "Membres et attributs autorisés dans une énumération" #: ../Doc/library/enum.rst:343 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." +"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." +"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." #: ../Doc/library/enum.rst:349 msgid "" -"Enumerations are Python classes, and can have methods and special methods as usual. If we " -"have this enumeration::" +"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 : ::" +"Les énumérations sont des classes Python (??????????????????), et peuvent " +"donc avoir des méthodes et des méthodes spéciales. L'énumération " +"suivante : ::" #: ../Doc/library/enum.rst:369 msgid "Then::" @@ -369,28 +402,30 @@ msgstr "amène : ::" #: ../Doc/library/enum.rst:378 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_`." +"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_`." #: ../Doc/library/enum.rst:385 msgid "" -"Note: if your enumeration defines :meth:`__new__` and/or :meth:`__init__` then whatever " -"value(s) were given to the enum member will be passed into those methods. See `Planet`_ " -"for an example." +"Note: if your enumeration defines :meth:`__new__` and/or :meth:`__init__` " +"then whatever value(s) were given to the enum member will be passed into " +"those methods. See `Planet`_ for an example." msgstr "" -"Remarque : si l'énumération définit :meth:`__new__` and/or :meth:`__init__`, alors " -"(double ????) la (ou les) valeur affectée au membre sera passée à ces méthodes. Voir " -"l'exemple de `Planet`_." +"Remarque : si l'énumération définit :meth:`__new__` and/or :meth:`__init__`, " +"alors (double ????) la (ou les) valeur affectée au membre sera passée à ces " +"méthodes. Voir l'exemple de `Planet`_." #: ../Doc/library/enum.rst:391 msgid "Restricted Enum subclassing" @@ -398,21 +433,22 @@ msgstr "Restrictions sur l'héritage" #: ../Doc/library/enum.rst:393 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::" +"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 : ::" +"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 : ::" #: ../Doc/library/enum.rst:400 msgid "" -"Also, subclassing an enumeration is allowed only if the enumeration does not define any " -"members. So this is forbidden::" +"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é : ::" +"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é : ::" #: ../Doc/library/enum.rst:410 msgid "But this is allowed::" @@ -420,14 +456,15 @@ msgstr "Mais celui-ci est correct : ::" #: ../Doc/library/enum.rst:421 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.)" +"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 `OrderedEnum`_ pour exemple)." +"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 " +"`OrderedEnum`_ pour exemple)." #: ../Doc/library/enum.rst:428 msgid "Pickling" @@ -439,104 +476,117 @@ msgstr "Les énumérations peuvent être sérialisées et dé-sérialisées : : #: ../Doc/library/enum.rst:437 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." +"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ées dans l'espace de nom de haut niveau du module car la dé-" -"sérialisation nécessite que ces *enums* puissent être importées depuis ce module." +"Les restrictions habituelles de sérialisation s'appliquent : les *enums* à " +"sérialiser doivent être déclarées dans l'espace de nom de haut niveau du " +"module car la dé-sérialisation nécessite que ces *enums* puissent être " +"importées depuis ce module." #: ../Doc/library/enum.rst:443 msgid "" -"With pickle protocol version 4 it is possible to easily pickle enums nested in other " -"classes." +"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ées dans d'autres classes." +"Depuis la version 4 du protocole de *pickle*, il est possible de sérialiser " +"facilement des *enums* imbriquées dans d'autres classes." #: ../Doc/library/enum.rst:446 msgid "" -"It is possible to modify how Enum members are pickled/unpickled by defining :meth:" -"`__reduce_ex__` in the enumeration class." +"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." +"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." #: ../Doc/library/enum.rst:451 msgid "Functional API" msgstr "API par fonction" #: ../Doc/library/enum.rst:453 -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 :class:`Enum` class is callable, providing the following functional API::" +msgstr "" +"La :class:`Enum` est appelable et implémente l'API par fonction suivante : ::" #: ../Doc/library/enum.rst:465 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." +"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." +"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." #: ../Doc/library/enum.rst:468 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 des noms séparés par des espaces, une séquence de noms, une séquence " -"de duets clé / valeur ou une correspondance (p. ex. un dictionnaire) entre noms et " -"valeurs. 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 à : ::" +"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 des noms séparés par des espaces, une " +"séquence de noms, une séquence de duets clé / valeur ou une correspondance " +"(p. ex. un dictionnaire) entre noms et valeurs. 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 à : ::" #: ../Doc/library/enum.rst:484 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``." +"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``." +"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``." #: ../Doc/library/enum.rst:488 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éés 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 oy Jython). La solution consiste à préciser explicitement le nom du module " +"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éés 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 oy " +"Jython). La solution consiste à préciser explicitement le nom du module " "comme ceci : ::" #: ../Doc/library/enum.rst:498 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." +"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 non-sérialisables (?????) ; ." +"Si ``module`` n'est pas fourni et que *Enum* ne peut pas le deviner, les " +"nouveaux membres de l' *Enum* ne seront pas non-sérialisables (?????) ; ." #: ../Doc/library/enum.rst:502 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::" +"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 : ::" +"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 : ::" #: ../Doc/library/enum.rst:509 msgid "The complete signature is::" @@ -556,11 +606,12 @@ msgstr "names" #: ../Doc/library/enum.rst:515 msgid "" -"The Enum members. This can be a whitespace or comma separated string (values will start " -"at 1 unless otherwise specified)::" +"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) : ::" +"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) : ::" #: ../Doc/library/enum.rst:520 msgid "or an iterator of names::" @@ -620,26 +671,30 @@ msgstr "IntEnum" #: ../Doc/library/enum.rst:550 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::" +"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ération entières de type différent sont " -"possibles : ::" +"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ération entières de type différent sont possibles : ::" #: ../Doc/library/enum.rst:571 -msgid "However, they still can't be compared to standard :class:`Enum` enumerations::" +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` : ::" +"Elles ne peuvent cependant toujours pas être comparées à des énumérations " +"standards de :class:`Enum` : ::" #: ../Doc/library/enum.rst:584 -msgid ":class:`IntEnum` values behave like integers in other ways you'd expect::" +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 : ::" +"Les valeurs de :class:`IntEnum` se comportent comme des entiers, comme on " +"pouvait s'y attendre : ::" #: ../Doc/library/enum.rst:595 msgid "IntFlag" @@ -647,20 +702,23 @@ msgstr "IntFlag" #: ../Doc/library/enum.rst:597 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 :class:" -"`IntFlag` sont aussi des sous-classes de :class:`int` et peuvent être utilisés là où un :" -"class:`int` est utilisé. Toute opération sur un membre d'une :class:`IntFlag`, autre qu'un " -"opérateur bit-à-bit lui fait perdre sa qualité de :class:`IntFlag`." +"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 :class:`IntFlag` sont " +"aussi des sous-classes de :class:`int` et peuvent être utilisés là où un :" +"class:`int` est utilisé. Toute opération sur un membre d'une :class:" +"`IntFlag`, autre qu'un opérateur bit-à-bit lui fait perdre sa qualité de :" +"class:`IntFlag`." #: ../Doc/library/enum.rst:607 msgid "Sample :class:`IntFlag` class::" @@ -672,19 +730,21 @@ msgstr "Il est aussi possible de nommer les combinaisons : ::" #: ../Doc/library/enum.rst:635 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`::" +"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` : ::" +"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` : ::" #: ../Doc/library/enum.rst:643 msgid "" -"Because :class:`IntFlag` members are also subclasses of :class:`int` they can be combined " -"with them::" +"Because :class:`IntFlag` members are also subclasses of :class:`int` they " +"can be combined with them::" msgstr "" -"Comme les membres d'une :class:`IntFlag` sont aussi des sous-classes de :class:`int`, ils " -"peuvent être combinés avec eux : ::" +"Comme les membres d'une :class:`IntFlag` sont aussi des sous-classes de :" +"class:`int`, ils peuvent être combinés avec eux : ::" #: ../Doc/library/enum.rst:651 msgid "Flag" @@ -692,57 +752,66 @@ msgstr "Option" #: ../Doc/library/enum.rst:653 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 :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." +"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 :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." #: ../Doc/library/enum.rst:662 msgid "" -"Like :class:`IntFlag`, if a combination of :class:`Flag` members results in no flags being " -"set, the boolean evaluation is :data:`False`::" +"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 de :class:`Flag` n'active " -"aucune option, l'évaluation booléenne de la comparaison est :data:`False` : ::" +"Comme avec :class:`IntFlag`, si une combinaison de membres de :class:`Flag` " +"n'active aucune option, l'évaluation booléenne de la comparaison est :data:" +"`False` : ::" #: ../Doc/library/enum.rst:676 msgid "" -"Individual flags should have values that are powers of two (1, 2, 4, 8, ...), while " -"combinations of flags won't::" +"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 : ::" +"Les options de base doivent avoir des puissances de deux pour valeurs (1, 2, " +"4, 8, ...) mais pas les combinaisons : ::" #: ../Doc/library/enum.rst:688 -msgid "Giving a name to the \"no flags set\" condition does not change its boolean value::" +msgid "" +"Giving a name to the \"no flags set\" condition does not change its boolean " +"value::" msgstr "" -"Donner un nom à la valeur \"aucun option activée\" ne change pas sa valeur booléenne ::" +"Donner un nom à la valeur \"aucun option activée\" ne change pas sa valeur " +"booléenne ::" #: ../Doc/library/enum.rst:704 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` and :class:" -"`Flag` pour écrire du code nouveau, car :class:`IntEnum` and :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` and :class:`IntFlag` " -"ne doivent être utilisées que dans les cas où :class:`Enum` and :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." +"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` and :class:`Flag` pour écrire du code nouveau, car :class:`IntEnum` " +"and :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` and :class:" +"`IntFlag` ne doivent être utilisées que dans les cas où :class:`Enum` and :" +"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." #: ../Doc/library/enum.rst:714 msgid "Others" @@ -750,19 +819,21 @@ msgstr "Autres" #: ../Doc/library/enum.rst:716 msgid "" -"While :class:`IntEnum` is part of the :mod:`enum` module, it would be very simple to " -"implement independently::" +"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 : ::" +"Bien que :class:`IntEnum` fasse partie du module :mod:`enum`, elle serait " +"très simple à implémenter hors de ce module : ::" #: ../Doc/library/enum.rst:722 msgid "" -"This demonstrates how similar derived enumerations can be defined; for example a :class:" -"`StrEnum` that mixes in :class:`str` instead of :class:`int`." +"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`." +"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`." #: ../Doc/library/enum.rst:725 msgid "Some rules:" @@ -770,56 +841,62 @@ msgstr "Quelques règles :" #: ../Doc/library/enum.rst:727 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." +"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." +"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." #: ../Doc/library/enum.rst:730 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 data type such as :" -"class:`int` or :class:`str`." +"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 data type such as :class:`int` or :class:" +"`str`." msgstr "" -"Même si une classe :class:`Enum` peut avoir des membres de n'importe quel type, dès lors " -"qu'un type de mélange est ajouté, tous les membres doivent être de ce type, p. ex. :class:" -"`int` ci-dessus. Cette restriction ne s'applique pas aux types de mélange qui ne font " -"qu'ajouter des méthodes et ne définissent pas de type de données, tels :class:`int` ou :" -"class:`str`. (???)." +"Même si une classe :class:`Enum` peut avoir des membres de n'importe quel " +"type, dès lors qu'un type de mélange est ajouté, tous les membres doivent " +"être de ce type, p. ex. :class:`int` ci-dessus. Cette restriction ne " +"s'applique pas aux types de mélange qui ne font qu'ajouter des méthodes et " +"ne définissent pas de type de données, tels :class:`int` ou :class:`str`. " +"(???)." #: ../Doc/library/enum.rst:735 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." +"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." +"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." #: ../Doc/library/enum.rst:738 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." +"%-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." +"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." #: ../Doc/library/enum.rst:741 msgid "" -":ref:`Formatted string literals `, :meth:`str.format`, and :func:`format` will " -"use the mixed-in type's :meth:`__format__`. If the :class:`Enum` class's :func:`str` or :" -"func:`repr` is desired, use the `!s` or `!r` format codes." +":ref:`Formatted string literals `, :meth:`str.format`, and :func:" +"`format` will use the mixed-in type's :meth:`__format__`. If the :class:" +"`Enum` class's :func:`str` or :func:`repr` is desired, use the `!s` or `!r` " +"format codes." msgstr "" -":ref:`Chaînes de caractères formatées littérales ` : (???) :meth:`str.format`, " -"et :func:`format` appellent la méthode :meth:`__format__` du type de mélange. Pour " -"appeler les fonctions :func:`str` ou :func:`repr` de la classe :class:`Enum`, il faut " -"utiliser les codes de formatage `!s` ou `!r`." +":ref:`Chaînes de caractères formatées littérales ` : (???) :meth:" +"`str.format`, et :func:`format` appellent la méthode :meth:`__format__` du " +"type de mélange. Pour appeler les fonctions :func:`str` ou :func:`repr` de " +"la classe :class:`Enum`, il faut utiliser les codes de formatage `!s` ou `!" +"r`." #: ../Doc/library/enum.rst:748 msgid "Interesting examples" @@ -827,15 +904,16 @@ msgstr "Exemples intéressants" #: ../Doc/library/enum.rst:750 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." +"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." +"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." #: ../Doc/library/enum.rst:757 msgid "Omitting values" @@ -843,11 +921,12 @@ msgstr "Omettre les valeurs" #: ../Doc/library/enum.rst:759 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:" +"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 :" +"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 :" #: ../Doc/library/enum.rst:762 msgid "use instances of :class:`auto` for the value" @@ -863,29 +942,29 @@ msgstr "affecter des chaînes de caractères aux valeurs pour les décrire" #: ../Doc/library/enum.rst:765 msgid "" -"use a tuple as the value and a custom :meth:`__new__` to replace the tuple with an :class:" -"`int` value" +"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`" +"affecter un n-uplet aux valeurs et définir une méthode :meth:`__new__` pour " +"remplacer les n-uplets avec un :class:`int`" #: ../Doc/library/enum.rst:768 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." +"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." +"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." #: ../Doc/library/enum.rst:772 msgid "" -"Whichever method you choose, you should provide a :meth:`repr` that also hides the " -"(unimportant) value::" +"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) : ::" +"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) : ::" #: ../Doc/library/enum.rst:782 msgid "Using :class:`auto`" @@ -917,17 +996,20 @@ msgstr "Utiliser une méthode ad-hoc :meth:`__new__`" #: ../Doc/library/enum.rst:828 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 : ::" +msgstr "" +"On utilise une méthode :meth:`__new__` d'énumération de la manière " +"suivante : ::" #: ../Doc/library/enum.rst:850 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." +"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." +"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." #: ../Doc/library/enum.rst:856 msgid "OrderedEnum" @@ -935,30 +1017,35 @@ msgstr "OrderedEnum" #: ../Doc/library/enum.rst:858 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)::" +"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) ::" +"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) ::" #: ../Doc/library/enum.rst:892 msgid "DuplicateFreeEnum" msgstr "DuplicateFreeEnum" #: ../Doc/library/enum.rst:894 -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 "" +"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 : ::" #: ../Doc/library/enum.rst:919 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." +"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`." +"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`." #: ../Doc/library/enum.rst:925 msgid "Planet" @@ -966,11 +1053,11 @@ msgstr "Planet" #: ../Doc/library/enum.rst:927 msgid "" -"If :meth:`__new__` or :meth:`__init__` is defined the value of the enum member will be " -"passed to those methods::" +"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 : ::" +"Si :meth:`__new__` ou :meth:`__init__` sont définies, la valeur du membre de " +"l'énumération sera passée à ces méthodes : ::" #: ../Doc/library/enum.rst:955 msgid "TimePeriod" @@ -986,11 +1073,11 @@ msgstr "En quoi les *Enums* sont différentes ?" #: ../Doc/library/enum.rst:976 msgid "" -"Enums have a custom metaclass that affects many aspects of both derived Enum classes and " -"their instances (members)." +"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 leur instances (membres)." +"Les *enums* ont une métaclasse spéciale qui affecte de nombreux aspects des " +"classes dérivées de *Enum* et de leur instances (membres)." #: ../Doc/library/enum.rst:981 msgid "Enum Classes" @@ -998,18 +1085,20 @@ msgstr "Classes *Enum*" #: ../Doc/library/enum.rst:983 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étaclass :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:" +"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étaclass :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__`)." #: ../Doc/library/enum.rst:993 @@ -1018,16 +1107,18 @@ msgstr "Membres d'Enum (c.-à-d. instances)" #: ../Doc/library/enum.rst:995 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." +"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." +"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." #: ../Doc/library/enum.rst:1003 msgid "Finer Points" @@ -1039,21 +1130,22 @@ msgstr "Noms de la forme ``__dunder__`` disponibles" #: ../Doc/library/enum.rst:1008 msgid "" -":attr:`__members__` is an :class:`OrderedDict` of ``member_name``:``member`` items. It is " -"only available on the class." +":attr:`__members__` is an :class:`OrderedDict` of ``member_name``:``member`` " +"items. It is only available on the class." msgstr "" ":attr:`__members__` est une :class:`OrderedDict` de correspondances " "``nom_du_membre`` / ``membre``. Elle n'est disponible que depuis la classe." #: ../Doc/library/enum.rst:1011 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." +":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." +"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." #: ../Doc/library/enum.rst:1017 msgid "Supported ``_sunder_`` names" @@ -1064,40 +1156,46 @@ msgid "``_name_`` -- name of the member" msgstr "``_name_`` -- nom du membre" #: ../Doc/library/enum.rst:1020 -msgid "``_value_`` -- value of the member; can be set / modified in ``__new__``" -msgstr "``_value_`` -- valeur du membre ; peut être accédé ou mué dans ``__new__``" +msgid "" +"``_value_`` -- value of the member; can be set / modified in ``__new__``" +msgstr "" +"``_value_`` -- valeur du membre ; peut être accédé ou mué dans ``__new__``" #: ../Doc/library/enum.rst:1022 -msgid "``_missing_`` -- a lookup function used when a value is not found; may be overridden" +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" +"``_missing_`` -- une fonction de recherche qui est appelée quand la valeur " +"n'est pas trouvée ; elle peut être redéfinie" #: ../Doc/library/enum.rst:1024 msgid "" -"``_ignore_`` -- a list of names, either as a :func:`list` or a :func:`str`, that will not " -"be transformed into members, and will be removed from the final class" +"``_ignore_`` -- a list of names, either as a :func:`list` or a :func:`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 de :func:`list` ou de :func:`str`, " -"(func ?????) qui ne seront pas transformés en membres, et seront supprimés de la classe " -"résultante" +"``_ignore_`` -- une liste de noms, sous la forme de :func:`list` ou de :func:" +"`str`, (func ?????) qui ne seront pas transformés en membres, et seront " +"supprimés de la classe résultante" #: ../Doc/library/enum.rst:1027 msgid "" -"``_order_`` -- used in Python 2/3 code to ensure member order is consistent (class " -"attribute, removed during class creation)" +"``_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)" +"``_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)" #: ../Doc/library/enum.rst:1029 msgid "" -"``_generate_next_value_`` -- used by the `Functional API`_ and by :class:`auto` to get an " -"appropriate value for an enum member; may be overridden" +"``_generate_next_value_`` -- used by the `Functional API`_ and by :class:" +"`auto` to get an appropriate value for an enum member; may be overridden" msgstr "" -"``_generate_next_value_`` -- (??? une fonction) 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" +"``_generate_next_value_`` -- (??? une fonction) 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" #: ../Doc/library/enum.rst:1033 msgid "``_missing_``, ``_order_``, ``_generate_next_value_``" @@ -1109,21 +1207,21 @@ msgstr "``_ignore_``" #: ../Doc/library/enum.rst:1036 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::" +"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 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 : ::" +"Pour faciliter la transition de Python 2 en Python 3, l'attribut 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 : ::" #: ../Doc/library/enum.rst:1052 msgid "" -"In Python 2 code the :attr:`_order_` attribute is necessary as definition order is lost " -"before it can be recorded." +"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 \n" +"En Python 2, l'attribut :attr:`_order_` est indispensable car l'ordre de la " +"définition est perdu avant de pouvoir \n" "être enregistré." #: ../Doc/library/enum.rst:1056 @@ -1132,17 +1230,19 @@ msgstr "Type des membres de ``Enum``" #: ../Doc/library/enum.rst:1058 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 " +":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) : ::" #: ../Doc/library/enum.rst:1079 @@ -1151,16 +1251,17 @@ msgstr "Valeur booléenne des classes ``Enum`` et de leurs membres" #: ../Doc/library/enum.rst:1081 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::" +":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és 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 : ::" +"Les membres d'une classe :class:`Enum` mélangés 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 : ::" #: ../Doc/library/enum.rst:1090 msgid ":class:`Enum` classes always evaluate as :data:`True`." @@ -1172,12 +1273,13 @@ msgstr "Classes ``Enum`` avec des méthodes" #: ../Doc/library/enum.rst:1096 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::" +"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 : ::" +"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 : ::" #: ../Doc/library/enum.rst:1107 msgid "Combining members of ``Flag``" @@ -1185,9 +1287,9 @@ msgstr "Combinaison de membres de ``Flag``" #: ../Doc/library/enum.rst:1109 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::" +"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 : ::" +"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 : ::" From e06088cb4a15157243a3c37614605079dc5b8e0e Mon Sep 17 00:00:00 2001 From: awecx Date: Fri, 26 Jul 2019 19:17:32 +0200 Subject: [PATCH 04/12] modifs finales --- library/enum.po | 131 ++++++++++++++++++++++++------------------------ 1 file changed, 65 insertions(+), 66 deletions(-) diff --git a/library/enum.po b/library/enum.po index d600584fa..d34847509 100644 --- a/library/enum.po +++ b/library/enum.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-10-12 18:59+0200\n" -"PO-Revision-Date: 2019-07-24 07:53+0200\n" +"PO-Revision-Date: 2019-07-26 19:08+0200\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -45,7 +45,7 @@ msgid "" "`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 permettend de définir des " +"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`." @@ -116,7 +116,7 @@ msgid "" 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 sous-classer :class:`Enum` " +"fonction`_. Pour définir une énumération, il faut hériter de :class:`Enum` " "de la manière suivante : ::" #: ../Doc/library/enum.rst:78 @@ -141,7 +141,7 @@ msgstr "Nomenclature" #: ../Doc/library/enum.rst:87 msgid "The class :class:`Color` is an *enumeration* (or *enum*)" -msgstr "La classe :class:`Color` est une *énumeration* (ou un *enum*)." +msgstr "La classe :class:`Color` est une *énumération* (ou un *enum*)." #: ../Doc/library/enum.rst:88 msgid "" @@ -157,17 +157,17 @@ 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." +"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." #: ../Doc/library/enum.rst:96 msgid "" "Even though we use the :keyword:`class` syntax to create Enums, Enums are " "not normal Python classes. See `How are Enums different?`_ for more details." msgstr "" -"Même si on utilise la syntaxe en :keyword:`class` pour créer des enums, les " -"*Enums* ne sont pas des vraies classes Python. Voir `En quoi les Enums sont " -"différentes ?`_ pour plus de détails." +"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." #: ../Doc/library/enum.rst:100 msgid "Enumeration members have human readable string representations::" @@ -200,7 +200,7 @@ msgid "" "sets::" msgstr "" "Les membres d'une énumération sont hachables, ils peuvent ainsi être " -"utilisés dans des dictionnaires ou des ensembles ::" +"utilisés dans des dictionnaires ou des ensembles : ::" #: ../Doc/library/enum.rst:149 msgid "Programmatic access to enumeration members and their attributes" @@ -233,7 +233,7 @@ msgstr "Duplication de membres et de valeurs" #: ../Doc/library/enum.rst:179 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 une *enum* : ::" +"Il n'est pas possible d'avoir deux membres du même nom dans un *enum* : ::" #: ../Doc/library/enum.rst:189 msgid "" @@ -269,8 +269,8 @@ msgid "" 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 pour s'assurer que chaque valeur n'est utilisée qu'une seule fois " -"au sein de l'énumération : ::" +"décorateur suivant pour s'assurer que chaque valeur n'est utilisée qu'une " +"seule fois au sein de l'énumération : ::" #: ../Doc/library/enum.rst:223 msgid "" @@ -351,7 +351,7 @@ msgid "" "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'une *enum* ne sont pas des entiers (voir cependant " +"*pas* ; les membres d'un *enum* ne sont pas des entiers (voir cependant " "`IntEnum`_ ci-dessous) : ::" #: ../Doc/library/enum.rst:323 @@ -392,9 +392,8 @@ 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 : ::" +"Les énumérations sont des classes Python, et peuvent donc avoir des méthodes " +"et des méthodes spéciales. L'énumération suivante : ::" #: ../Doc/library/enum.rst:369 msgid "Then::" @@ -424,8 +423,8 @@ msgid "" "those methods. See `Planet`_ for an example." msgstr "" "Remarque : si l'énumération définit :meth:`__new__` and/or :meth:`__init__`, " -"alors (double ????) la (ou les) valeur affectée au membre sera passée à ces " -"méthodes. Voir l'exemple de `Planet`_." +"alors la (ou les) valeur affectée au membre sera passée à ces méthodes. Voir " +"l'exemple de `Planet`_." #: ../Doc/library/enum.rst:391 msgid "Restricted Enum subclassing" @@ -437,7 +436,7 @@ msgid "" "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 " +"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 : ::" @@ -481,9 +480,9 @@ msgid "" "importable from that module." msgstr "" "Les restrictions habituelles de sérialisation s'appliquent : les *enums* à " -"sérialiser doivent être déclarées dans l'espace de nom de haut niveau du " +"sérialiser doivent être déclarés dans l'espace de nom de haut niveau du " "module car la dé-sérialisation nécessite que ces *enums* puissent être " -"importées depuis ce module." +"importés depuis ce module." #: ../Doc/library/enum.rst:443 msgid "" @@ -491,7 +490,7 @@ msgid "" "in other classes." msgstr "" "Depuis la version 4 du protocole de *pickle*, il est possible de sérialiser " -"facilement des *enums* imbriquées dans d'autres classes." +"facilement des *enums* imbriqués dans d'autres classes." #: ../Doc/library/enum.rst:446 msgid "" @@ -532,14 +531,14 @@ msgid "" "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 des noms séparés par des espaces, une " -"séquence de noms, une séquence de duets clé / valeur ou une correspondance " -"(p. ex. un dictionnaire) entre noms et valeurs. 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 à : ::" +"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 une " +"correspondance (p. ex. un dictionnaire) entre noms et valeurs. 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 à : ::" #: ../Doc/library/enum.rst:484 msgid "" @@ -558,11 +557,11 @@ msgid "" "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éés avec l'API en fonction peut être " -"source de problèmes car celle-ci repose sur des détails d'implémentation de " +"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 oy " +"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 : ::" @@ -573,7 +572,8 @@ msgid "" "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 non-sérialisables (?????) ; ." +"nouveaux membres de *l' Enum* ne seront pas non-sérialisables ; pour garder " +"les erreurs au plus près de leur origine, la sérialisation sera désactivée." #: ../Doc/library/enum.rst:502 msgid "" @@ -678,7 +678,7 @@ msgid "" 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 " +"comparés à des entiers et, par extension, les comparaisons entre des " "énumération entières de type différent sont possibles : ::" #: ../Doc/library/enum.rst:571 @@ -714,9 +714,9 @@ msgstr "" "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 :class:`IntFlag` sont " -"aussi des sous-classes de :class:`int` et peuvent être utilisés là où un :" -"class:`int` est utilisé. Toute opération sur un membre d'une :class:" +"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`." @@ -743,8 +743,8 @@ msgid "" "Because :class:`IntFlag` members are also subclasses of :class:`int` they " "can be combined with them::" msgstr "" -"Comme les membres d'une :class:`IntFlag` sont aussi des sous-classes de :" -"class:`int`, ils peuvent être combinés avec eux : ::" +"Comme les membres d'une classe :class:`IntFlag` héritent aussi de :class:" +"`int`, ils peuvent être combinés avec eux : ::" #: ../Doc/library/enum.rst:651 msgid "Flag" @@ -760,7 +760,7 @@ msgid "" "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 :class:`Flag` peuvent être combinés en " +"`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`. " @@ -773,9 +773,9 @@ 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 de :class:`Flag` " -"n'active aucune option, l'évaluation booléenne de la comparaison est :data:" -"`False` : ::" +"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` : ::" #: ../Doc/library/enum.rst:676 msgid "" @@ -790,8 +790,8 @@ msgid "" "Giving a name to the \"no flags set\" condition does not change its boolean " "value::" msgstr "" -"Donner un nom à la valeur \"aucun option activée\" ne change pas sa valeur " -"booléenne ::" +"Donner un nom à la valeur \"aucune option activée\" ne change pas sa valeur " +"booléenne : ::" #: ../Doc/library/enum.rst:704 msgid "" @@ -862,7 +862,6 @@ msgstr "" "être de ce type, p. ex. :class:`int` ci-dessus. Cette restriction ne " "s'applique pas aux types de mélange qui ne font qu'ajouter des méthodes et " "ne définissent pas de type de données, tels :class:`int` ou :class:`str`. " -"(???)." #: ../Doc/library/enum.rst:735 msgid "" @@ -892,11 +891,10 @@ msgid "" "`Enum` class's :func:`str` or :func:`repr` is desired, use the `!s` or `!r` " "format codes." msgstr "" -":ref:`Chaînes de caractères formatées littérales ` : (???) :meth:" -"`str.format`, et :func:`format` appellent la méthode :meth:`__format__` du " -"type de mélange. Pour appeler les fonctions :func:`str` ou :func:`repr` de " -"la classe :class:`Enum`, il faut utiliser les codes de formatage `!s` ou `!" -"r`." +":ref:`Chaînes de caractères formatées littérales ` : :meth:`str." +"format`, et :func:`format` appellent la méthode :meth:`__format__` du type " +"de mélange. Pour appeler les fonctions :func:`str` ou :func:`repr` de la " +"classe :class:`Enum`, il faut utiliser les codes de formatage `!s` ou `!r`." #: ../Doc/library/enum.rst:748 msgid "Interesting examples" @@ -925,7 +923,7 @@ msgid "" "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 " +"d'importance. Il y a plusieurs façons de définir ce type d'énumération " "simple :" #: ../Doc/library/enum.rst:762 @@ -968,7 +966,7 @@ msgstr "" #: ../Doc/library/enum.rst:782 msgid "Using :class:`auto`" -msgstr "Utiliser :class:`auto`" +msgstr "Avec :class:`auto`" #: ../Doc/library/enum.rst:784 msgid "Using :class:`auto` would look like::" @@ -976,7 +974,7 @@ msgstr "On utilise :class:`auto` de la manière suivante : ::" #: ../Doc/library/enum.rst:796 msgid "Using :class:`object`" -msgstr "Utiliser :class:`object`" +msgstr "Avec :class:`object`" #: ../Doc/library/enum.rst:798 msgid "Using :class:`object` would look like::" @@ -984,7 +982,7 @@ msgstr "On utilise :class:`object` de la manière suivante : ::" #: ../Doc/library/enum.rst:810 msgid "Using a descriptive string" -msgstr "Utiliser une chaîne de caractères de description" +msgstr "Avec une chaîne de caractères de description" #: ../Doc/library/enum.rst:812 msgid "Using a string as the value would look like::" @@ -992,7 +990,7 @@ msgstr "On utilise une chaîne de caractères de la manière suivante : ::" #: ../Doc/library/enum.rst:826 msgid "Using a custom :meth:`__new__`" -msgstr "Utiliser une méthode ad-hoc :meth:`__new__`" +msgstr "Avec une méthode ad-hoc :meth:`__new__`" #: ../Doc/library/enum.rst:828 msgid "Using an auto-numbering :meth:`__new__` would look like::" @@ -1093,7 +1091,7 @@ msgid "" "`Enum` class are correct (such as :meth:`__new__`, :meth:`__getnewargs__`, :" "meth:`__str__` and :meth:`__repr__`)." msgstr "" -"La métaclass :class:`EnumMeta` se charge de fournir les méthodes :meth:" +"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 " @@ -1159,7 +1157,8 @@ msgstr "``_name_`` -- nom du membre" msgid "" "``_value_`` -- value of the member; can be set / modified in ``__new__``" msgstr "" -"``_value_`` -- valeur du membre ; peut être accédé ou mué dans ``__new__``" +"``_value_`` -- valeur du membre ; il est possible d'y accéder ou de la muer " +"dans ``__new__``" #: ../Doc/library/enum.rst:1022 msgid "" @@ -1176,8 +1175,8 @@ msgid "" "final class" msgstr "" "``_ignore_`` -- une liste de noms, sous la forme de :func:`list` ou de :func:" -"`str`, (func ?????) qui ne seront pas transformés en membres, et seront " -"supprimés de la classe résultante" +"`str`, qui ne seront pas transformés en membres, et seront supprimés de la " +"classe résultante" #: ../Doc/library/enum.rst:1027 msgid "" @@ -1193,9 +1192,9 @@ msgid "" "``_generate_next_value_`` -- used by the `Functional API`_ and by :class:" "`auto` to get an appropriate value for an enum member; may be overridden" msgstr "" -"``_generate_next_value_`` -- (??? une fonction) 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" +"``_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" #: ../Doc/library/enum.rst:1033 msgid "``_missing_``, ``_order_``, ``_generate_next_value_``" @@ -1257,7 +1256,7 @@ msgid "" "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és avec un type non dérivé de :" +"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 " From 5e6c1880cbe7adcd4b12eeb9ed07d71208215ff9 Mon Sep 17 00:00:00 2001 From: awecx Date: Fri, 26 Jul 2019 19:33:31 +0200 Subject: [PATCH 05/12] Corrections pospell --- library/enum.po | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/library/enum.po b/library/enum.po index d34847509..8503c1eaf 100644 --- a/library/enum.po +++ b/library/enum.po @@ -422,7 +422,7 @@ msgid "" "then whatever value(s) were given to the enum member will be passed into " "those methods. See `Planet`_ for an example." msgstr "" -"Remarque : si l'énumération définit :meth:`__new__` and/or :meth:`__init__`, " +"Remarque : si l'énumération définit :meth:`__new__` ou :meth:`__init__`, " "alors la (ou les) valeur affectée au membre sera passée à ces méthodes. Voir " "l'exemple de `Planet`_." @@ -547,7 +547,8 @@ msgid "" "``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``." +"booléen vaut ``False`` alors que tous les membres d'une *enum* valent " +"``True``." #: ../Doc/library/enum.rst:488 msgid "" @@ -807,11 +808,11 @@ msgstr "" "`Enum` and :class:`Flag` pour écrire du code nouveau, car :class:`IntEnum` " "and :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` and :class:" -"`IntFlag` ne doivent être utilisées que dans les cas où :class:`Enum` and :" -"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." +"transitivité, à d'autres énumérations). :class:`IntEnum` et :class:`IntFlag` " +"ne doivent être utilisées que dans les cas où :class:`Enum` and :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." #: ../Doc/library/enum.rst:714 msgid "Others" From 3b9a3105b17008f6e98cdefdb7e1f5616ca5f86b Mon Sep 17 00:00:00 2001 From: awecx Date: Fri, 26 Jul 2019 19:50:01 +0200 Subject: [PATCH 06/12] Correction erreurs pospell --- library/enum.po | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/library/enum.po b/library/enum.po index 8503c1eaf..be6a55108 100644 --- a/library/enum.po +++ b/library/enum.po @@ -805,14 +805,13 @@ msgid "" "enumerations, or for interoperability with other systems." msgstr "" "Dans la plupart des cas, il est fortement recommandé d'utiliser :class:" -"`Enum` and :class:`Flag` pour écrire du code nouveau, car :class:`IntEnum` " -"and :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` and :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." +"`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." #: ../Doc/library/enum.rst:714 msgid "Others" From 74674160ef083fdfaed1582889d50bbf4fcdf017 Mon Sep 17 00:00:00 2001 From: Antoine <43954001+awecx@users.noreply.github.com> Date: Fri, 2 Aug 2019 21:00:46 +0200 Subject: [PATCH 07/12] Suggestions de JulienPalard Co-Authored-By: Julien Palard --- library/enum.po | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/library/enum.po b/library/enum.po index be6a55108..fc953a0e7 100644 --- a/library/enum.po +++ b/library/enum.po @@ -334,7 +334,7 @@ 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 " +"L'attribut ``__members__`` peut servir à accéder dynamiquement aux membres " "de l'énumération. Par exemple, pour trouver tous les alias : ::" #: ../Doc/library/enum.rst:304 @@ -460,7 +460,7 @@ msgid "" "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 " +"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 " "`OrderedEnum`_ pour exemple)." @@ -515,7 +515,7 @@ 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." +"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." @@ -573,7 +573,7 @@ msgid "" "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 non-sérialisables ; pour garder " +"nouveaux membres de *l'Enum* ne seront pas non-sérialisables ; pour garder " "les erreurs au plus près de leur origine, la sérialisation sera désactivée." #: ../Doc/library/enum.rst:502 From 296fd156901d2bd0bee15963f4645cdeb52fdd4a Mon Sep 17 00:00:00 2001 From: awecx Date: Fri, 2 Aug 2019 21:40:36 +0200 Subject: [PATCH 08/12] Suggestions de JulienPalard + powrap --- library/enum.po | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/library/enum.po b/library/enum.po index fc953a0e7..31ce59fcb 100644 --- a/library/enum.po +++ b/library/enum.po @@ -463,7 +463,7 @@ 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 " -"`OrderedEnum`_ pour exemple)." +"par exemple `OrderedEnum`_)." #: ../Doc/library/enum.rst:428 msgid "Pickling" @@ -515,9 +515,8 @@ 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." +"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." #: ../Doc/library/enum.rst:468 msgid "" From baf3a82d1740994a32032c83a606f716e62415ad Mon Sep 17 00:00:00 2001 From: awecx Date: Fri, 2 Aug 2019 21:55:38 +0200 Subject: [PATCH 09/12] Suggestion de JulienPalard, oubli --- library/enum.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/enum.po b/library/enum.po index 31ce59fcb..79afbe1df 100644 --- a/library/enum.po +++ b/library/enum.po @@ -381,7 +381,7 @@ msgid "" "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 " +"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 " From b02cca0612b5296f58f00fff3dcdddc291913cb9 Mon Sep 17 00:00:00 2001 From: awecx Date: Tue, 6 Aug 2019 21:24:13 +0200 Subject: [PATCH 10/12] =?UTF-8?q?Derni=C3=A8res=20modifications.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/enum.po | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/library/enum.po b/library/enum.po index 79afbe1df..a0a23ff71 100644 --- a/library/enum.po +++ b/library/enum.po @@ -531,8 +531,8 @@ msgid "" 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 une " -"correspondance (p. ex. un dictionnaire) entre noms et valeurs. Les deux " +"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 " @@ -572,8 +572,8 @@ msgid "" "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 non-sérialisables ; pour garder " -"les erreurs au plus près de leur origine, la sérialisation sera désactivée." +"nouveaux membres de *l'Enum* ne seront pas désérialisables ; pour garder les " +"erreurs au plus près de leur origine, la sérialisation sera désactivée." #: ../Doc/library/enum.rst:502 msgid "" From 59f952f10ef24a04d0209f229072d1520ec0e61a Mon Sep 17 00:00:00 2001 From: awecx Date: Tue, 6 Aug 2019 22:20:35 +0200 Subject: [PATCH 11/12] Corrige pb de powrap + modifs. mineures --- library/enum.po | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/library/enum.po b/library/enum.po index a0a23ff71..d496f5968 100644 --- a/library/enum.po +++ b/library/enum.po @@ -381,9 +381,9 @@ msgid "" "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 " +"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." @@ -460,7 +460,7 @@ msgid "" "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 " +"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`_)." @@ -679,7 +679,7 @@ 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ération entières de type différent sont possibles : ::" +"énumérations entières de type différent sont possibles : ::" #: ../Doc/library/enum.rst:571 msgid "" @@ -790,7 +790,7 @@ 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 " +"Donner un nom à la valeur « aucune option activée » ne change pas sa valeur " "booléenne : ::" #: ../Doc/library/enum.rst:704 From 43c53c977101521d9daf88f07665611628cf7e48 Mon Sep 17 00:00:00 2001 From: awecx Date: Tue, 6 Aug 2019 22:31:54 +0200 Subject: [PATCH 12/12] Powrap + pospell --- library/enum.po | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/library/enum.po b/library/enum.po index d496f5968..f559d936a 100644 --- a/library/enum.po +++ b/library/enum.po @@ -381,9 +381,9 @@ msgid "" "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 " +"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." @@ -460,7 +460,7 @@ msgid "" "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 " +"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`_)." @@ -572,8 +572,8 @@ msgid "" "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ésérialisables ; pour garder les " -"erreurs au plus près de leur origine, la sérialisation sera désactivée." +"nouveaux membres de *l'Enum* ne seront pas dé-sérialisables ; pour garder " +"les erreurs au plus près de leur origine, la sérialisation sera désactivée." #: ../Doc/library/enum.rst:502 msgid ""