# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-13 15:10+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid "Enum HOWTO"

msgstr ""

msgid ""

"An :class:`Enum` is a set of symbolic names bound to unique values. They "

"are similar to global variables, but they offer a more useful :func:`repr`, "

"grouping, type-safety, and a few other features."

msgstr ""

msgid ""

"They are most useful when you have a variable that can take one of a limited "

"selection of values. For example, the days of the week::"

msgstr ""

msgid ""

">>> from enum import Enum\n"

">>> class Weekday(Enum):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 3\n"

"... THURSDAY = 4\n"

"... FRIDAY = 5\n"

"... SATURDAY = 6\n"

"... SUNDAY = 7"

msgstr ""

msgid "Or perhaps the RGB primary colors::"

msgstr ""

msgid ""

">>> from enum import Enum\n"

">>> class Color(Enum):\n"

"... RED = 1\n"

"... GREEN = 2\n"

"... BLUE = 3"

msgstr ""

msgid ""

"As you can see, creating an :class:`Enum` is as simple as writing a class "

"that inherits from :class:`Enum` itself."

msgstr ""

msgid "Case of Enum Members"

msgstr "Wielkość liter literałów wyliczeniowych"

msgid ""

"Because Enums are used to represent constants, and to help avoid issues with "

"name clashes between mixin-class methods/attributes and enum names, we "

"strongly recommend using UPPER_CASE names for members, and will be using "

"that style in our examples."

msgstr ""

msgid ""

"Depending on the nature of the enum a member's value may or may not be "

"important, but either way that value can be used to get the corresponding "

"member::"

msgstr ""

msgid ""

">>> Weekday(3)\n"

"<Weekday.WEDNESDAY: 3>"

msgstr ""

">>> Weekday(3)\n"

"<Weekday.WEDNESDAY: 3>"

msgid ""

"As you can see, the ``repr()`` of a member shows the enum name, the member "

"name, and the value. The ``str()`` of a member shows only the enum name and "

"member name::"

msgstr ""

msgid ""

">>> print(Weekday.THURSDAY)\n"

"Weekday.THURSDAY"

msgstr ""

">>> print(Weekday.THURSDAY)\n"

"Weekday.THURSDAY"

msgid "The *type* of an enumeration member is the enum it belongs to::"

msgstr ""

msgid ""

">>> type(Weekday.MONDAY)\n"

"<enum 'Weekday'>\n"

">>> isinstance(Weekday.FRIDAY, Weekday)\n"

"True"

msgstr ""

">>> type(Weekday.MONDAY)\n"

"<enum 'Weekday'>\n"

">>> isinstance(Weekday.FRIDAY, Weekday)\n"

"True"

msgid "Enum members have an attribute that contains just their :attr:`!name`::"

msgstr ""

msgid ""

">>> print(Weekday.TUESDAY.name)\n"

"TUESDAY"

msgstr ""

">>> print(Weekday.TUESDAY.name)\n"

"TUESDAY"

msgid "Likewise, they have an attribute for their :attr:`!value`::"

msgstr ""

msgid ""

">>> Weekday.WEDNESDAY.value\n"

"3"

msgstr ""

">>> Weekday.WEDNESDAY.value\n"

"3"

msgid ""

"Unlike many languages that treat enumerations solely as name/value pairs, "

"Python Enums can have behavior added. For example, :class:`datetime.date` "

"has two methods for returning the weekday: :meth:`~datetime.date.weekday` "

"and :meth:`~datetime.date.isoweekday`. The difference is that one of them "

"counts from 0-6 and the other from 1-7. Rather than keep track of that "

"ourselves we can add a method to the :class:`!Weekday` enum to extract the "

"day from the :class:`~datetime.date` instance and return the matching enum "

"member::"

msgstr ""

msgid ""

"@classmethod\n"

"def from_date(cls, date):\n"

" return cls(date.isoweekday())"

msgstr ""

msgid "The complete :class:`!Weekday` enum now looks like this::"

msgstr ""

msgid ""

">>> class Weekday(Enum):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 3\n"

"... THURSDAY = 4\n"

"... FRIDAY = 5\n"

"... SATURDAY = 6\n"

"... SUNDAY = 7\n"

"... #\n"

"... @classmethod\n"

"... def from_date(cls, date):\n"

"... return cls(date.isoweekday())"

msgstr ""

msgid "Now we can find out what today is! Observe::"

msgstr ""

msgid ""

">>> import datetime as dt\n"

">>> Weekday.from_date(dt.date.today())\n"

