# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-08-24 09:01+0200\n"
"PO-Revision-Date: 2018-12-24 14:53+0100\n"
"Last-Translator: Julien Palard <julien@palard.fr>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.1.1\n"

#: library/dataclasses.rst:2
msgid ":mod:`dataclasses` --- Data Classes"
msgstr ":mod:`dataclasses` — Classes de Données"

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

#: library/dataclasses.rst:14
msgid ""
"This module provides a decorator and functions for automatically adding "
"generated :term:`special method`\\s such as :meth:`__init__` and :meth:"
"`__repr__` to user-defined classes.  It was originally described in :pep:"
"`557`."
msgstr ""
"Ce module fournit un décorateur et des fonctions pour générer "
"automatiquement les  :term:`méthodes spéciales <special method>` comme :meth:"
"`__init__` et :meth:`__repr__` dans les *Classes de Données* définies par "
"l’utilisateur.  Ces classes ont été décrites dans la :pep:`557`."

#: library/dataclasses.rst:19
msgid ""
"The member variables to use in these generated methods are defined using :"
"pep:`526` type annotations.  For example this code::"
msgstr ""
"Les variables membres à utiliser dans ces méthodes générées sont définies en "
"utilisant les annotations de type :pep:`526`.  Par exemple, ce code ::"

#: library/dataclasses.rst:34
msgid "Will add, among other things, a :meth:`__init__` that looks like::"
msgstr ""
"Ajoute, entre autres choses, une méthode :meth:`__init__` qui ressemble à ::"

#: library/dataclasses.rst:41
msgid ""
"Note that this method is automatically added to the class: it is not "
"directly specified in the ``InventoryItem`` definition shown above."
msgstr ""
"Il est important de noter que cette méthode est ajoutée automatiquement dans "
"la classe : elle n’est pas à écrire dans la définition de ``InventoryItem`` "
"ci-dessus."

#: library/dataclasses.rst:47
msgid "Module-level decorators, classes, and functions"
msgstr "Décorateurs, classes et fonctions au niveau du module"

#: library/dataclasses.rst:51
msgid ""
"This function is a :term:`decorator` that is used to add generated :term:"
"`special method`\\s to classes, as described below."
msgstr ""
"Cette fonction est un :term:`décorateur` qui est utilisé pour ajouter les :"
"term:`méthodes spéciales <special method>` générées aux classes, comme "
"décrit ci-dessous."

#: library/dataclasses.rst:54
msgid ""
"The :func:`dataclass` decorator examines the class to find ``field``\\s.  A "
"``field`` is defined as class variable that has a :term:`type annotation "
"<variable annotation>`.  With two exceptions described below, nothing in :"
"func:`dataclass` examines the type specified in the variable annotation."
msgstr ""
"Le décorateur :func:`dataclass` examine la classe pour trouver des ``champs``"
"\\s.  Un ``champ`` est défini comme une variable de classe qui possède une :"
"term:`annotation de type <variable annotation>`.  À deux exceptions près "
"décrites plus bas, il n’y a rien dans :func:`dataclass` qui examine le type "
"spécifié dans l’annotation de variable."

#: library/dataclasses.rst:60
msgid ""
"The order of the fields in all of the generated methods is the order in "
"which they appear in the class definition."
msgstr ""
"L’ordre des paramètres des méthodes générées est celui d’apparition des "
"champs dans la définition de la classe."

#: library/dataclasses.rst:63
#, fuzzy
msgid ""
"The :func:`dataclass` decorator will add various \"dunder\" methods to the "
"class, described below.  If any of the added methods already exist on the "
"class, the behavior depends on the parameter, as documented below. The "
"decorator returns the same class that is called on; no new class is created."
msgstr ""
"Le décorateur :func:`dataclass` ajoute diverses méthodes « spéciales » à la "
"classe, décrites ci-après.  Si l’une des méthodes ajoutées existe déjà dans "
"la classe, le comportement dépend des paramètres, comme documenté ci-"
"dessous. Le décorateur renvoie la classe sur laquelle il est appelé ; il n’y "
"a pas de nouvelle classe créée."

