"enum" --- 列挙型のサポート
***************************

Added in version 3.4.

**ソースコード:** Lib/enum.py


Important
^^^^^^^^^

このページには API リファレンス情報が記載されています。 チュートリアル
や、より高度な話題の説明については以下を参照してください。

* 基本チュートリアル

* 上級チュートリアル

* Enum クックブック

======================================================================

列挙型とは:

* 一意の値に紐付けられたシンボリックな名前の集合です

* 反復可能であり、定義順にその正規の（エイリアスでない）メンバーを返し
  ます

* 値を渡してメンバーを返すために、 *呼び出し* 構文を使用します

* 名前を受け取ってメンバーを返すために、 *インデックス* 構文を使用しま
  す

列挙型は、"class" 構文を使用するか、関数呼び出し構文を使用して作成され
ます:

   >>> from enum import Enum

   >>> # class 構文
   >>> class Color(Enum):
   ...     RED = 1
   ...     GREEN = 2
   ...     BLUE = 3

   >>> # 関数呼び出し構文
   >>> Color = Enum('Color', [('RED', 1), ('GREEN', 2), ('BLUE', 3)])

Enum の作成に "class" 文を使用できるものの、Enum は通常の Python クラ
スではありません。詳細は Enum はどう違うのか? を参照してください。

注釈:

  用語

  * クラス "Color" は *列挙型* (または *Enum*) です

  * 属性 "Color.RED", "Color.GREEN" などは *列挙型のメンバー* (または
    *メンバー*) で、機能的には定数です。

  * 列挙型のメンバーは *名前* と *値* を持ちます ("Color.RED" の名前は
    "RED" 、 "Color.BLUE" の値は "3" など。)

======================================================================


モジュールの内容
================

   "EnumType"

      Enumおよびそのサブクラスのための "type" です。

   "Enum"

      列挙型定数を作成する基底クラスです。

   "IntEnum"

      "int" のサブクラスでもある列挙型定数を作成する基底クラスです。
      (Notes)

   "StrEnum"

      "str" のサブクラスでもある列挙型定数を作成する基底クラスです。
      (Notes)

   "Flag"

      列挙型定数を作成する基底クラスで、ビット演算を使って組み合わせら
      れ、その結果も "Flag" メンバーになります。

   "IntFlag"

      列挙型定数を作成する基底クラスで、ビット演算子を使って組み合わせ
      られ、その結果も "IntFlag" メンバーになります。 "IntFlag" は
      "int" のサブクラスでもあります。(Notes)

   "ReprEnum"

      "IntEnum"、"StrEnum"、および "IntFlag" によって使用され、mix-in
      された型の "str()" を保持します。

   "EnumCheck"

      "CONTINUOUS"、"NAMED_FLAGS"、"UNIQUE" の値を持つ列挙型です。
      "verify()" と共に使用して、指定された列挙型がさまざまな制約を満
      たしていることを確認します。

   "FlagBoundary"

      An enumeration with the values "STRICT", "CONFORM", "EJECT", and
      "KEEP" which allows for more fine-grained control over how
      invalid values are dealt with in an enumeration.

   "EnumDict"

      "EnumType" のサブクラスを作成するときに使う "dict" のサブクラス
      です。

   "auto"

      インスタンスは列挙型のメンバーに適切な値で置き換えられます。
      "StrEnum" ではデフォルトの値がメンバー名を小文字にしたものですが
      、その他の列挙型のデフォルトは1から連番で増加する値となります。

   "@~enum.property"

      メンバー名との競合を避けながら "Enum" メンバーに属性を持たせます
      。"value" 属性と "name" 属性はこの方法で実装されます。

   "@unique"

      一つの名前だけがひとつの値に束縛されていることを保証する Enum ク
      ラスのデコレーターです。

   "@verify"

      列挙型が、利用者の選択した制約を満たすか確認する Enum クラスのデ
      コレータです。

   "@member"

      "obj" をメンバーにします。デコレータとして使用できます。

   "@nonmember"

      "obj" をメンバーにしません。デコレータとして使用できます。

   "@global_enum"

      列挙型の "str()" と "repr()" を変更し、メンバーがクラスではなく
      モジュールに属するように表示します。 また、列挙型のメンバーをグ
      ローバル名前空間に公開します。

   "show_flag_values()"

      フラグに含まれる、全ての2の累乗の整数のリストを返します。

   "enum.bin()"

      組み込みの "bin()" と似ていますが、負の値は 2 の補数で表し、先頭
      のビットは常に符号を示します ("0" は正、"1" は負を示します)。