"<Weekday.TUESDAY: 2>"

msgstr ""

msgid ""

"Of course, if you're reading this on some other day, you'll see that day "

"instead."

msgstr ""

msgid ""

"This :class:`!Weekday` enum is great if our variable only needs one day, but "

"what if we need several? Maybe we're writing a function to plot chores "

"during a week, and don't want to use a :class:`list` -- we could use a "

"different type of :class:`Enum`::"

msgstr ""

msgid ""

">>> from enum import Flag\n"

">>> class Weekday(Flag):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 4\n"

"... THURSDAY = 8\n"

"... FRIDAY = 16\n"

"... SATURDAY = 32\n"

"... SUNDAY = 64"

msgstr ""

msgid ""

"We've changed two things: we're inherited from :class:`Flag`, and the values "

"are all powers of 2."

msgstr ""

msgid ""

"Just like the original :class:`!Weekday` enum above, we can have a single "

"selection::"

msgstr ""

msgid ""

">>> first_week_day = Weekday.MONDAY\n"

">>> first_week_day\n"

"<Weekday.MONDAY: 1>"

msgstr ""

">>> first_week_day = Weekday.MONDAY\n"

">>> first_week_day\n"

"<Weekday.MONDAY: 1>"

msgid ""

"But :class:`Flag` also allows us to combine several members into a single "

"variable::"

msgstr ""

msgid ""

">>> weekend = Weekday.SATURDAY | Weekday.SUNDAY\n"

">>> weekend\n"

"<Weekday.SATURDAY|SUNDAY: 96>"

msgstr ""

">>> weekend = Weekday.SATURDAY | Weekday.SUNDAY\n"

">>> weekend\n"

"<Weekday.SATURDAY|SUNDAY: 96>"

msgid "You can even iterate over a :class:`Flag` variable::"

msgstr ""

msgid ""

">>> for day in weekend:\n"

"... print(day)\n"

"Weekday.SATURDAY\n"

"Weekday.SUNDAY"

msgstr ""

">>> for day in weekend:\n"

"... print(day)\n"

"Weekday.SATURDAY\n"

"Weekday.SUNDAY"

msgid "Okay, let's get some chores set up::"

msgstr ""

msgid ""

">>> chores_for_ethan = {\n"

"... 'feed the cat': Weekday.MONDAY | Weekday.WEDNESDAY | Weekday."

"FRIDAY,\n"

"... 'do the dishes': Weekday.TUESDAY | Weekday.THURSDAY,\n"

"... 'answer SO questions': Weekday.SATURDAY,\n"

"... }"

msgstr ""

msgid "And a function to display the chores for a given day::"

msgstr ""

msgid ""

">>> def show_chores(chores, day):\n"

"... for chore, days in chores.items():\n"

"... if day in days:\n"

"... print(chore)\n"

"...\n"

">>> show_chores(chores_for_ethan, Weekday.SATURDAY)\n"

"answer SO questions"

msgstr ""

msgid ""

"In cases where the actual values of the members do not matter, you can save "

"yourself some work and use :func:`auto` for the values::"

msgstr ""

msgid ""

">>> from enum import auto\n"

">>> class Weekday(Flag):\n"

"... MONDAY = auto()\n"

"... TUESDAY = auto()\n"

"... WEDNESDAY = auto()\n"

"... THURSDAY = auto()\n"

"... FRIDAY = auto()\n"

"... SATURDAY = auto()\n"

"... SUNDAY = auto()\n"

"... WEEKEND = SATURDAY | SUNDAY"

msgstr ""

msgid "Programmatic access to enumeration members and their attributes"

msgstr ""

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 ""

msgid ""

">>> Color(1)\n"

"<Color.RED: 1>\n"

">>> Color(3)\n"

"<Color.BLUE: 3>"

msgstr ""

">>> Color(1)\n"

"<Color.RED: 1>\n"

">>> Color(3)\n"

"<Color.BLUE: 3>"

msgid "If you want to access enum members by *name*, use item access::"

msgstr ""

msgid ""

">>> Color['RED']\n"

"<Color.RED: 1>\n"

">>> Color['GREEN']\n"

"<Color.GREEN: 2>"

msgstr ""

">>> Color['RED']\n"

"<Color.RED: 1>\n"

">>> Color['GREEN']\n"

"<Color.GREEN: 2>"

msgid ""

"If you have an enum member and need its :attr:`!name` or :attr:`!value`::"

msgstr ""

msgid ""

">>> member = Color.RED\n"