#: library/dataclasses.rst:69
msgid ""
"If :func:`dataclass` is used just as a simple decorator with no parameters, "
"it acts as if it has the default values documented in this signature.  That "
"is, these three uses of :func:`dataclass` are equivalent::"
msgstr ""
"Si :func:`dataclass` est utilisé comme simple décorateur sans paramètres, il "
"se comporte comme si on l’avait appelé avec les valeurs par défaut présentes "
"en signature.  Ainsi, les trois usages suivants de :func:`dataclass` sont "
"équivalents ::"

#: library/dataclasses.rst:86
msgid "The parameters to :func:`dataclass` are:"
msgstr "Les paramètres de :func:`dataclass` sont :"

#: library/dataclasses.rst:88
msgid ""
"``init``: If true (the default), a :meth:`__init__` method will be generated."
msgstr ""
"``init``: Si vrai (par défaut), une méthode :meth:`__init__` est générée."

#: library/dataclasses.rst:91
msgid ""
"If the class already defines :meth:`__init__`, this parameter is ignored."
msgstr ""
"Si la classe définit déjà une méthode :meth:`__init__`, ce paramètre est "
"ignoré."

#: library/dataclasses.rst:94
msgid ""
"``repr``: If true (the default), a :meth:`__repr__` method will be "
"generated.  The generated repr string will have the class name and the name "
"and repr of each field, in the order they are defined in the class.  Fields "
"that are marked as being excluded from the repr are not included.  For "
"example: ``InventoryItem(name='widget', unit_price=3.0, "
"quantity_on_hand=10)``."
msgstr ""
"``repr``: Si vrai (par défaut), une méthode :meth:`__repr__` sera générée.  "
"La chaîne de représentation comportera le nom de la classe et le nom ainsi "
"que la représentation de chaque champ, suivant leur ordre de définition.  "
"Les champs marqués comme exclus (voir ``Field`` ci-dessous) de la "
"représentation ne sont pas inclus.  Par exemple : "
"``InventoryItem(name='widget', unit_price=3.0, quantity_on_hand=10)``."

#: library/dataclasses.rst:101
msgid ""
"If the class already defines :meth:`__repr__`, this parameter is ignored."
msgstr ""
"Si la classe définit déjà une méthode :meth:`__repr__`, ce paramètre est "
"ignoré."

#: library/dataclasses.rst:104
msgid ""
"``eq``: If true (the default), an :meth:`__eq__` method will be generated.  "
"This method compares the class as if it were a tuple of its fields, in "
"order.  Both instances in the comparison must be of the identical type."
msgstr ""
"``eq``: Si vrai (par défaut), une méthode :meth:`__eq__` est générée.  Cette "
"méthode permet de comparer les instances de la classe comme s’il s’agissait "
"d’un tuple de ses champs, dans l’ordre. Les deux instances dans la "
"comparaison doivent être de même type."

#: library/dataclasses.rst:109
msgid "If the class already defines :meth:`__eq__`, this parameter is ignored."
msgstr ""
"Si la classe définit déjà une méthode :meth:`__eq__`, ce paramètre est "
"ignoré."

#: library/dataclasses.rst:112
msgid ""
"``order``: If true (the default is ``False``), :meth:`__lt__`, :meth:"
"`__le__`, :meth:`__gt__`, and :meth:`__ge__` methods will be generated.  "
"These compare the class as if it were a tuple of its fields, in order.  Both "
"instances in the comparison must be of the identical type.  If ``order`` is "
"true and ``eq`` is false, a :exc:`ValueError` is raised."
msgstr ""
"``order``: Si vrai (``False`` par défaut), les méthodes :meth:`__lt__`, :"
"meth:`__le__`, :meth:`__gt__`, et :meth:`__ge__` sont générées.  Elles "
"permettent de comparer les instances de la classe en les considérant comme "
"des tuples, dans l’ordre de définition des champs.  Chaque instance dans la "
"comparaison doit être de même type.  Si ``order`` est vrai mais que ``eq`` "
"est faux, une :exc:`ValueError` est levée."