Added in version 3.6: "Flag", "IntFlag", "auto"

Added in version 3.11: "StrEnum", "EnumCheck", "ReprEnum",
"FlagBoundary", "property", "member", "nonmember", "global_enum",
"show_flag_values"

Added in version 3.13: "EnumDict"

======================================================================


データ型
========

class enum.EnumType

   *EnumType* は *enum* 列挙型の *メタクラス* です。 *EnumType* のサブ
   クラスを作成することが可能です -- 詳細は EnumTypeのサブクラスを作る
   を参照してください。

   "EnumType" は、最終的な *enum* に正しい "__repr__()"、"__str__()"、
   "__format__()"、"__reduce__()" メソッドを設定します。 また、列挙型
   のメンバーの作成、重複の適切な処理、列挙型クラスの反復処理の提供な
   ども担当します。

   Added in version 3.11: 3.11 より前は "EnumType" は "EnumMeta" と呼
   ばれていました。 この名前は現在もエイリアスとして使えます。

   __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

      このメソッドは2つの異なる方法で呼び出されます。

      * 既存のメンバーを検索する:

           cls:
              呼び出されるenumクラス。

           value:
              検索する値。

      * "cls" を使って新しい列挙型を作成する（既存の列挙型がメンバーを
        持たない場合のみ）:

           cls:
              呼び出されるenumクラス。

           value:
              新しく作成するEnumの名前。

           names:
              新しく作成するEnumのメンバーの名前/値のリスト。

           module:
              新しく作成するEnumの属するモジュール名。

           qualname:
              この Enum がモジュール内にある実際の位置。

           type:
              新しく作成するEnumのmix-in型。

           start:
              Enumの最初の整数値（"auto" で使用されます）。

           boundary:
              bit演算での範囲外の値の扱い方（"Flag" のみ）。

   __contains__(cls, member)

      メンバーが "cls" に属している場合は "True" を返します:

         >>> some_var = Color.RED
         >>> some_var in Color
         True
         >>> Color.RED.value in Color
         True

      バージョン 3.12 で変更: Python 3.12 より前では、非Enumメンバーの
      包含判定が行われた場合、"TypeError" が送出されます。

   __dir__(cls)

      "['__class__', '__doc__', '__members__', '__module__']" と、
      *cls* に属するメンバー名を返します:

         >>> dir(Color)
         ['BLUE', 'GREEN', 'RED', '__class__', '__contains__', '__doc__', '__getitem__', '__init_subclass__', '__iter__', '__len__', '__members__', '__module__', '__name__', '__qualname__']

   __getitem__(cls, name)

      *cls* 内で *name* に一致する Enum メンバーを返します。 見つから
      なければ "KeyError" を送出します。

         >>> Color['BLUE']
         <Color.BLUE: 3>

   __iter__(cls)

      *cls* 内の各メンバー を定義順に返します:

         >>> list(Color)
         [<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]

   __len__(cls)

      *cls* のメンバー数を返します。

         >>> len(Color)
         3

   __members__

      エイリアスも含め、列挙型のすべての名前を対応するメンバーに結び付
      けるマッピングを返します。

   __reversed__(cls)

      *cls* 内の各メンバー を定義順の逆順で返します:

         >>> list(reversed(Color))
         [<Color.BLUE: 3>, <Color.GREEN: 2>, <Color.RED: 1>]