">>> member.name\n"

"'RED'\n"

">>> member.value\n"

"1"

msgstr ""

">>> member = Color.RED\n"

">>> member.name\n"

"'RED'\n"

">>> member.value\n"

"1"

msgid "Duplicating enum members and values"

msgstr ""

msgid "Having two enum members with the same name is invalid::"

msgstr ""

msgid ""

">>> class Shape(Enum):\n"

"... SQUARE = 2\n"

"... SQUARE = 3\n"

"...\n"

"Traceback (most recent call last):\n"

"...\n"

"TypeError: 'SQUARE' already defined as 2"

msgstr ""

msgid ""

"However, an enum member can have other names associated with it. Given two "

"entries ``A`` and ``B`` with the same value (and ``A`` defined first), ``B`` "

"is an alias for the member ``A``. By-value lookup of the value of ``A`` "

"will return the member ``A``. By-name lookup of ``A`` will return the "

"member ``A``. By-name lookup of ``B`` will also return the member ``A``::"

msgstr ""

msgid ""

">>> class Shape(Enum):\n"

"... SQUARE = 2\n"

"... DIAMOND = 1\n"

"... CIRCLE = 3\n"

"... ALIAS_FOR_SQUARE = 2\n"

"...\n"

">>> Shape.SQUARE\n"

"<Shape.SQUARE: 2>\n"

">>> Shape.ALIAS_FOR_SQUARE\n"

"<Shape.SQUARE: 2>\n"

">>> Shape(2)\n"

"<Shape.SQUARE: 2>"

msgstr ""

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 ""

msgid "Ensuring unique enumeration values"

msgstr ""

msgid ""

"By default, enumerations allow multiple names as aliases for the same value. "

"When this behavior isn't desired, you can use the :func:`unique` decorator::"

msgstr ""

msgid ""

">>> from enum import Enum, unique\n"

">>> @unique\n"

"... class Mistake(Enum):\n"

"... ONE = 1\n"

"... TWO = 2\n"

"... THREE = 3\n"

"... FOUR = 3\n"

"...\n"

"Traceback (most recent call last):\n"

"...\n"

"ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE"

msgstr ""

msgid "Using automatic values"

msgstr ""

msgid "If the exact value is unimportant you can use :class:`auto`::"

msgstr ""

msgid ""

">>> from enum import Enum, auto\n"

">>> class Color(Enum):\n"

"... RED = auto()\n"

"... BLUE = auto()\n"

"... GREEN = auto()\n"

"...\n"

">>> [member.value for member in Color]\n"

"[1, 2, 3]"

msgstr ""

msgid ""

"The values are chosen by :func:`~Enum._generate_next_value_`, which can be "

"overridden::"

msgstr ""

msgid ""

">>> class AutoName(Enum):\n"

"... @staticmethod\n"

"... def _generate_next_value_(name, start, count, last_values):\n"

"... return name\n"

"...\n"

">>> class Ordinal(AutoName):\n"

"... NORTH = auto()\n"

"... SOUTH = auto()\n"

"... EAST = auto()\n"

"... WEST = auto()\n"

"...\n"

">>> [member.value for member in Ordinal]\n"

"['NORTH', 'SOUTH', 'EAST', 'WEST']"

msgstr ""

msgid ""

"The :meth:`~Enum._generate_next_value_` method must be defined before any "

"members."

msgstr ""

msgid "Iteration"

msgstr "Iteracja"

msgid "Iterating over the members of an enum does not provide the aliases::"

msgstr ""

msgid ""

">>> list(Shape)\n"

"[<Shape.SQUARE: 2>, <Shape.DIAMOND: 1>, <Shape.CIRCLE: 3>]\n"

">>> list(Weekday)\n"

"[<Weekday.MONDAY: 1>, <Weekday.TUESDAY: 2>, <Weekday.WEDNESDAY: 4>, <Weekday."

"THURSDAY: 8>, <Weekday.FRIDAY: 16>, <Weekday.SATURDAY: 32>, <Weekday.SUNDAY: "

"64>]"

msgstr ""

msgid ""

"Note that the aliases ``Shape.ALIAS_FOR_SQUARE`` and ``Weekday.WEEKEND`` "

"aren't shown."

msgstr ""

msgid ""

"The special attribute ``__members__`` is a read-only ordered mapping of "

"names to members. It includes all names defined in the enumeration, "

"including the aliases::"

msgstr ""

msgid ""

">>> for name, member in Shape.__members__.items():\n"

"... name, member\n"