#: library/dataclasses.rst:119
#, fuzzy
msgid ""
"If the class already defines any of :meth:`__lt__`, :meth:`__le__`, :meth:"
"`__gt__`, or :meth:`__ge__`, then :exc:`TypeError` is raised."
msgstr ""
"Si la classe définit déjà l’une des méthodes :meth:`__lt__`, :meth:"
"`__le__`, :meth:`__gt__`, ou :meth:`__ge__`, alors une :exc:`TypeError` est "
"levée."

#: library/dataclasses.rst:123
msgid ""
"``unsafe_hash``: If ``False`` (the default), a :meth:`__hash__` method is "
"generated according to how ``eq`` and ``frozen`` are set."
msgstr ""
"``unsafe_hash``: Si ``False`` (par défaut), une méthode :meth:`__hash__` est "
"générée et son comportement dépend des valeurs de ``eq`` et ``frozen``."

#: library/dataclasses.rst:126
msgid ""
":meth:`__hash__` is used by built-in :meth:`hash()`, and when objects are "
"added to hashed collections such as dictionaries and sets.  Having a :meth:"
"`__hash__` implies that instances of the class are immutable. Mutability is "
"a complicated property that depends on the programmer's intent, the "
"existence and behavior of :meth:`__eq__`, and the values of the ``eq`` and "
"``frozen`` flags in the :func:`dataclass` decorator."
msgstr ""
":meth:`__hash__` est utilisée par la fonction native :meth:`hash()`, ainsi "
"que lorsqu’un objet est inséré dans une collection utilisant du hachage, tel "
"qu’un dictionnaire ou un ensemble.  Avoir une méthode :meth:`__hash__` "
"implique que les instances de la classe sont immuables. La muabilité est une "
"propriété complexe qui dépends des intentions du programmeur, de l’existence "
"et du comportement de la méthode :meth:`__eq__`, et des valeurs des options "
"``eq`` et ``frozen`` dans l’appel au décorateur :func:`dataclass`."

#: library/dataclasses.rst:133
msgid ""
"By default, :func:`dataclass` will not implicitly add a :meth:`__hash__` "
"method unless it is safe to do so.  Neither will it add or change an "
"existing explicitly defined :meth:`__hash__` method.  Setting the class "
"attribute ``__hash__ = None`` has a specific meaning to Python, as described "
"in the :meth:`__hash__` documentation."
msgstr ""
"Par défaut, :func:`dataclass` n’ajoute pas de méthode implicite :meth:"
"`__hash__`, sauf s’il n’existe aucun risque sous-jacent.  Il n’ajoute ou ne "
"modifie pas non plus la méthode :meth:`__hash__` si elle a est définie "
"explicitement.  Définir l’attribut de classe ``__hash__ = None`` a une "
"signification particulière en Python, comme précisé dans la documentation "
"de :meth:`__hash__`."

#: library/dataclasses.rst:139
msgid ""
"If :meth:`__hash__` is not explicit defined, or if it is set to ``None``, "
"then :func:`dataclass` *may* add an implicit :meth:`__hash__` method. "
"Although not recommended, you can force :func:`dataclass` to create a :meth:"
"`__hash__` method with ``unsafe_hash=True``. This might be the case if your "
"class is logically immutable but can nonetheless be mutated. This is a "
"specialized use case and should be considered carefully."
msgstr ""
"Si :meth:`__hash__` n’est pas défini explicitement, ou s’il a pour valeur "
"``None``, alors :func:`dataclass` *peut* ajouter une méthode :meth:"
"`__hash__` implicite. Bien que ce ne soit pas recommandé,, vous pouvez "
"forcer :func:`dataclass` à créer une méthode :meth:`__hash__` en utilisant "
"``unsafe_hash=True``. Cela pourrait être nécessaire si votre classe est "
"logiquement immuable mais qu’une mutation est tout de même possible. C’est "
"un cas très particulier qui doit être considéré avec la plus grande prudence."