class enum.Enum

   *Enum* は全ての *enum* 列挙型の基底クラスです。

   name

      "Enum" メンバーを定義するために使用される名前:

         >>> Color.BLUE.name
         'BLUE'

   value

      "Enum" メンバーに与えられた値:

         >>> Color.RED.value
         1

      メンバーの値です。 "__new__()" で設定できます。

      注釈:

        列挙型のメンバー値メンバー値は何であっても構いません: "int",
        "str" などなど。 正確な値が重要でない場合は、 "auto" インスタ
        ンスを使っておくと、適切な値が選ばれます。 詳細は "auto" を参
        照してください。"dict"、"list"、ミュータブルな "dataclass" な
        ど、ミュータブルまたはハッシュ不可能な値も使えます。 ただし作
        成時の処理時間には、列挙型内のそのような値の総数に対して二次的
        に増大する影響があります。

   _name_

      メンバーの名前。

   _value_

      メンバーの値です。 "__new__()" で設定できます。

   _order_

      No longer used, kept for backward compatibility. (class
      attribute, removed during class creation).

      "_order_" 属性を指定すると、Python 2 と Python 3 のコードを揃え
      ておくのに役立ちます。 この属性を列挙型の実際の順序と照合し、一
      致しない場合はエラーを送出します。

         >>> class Color(Enum):
         ...     _order_ = 'RED GREEN BLUE'
         ...     RED = 1
         ...     BLUE = 3
         ...     GREEN = 2
         ...
         Traceback (most recent call last):
         ...
         TypeError: member order does not match _order_:
            ['RED', 'BLUE', 'GREEN']
            ['RED', 'GREEN', 'BLUE']

      注釈:

        Python 2 では、記録する前に定義の順序が失われるため、"_order_"
        属性が必要です。

      Added in version 3.6.

   _ignore_

      "_ignore_" は列挙の作成中にのみ使用され、作成が完了すると削除さ
      れます。

      "_ignore_" は、メンバーにならず、作成された列挙から削除される名
      前のリストです。例については、TimePeriod を参照してください。

      Added in version 3.7.

   __dir__(self)

      Returns "['__class__', '__doc__', '__module__', 'name',
      'value']" and any public methods defined on *self.__class__*:

         >>> from enum import Enum
         >>> import datetime as dt
         >>> class Weekday(Enum):
         ...     MONDAY = 1
         ...     TUESDAY = 2
         ...     WEDNESDAY = 3
         ...     THURSDAY = 4
         ...     FRIDAY = 5
         ...     SATURDAY = 6
         ...     SUNDAY = 7
         ...     @classmethod
         ...     def today(cls):
         ...         print(f'today is {cls(dt.date.today().isoweekday()).name}')
         ...
         >>> dir(Weekday.SATURDAY)
         ['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'today', 'value']

   _generate_next_value_(name, start, count, last_values)

         name:
            定義されているメンバーの名前（例：'RED'）。

         start:
            Enumの開始値。デフォルトは1です。

         count:
            定義済みのメンバーの数。現在のメンバーを含めない。

         last_values:
            定義済みの値のリスト。

      "auto" が次に返す値を決めるための *staticmethod* です。

      注釈:

        標準の "Enum" クラスの場合、次の値として選択されるのは、定義さ
        れた最大の値に1を加えたものです。"Flag" クラスでは、次に選ばれ
        る値は、次の最大の2のべき乗となります。

      このメソッドはオーバーライドできます。 例えば次のようにします。

         >>> from enum import auto, Enum
         >>> class PowersOfThree(Enum):
         ...     @staticmethod
         ...     def _generate_next_value_(name, start, count, last_values):
         ...         return 3 ** (count + 1)
         ...     FIRST = auto()
         ...     SECOND = auto()
         ...
         >>> PowersOfThree.SECOND.value
         9

      Added in version 3.6.

      バージョン 3.13 で変更: 以前のバージョンでは最大の値ではなく最後
      に定義された値を使っていました。

   __init__(self, *args, **kwds)

      デフォルトでは何もしません。メンバーに複数の値が指定されている場
      合、それらの値は "__init__" の別々の引数となります。例えば、

      >>> from enum import Enum
      >>> class Weekday(Enum):
      ...     MONDAY = 1, 'Mon'

      "Weekday.__init__()" は "Weekday.__init__(self, 1, 'Mon')" とし
      て呼び出されます。

   __init_subclass__(cls, **kwds)

      サブクラスを更に設定するために使用される *classmethod* です。デ
      フォルトでは何も行いません。

   _missing_(cls, value)

      *cls* で見つからない値を検索するための *classmethod* です。デフ
      ォルトでは何もしませんが、カスタムの検索の振る舞いを実装するため
      にオーバーライドすることができます:

         >>> from enum import auto, StrEnum
         >>> class Build(StrEnum):
         ...     DEBUG = auto()
         ...     OPTIMIZED = auto()
         ...     @classmethod
         ...     def _missing_(cls, value):
         ...         value = value.lower()
         ...         for member in cls:
         ...             if member.value == value:
         ...                 return member
         ...         return None
         ...
         >>> Build.DEBUG.value
         'debug'
         >>> Build('deBUG')
         <Build.DEBUG: 'debug'>

      Added in version 3.6.

   __new__(cls, *args, **kwds)

      デフォルトでは存在しません。指定された場合、列挙型のクラス定義ま
      たはmix-inクラス（例えば "int" など）のいずれかで、メンバーに代
      入されたすべての値が渡されます。例:

      >>> from enum import Enum
      >>> class MyIntEnum(int, Enum):
      ...     TWENTYSIX = '1a', 16

      この場合は "int('1a', 16)" が呼び出され、メンバーの値は "26" に
      なります。

      注釈:

        独自の "__new__" を書く場合、"super().__new__" を使わず、適切
        な "__new__" を直接呼び出してください。

   __repr__(self)

      *repr()* の呼び出しに使用される文字列を返します。デフォルトでは
      、 *Enum* 名、メンバー名、および値を返しますが、オーバーライドす
      ることもできます:

         >>> from enum import auto, Enum
         >>> class OtherStyle(Enum):
         ...     ALTERNATE = auto()
         ...     OTHER = auto()
         ...     SOMETHING_ELSE = auto()
         ...     def __repr__(self):
         ...         cls_name = self.__class__.__name__
         ...         return f'{cls_name}.{self.name}'
         ...
         >>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
         (OtherStyle.ALTERNATE, 'OtherStyle.ALTERNATE', 'OtherStyle.ALTERNATE')

   __str__(self)

      *str()* の呼び出しに使用される文字列を返します。デフォルトでは、
      *Enum* の名前とメンバーの名前を返しますが、オーバーライドするこ
      ともできます:

         >>> from enum import auto, Enum
         >>> class OtherStyle(Enum):
         ...     ALTERNATE = auto()
         ...     OTHER = auto()
         ...     SOMETHING_ELSE = auto()
         ...     def __str__(self):
         ...         return f'{self.name}'
         ...
         >>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
         (<OtherStyle.ALTERNATE: 1>, 'ALTERNATE', 'ALTERNATE')

   __format__(self)

      *format()* および *f-string* の呼び出しに使用される文字列を返し
      ます。デフォルトでは、"__str__()" の戻り値を返しますが、オーバー
      ライドすることもできます。:

         >>> from enum import auto, Enum
         >>> class OtherStyle(Enum):
         ...     ALTERNATE = auto()
         ...     OTHER = auto()
         ...     SOMETHING_ELSE = auto()
         ...     def __format__(self, spec):
         ...         return f'{self.name}'
         ...
         >>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
         (<OtherStyle.ALTERNATE: 1>, 'OtherStyle.ALTERNATE', 'ALTERNATE')

   注釈:

     "Enum" で "auto" を使用すると、 "1" から始まりインクリメントする
     整数が値となります。

   バージョン 3.12 で変更: データクラスのサポート が追加されました。

   _add_alias_()

      既存のメンバーのエイリアスとして新しい名前を追加します。

         >>> Color.RED._add_alias_("ERROR")
         >>> Color.ERROR
         <Color.RED: 1>

      その名前がすでに別のメンバーに割り当てられている場合、
      "NameError" を送出します。

      Added in version 3.13.

   _add_value_alias_()

      既存のメンバーのエイリアスとして新しい値を追加します。

         >>> Color.RED._add_value_alias_(42)
         >>> Color(42)
         <Color.RED: 1>

         その値がすでに別のメンバーに結び付けられている場合、"ValueError" を送出します。
         例は MultiValueEnum を参照してください。

      Added in version 3.13.

class enum.IntEnum

   *IntEnum* は "Enum" と同様ですが、メンバーは整数でもあり、整数が使
   える場所ならどこでも使えます。 *IntEnum* のメンバーを使って整数演算
   を行うと、結果の値は列挙型ではなくなります。

   >>> from enum import IntEnum
   >>> class Number(IntEnum):
   ...     ONE = 1
   ...     TWO = 2
   ...     THREE = 3
   ...
   >>> Number.THREE
   <Number.THREE: 3>
   >>> Number.ONE + Number.TWO
   3
   >>> Number.THREE + 5
   8
   >>> Number.THREE == 3
   True

   注釈:

     "IntEnum" で "auto" を使用すると、 "1" から始まりインクリメントす
     る整数が値となります。

   バージョン 3.11 で変更: "__str__()" は、既存の定数を置き換えるユー
   スケースをより良くサポートするために "int.__str__()" に変更されまし
   た。同じ理由で、"__format__()" は既に "int.__format__()" に変更され
   ています。

class enum.StrEnum

   *StrEnum* は "Enum" と同様ですが、メンバーは文字列でもあり、文字列
   が使える場所のほとんどで使えます。 *StrEnum* のメンバーに対して、ま
   たはそれを使って文字列操作を行った結果は、列挙型のメンバーにはなり
   ません。

   >>> from enum import StrEnum, auto
   >>> class Color(StrEnum):
   ...     RED = 'r'
   ...     GREEN = 'g'
   ...     BLUE = 'b'
   ...     UNKNOWN = auto()
   ...
   >>> Color.RED
   <Color.RED: 'r'>
   >>> Color.UNKNOWN
   <Color.UNKNOWN: 'unknown'>
   >>> str(Color.UNKNOWN)
   'unknown'

   注釈:

     標準ライブラリには "str" のサブクラスを受け付けず、型が厳密に
     "str" かどうかを調べる箇所があります (つまり "isinstance(unknown,
     str)" ではなく "type(unknown) == str" を使います)。 そのような箇
     所では "str(MyStrEnum.MY_MEMBER)" を使う必要があります。

   注釈:

     "StrEnum" で "auto" を使用すると、メンバー名を小文字に変換したも
     のが値となります。

   注釈:

     "__str__()" は *既存の定数の置換* ユースケースをより良くサポート
     するために "str.__str__()" となりました。 "__format__()" も同様に
     、同じ理由で "str.__format__()" となりました。

   Added in version 3.11.

class enum.Flag

   "Flag" は "Enum" と同様ですが、メンバーはビット演算子 "&" (*AND*)、
   "|" (*OR*)、"^" (*XOR*)、"~" (*INVERT*) をサポートします。 これらの
   演算結果は列挙型のメンバー (のエイリアス) になります。

   __contains__(self, value)

      値を含む場合に *True* を返します:

         >>> from enum import Flag, auto
         >>> class Color(Flag):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
         ...
         >>> purple = Color.RED | Color.BLUE
         >>> white = Color.RED | Color.GREEN | Color.BLUE
         >>> Color.GREEN in purple
         False
         >>> Color.GREEN in white
         True
         >>> purple in white
         True
         >>> white in purple
         False

   __iter__(self)

      このフラグに含まれるメンバーのうち、エイリアスでないものをすべて
      返します。

         >>> list(Color.RED)
         [<Color.RED: 1>]
         >>> list(purple)
         [<Color.RED: 1>, <Color.BLUE: 4>]

      Added in version 3.11.

   __len__(self)

      flag 内のメンバーの数を返します:

         >>> len(Color.GREEN)
         1
         >>> len(white)
         3

      Added in version 3.11.

   __bool__(self)

      メンバーがflagに含まれている場合は *True* を返し、それ以外の場合
      は *False* を返します:

         >>> bool(Color.GREEN)
         True
         >>> bool(white)
         True
         >>> black = Color(0)
         >>> bool(black)
         False

   __or__(self, other)

      現在のフラグと他のフラグの論理和となるフラグを返します:

         >>> Color.RED | Color.GREEN
         <Color.RED|GREEN: 3>

   __and__(self, other)

      現在のフラグと他のフラグの論理積となるフラグを返します:

         >>> purple & white
         <Color.RED|BLUE: 5>
         >>> purple & Color.GREEN
         <Color: 0>

   __xor__(self, other)

      現在のフラグと他のフラグの排他的論理和となるフラグを返します:

         >>> purple ^ white
         <Color.GREEN: 2>
         >>> purple ^ Color.GREEN
         <Color.RED|GREEN|BLUE: 7>

   __invert__(self)

      *type(self)* に含まれるフラグのうち、*self* に含まれないものをす
      べて返します。

         >>> ~white
         <Color: 0>
         >>> ~purple
         <Color.GREEN: 2>
         >>> ~Color.RED
         <Color.GREEN|BLUE: 6>

   _numeric_repr_()

      名前のない残りの数値を書式化する関数です。 デフォルトは値の
      "repr()" 結果です。 よく使われる選択肢は "hex()" と "oct()" です
      。

   注釈:

     "auto" と "Flag" を一緒に使うと、"1" から始まる2の累乗の整数にな
     ります。

   バージョン 3.11 で変更: 値がゼロのフラグの *repr()* が変更されまし
   た。 現在は次のようになります:

   >>> Color(0)
   <Color: 0>

class enum.IntFlag

   "IntFlag" は "Flag" と同様ですが、メンバーは整数でもあり、整数が使
   える場所ならどこでも使えます。

   >>> from enum import IntFlag, auto
   >>> class Color(IntFlag):
   ...     RED = auto()
   ...     GREEN = auto()
   ...     BLUE = auto()
   ...
   >>> Color.RED & 2
   <Color: 0>
   >>> Color.RED | 2
   <Color.RED|GREEN: 3>

   *IntFlag* のメンバーと整数の演算が行われた場合、結果は *IntFlag* で
   はありません:

      >>> Color.RED + 2
      3

   *IntFlag* のメンバーに対して "Flag" の演算を行うと:

   * 結果が有効な *IntFlag*: *IntFlag* が返されます

   * 結果が有効な *IntFlag* でない場合、結果は "FlagBoundary" の設定に
     よって決まります。

   名前がなく値がゼロのフラグの "repr()" が変更されました。 現在は次の
   ようになります。

      >>> Color(0)
      <Color: 0>

   注釈:

     "auto" と "IntFlag" を一緒に使うと、"1" から始まる2の累乗の整数に
     なります。

   バージョン 3.11 で変更: "__str__()" は、既存の定数を置き換えるユー
   スケースをより良くサポートするために "int.__str__()" に変更されまし
   た。同じ理由で、"__format__()" は既に "int.__format__()" に変更され
   ています。"IntFlag" の反転は、与えられたフラグ以外のすべてのフラグ
   の結合となる正の値を返すようになりました。これは既存の "Flag" の振
   る舞いに一致します。

class enum.ReprEnum

   "ReprEnum" は "Enum" の "repr()" を使いますが、"str()" には混ぜ込ま
   れたデータ型のものを使います:

   * "IntEnum" と "IntFlag" では "int.__str__()"

   * "StrEnum" では "str.__str__()"

   "ReprEnum" を継承することで、"Enum" デフォルトの "str()"  を使用す
   る代わりに、mix-inされたデータ型の "str()"  /  "format()" を使用し
   ます。

   Added in version 3.11.

class enum.EnumCheck

   *EnumCheck* には、"verify()" デコレータが各種の制約を確認するために
   使うオプションが含まれています。 制約を満たさない場合は
   "ValueError" が送出されます。

   UNIQUE

      それぞれの値が1つの名前しか持たないことを確認します:

         >>> from enum import Enum, verify, UNIQUE
         >>> @verify(UNIQUE)
         ... class Color(Enum):
         ...     RED = 1
         ...     GREEN = 2
         ...     BLUE = 3
         ...     CRIMSON = 1
         Traceback (most recent call last):
         ...
         ValueError: aliases found in <enum 'Color'>: CRIMSON -> RED

   CONTINUOUS

      最小値のメンバーと最大値のメンバーの間に欠損値がないことを確認し
      ます:

         >>> from enum import Enum, verify, CONTINUOUS
         >>> @verify(CONTINUOUS)
         ... class Color(Enum):
         ...     RED = 1
         ...     GREEN = 2
         ...     BLUE = 5
         Traceback (most recent call last):
         ...
         ValueError: invalid enum 'Color': missing values 3, 4

   NAMED_FLAGS

      フラグのグループやマスクに、名前付きのフラグだけが含まれることを
      確認します。 "auto()" で値を生成する代わりに、値を直接指定する場
      合に便利です。

         >>> from enum import Flag, verify, NAMED_FLAGS
         >>> @verify(NAMED_FLAGS)
         ... class Color(Flag):
         ...     RED = 1
         ...     GREEN = 2
         ...     BLUE = 4
         ...     WHITE = 15
         ...     NEON = 31
         Traceback (most recent call last):
         ...
         ValueError: invalid Flag 'Color': aliases WHITE and NEON are missing combined values of 0x18 [use enum.show_flag_values(value) for details]

   注釈:

     CONTINUOUSとNAMED_FLAGSは整数値のメンバーとともに動作するように設
     計されています。

   Added in version 3.11.

class enum.FlagBoundary

   "FlagBoundary" は "Flag" とそのサブクラスで範囲外の値をどう扱うかを
   制御します。

   STRICT

      範囲外の値は "ValueError" を送出します。これは "Flag" のデフォル
      トです:

         >>> from enum import Flag, STRICT, auto
         >>> class StrictFlag(Flag, boundary=STRICT):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
         ...
         >>> StrictFlag(2**2 + 2**4)
         Traceback (most recent call last):
         ...
         ValueError: <flag 'StrictFlag'> invalid value 20
             given 0b0 10100
           allowed 0b0 00111

   CONFORM

      範囲外の値から無効な部分を取り除き、有効な "Flag" の値を残します
      。

         >>> from enum import Flag, CONFORM, auto
         >>> class ConformFlag(Flag, boundary=CONFORM):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
         ...
         >>> ConformFlag(2**2 + 2**4)
         <ConformFlag.BLUE: 4>

   EJECT

      範囲外の値は "Flag" のメンバーではなくなり、"int" に戻ります。

      >>> from enum import Flag, EJECT, auto
      >>> class EjectFlag(Flag, boundary=EJECT):
      ...     RED = auto()
      ...     GREEN = auto()
      ...     BLUE = auto()
      ...
      >>> EjectFlag(2**2 + 2**4)
      20

   KEEP

      範囲外の値をそのまま保持し、"Flag" のメンバーであることも維持し
      ます。 これは "IntFlag" のデフォルトです。

         >>> from enum import Flag, KEEP, auto
         >>> class KeepFlag(Flag, boundary=KEEP):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
         ...
         >>> KeepFlag(2**2 + 2**4)
         <KeepFlag.BLUE|16: 20>

   Added in version 3.11.

class enum.EnumDict

   *EnumDict* は "dict" のサブクラスで、列挙型クラスを定義する名前空間
   として使います (クラスの名前空間の準備 を参照)。 メンバーごとに複数
   の値を持たせるなど、高度な動作を持つ "EnumType" のサブクラスを作成
   できるように公開されています。 作成する列挙型クラスの名前を渡して呼
   び出してください。 そうしないと、プライベートな名前や内部クラスが正
   しく処理されません。

   オーバーライドされているのは "MutableMapping" のインターフェイス
   ("__setitem__()" と "update()") だけであることに注意してください。
   "|=" など、ほかの "dict" の操作では検査を回避できる場合があります。

   member_names

      メンバー名のリスト。

   Added in version 3.13.

======================================================================


"__dunder__" 名のサポート
-------------------------

"__members__" は読み込み専用の、 "member_name":"member"  を要素とする
順序付きマッピングです。これはクラスでのみ利用可能です。

"__new__()" を指定する場合は、列挙型のメンバーを作成して返す必要があり
ます。 メンバーの "_value_" を適切に設定することも強く推奨します。 す
べてのメンバーの作成が終わると、このメソッドは使われなくなります。


"_sunder_" 名のサポート
-----------------------

* "_name_" -- メンバー名

* "_value_" -- メンバーの値; "__new__" で設定できます

* "_missing_()" -- 値が見付からなかったときに使われる検索関数; オーバ
  ーライドできます

* "_ignore_" -- 名前のリストで、 "list" もしくは "str" です。この名前
  の要素はメンバーへの変換が行われず、最終的なクラスから削除されます。

* "_order_" -- no longer used, kept for backward compatibility (class
  attribute, removed during class creation)

* "_generate_next_value_()" -- 列挙型のメンバーの適切な値を取得するの
  に使われます。 オーバーライドできます。

* "_add_alias_()" -- 既存のメンバーのエイリアスとして新しい名前を追加
  します。

* "_add_value_alias_()" -- 既存のメンバーのエイリアスとして新しい値を
  追加します。

* "_sunder_" 名は通常、"Enum" クラスの今後の開発のために予約されており
  使えませんが、明示的に許可されているものもあります:

  * IPython のリッチな表示機能 で使われる "_repr_*" ("_repr_html_" な
    ど)

Added in version 3.6: "_missing_", "_order_", "_generate_next_value_"

Added in version 3.7: "_ignore_"

Added in version 3.13: "_add_alias_", "_add_value_alias_", "_repr_*"

======================================================================


ユーティリティとデコレータ
==========================

class enum.auto

   値の代わりに *auto* を使えます。 使った場合、*Enum* の仕組みが
   "Enum" の "_generate_next_value_()" を呼び出し、適切な値を取得しま
   す。 "Enum" と "IntEnum" では、それまでの最大値に 1 を加えた値にな
   ります。 "Flag" と "IntFlag" では、それまでの最大値を超える最小の 2
   の累乗になります。 "StrEnum" ではメンバー名を小文字にした値になりま
   す。 *auto()* と手動で指定した値を混在させる場合は注意が必要です。

   *auto* インスタンスが値に置き換えられるのは、代入の最上位に単独で置
   くか、タプルの要素として置く場合だけです:

   * "FIRST = auto()" は動作します（auto() は "1" に置き換えられます）

   * "SECOND = auto(), -2" は動作します（auto は "2" に置き換えられる
     ため、 "SECOND" 列挙型のメンバーには "2, -2" が使用されます）

   * "THIRD = [auto(), -3]" は意図どおりには動作 *しません* ("[<auto
     instance>, -3]" を使って列挙型のメンバー "THIRD" が作成されます)
     。

   バージョン 3.11.1 で変更: 以前のバージョンでは、 "auto()" は、代入
   行に他のものがあると正しく動作しませんでした。

   "_generate_next_value_" は、 *auto* が使用する値をカスタマイズする
   ためにオーバーライドすることができる。

   注釈:

     In version 3.13 the default "_generate_next_value_" will always
     return the highest member value incremented by 1, and will fail
     if any member is an incompatible type.

@enum.property

   組み込みの "@property" に似ていますが、列挙型専用のデコレータです。
   メンバーの属性に、メンバー自体と同じ名前を使えるようにします。

   注釈:

     *property* とメンバーは別々のクラスで定義する必要があります。 例
     えば *value* と *name* 属性は *Enum* クラスで定義されていますが、
     *Enum* のサブクラスでは "value" や "name" という名前のメンバーを
     定義できます。

   Added in version 3.11.

@enum.unique

   列挙型専用の "class" デコレーターです。列挙型の "__members__" に別
   名がないかどうか検索します; 見つかった場合、"ValueError" が詳細情報
   とともに送出されます:

      >>> from enum import Enum, unique
      >>> @unique
      ... class Mistake(Enum):
      ...     ONE = 1
      ...     TWO = 2
      ...     THREE = 3
      ...     FOUR = 3
      ...
      Traceback (most recent call last):
      ...
      ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE

@enum.verify

   列挙型専用の "class" デコレーターです。対象の列挙型に対してチェック
   を行う制約の指定には "EnumCheck" のメンバーが使用されます。

   Added in version 3.11.

@enum.member

   列挙型で使用するデコレータ: 対象は列挙型のメンバー になります。

   Added in version 3.11.

@enum.nonmember

   列挙型で使用するデコレータ: 対象は列挙型のメンバー になりません。

   Added in version 3.11.

@enum.global_enum

   列挙型の "str()" と "repr()" を変更して、メンバーがクラスではなくモ
   ジュールに属するように表示するデコレータです。 列挙型のメンバーをモ
   ジュールのグローバル名前空間に公開している場合だけ使ってください (
   例は "re.RegexFlag" を参照)。

   Added in version 3.11.

enum.show_flag_values(value)

   フラグの *value* に含まれる全ての2の累乗の整数のリストを返します。

   Added in version 3.11.

enum.bin(num, max_bits=None)

   組み込みの "bin()" と似ていますが、負の値は 2 の補数で表し、先頭の
   ビットは常に符号を示します ("0" は正、"1" は負を示します)。

   >>> import enum
   >>> enum.bin(10)
   '0b0 1010'
   >>> enum.bin(~10)   # ~10 is -11
   '0b1 0101'

   Added in version 3.11.

======================================================================


注釈
====

"IntEnum" 、 "StrEnum" 、 "IntFlag"

   これらの3つの列挙型は、既存の整数ベースおよび文字列ベースの値の代替
   として設計されています。そのため、追加の制限があります:

   * "__str__" は、列挙型のメンバーの名前ではなく値を使用します

   * "__format__" は "__str__" を使用するため、列挙型のメンバーの名前
     ではなく値を使用します

   もし、そのような制限が必要でない/望まない場合は、"int" または "str"
   タイプを継承して、カスタムの基底クラスを作成することができます:

      >>> from enum import Enum
      >>> class MyIntEnum(int, Enum):
      ...     pass

   または列挙型の中で適切な "str()" などを再代入することもできます:

      >>> from enum import Enum, IntEnum
      >>> class MyIntEnum(IntEnum):
      ...     __str__ = Enum.__str__
