enum.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Language-Team: Hungarian (https://www.transifex.com/python-doc/teams/5390/hu/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: hu\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../library/enum.rst:2
msgid ":mod:`enum` --- Support for enumerations"
msgstr ""

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

#: ../../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."
msgstr ""

#: ../../library/enum.rst:24
msgid "Module Contents"
msgstr ""

#: ../../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`."
msgstr ""

#: ../../library/enum.rst:33
msgid ""
"Base class for creating enumerated constants.  See section `Functional API`_"
" for an alternate construction syntax."
msgstr ""

#: ../../library/enum.rst:38
msgid ""
"Base class for creating enumerated constants that are also subclasses of "
":class:`int`."
msgstr ""

#: ../../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`."
msgstr ""

#: ../../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."
msgstr ""

#: ../../library/enum.rst:54
msgid ""
"Enum class decorator that ensures only one name is bound to any one value."
msgstr ""

#: ../../library/enum.rst:58
msgid "Instances are replaced with an appropriate value for Enum members."
msgstr ""

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

#: ../../library/enum.rst:64
msgid "Creating an Enum"
msgstr ""

#: ../../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::"
msgstr ""

#: ../../library/enum.rst:78
msgid "Enum member values"
msgstr ""

#: ../../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."
msgstr ""

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

#: ../../library/enum.rst:87
msgid "The class :class:`Color` is an *enumeration* (or *enum*)"
msgstr ""

#: ../../library/enum.rst:88
msgid ""
"The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are "
"*enumeration members* (or *enum members*) and are functionally constants."
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../library/enum.rst:100
msgid "Enumeration members have human readable string representations::"
msgstr ""

#: ../../library/enum.rst:105
msgid "...while their ``repr`` has more information::"
msgstr ""

#: ../../library/enum.rst:110
msgid "The *type* of an enumeration member is the enumeration it belongs to::"
msgstr ""

#: ../../library/enum.rst:118
msgid "Enum members also have a property that contains just their item name::"
msgstr ""

#: ../../library/enum.rst:123
msgid "Enumerations support iteration, in definition order::"
msgstr ""

#: ../../library/enum.rst:139
msgid ""
"Enumeration members are hashable, so they can be used in dictionaries and "
"sets::"
msgstr ""

#: ../../library/enum.rst:149
msgid "Programmatic access to enumeration members and their attributes"
msgstr ""

#: ../../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::"
msgstr ""

#: ../../library/enum.rst:160
msgid "If you want to access enum members by *name*, use item access::"
msgstr ""

#: ../../library/enum.rst:167
msgid ""
"If you have an enum member and need its :attr:`name` or :attr:`value`::"
msgstr ""

#: ../../library/enum.rst:177
msgid "Duplicating enum members and values"
msgstr ""

#: ../../library/enum.rst:179
msgid "Having two enum members with the same name is invalid::"
msgstr ""

#: ../../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::"
msgstr ""

#: ../../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."
msgstr ""

#: ../../library/enum.rst:215
msgid "Ensuring unique enumeration values"
msgstr ""

#: ../../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:"
msgstr ""

#: ../../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::"
msgstr ""

#: ../../library/enum.rst:241
msgid "Using automatic values"
msgstr ""

#: ../../library/enum.rst:243
msgid "If the exact value is unimportant you can use :class:`auto`::"
msgstr ""

#: ../../library/enum.rst:254
msgid ""
"The values are chosen by :func:`_generate_next_value_`, which can be "
"overridden::"
msgstr ""

#: ../../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."
msgstr ""

#: ../../library/enum.rst:277
msgid "Iteration"
msgstr ""

#: ../../library/enum.rst:279
msgid "Iterating over the members of an enum does not provide the aliases::"
msgstr ""

#: ../../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::"
msgstr ""

#: ../../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::"
msgstr ""

#: ../../library/enum.rst:304
msgid "Comparisons"
msgstr ""

#: ../../library/enum.rst:306
msgid "Enumeration members are compared by identity::"
msgstr ""

#: ../../library/enum.rst:315
msgid ""
"Ordered comparisons between enumeration values are *not* supported.  Enum "
"members are not integers (but see `IntEnum`_ below)::"
msgstr ""

#: ../../library/enum.rst:323
msgid "Equality comparisons are defined though::"
msgstr ""

#: ../../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)::"
msgstr ""

#: ../../library/enum.rst:341
msgid "Allowed members and attributes of enumerations"
msgstr ""

#: ../../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."
msgstr ""

#: ../../library/enum.rst:349
msgid ""
"Enumerations are Python classes, and can have methods and special methods as"
" usual.  If we have this enumeration::"
msgstr ""

#: ../../library/enum.rst:369
msgid "Then::"
msgstr ""

#: ../../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.) and descriptors (methods are also descriptors)."
msgstr ""

#: ../../library/enum.rst:384
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."
msgstr ""

#: ../../library/enum.rst:390
msgid "Restricted subclassing of enumerations"
msgstr ""

#: ../../library/enum.rst:392
msgid ""
"Subclassing an enumeration is allowed only if the enumeration does not "
"define any members.  So this is forbidden::"
msgstr ""

#: ../../library/enum.rst:402
msgid "But this is allowed::"
msgstr ""

#: ../../library/enum.rst:413
msgid ""
"Allowing subclassing of enums that define members would lead to a violation "
"of some important invariants of types and instances.  On the other hand, it "
"makes sense to allow sharing some common behavior between a group of "
"enumerations. (See `OrderedEnum`_ for an example.)"
msgstr ""

#: ../../library/enum.rst:420
msgid "Pickling"
msgstr ""

#: ../../library/enum.rst:422
msgid "Enumerations can be pickled and unpickled::"
msgstr ""

#: ../../library/enum.rst:429
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 ""

#: ../../library/enum.rst:435
msgid ""
"With pickle protocol version 4 it is possible to easily pickle enums nested "
"in other classes."
msgstr ""

#: ../../library/enum.rst:438
msgid ""
"It is possible to modify how Enum members are pickled/unpickled by defining "
":meth:`__reduce_ex__` in the enumeration class."
msgstr ""

#: ../../library/enum.rst:443
msgid "Functional API"
msgstr ""

#: ../../library/enum.rst:445
msgid ""
"The :class:`Enum` class is callable, providing the following functional "
"API::"
msgstr ""

#: ../../library/enum.rst:457
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 ""

#: ../../library/enum.rst:460
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 ""

#: ../../library/enum.rst:476
msgid ""
"The reason for defaulting to ``1`` as the starting number and not ``0`` is "
"that ``0`` is ``False`` in a boolean sense, but enum members all evaluate to"
" ``True``."
msgstr ""

#: ../../library/enum.rst:480
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 ""

#: ../../library/enum.rst:490
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 ""

#: ../../library/enum.rst:494
msgid ""
"The new pickle protocol 4 also, in some circumstances, relies on "
":attr:`~definition.__qualname__` being set to the location where pickle will"
" be able to find the class.  For example, if the class was made available in"
" class SomeData in the global scope::"
msgstr ""

#: ../../library/enum.rst:501
msgid "The complete signature is::"
msgstr ""

#: ../../library/enum.rst:505
msgid "What the new Enum class will record as its name."
msgstr ""

#: ../../library/enum.rst:507
msgid ""
"The Enum members.  This can be a whitespace or comma separated string "
"(values will start at 1 unless otherwise specified)::"
msgstr ""

#: ../../library/enum.rst:512
msgid "or an iterator of names::"
msgstr ""

#: ../../library/enum.rst:516
msgid "or an iterator of (name, value) pairs::"
msgstr ""

#: ../../library/enum.rst:520
msgid "or a mapping::"
msgstr ""

#: ../../library/enum.rst:524
msgid "name of module where new Enum class can be found."
msgstr ""

#: ../../library/enum.rst:526
msgid "where in module new Enum class can be found."
msgstr ""

#: ../../library/enum.rst:528
msgid "type to mix in to new Enum class."
msgstr ""

#: ../../library/enum.rst:530
msgid "number to start counting at if only names are passed in."
msgstr ""

#: ../../library/enum.rst:532
msgid "The *start* parameter was added."
msgstr ""

#: ../../library/enum.rst:537
msgid "Derived Enumerations"
msgstr ""

#: ../../library/enum.rst:540
msgid "IntEnum"
msgstr ""

#: ../../library/enum.rst:542
msgid ""
"The first variation of :class:`Enum` that is provided is also a subclass of "
":class:`int`.  Members of an :class:`IntEnum` can be compared to integers; "
"by extension, integer enumerations of different types can also be compared "
"to each other::"
msgstr ""

#: ../../library/enum.rst:563
msgid ""
"However, they still can't be compared to standard :class:`Enum` "
"enumerations::"
msgstr ""

#: ../../library/enum.rst:576
msgid ""
":class:`IntEnum` values behave like integers in other ways you'd expect::"
msgstr ""

#: ../../library/enum.rst:587
msgid "IntFlag"
msgstr ""

#: ../../library/enum.rst:589
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 ""

#: ../../library/enum.rst:599
msgid "Sample :class:`IntFlag` class::"
msgstr ""

#: ../../library/enum.rst:615
msgid "It is also possible to name the combinations::"
msgstr ""

#: ../../library/enum.rst:627
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 ""

#: ../../library/enum.rst:635
msgid ""
"Because :class:`IntFlag` members are also subclasses of :class:`int` they "
"can be combined with them::"
msgstr ""

#: ../../library/enum.rst:643
msgid "Flag"
msgstr ""

#: ../../library/enum.rst:645
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 ""

#: ../../library/enum.rst:654
msgid ""
"Like :class:`IntFlag`, if a combination of :class:`Flag` members results in "
"no flags being set, the boolean evaluation is :data:`False`::"
msgstr ""

#: ../../library/enum.rst:668
msgid ""
"Individual flags should have values that are powers of two (1, 2, 4, 8, "
"...), while combinations of flags won't::"
msgstr ""

#: ../../library/enum.rst:680
msgid ""
"Giving a name to the \"no flags set\" condition does not change its boolean "
"value::"
msgstr ""

#: ../../library/enum.rst:696
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 ""

#: ../../library/enum.rst:706
msgid "Others"
msgstr ""

#: ../../library/enum.rst:708
msgid ""
"While :class:`IntEnum` is part of the :mod:`enum` module, it would be very "
"simple to implement independently::"
msgstr ""

#: ../../library/enum.rst:714
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 ""

#: ../../library/enum.rst:717
msgid "Some rules:"
msgstr ""

#: ../../library/enum.rst:719
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 ""

#: ../../library/enum.rst:722
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`."
msgstr ""

#: ../../library/enum.rst:727
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 ""

#: ../../library/enum.rst:730
msgid ""
"%-style formatting:  `%s` and `%r` call the :class:`Enum` class's "
":meth:`__str__` and :meth:`__repr__` respectively; other codes (such as `%i`"
" or `%h` for IntEnum) treat the enum member as its mixed-in type."
msgstr ""

#: ../../library/enum.rst:733
msgid ""
":ref:`Formatted string literals <f-strings>`, :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 ""

#: ../../library/enum.rst:740
msgid "Interesting examples"
msgstr ""

#: ../../library/enum.rst:742
msgid ""
"While :class:`Enum`, :class:`IntEnum`, :class:`IntFlag`, and :class:`Flag` "
"are expected to cover the majority of use-cases, they cannot cover them all."
"  Here are recipes for some different types of enumerations that can be used"
" directly, or as examples for creating one's own."
msgstr ""

#: ../../library/enum.rst:749
msgid "Omitting values"
msgstr ""

#: ../../library/enum.rst:751
msgid ""
"In many use-cases one doesn't care what the actual value of an enumeration "
"is. There are several ways to define this type of simple enumeration:"
msgstr ""

#: ../../library/enum.rst:754
msgid "use instances of :class:`auto` for the value"
msgstr ""

#: ../../library/enum.rst:755
msgid "use instances of :class:`object` as the value"
msgstr ""

#: ../../library/enum.rst:756
msgid "use a descriptive string as the value"
msgstr ""

#: ../../library/enum.rst:757
msgid ""
"use a tuple as the value and a custom :meth:`__new__` to replace the tuple "
"with an :class:`int` value"
msgstr ""

#: ../../library/enum.rst:760
msgid ""
"Using any of these methods signifies to the user that these values are not "
"important, and also enables one to add, remove, or reorder members without "
"having to renumber the remaining members."
msgstr ""

#: ../../library/enum.rst:764
msgid ""
"Whichever method you choose, you should provide a :meth:`repr` that also "
"hides the (unimportant) value::"
msgstr ""

#: ../../library/enum.rst:774
msgid "Using :class:`auto`"
msgstr ""

#: ../../library/enum.rst:776
msgid "Using :class:`auto` would look like::"
msgstr ""

#: ../../library/enum.rst:788
msgid "Using :class:`object`"
msgstr ""

#: ../../library/enum.rst:790
msgid "Using :class:`object` would look like::"
msgstr ""

#: ../../library/enum.rst:802
msgid "Using a descriptive string"
msgstr ""

#: ../../library/enum.rst:804
msgid "Using a string as the value would look like::"
msgstr ""

#: ../../library/enum.rst:818
msgid "Using a custom :meth:`__new__`"
msgstr ""

#: ../../library/enum.rst:820
msgid "Using an auto-numbering :meth:`__new__` would look like::"
msgstr ""

#: ../../library/enum.rst:842
msgid ""
"The :meth:`__new__` method, if defined, is used during creation of the Enum "
"members; it is then replaced by Enum's :meth:`__new__` which is used after "
"class creation for lookup of existing members."
msgstr ""

#: ../../library/enum.rst:848
msgid "OrderedEnum"
msgstr ""

#: ../../library/enum.rst:850
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 ""

#: ../../library/enum.rst:884
msgid "DuplicateFreeEnum"
msgstr ""

#: ../../library/enum.rst:886
msgid ""
"Raises an error if a duplicate member name is found instead of creating an "
"alias::"
msgstr ""

#: ../../library/enum.rst:911
msgid ""
"This is a useful example for subclassing Enum to add or change other "
"behaviors as well as disallowing aliases.  If the only desired change is "
"disallowing aliases, the :func:`unique` decorator can be used instead."
msgstr ""

#: ../../library/enum.rst:917
msgid "Planet"
msgstr ""

#: ../../library/enum.rst:919
msgid ""
"If :meth:`__new__` or :meth:`__init__` is defined the value of the enum "
"member will be passed to those methods::"
msgstr ""

#: ../../library/enum.rst:947
msgid "How are Enums different?"
msgstr ""

#: ../../library/enum.rst:949
msgid ""
"Enums have a custom metaclass that affects many aspects of both derived Enum"
" classes and their instances (members)."
msgstr ""

#: ../../library/enum.rst:954
msgid "Enum Classes"
msgstr ""

#: ../../library/enum.rst:956
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_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 ""

#: ../../library/enum.rst:966
msgid "Enum Members (aka instances)"
msgstr ""

#: ../../library/enum.rst:968
msgid ""
"The most interesting thing about Enum members is that they are singletons. "
":class:`EnumMeta` creates them all while it is creating the :class:`Enum` "
"class itself, and then puts a custom :meth:`__new__` in place to ensure that"
" no new ones are ever instantiated by returning only the existing member "
"instances."
msgstr ""

#: ../../library/enum.rst:976
msgid "Finer Points"
msgstr ""

#: ../../library/enum.rst:979
msgid "Supported ``__dunder__`` names"
msgstr ""

#: ../../library/enum.rst:981
msgid ""
":attr:`__members__` is an :class:`OrderedDict` of ``member_name``:``member``"
" items.  It is only available on the class."
msgstr ""

#: ../../library/enum.rst:984
msgid ""
":meth:`__new__`, if specified, must create and return the enum members; it "
"is also a very good idea to set the member's :attr:`_value_` appropriately."
"  Once all the members are created it is no longer used."
msgstr ""

#: ../../library/enum.rst:990
msgid "Supported ``_sunder_`` names"
msgstr ""

#: ../../library/enum.rst:992
msgid "``_name_`` -- name of the member"
msgstr ""

#: ../../library/enum.rst:993
msgid ""
"``_value_`` -- value of the member; can be set / modified in ``__new__``"
msgstr ""

#: ../../library/enum.rst:995
msgid ""
"``_missing_`` -- a lookup function used when a value is not found; may be "
"overridden"
msgstr ""

#: ../../library/enum.rst:997
msgid ""
"``_order_`` -- used in Python 2/3 code to ensure member order is consistent "
"(class attribute, removed during class creation)"
msgstr ""

#: ../../library/enum.rst:999
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 ""

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

#: ../../library/enum.rst:1005
msgid ""
"To help keep Python 2 / Python 3 code in sync an :attr:`_order_` attribute "
"can be provided.  It will be checked against the actual order of the "
"enumeration and raise an error if the two do not match::"
msgstr ""

#: ../../library/enum.rst:1021
msgid ""
"In Python 2 code the :attr:`_order_` attribute is necessary as definition "
"order is lost before it can be recorded."
msgstr ""

#: ../../library/enum.rst:1025
msgid "``Enum`` member type"
msgstr ""

#: ../../library/enum.rst:1027
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 ""

#: ../../library/enum.rst:1048
msgid "Boolean value of ``Enum`` classes and members"
msgstr ""

#: ../../library/enum.rst:1050
msgid ""
":class:`Enum` members that are mixed with non-:class:`Enum` types (such as "
":class:`int`, :class:`str`, etc.) are evaluated according to the mixed-in "
"type's rules; otherwise, all members evaluate as :data:`True`.  To make your"
" own Enum's boolean evaluation depend on the member's value add the "
"following to your class::"
msgstr ""

#: ../../library/enum.rst:1059
msgid ":class:`Enum` classes always evaluate as :data:`True`."
msgstr ""

#: ../../library/enum.rst:1063
msgid "``Enum`` classes with methods"
msgstr ""

#: ../../library/enum.rst:1065
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 ""

#: ../../library/enum.rst:1076
msgid "Combining members of ``Flag``"
msgstr ""

#: ../../library/enum.rst:1078
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 ""