#: library/dataclasses.rst:146
msgid ""
"Here are the rules governing implicit creation of a :meth:`__hash__` "
"method.  Note that you cannot both have an explicit :meth:`__hash__` method "
"in your dataclass and set ``unsafe_hash=True``; this will result in a :exc:"
"`TypeError`."
msgstr ""
"Ce sont les règles autour de la création implicite de la méthode :meth:"
"`__hash__`.  Il faut noter que vous ne pouvez pas avoir à la fois une "
"méthode :meth:`__hash__` explicite dans votre *dataclass* et définir "
"``unsafe_hash=True``; cela lèvera une :exc:`TypeError`."

#: library/dataclasses.rst:151
msgid ""
"If ``eq`` and ``frozen`` are both true, by default :func:`dataclass` will "
"generate a :meth:`__hash__` method for you.  If ``eq`` is true and "
"``frozen`` is false, :meth:`__hash__` will be set to ``None``, marking it "
"unhashable (which it is, since it is mutable).  If ``eq`` is false, :meth:"
"`__hash__` will be left untouched meaning the :meth:`__hash__` method of the "
"superclass will be used (if the superclass is :class:`object`, this means it "
"will fall back to id-based hashing)."
msgstr ""
"Si ``eq`` et ``frozen`` sont tous deux vrais, :func:`dataclass` génère par "
"défaut une méthode :meth:`__hash__` pour vous.  Si ``eq`` est vrai mais que "
"``frozen`` est faux, :meth:`__hash__` prend la valeur ``None``, marquant la "
"classe comme non-hachable (et c’est le cas, puisqu’elle est modifiable).  Si "
"``eq`` est faux, la méthode :meth:`__hash__` est laissée intacte, ce qui "
"veut dire que la méthode :meth:`__hash__` de la classe parente sera utilisée "
"(si la classe parente est :class:`object`, le comportement est un hachage "
"basé sur les id)."

#: library/dataclasses.rst:159
#, fuzzy
msgid ""
"``frozen``: If true (the default is ``False``), assigning to fields will "
"generate an exception.  This emulates read-only frozen instances.  If :meth:"
"`__setattr__` or :meth:`__delattr__` is defined in the class, then :exc:"
"`TypeError` is raised.  See the discussion below."
msgstr ""
"``frozen``: Si vrai (faux par défaut), assigner une valeur à un champ lèvera "
"une exception.  Cela simule le comportement des instances figées en lecture "
"seule.  Si la méthode :meth:`__setattr__` ou :meth:`__delattr__` est définie "
"sur la classe, alors une :exc:`TypeError` est levée.  Voir la discussion ci-"
"dessous."

#: library/dataclasses.rst:164
msgid ""
"``field``\\s may optionally specify a default value, using normal Python "
"syntax::"
msgstr ""
"Les ``field``\\s peuvent éventuellement spécifier une valeur par défaut, en "
"utilisant la syntaxe Python normale ::"

#: library/dataclasses.rst:172
msgid ""
"In this example, both ``a`` and ``b`` will be included in the added :meth:"
"`__init__` method, which will be defined as::"
msgstr ""
"Dans cet exemple, ``a`` et ``b`` sont tous deux inclus dans la signature de "
"la méthode générée :meth:`__init__`, qui est définie comme suit ::"

#: library/dataclasses.rst:177
msgid ""
":exc:`TypeError` will be raised if a field without a default value follows a "
"field with a default value.  This is true either when this occurs in a "
"single class, or as a result of class inheritance."
msgstr ""
"Une :exc:`TypeError` est levée si un champ sans valeur par défaut est défini "
"après un champ avec une valeur par défaut.  C’est le cas que ce soit dans "
"une seule classe, mais également si c’est le résultat d’un héritage de "
"classes."