"...\n"

"('SQUARE', <Shape.SQUARE: 2>)\n"

"('DIAMOND', <Shape.DIAMOND: 1>)\n"

"('CIRCLE', <Shape.CIRCLE: 3>)\n"

"('ALIAS_FOR_SQUARE', <Shape.SQUARE: 2>)"

msgstr ""

msgid ""

"The ``__members__`` attribute can be used for detailed programmatic access "

"to the enumeration members. For example, finding all the aliases::"

msgstr ""

msgid ""

">>> [name for name, member in Shape.__members__.items() if member.name != "

"name]\n"

"['ALIAS_FOR_SQUARE']"

msgstr ""

">>> [name for name, member in Shape.__members__.items() if member.name != "

"name]\n"

"['ALIAS_FOR_SQUARE']"

msgid ""

"Aliases for flags include values with multiple flags set, such as ``3``, and "

"no flags set, i.e. ``0``."

msgstr ""

msgid "Comparisons"

msgstr ""

msgid "Enumeration members are compared by identity::"

msgstr ""

msgid ""

">>> Color.RED is Color.RED\n"

"True\n"

">>> Color.RED is Color.BLUE\n"

"False\n"

">>> Color.RED is not Color.BLUE\n"

"True"

msgstr ""

msgid ""

"Ordered comparisons between enumeration values are *not* supported. Enum "

"members are not integers (but see `IntEnum`_ below)::"

msgstr ""

msgid ""

">>> Color.RED < Color.BLUE\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: '<' not supported between instances of 'Color' and 'Color'"

msgstr ""

msgid "Equality comparisons are defined though::"

msgstr ""

msgid ""

">>> Color.BLUE == Color.RED\n"

"False\n"

">>> Color.BLUE != Color.RED\n"

"True\n"

">>> Color.BLUE == Color.BLUE\n"

"True"

msgstr ""

msgid ""

"Comparisons against non-enumeration values will always compare not equal "

"(again, :class:`IntEnum` was explicitly designed to behave differently, see "

"below)::"

msgstr ""

msgid ""

">>> Color.BLUE == 2\n"

"False"

msgstr ""

">>> Color.BLUE == 2\n"

"False"

msgid ""

"It is possible to reload modules -- if a reloaded module contains enums, "

"they will be recreated, and the new members may not compare identical/equal "

"to the original members."

msgstr ""

msgid "Allowed members and attributes of enumerations"

msgstr ""

msgid ""

"Most of 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 ""

msgid ""

"Enumerations are Python classes, and can have methods and special methods as "

"usual. If we have this enumeration::"

msgstr ""

msgid ""

">>> class Mood(Enum):\n"

"... FUNKY = 1\n"

"... HAPPY = 3\n"

"...\n"

"... def describe(self):\n"

"... # self is the member here\n"

"... return self.name, self.value\n"

"...\n"

"... def __str__(self):\n"

"... return 'my custom str! {0}'.format(self.value)\n"

"...\n"

"... @classmethod\n"

"... def favorite_mood(cls):\n"

"... # cls here is the enumeration\n"

"... return cls.HAPPY\n"

"..."

msgstr ""

msgid "Then::"

msgstr ""

msgid ""

">>> Mood.favorite_mood()\n"

"<Mood.HAPPY: 3>\n"

">>> Mood.HAPPY.describe()\n"

"('HAPPY', 3)\n"

">>> str(Mood.FUNKY)\n"

"'my custom str! 1'"

