class_docstr: Metaclass for Enum
class_docstr_tok: ["Metaclass","for","Enum"]
code: def __new__(metacls, cls, bases, classdict):
      # an Enum class is final once enumeration items have been defined; it
      # cannot be mixed with other types (int, float, etc.) if it has an
      # inherited __new__ unless a new __new__ is defined (or the resulting
      # class will fail).
      if type(classdict) is dict:
          original_dict = classdict
          classdict = _EnumDict()
          for k, v in original_dict.items():
              classdict[k] = v
  
      member_type, first_enum = metacls._get_mixins_(bases)
      __new__, save_new, use_args = metacls._find_new_(
          classdict, member_type, first_enum
      )
      # save enum items into separate mapping so they don't get baked into
      # the new class
      members = dict((k, classdict[k]) for k in classdict._member_names)
      for name in classdict._member_names:
          del classdict[name]
  
      # py2 support for definition order
      _order_ = classdict.get("_order_")
      if _order_ is None:
          if pyver < 3.0:
              try:
                  _order_ = [
                      name
                      for (name, value) in sorted(
                          members.items(), key=lambda item: item[1]
                      )
                  ]
              except TypeError:
                  _order_ = [name for name in sorted(members.keys())]
          else:
              _order_ = classdict._member_names
      else:
          del classdict["_order_"]
          if pyver < 3.0:
              _order_ = _order_.replace(",", " ").split()
              aliases = [
                  name for name in members if name not in _order_
              ]
              _order_ += aliases
  
      # check for illegal enum names (any others?)
      invalid_names = set(members) & set(["mro"])
      if invalid_names:
          raise ValueError(
              "Invalid enum member name(s): %s"
              % (", ".join(invalid_names),)
          )
  
      # save attributes from super classes so we know if we can take
      # the shortcut of storing members in the class dict
      base_attributes = set([a for b in bases for a in b.__dict__])
      # create our new Enum type
      enum_class = super(EnumMeta, metacls).__new__(
          metacls, cls, bases, classdict
      )
      enum_class._member_names_ = []  # names in random order
      if OrderedDict is not None:
          enum_class._member_map_ = OrderedDict()
      else:
          enum_class._member_map_ = {}  # name->value map
      enum_class._member_type_ = member_type
  
      # Reverse value->name map for hashable values.
      enum_class._value2member_map_ = {}
  
      # instantiate them, checking for duplicates as we go
      # we instantiate first instead of checking for duplicates first in case
      # a custom __new__ is doing something funky with the values -- such as
      # auto-numbering ;)
      if __new__ is None:
          __new__ = enum_class.__new__
      for member_name in _order_:
          value = members[member_name]
          if not isinstance(value, tuple):
              args = (value,)
          else:
              args = value
          if member_type is tuple:  # special case for tuple enums
              args = (args,)  # wrap it one more time
          if not use_args or not args:
              enum_member = __new__(enum_class)
              if not hasattr(enum_member, "_value_"):
                  enum_member._value_ = value
          else:
              enum_member = __new__(enum_class, *args)
              if not hasattr(enum_member, "_value_"):
                  enum_member._value_ = member_type(*args)
          value = enum_member._value_
          enum_member._name_ = member_name
          enum_member.__objclass__ = enum_class
          enum_member.__init__(*args)
          # If another member with the same value was already defined, the
          # new member becomes an alias to the existing one.
          for name, canonical_member in enum_class._member_map_.items():
              if canonical_member.value == enum_member._value_:
                  enum_member = canonical_member
                  break
          else:
              # Aliases don't appear in member names (only in __members__).
              enum_class._member_names_.append(member_name)
          # performance boost for any member that would not shadow
          # a DynamicClassAttribute (aka _RouteClassAttributeToGetattr)
          if member_name not in base_attributes:
              setattr(enum_class, member_name, enum_member)
          # now add to _member_map_
          enum_class._member_map_[member_name] = enum_member
          try:
              # This may fail if value is not hashable. We can't add the value
              # to the map, and by-value lookups for this value will be
              # linear.
              enum_class._value2member_map_[value] = enum_member
          except TypeError:
              pass
  
      # If a custom type is mixed into the Enum, and it does not know how
      # to pickle itself, pickle.dumps will succeed but pickle.loads will
      # fail.  Rather than have the error show up later and possibly far
      # from the source, sabotage the pickle protocol for this class so
      # that pickle.dumps also fails.
      #
      # However, if the new class implements its own __reduce_ex__, do not
      # sabotage -- it's on them to make sure it works correctly.  We use
      # __reduce_ex__ instead of any of the others as it is preferred by
      # pickle over __reduce__, and it handles all pickle protocols.
      unpicklable = False
      if "__reduce_ex__" not in classdict:
          if member_type is not object:
              methods = (
                  "__getnewargs_ex__",
                  "__getnewargs__",
                  "__reduce_ex__",
                  "__reduce__",
              )
              if not any(m in member_type.__dict__ for m in methods):
                  _make_class_unpicklable(enum_class)
                  unpicklable = True
  
      # double check that repr and friends are not the mixin's or various
      # things break (such as pickle)
      for name in (
          "__repr__",
          "__str__",
          "__format__",
          "__reduce_ex__",
      ):
          class_method = getattr(enum_class, name)
          obj_method = getattr(member_type, name, None)
          enum_method = getattr(first_enum, name, None)
          if name not in classdict and class_method is not enum_method:
              if name == "__reduce_ex__" and unpicklable:
                  continue
              setattr(enum_class, name, enum_method)
  
      # method resolution and int's are not playing nice
      # Python's less than 2.6 use __cmp__
  
      if pyver < 2.6:
          if issubclass(enum_class, int):
              setattr(enum_class, "__cmp__", getattr(int, "__cmp__"))
  
      elif pyver < 3.0:
          if issubclass(enum_class, int):
              for method in (
                  "__le__",
                  "__lt__",
                  "__gt__",
                  "__ge__",
                  "__eq__",
                  "__ne__",
                  "__hash__",
              ):
                  setattr(enum_class, method, getattr(int, method))
  
      # replace any other __new__ with our own (as long as Enum is not None,
      # anyway) -- again, this is to support pickle
      if Enum is not None:
          # if the user defined their own __new__, save it before it gets
          # clobbered in case they subclass later
          if save_new:
              setattr(
                  enum_class,
                  "__member_new__",
                  enum_class.__dict__["__new__"],
              )
          setattr(enum_class, "__new__", Enum.__dict__["__new__"])
      return enum_class
  
imports: import sys
label_desc: Use image node_id 2 for calling the EnumMeta obj's underlying member method code with example usage: obj.__new__(metacls, cls, bases, classdict) and returns: enum_class