#: library/dataclasses.rst:183
msgid ""
"For common and simple use cases, no other functionality is required.  There "
"are, however, some dataclass features that require additional per-field "
"information.  To satisfy this need for additional information, you can "
"replace the default field value with a call to the provided :func:`field` "
"function.  For example::"
msgstr ""

#: library/dataclasses.rst:196
msgid ""
"As shown above, the ``MISSING`` value is a sentinel object used to detect if "
"the ``default`` and ``default_factory`` parameters are provided.  This "
"sentinel is used because ``None`` is a valid value for ``default``.  No code "
"should directly use the ``MISSING`` value."
msgstr ""

#: library/dataclasses.rst:202
msgid "The parameters to :func:`field` are:"
msgstr ""

#: library/dataclasses.rst:204
msgid ""
"``default``: If provided, this will be the default value for this field.  "
"This is needed because the :meth:`field` call itself replaces the normal "
"position of the default value."
msgstr ""

#: library/dataclasses.rst:208
msgid ""
"``default_factory``: If provided, it must be a zero-argument callable that "
"will be called when a default value is needed for this field.  Among other "
"purposes, this can be used to specify fields with mutable default values, as "
"discussed below.  It is an error to specify both ``default`` and "
"``default_factory``."
msgstr ""

#: library/dataclasses.rst:214
msgid ""
"``init``: If true (the default), this field is included as a parameter to "
"the generated :meth:`__init__` method."
msgstr ""

#: library/dataclasses.rst:217
msgid ""
"``repr``: If true (the default), this field is included in the string "
"returned by the generated :meth:`__repr__` method."
msgstr ""

#: library/dataclasses.rst:220
msgid ""
"``compare``: If true (the default), this field is included in the generated "
"equality and comparison methods (:meth:`__eq__`, :meth:`__gt__`, et al.)."
msgstr ""

#: library/dataclasses.rst:224
msgid ""
"``hash``: This can be a bool or ``None``.  If true, this field is included "
"in the generated :meth:`__hash__` method.  If ``None`` (the default), use "
"the value of ``compare``: this would normally be the expected behavior.  A "
"field should be considered in the hash if it's used for comparisons.  "
"Setting this value to anything other than ``None`` is discouraged."
msgstr ""

#: library/dataclasses.rst:231
msgid ""
"One possible reason to set ``hash=False`` but ``compare=True`` would be if a "
"field is expensive to compute a hash value for, that field is needed for "
"equality testing, and there are other fields that contribute to the type's "
"hash value.  Even if a field is excluded from the hash, it will still be "
"used for comparisons."
msgstr ""

#: library/dataclasses.rst:237
msgid ""
"``metadata``: This can be a mapping or None. None is treated as an empty "
"dict.  This value is wrapped in :func:`~types.MappingProxyType` to make it "
"read-only, and exposed on the :class:`Field` object. It is not used at all "
"by Data Classes, and is provided as a third-party extension mechanism. "
"Multiple third-parties can each have their own key, to use as a namespace in "
"the metadata."
msgstr ""

#: library/dataclasses.rst:245
msgid ""
"If the default value of a field is specified by a call to :func:`field()`, "
"then the class attribute for this field will be replaced by the specified "
"``default`` value.  If no ``default`` is provided, then the class attribute "
"will be deleted.  The intent is that after the :func:`dataclass` decorator "
"runs, the class attributes will all contain the default values for the "
"fields, just as if the default value itself were specified.  For example, "
"after::"
msgstr ""

#: library/dataclasses.rst:261
msgid ""
"The class attribute ``C.z`` will be ``10``, the class attribute ``C.t`` will "
"be ``20``, and the class attributes ``C.x`` and ``C.y`` will not be set."
msgstr ""