msgstr ""

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:`~object."

"__str__`, :meth:`~object.__add__`, etc.), descriptors (methods are also "

"descriptors), and variable names listed in :attr:`~Enum._ignore_`."

msgstr ""

msgid ""

"Note: if your enumeration defines :meth:`~object.__new__` and/or :meth:"

"`~object.__init__`, any value(s) given to the enum member will be passed "

"into those methods. See `Planet`_ for an example."

msgstr ""

msgid ""

"The :meth:`~object.__new__` method, if defined, is used during creation of "

"the Enum members; it is then replaced by Enum's :meth:`~object.__new__` "

"which is used after class creation for lookup of existing members. See :ref:"

"`new-vs-init` for more details."

msgstr ""

msgid "Restricted Enum subclassing"

msgstr ""

msgid ""

"A new :class:`Enum` class must have one base enum class, up to one concrete "

"data type, and as many :class:`object`-based mixin classes as needed. The "

"order of these base classes is::"

msgstr ""

msgid ""

"class EnumName([mix-in, ...,] [data-type,] base-enum):\n"

" pass"

msgstr ""

msgid ""

"Also, subclassing an enumeration is allowed only if the enumeration does not "

"define any members. So this is forbidden::"

msgstr ""

msgid ""

">>> class MoreColor(Color):\n"

"... PINK = 17\n"

"...\n"

"Traceback (most recent call last):\n"

"...\n"

"TypeError: <enum 'MoreColor'> cannot extend <enum 'Color'>"

msgstr ""

msgid "But this is allowed::"

msgstr ""

msgid ""

">>> class Foo(Enum):\n"

"... def some_behavior(self):\n"

"... pass\n"

"...\n"

">>> class Bar(Foo):\n"

"... HAPPY = 1\n"

"... SAD = 2\n"

"..."

msgstr ""

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 ""

msgid "Dataclass support"

msgstr ""

msgid ""

"When inheriting from a :class:`~dataclasses.dataclass`, the :meth:`~Enum."

"__repr__` omits the inherited class' name. For example::"

msgstr ""

msgid ""

">>> from dataclasses import dataclass, field\n"

">>> @dataclass\n"

"... class CreatureDataMixin:\n"

"... size: str\n"

"... legs: int\n"

"... tail: bool = field(repr=False, default=True)\n"

"...\n"

">>> class Creature(CreatureDataMixin, Enum):\n"

"... BEETLE = 'small', 6\n"

"... DOG = 'medium', 4\n"

"...\n"

">>> Creature.DOG\n"

"<Creature.DOG: size='medium', legs=4>"

msgstr ""

msgid ""

"Use the :func:`~dataclasses.dataclass` argument ``repr=False`` to use the "

"standard :func:`repr`."

msgstr ""

msgid ""

"Only the dataclass fields are shown in the value area, not the dataclass' "

"name."

msgstr ""

msgid ""

"Adding :func:`~dataclasses.dataclass` decorator to :class:`Enum` and its "

"subclasses is not supported. It will not raise any errors, but it will "

"produce very strange results at runtime, such as members being equal to each "

"other::"

msgstr ""

msgid ""

">>> @dataclass # don't do this: it does not make any sense\n"

"... class Color(Enum):\n"

"... RED = 1\n"

"... BLUE = 2\n"

"...\n"

">>> Color.RED is Color.BLUE\n"

"False\n"

">>> Color.RED == Color.BLUE # problem is here: they should not be equal\n"

"True"

msgstr ""

msgid "Pickling"

msgstr ""

msgid "Enumerations can be pickled and unpickled::"

msgstr ""

msgid ""

">>> from test.test_enum import Fruit\n"

">>> from pickle import dumps, loads\n"

">>> Fruit.TOMATO is loads(dumps(Fruit.TOMATO))\n"

"True"

msgstr ""

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 ""

msgid ""

"With pickle protocol version 4 it is possible to easily pickle enums nested "

"in other classes."

msgstr ""

msgid ""

"It is possible to modify how enum members are pickled/unpickled by defining :"

"meth:`~object.__reduce_ex__` in the enumeration class. The default method "

"is by-value, but enums with complicated values may want to use by-name::"

msgstr ""

msgid ""

">>> import enum\n"

">>> class MyEnum(enum.Enum):\n"

"... __reduce_ex__ = enum.pickle_by_enum_name"

msgstr ""

">>> import enum\n"

">>> class MyEnum(enum.Enum):\n"

"... __reduce_ex__ = enum.pickle_by_enum_name"

msgid ""

"Using by-name for flags is not recommended, as unnamed aliases will not "

"unpickle."

msgstr ""

msgid "Functional API"

msgstr ""

msgid ""

"The :class:`Enum` class is callable, providing the following functional API::"

msgstr ""

msgid ""

">>> Animal = Enum('Animal', 'ANT BEE CAT DOG')\n"

">>> Animal\n"

"<enum 'Animal'>\n"

">>> Animal.ANT\n"

"<Animal.ANT: 1>\n"

">>> list(Animal)\n"

"[<Animal.ANT: 1>, <Animal.BEE: 2>, <Animal.CAT: 3>, <Animal.DOG: 4>]"

msgstr ""

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 ""

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 ""

msgid ""

">>> class Animal(Enum):\n"

"... ANT = 1\n"

"... BEE = 2\n"

"... CAT = 3\n"

"... DOG = 4\n"

"..."

msgstr ""

msgid ""

"The reason for defaulting to ``1`` as the starting number and not ``0`` is "

"that ``0`` is ``False`` in a boolean sense, but by default enum members all "

"evaluate to ``True``."

msgstr ""

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 a separate module, and also may not work on IronPython or "

"Jython). The solution is to specify the module name explicitly as follows::"

msgstr ""

msgid ">>> Animal = Enum('Animal', 'ANT BEE CAT DOG', module=__name__)"

msgstr ">>> Animal = Enum('Animal', 'ANT BEE CAT DOG', module=__name__)"

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 ""

msgid ""

"The new pickle protocol 4 also, in some circumstances, relies on :attr:"

"`~type.__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 ""

msgid ""

">>> Animal = Enum('Animal', 'ANT BEE CAT DOG', qualname='SomeData.Animal')"

msgstr ""

">>> Animal = Enum('Animal', 'ANT BEE CAT DOG', qualname='SomeData.Animal')"

msgid "The complete signature is::"

msgstr ""

msgid ""

"Enum(\n"

" value='NewEnumName',\n"

" names=<...>,\n"

" *,\n"

" module='...',\n"

" qualname='...',\n"

" type=<mixed-in class>,\n"

" start=1,\n"

" )"

msgstr ""

msgid "*value*: What the new enum class will record as its name."

msgstr ""

msgid ""

"*names*: The enum members. This can be a whitespace- or comma-separated "

"string (values will start at 1 unless otherwise specified)::"

msgstr ""

msgid "'RED GREEN BLUE' | 'RED,GREEN,BLUE' | 'RED, GREEN, BLUE'"

msgstr ""

msgid "or an iterator of names::"

msgstr ""

msgid "['RED', 'GREEN', 'BLUE']"

msgstr ""

msgid "or an iterator of (name, value) pairs::"

msgstr ""

msgid "[('CYAN', 4), ('MAGENTA', 5), ('YELLOW', 6)]"

msgstr ""

msgid "or a mapping::"

msgstr ""

msgid "{'CHARTREUSE': 7, 'SEA_GREEN': 11, 'ROSEMARY': 42}"

msgstr ""

msgid "*module*: name of module where new enum class can be found."

msgstr ""

msgid "*qualname*: where in module new enum class can be found."

msgstr ""

msgid "*type*: type to mix in to new enum class."

msgstr ""

msgid "*start*: number to start counting at if only names are passed in."

msgstr ""

msgid "The *start* parameter was added."

msgstr ""

msgid "Derived Enumerations"

msgstr ""

msgid "IntEnum"

msgstr ""

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 ""

msgid ""

">>> from enum import IntEnum\n"

">>> class Shape(IntEnum):\n"

"... CIRCLE = 1\n"

"... SQUARE = 2\n"

"...\n"

">>> class Request(IntEnum):\n"

"... POST = 1\n"

"... GET = 2\n"

"...\n"

">>> Shape == 1\n"

"False\n"

">>> Shape.CIRCLE == 1\n"

"True\n"

">>> Shape.CIRCLE == Request.POST\n"

"True"

msgstr ""

msgid ""

"However, they still can't be compared to standard :class:`Enum` "

"enumerations::"

msgstr ""

msgid ""

">>> class Shape(IntEnum):\n"

"... CIRCLE = 1\n"

"... SQUARE = 2\n"

"...\n"

">>> class Color(Enum):\n"

"... RED = 1\n"

"... GREEN = 2\n"

"...\n"

">>> Shape.CIRCLE == Color.RED\n"

"False"

msgstr ""

msgid ""

":class:`IntEnum` values behave like integers in other ways you'd expect::"

msgstr ""

msgid ""

">>> int(Shape.CIRCLE)\n"

"1\n"

">>> ['a', 'b', 'c'][Shape.CIRCLE]\n"

"'b'\n"

">>> [i for i in range(Shape.SQUARE)]\n"

"[0, 1]"

msgstr ""

msgid "StrEnum"

msgstr "StrEnum"

msgid ""

"The second variation of :class:`Enum` that is provided is also a subclass "

"of :class:`str`. Members of a :class:`StrEnum` can be compared to strings; "

"by extension, string enumerations of different types can also be compared to "

"each other."

msgstr ""

msgid "IntFlag"

msgstr "IntFlag"

msgid ""

"The next variation of :class:`Enum` provided, :class:`IntFlag`, is also "

"based on :class:`int`. The difference being :class:`IntFlag` members can be "

"combined using the bitwise operators (&, \\|, ^, ~) and the result is still "

"an :class:`IntFlag` member, if possible. Like :class:`IntEnum`, :class:"