#: library/dataclasses.rst:267
msgid ""
":class:`Field` objects describe each defined field. These objects are "
"created internally, and are returned by the :func:`fields` module-level "
"method (see below).  Users should never instantiate a :class:`Field` object "
"directly.  Its documented attributes are:"
msgstr ""

#: library/dataclasses.rst:272
msgid "``name``: The name of the field."
msgstr ""

#: library/dataclasses.rst:274
msgid "``type``: The type of the field."
msgstr ""

#: library/dataclasses.rst:276
msgid ""
"``default``, ``default_factory``, ``init``, ``repr``, ``hash``, ``compare``, "
"and ``metadata`` have the identical meaning and values as they do in the :"
"func:`field` declaration."
msgstr ""

#: library/dataclasses.rst:280
msgid ""
"Other attributes may exist, but they are private and must not be inspected "
"or relied on."
msgstr ""

#: library/dataclasses.rst:285
msgid ""
"Returns a tuple of :class:`Field` objects that define the fields for this "
"dataclass.  Accepts either a dataclass, or an instance of a dataclass. "
"Raises :exc:`TypeError` if not passed a dataclass or instance of one. Does "
"not return pseudo-fields which are ``ClassVar`` or ``InitVar``."
msgstr ""

#: library/dataclasses.rst:292
msgid ""
"Converts the dataclass ``instance`` to a dict (by using the factory function "
"``dict_factory``).  Each dataclass is converted to a dict of its fields, as "
"``name: value`` pairs.  dataclasses, dicts, lists, and tuples are recursed "
"into.  For example::"
msgstr ""

#: library/dataclasses.rst:312 library/dataclasses.rst:326
msgid "Raises :exc:`TypeError` if ``instance`` is not a dataclass instance."
msgstr ""

#: library/dataclasses.rst:316
msgid ""
"Converts the dataclass ``instance`` to a tuple (by using the factory "
"function ``tuple_factory``).  Each dataclass is converted to a tuple of its "
"field values.  dataclasses, dicts, lists, and tuples are recursed into."
msgstr ""

#: library/dataclasses.rst:321
msgid "Continuing from the previous example::"
msgstr ""

#: library/dataclasses.rst:330
msgid ""
"Creates a new dataclass with name ``cls_name``, fields as defined in "
"``fields``, base classes as given in ``bases``, and initialized with a "
"namespace as given in ``namespace``.  ``fields`` is an iterable whose "
"elements are each either ``name``, ``(name, type)``, or ``(name, type, "
"Field)``.  If just ``name`` is supplied, ``typing.Any`` is used for "
"``type``.  The values of ``init``, ``repr``, ``eq``, ``order``, "
"``unsafe_hash``, and ``frozen`` have the same meaning as they do in :func:"
"`dataclass`."
msgstr ""

#: library/dataclasses.rst:339
msgid ""
"This function is not strictly required, because any Python mechanism for "
"creating a new class with ``__annotations__`` can then apply the :func:"
"`dataclass` function to convert that class to a dataclass.  This function is "
"provided as a convenience.  For example::"
msgstr ""

#: library/dataclasses.rst:351
msgid "Is equivalent to::"
msgstr ""

#: library/dataclasses.rst:364
msgid ""
"Creates a new object of the same type of ``instance``, replacing fields with "
"values from ``changes``.  If ``instance`` is not a Data Class, raises :exc:"
"`TypeError`.  If values in ``changes`` do not specify fields, raises :exc:"
"`TypeError`."
msgstr ""

#: library/dataclasses.rst:369
msgid ""
"The newly returned object is created by calling the :meth:`__init__` method "
"of the dataclass.  This ensures that :meth:`__post_init__`, if present, is "
"also called."
msgstr ""

#: library/dataclasses.rst:373
msgid ""
"Init-only variables without default values, if any exist, must be specified "
"on the call to :func:`replace` so that they can be passed to :meth:"
"`__init__` and :meth:`__post_init__`."
msgstr ""

#: library/dataclasses.rst:377
msgid ""
"It is an error for ``changes`` to contain any fields that are defined as "
"having ``init=False``.  A :exc:`ValueError` will be raised in this case."
msgstr ""

#: library/dataclasses.rst:381
msgid ""
"Be forewarned about how ``init=False`` fields work during a call to :func:"
"`replace`.  They are not copied from the source object, but rather are "
"initialized in :meth:`__post_init__`, if they're initialized at all.  It is "
"expected that ``init=False`` fields will be rarely and judiciously used.  If "
"they are used, it might be wise to have alternate class constructors, or "
"perhaps a custom ``replace()`` (or similarly named) method which handles "
"instance copying."
msgstr ""

#: library/dataclasses.rst:392
msgid ""
"Return ``True`` if its parameter is a dataclass or an instance of one, "
"otherwise return ``False``."
msgstr ""

#: library/dataclasses.rst:395
msgid ""
"If you need to know if a class is an instance of a dataclass (and not a "
"dataclass itself), then add a further check for ``not isinstance(obj, "
"type)``::"
msgstr ""

#: library/dataclasses.rst:403
msgid "Post-init processing"
msgstr ""

#: library/dataclasses.rst:405
msgid ""
"The generated :meth:`__init__` code will call a method named :meth:"
"`__post_init__`, if :meth:`__post_init__` is defined on the class.  It will "
"normally be called as ``self.__post_init__()``. However, if any ``InitVar`` "
"fields are defined, they will also be passed to :meth:`__post_init__` in the "
"order they were defined in the class.  If no :meth:`__init__` method is "
"generated, then :meth:`__post_init__` will not automatically be called."
msgstr ""

#: library/dataclasses.rst:413
msgid ""
"Among other uses, this allows for initializing field values that depend on "
"one or more other fields.  For example::"
msgstr ""

#: library/dataclasses.rst:425
msgid ""
"See the section below on init-only variables for ways to pass parameters to :"
"meth:`__post_init__`.  Also see the warning about how :func:`replace` "
"handles ``init=False`` fields."
msgstr ""

#: library/dataclasses.rst:430
msgid "Class variables"
msgstr ""

#: library/dataclasses.rst:432
msgid ""
"One of two places where :func:`dataclass` actually inspects the type of a "
"field is to determine if a field is a class variable as defined in :pep:"
"`526`.  It does this by checking if the type of the field is ``typing."
"ClassVar``.  If a field is a ``ClassVar``, it is excluded from consideration "
"as a field and is ignored by the dataclass mechanisms.  Such ``ClassVar`` "
"pseudo-fields are not returned by the module-level :func:`fields` function."
msgstr ""

#: library/dataclasses.rst:441
msgid "Init-only variables"
msgstr ""

#: library/dataclasses.rst:443
msgid ""
"The other place where :func:`dataclass` inspects a type annotation is to "
"determine if a field is an init-only variable.  It does this by seeing if "
"the type of a field is of type ``dataclasses.InitVar``.  If a field is an "
"``InitVar``, it is considered a pseudo-field called an init-only field.  As "
"it is not a true field, it is not returned by the module-level :func:"
"`fields` function.  Init-only fields are added as parameters to the "
"generated :meth:`__init__` method, and are passed to the optional :meth:"
"`__post_init__` method.  They are not otherwise used by dataclasses."
msgstr ""

#: library/dataclasses.rst:453
msgid ""
"For example, suppose a field will be initialized from a database, if a value "
"is not provided when creating the class::"
msgstr ""

#: library/dataclasses.rst:468
msgid ""
"In this case, :func:`fields` will return :class:`Field` objects for ``i`` "
"and ``j``, but not for ``database``."
msgstr ""

#: library/dataclasses.rst:472
msgid "Frozen instances"
msgstr ""

#: library/dataclasses.rst:474
msgid ""
"It is not possible to create truly immutable Python objects.  However, by "
"passing ``frozen=True`` to the :meth:`dataclass` decorator you can emulate "
"immutability.  In that case, dataclasses will add :meth:`__setattr__` and :"
"meth:`__delattr__` methods to the class.  These methods will raise a :exc:"
"`FrozenInstanceError` when invoked."
msgstr ""

#: library/dataclasses.rst:480
msgid ""
"There is a tiny performance penalty when using ``frozen=True``: :meth:"
"`__init__` cannot use simple assignment to initialize fields, and must use :"
"meth:`object.__setattr__`."
msgstr ""

#: library/dataclasses.rst:485
msgid "Inheritance"
msgstr "Héritage"

#: library/dataclasses.rst:487
msgid ""
"When the dataclass is being created by the :meth:`dataclass` decorator, it "
"looks through all of the class's base classes in reverse MRO (that is, "
"starting at :class:`object`) and, for each dataclass that it finds, adds the "
"fields from that base class to an ordered mapping of fields. After all of "
"the base class fields are added, it adds its own fields to the ordered "
"mapping.  All of the generated methods will use this combined, calculated "
"ordered mapping of fields.  Because the fields are in insertion order, "
"derived classes override base classes.  An example::"
msgstr ""

#: library/dataclasses.rst:507
msgid ""
"The final list of fields is, in order, ``x``, ``y``, ``z``.  The final type "
"of ``x`` is ``int``, as specified in class ``C``."
msgstr ""

#: library/dataclasses.rst:510
msgid "The generated :meth:`__init__` method for ``C`` will look like::"
msgstr ""

#: library/dataclasses.rst:515
msgid "Default factory functions"
msgstr ""

#: library/dataclasses.rst:517
msgid ""
"If a :func:`field` specifies a ``default_factory``, it is called with zero "
"arguments when a default value for the field is needed.  For example, to "
"create a new instance of a list, use::"
msgstr ""

#: library/dataclasses.rst:523
msgid ""
"If a field is excluded from :meth:`__init__` (using ``init=False``) and the "
"field also specifies ``default_factory``, then the default factory function "
"will always be called from the generated :meth:`__init__` function.  This "
"happens because there is no other way to give the field an initial value."
msgstr ""

#: library/dataclasses.rst:530
msgid "Mutable default values"
msgstr ""

#: library/dataclasses.rst:532
msgid ""
"Python stores default member variable values in class attributes. Consider "
"this example, not using dataclasses::"
msgstr ""

#: library/dataclasses.rst:547
msgid ""
"Note that the two instances of class ``C`` share the same class variable "
"``x``, as expected."
msgstr ""

#: library/dataclasses.rst:550
msgid "Using dataclasses, *if* this code was valid::"
msgstr ""

#: library/dataclasses.rst:558
msgid "it would generate code similar to::"
msgstr ""

#: library/dataclasses.rst:569
msgid ""
"This has the same issue as the original example using class ``C``. That is, "
"two instances of class ``D`` that do not specify a value for ``x`` when "
"creating a class instance will share the same copy of ``x``.  Because "
"dataclasses just use normal Python class creation they also share this "
"behavior.  There is no general way for Data Classes to detect this "
"condition.  Instead, dataclasses will raise a :exc:`TypeError` if it detects "
"a default parameter of type ``list``, ``dict``, or ``set``.  This is a "
"partial solution, but it does protect against many common errors."
msgstr ""

#: library/dataclasses.rst:579
msgid ""
"Using default factory functions is a way to create new instances of mutable "
"types as default values for fields::"
msgstr ""

#: library/dataclasses.rst:589
msgid "Exceptions"
msgstr "Exceptions"

#: library/dataclasses.rst:593
msgid ""
"Raised when an implicitly defined :meth:`__setattr__` or :meth:`__delattr__` "
"is called on a dataclass which was defined with ``frozen=True``."
msgstr ""
