Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

1 files changed, 296 insertions, 296 deletions

diff --git a/contrib/tools/python3/src/Lib/enum.py b/contrib/tools/python3/src/Lib/enum.py
index ee4c4c04f98..cda835e8529 100644
--- a/contrib/tools/python3/src/Lib/enum.py
+++ b/contrib/tools/python3/src/Lib/enum.py
@@ -10,54 +10,54 @@ __all__ = [
 
 
 def _is_descriptor(obj):
-    """
-    Returns True if obj is a descriptor, False otherwise.
-    """
+    """ 
+    Returns True if obj is a descriptor, False otherwise. 
+    """ 
     return (
             hasattr(obj, '__get__') or
             hasattr(obj, '__set__') or
-            hasattr(obj, '__delete__')
-            )
+            hasattr(obj, '__delete__') 
+            ) 
 
 def _is_dunder(name):
-    """
-    Returns True if a __dunder__ name, False otherwise.
-    """
-    return (
-            len(name) > 4 and
+    """ 
+    Returns True if a __dunder__ name, False otherwise. 
+    """ 
+    return ( 
+            len(name) > 4 and 
             name[:2] == name[-2:] == '__' and
             name[2] != '_' and
-            name[-3] != '_'
-            )
+            name[-3] != '_' 
+            ) 
 
 def _is_sunder(name):
-    """
-    Returns True if a _sunder_ name, False otherwise.
-    """
-    return (
-            len(name) > 2 and
+    """ 
+    Returns True if a _sunder_ name, False otherwise. 
+    """ 
+    return ( 
+            len(name) > 2 and 
             name[0] == name[-1] == '_' and
             name[1:2] != '_' and
-            name[-2:-1] != '_'
-            )
-
-def _is_private(cls_name, name):
-    # do not use `re` as `re` imports `enum`
-    pattern = '_%s__' % (cls_name, )
-    if (
-            len(name) >= 5
-            and name.startswith(pattern)
-            and name[len(pattern)] != '_'
-            and (name[-1] != '_' or name[-2] != '_')
-        ):
-        return True
-    else:
-        return False
-
+            name[-2:-1] != '_' 
+            ) 
+
+def _is_private(cls_name, name): 
+    # do not use `re` as `re` imports `enum` 
+    pattern = '_%s__' % (cls_name, ) 
+    if ( 
+            len(name) >= 5 
+            and name.startswith(pattern) 
+            and name[len(pattern)] != '_' 
+            and (name[-1] != '_' or name[-2] != '_') 
+        ): 
+        return True 
+    else: 
+        return False 
+ 
 def _make_class_unpicklable(cls):
-    """
-    Make the given class un-picklable.
-    """
+    """ 
+    Make the given class un-picklable. 
+    """ 
     def _break_on_call_reduce(self, proto):
         raise TypeError('%r cannot be pickled' % self)
     cls.__reduce_ex__ = _break_on_call_reduce
@@ -72,8 +72,8 @@ class auto:
 
 
 class _EnumDict(dict):
-    """
-    Track enum member order and ensure member names are not reused.
+    """ 
+    Track enum member order and ensure member names are not reused. 
 
     EnumMeta will use the names found in self._member_names as the
     enumeration member names.
@@ -83,25 +83,25 @@ class _EnumDict(dict):
         self._member_names = []
         self._last_values = []
         self._ignore = []
-        self._auto_called = False
+        self._auto_called = False 
 
     def __setitem__(self, key, value):
-        """
-        Changes anything not dundered or not a descriptor.
+        """ 
+        Changes anything not dundered or not a descriptor. 
 
         If an enum member name is used twice, an error is raised; duplicate
         values are not checked for.
 
         Single underscore (sunder) names are reserved.
         """
-        if _is_private(self._cls_name, key):
-            import warnings
-            warnings.warn(
-                    "private variables, such as %r, will be normal attributes in 3.10"
-                        % (key, ),
-                    DeprecationWarning,
-                    stacklevel=2,
-                    )
+        if _is_private(self._cls_name, key): 
+            import warnings 
+            warnings.warn( 
+                    "private variables, such as %r, will be normal attributes in 3.10" 
+                        % (key, ), 
+                    DeprecationWarning, 
+                    stacklevel=2, 
+                    ) 
         if _is_sunder(key):
             if key not in (
                     '_order_', '_create_pseudo_member_',
@@ -109,9 +109,9 @@ class _EnumDict(dict):
                     ):
                 raise ValueError('_names_ are reserved for future Enum use')
             if key == '_generate_next_value_':
-                # check if members already defined as auto()
-                if self._auto_called:
-                    raise TypeError("_generate_next_value_ must be defined before members")
+                # check if members already defined as auto() 
+                if self._auto_called: 
+                    raise TypeError("_generate_next_value_ must be defined before members") 
                 setattr(self, '_generate_next_value', value)
             elif key == '_ignore_':
                 if isinstance(value, str):
@@ -121,10 +121,10 @@ class _EnumDict(dict):
                 self._ignore = value
                 already = set(value) & set(self._member_names)
                 if already:
-                    raise ValueError(
-                            '_ignore_ cannot specify already set names: %r'
-                            % (already, )
-                            )
+                    raise ValueError( 
+                            '_ignore_ cannot specify already set names: %r' 
+                            % (already, ) 
+                            ) 
         elif _is_dunder(key):
             if key == '__order__':
                 key = '_order_'
@@ -139,13 +139,13 @@ class _EnumDict(dict):
                 raise TypeError('%r already defined as: %r' % (key, self[key]))
             if isinstance(value, auto):
                 if value.value == _auto_null:
-                    value.value = self._generate_next_value(
-                            key,
-                            1,
-                            len(self._member_names),
-                            self._last_values[:],
-                            )
-                    self._auto_called = True
+                    value.value = self._generate_next_value( 
+                            key, 
+                            1, 
+                            len(self._member_names), 
+                            self._last_values[:], 
+                            ) 
+                    self._auto_called = True 
                 value = value.value
             self._member_names.append(key)
             self._last_values.append(value)
@@ -158,25 +158,25 @@ class _EnumDict(dict):
 Enum = None
 
 class EnumMeta(type):
-    """
-    Metaclass for Enum
-    """
+    """ 
+    Metaclass for Enum 
+    """ 
     @classmethod
-    def __prepare__(metacls, cls, bases, **kwds):
-        # check that previous enum members do not exist
-        metacls._check_for_existing_members(cls, bases)
+    def __prepare__(metacls, cls, bases, **kwds): 
+        # check that previous enum members do not exist 
+        metacls._check_for_existing_members(cls, bases) 
         # create the namespace dict
         enum_dict = _EnumDict()
-        enum_dict._cls_name = cls
+        enum_dict._cls_name = cls 
         # inherit previous flags and _generate_next_value_ function
-        member_type, first_enum = metacls._get_mixins_(cls, bases)
+        member_type, first_enum = metacls._get_mixins_(cls, bases) 
         if first_enum is not None:
-            enum_dict['_generate_next_value_'] = getattr(
-                    first_enum, '_generate_next_value_', None,
-                    )
+            enum_dict['_generate_next_value_'] = getattr( 
+                    first_enum, '_generate_next_value_', None, 
+                    ) 
         return enum_dict
 
-    def __new__(metacls, cls, bases, classdict, **kwds):
+    def __new__(metacls, cls, bases, classdict, **kwds): 
         # 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
@@ -187,10 +187,10 @@ class EnumMeta(type):
         ignore = classdict['_ignore_']
         for key in ignore:
             classdict.pop(key, None)
-        member_type, first_enum = metacls._get_mixins_(cls, bases)
-        __new__, save_new, use_args = metacls._find_new_(
-                classdict, member_type, first_enum,
-                )
+        member_type, first_enum = metacls._get_mixins_(cls, 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
@@ -211,18 +211,18 @@ class EnumMeta(type):
         if '__doc__' not in classdict:
             classdict['__doc__'] = 'An enumeration.'
 
-        enum_class = super().__new__(metacls, cls, bases, classdict, **kwds)
+        enum_class = super().__new__(metacls, cls, bases, classdict, **kwds) 
         enum_class._member_names_ = []               # names in definition order
-        enum_class._member_map_ = {}                 # name->value map
+        enum_class._member_map_ = {}                 # name->value map 
         enum_class._member_type_ = member_type
 
         # save DynamicClassAttribute attributes from super classes so we know
         # if we can take the shortcut of storing members in the class dict
-        dynamic_attributes = {
-                k for c in enum_class.mro()
-                for k, v in c.__dict__.items()
-                if isinstance(v, DynamicClassAttribute)
-                }
+        dynamic_attributes = { 
+                k for c in enum_class.mro() 
+                for k, v in c.__dict__.items() 
+                if isinstance(v, DynamicClassAttribute) 
+                } 
 
         # Reverse value->name map for hashable values.
         enum_class._value2member_map_ = {}
@@ -242,32 +242,32 @@ class EnumMeta(type):
                 methods = ('__getnewargs_ex__', '__getnewargs__',
                         '__reduce_ex__', '__reduce__')
                 if not any(m in member_type.__dict__ for m in methods):
-                    if '__new__' in classdict:
-                        # too late, sabotage
-                        _make_class_unpicklable(enum_class)
-                    else:
-                        # final attempt to verify that pickling would work:
-                        # travel mro until __new__ is found, checking for
-                        # __reduce__ and friends along the way -- if any of them
-                        # are found before/when __new__ is found, pickling should
-                        # work
-                        sabotage = None
-                        for chain in bases:
-                            for base in chain.__mro__:
-                                if base is object:
-                                    continue
-                                elif any(m in base.__dict__ for m in methods):
-                                    # found one, we're good
-                                    sabotage = False
-                                    break
-                                elif '__new__' in base.__dict__:
-                                    # not good
-                                    sabotage = True
-                                    break
-                            if sabotage is not None:
-                                break
-                        if sabotage:
-                            _make_class_unpicklable(enum_class)
+                    if '__new__' in classdict: 
+                        # too late, sabotage 
+                        _make_class_unpicklable(enum_class) 
+                    else: 
+                        # final attempt to verify that pickling would work: 
+                        # travel mro until __new__ is found, checking for 
+                        # __reduce__ and friends along the way -- if any of them 
+                        # are found before/when __new__ is found, pickling should 
+                        # work 
+                        sabotage = None 
+                        for chain in bases: 
+                            for base in chain.__mro__: 
+                                if base is object: 
+                                    continue 
+                                elif any(m in base.__dict__ for m in methods): 
+                                    # found one, we're good 
+                                    sabotage = False 
+                                    break 
+                                elif '__new__' in base.__dict__: 
+                                    # not good 
+                                    sabotage = True 
+                                    break 
+                            if sabotage is not None: 
+                                break 
+                        if sabotage: 
+                            _make_class_unpicklable(enum_class) 
         # 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
@@ -320,11 +320,11 @@ class EnumMeta(type):
 
         # double check that repr and friends are not the mixin's or various
         # things break (such as pickle)
-        # however, if the method is defined in the Enum itself, don't replace
-        # it
+        # however, if the method is defined in the Enum itself, don't replace 
+        # it 
         for name in ('__repr__', '__str__', '__format__', '__reduce_ex__'):
-            if name in classdict:
-                continue
+            if name in classdict: 
+                continue 
             class_method = getattr(enum_class, name)
             obj_method = getattr(member_type, name, None)
             enum_method = getattr(first_enum, name, None)
@@ -356,8 +356,8 @@ class EnumMeta(type):
         return True
 
     def __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1):
-        """
-        Either returns an existing member, or creates a new enum class.
+        """ 
+        Either returns an existing member, or creates a new enum class. 
 
         This method is used both when an enum class is given a value to match
         to an enumeration member (i.e. Color(3)) and for the functional API
@@ -383,38 +383,38 @@ class EnumMeta(type):
         if names is None:  # simple value lookup
             return cls.__new__(cls, value)
         # otherwise, functional API: we're creating a new Enum type
-        return cls._create_(
-                value,
-                names,
-                module=module,
-                qualname=qualname,
-                type=type,
-                start=start,
-                )
+        return cls._create_( 
+                value, 
+                names, 
+                module=module, 
+                qualname=qualname, 
+                type=type, 
+                start=start, 
+                ) 
 
     def __contains__(cls, member):
         if not isinstance(member, Enum):
-            raise TypeError(
-                "unsupported operand type(s) for 'in': '%s' and '%s'" % (
-                    type(member).__qualname__, cls.__class__.__qualname__))
+            raise TypeError( 
+                "unsupported operand type(s) for 'in': '%s' and '%s'" % ( 
+                    type(member).__qualname__, cls.__class__.__qualname__)) 
         return isinstance(member, cls) and member._name_ in cls._member_map_
 
     def __delattr__(cls, attr):
         # nicer error message when someone tries to delete an attribute
         # (see issue19025).
         if attr in cls._member_map_:
-            raise AttributeError("%s: cannot delete Enum member." % cls.__name__)
+            raise AttributeError("%s: cannot delete Enum member." % cls.__name__) 
         super().__delattr__(attr)
 
     def __dir__(self):
-        return (
-                ['__class__', '__doc__', '__members__', '__module__']
-                + self._member_names_
-                )
+        return ( 
+                ['__class__', '__doc__', '__members__', '__module__'] 
+                + self._member_names_ 
+                ) 
 
     def __getattr__(cls, name):
-        """
-        Return the enum member matching `name`
+        """ 
+        Return the enum member matching `name` 
 
         We use __getattr__ instead of descriptors or inserting into the enum
         class' __dict__ in order to support `name` and `value` being both
@@ -432,9 +432,9 @@ class EnumMeta(type):
         return cls._member_map_[name]
 
     def __iter__(cls):
-        """
-        Returns members in definition order.
-        """
+        """ 
+        Returns members in definition order. 
+        """ 
         return (cls._member_map_[name] for name in cls._member_names_)
 
     def __len__(cls):
@@ -442,8 +442,8 @@ class EnumMeta(type):
 
     @property
     def __members__(cls):
-        """
-        Returns a mapping of member name->value.
+        """ 
+        Returns a mapping of member name->value. 
 
         This mapping lists all enum members, including aliases. Note that this
         is a read-only view of the internal mapping.
@@ -454,14 +454,14 @@ class EnumMeta(type):
         return "<enum %r>" % cls.__name__
 
     def __reversed__(cls):
-        """
-        Returns members in reverse definition order.
-        """
+        """ 
+        Returns members in reverse definition order. 
+        """ 
         return (cls._member_map_[name] for name in reversed(cls._member_names_))
 
     def __setattr__(cls, name, value):
-        """
-        Block attempts to reassign Enum members.
+        """ 
+        Block attempts to reassign Enum members. 
 
         A simple assignment to the class namespace only changes one of the
         several possible ways to get an Enum member from the Enum class,
@@ -473,8 +473,8 @@ class EnumMeta(type):
         super().__setattr__(name, value)
 
     def _create_(cls, class_name, names, *, module=None, qualname=None, type=None, start=1):
-        """
-        Convenience method to create a new Enum class.
+        """ 
+        Convenience method to create a new Enum class. 
 
         `names` can be:
 
@@ -486,7 +486,7 @@ class EnumMeta(type):
         """
         metacls = cls.__class__
         bases = (cls, ) if type is None else (type, cls)
-        _, first_enum = cls._get_mixins_(cls, bases)
+        _, first_enum = cls._get_mixins_(cls, bases) 
         classdict = metacls.__prepare__(class_name, bases)
 
         # special processing needed for names?
@@ -514,7 +514,7 @@ class EnumMeta(type):
         if module is None:
             try:
                 module = sys._getframe(2).f_globals['__name__']
-            except (AttributeError, ValueError, KeyError):
+            except (AttributeError, ValueError, KeyError): 
                 pass
         if module is None:
             _make_class_unpicklable(enum_class)
@@ -525,53 +525,53 @@ class EnumMeta(type):
 
         return enum_class
 
-    def _convert_(cls, name, module, filter, source=None):
-        """
-        Create a new Enum subclass that replaces a collection of global constants
-        """
-        # convert all constants from source (or module) that pass filter() to
-        # a new Enum called name, and export the enum and its members back to
-        # module;
-        # also, replace the __reduce_ex__ method so unpickling works in
-        # previous Python versions
-        module_globals = vars(sys.modules[module])
-        if source:
-            source = vars(source)
-        else:
-            source = module_globals
-        # _value2member_map_ is populated in the same order every time
-        # for a consistent reverse mapping of number to name when there
-        # are multiple names for the same number.
-        members = [
-                (name, value)
-                for name, value in source.items()
-                if filter(name)]
-        try:
-            # sort by value
-            members.sort(key=lambda t: (t[1], t[0]))
-        except TypeError:
-            # unless some values aren't comparable, in which case sort by name
-            members.sort(key=lambda t: t[0])
-        cls = cls(name, members, module=module)
-        cls.__reduce_ex__ = _reduce_ex_by_name
-        module_globals.update(cls.__members__)
-        module_globals[name] = cls
-        return cls
-
-    @staticmethod
-    def _check_for_existing_members(class_name, bases):
-        for chain in bases:
-            for base in chain.__mro__:
-                if issubclass(base, Enum) and base._member_names_:
-                    raise TypeError(
-                            "%s: cannot extend enumeration %r"
-                            % (class_name, base.__name__)
-                            )
-
+    def _convert_(cls, name, module, filter, source=None): 
+        """ 
+        Create a new Enum subclass that replaces a collection of global constants 
+        """ 
+        # convert all constants from source (or module) that pass filter() to 
+        # a new Enum called name, and export the enum and its members back to 
+        # module; 
+        # also, replace the __reduce_ex__ method so unpickling works in 
+        # previous Python versions 
+        module_globals = vars(sys.modules[module]) 
+        if source: 
+            source = vars(source) 
+        else: 
+            source = module_globals 
+        # _value2member_map_ is populated in the same order every time 
+        # for a consistent reverse mapping of number to name when there 
+        # are multiple names for the same number. 
+        members = [ 
+                (name, value) 
+                for name, value in source.items() 
+                if filter(name)] 
+        try: 
+            # sort by value 
+            members.sort(key=lambda t: (t[1], t[0])) 
+        except TypeError: 
+            # unless some values aren't comparable, in which case sort by name 
+            members.sort(key=lambda t: t[0]) 
+        cls = cls(name, members, module=module) 
+        cls.__reduce_ex__ = _reduce_ex_by_name 
+        module_globals.update(cls.__members__) 
+        module_globals[name] = cls 
+        return cls 
+ 
     @staticmethod
-    def _get_mixins_(class_name, bases):
-        """
-        Returns the type for creating enum members, and the first inherited
+    def _check_for_existing_members(class_name, bases): 
+        for chain in bases: 
+            for base in chain.__mro__: 
+                if issubclass(base, Enum) and base._member_names_: 
+                    raise TypeError( 
+                            "%s: cannot extend enumeration %r" 
+                            % (class_name, base.__name__) 
+                            ) 
+ 
+    @staticmethod 
+    def _get_mixins_(class_name, bases): 
+        """ 
+        Returns the type for creating enum members, and the first inherited 
         enum class.
 
         bases: the tuple of bases that was given to __new__
@@ -580,29 +580,29 @@ class EnumMeta(type):
             return object, Enum
 
         def _find_data_type(bases):
-            data_types = set()
+            data_types = set() 
             for chain in bases:
-                candidate = None
+                candidate = None 
                 for base in chain.__mro__:
                     if base is object:
                         continue
-                    elif issubclass(base, Enum):
-                        if base._member_type_ is not object:
-                            data_types.add(base._member_type_)
-                            break
+                    elif issubclass(base, Enum): 
+                        if base._member_type_ is not object: 
+                            data_types.add(base._member_type_) 
+                            break 
                     elif '__new__' in base.__dict__:
                         if issubclass(base, Enum):
                             continue
-                        data_types.add(candidate or base)
-                        break
-                    else:
-                        candidate = candidate or base
-            if len(data_types) > 1:
-                raise TypeError('%r: too many data types: %r' % (class_name, data_types))
-            elif data_types:
-                return data_types.pop()
-            else:
-                return None
+                        data_types.add(candidate or base) 
+                        break 
+                    else: 
+                        candidate = candidate or base 
+            if len(data_types) > 1: 
+                raise TypeError('%r: too many data types: %r' % (class_name, data_types)) 
+            elif data_types: 
+                return data_types.pop() 
+            else: 
+                return None 
 
         # ensure final parent class is an Enum derivative, find any concrete
         # data type, and check that Enum has no members
@@ -617,8 +617,8 @@ class EnumMeta(type):
 
     @staticmethod
     def _find_new_(classdict, member_type, first_enum):
-        """
-        Returns the __new__ to be used for creating the enum members.
+        """ 
+        Returns the __new__ to be used for creating the enum members. 
 
         classdict: the class dictionary given to __new__
         member_type: the data type whose __new__ will be used by default
@@ -662,8 +662,8 @@ class EnumMeta(type):
 
 
 class Enum(metaclass=EnumMeta):
-    """
-    Generic enumeration.
+    """ 
+    Generic enumeration. 
 
     Derive from this class to define new enumerations.
     """
@@ -693,34 +693,34 @@ class Enum(metaclass=EnumMeta):
         except Exception as e:
             exc = e
             result = None
-        try:
-            if isinstance(result, cls):
-                return result
-            else:
-                ve_exc = ValueError("%r is not a valid %s" % (value, cls.__qualname__))
-                if result is None and exc is None:
-                    raise ve_exc
-                elif exc is None:
-                    exc = TypeError(
-                            'error in %s._missing_: returned %r instead of None or a valid member'
-                            % (cls.__name__, result)
-                            )
-                exc.__context__ = ve_exc
-                raise exc
-        finally:
-            # ensure all variables that could hold an exception are destroyed
-            exc = None
-            ve_exc = None
+        try: 
+            if isinstance(result, cls): 
+                return result 
+            else: 
+                ve_exc = ValueError("%r is not a valid %s" % (value, cls.__qualname__)) 
+                if result is None and exc is None: 
+                    raise ve_exc 
+                elif exc is None: 
+                    exc = TypeError( 
+                            'error in %s._missing_: returned %r instead of None or a valid member' 
+                            % (cls.__name__, result) 
+                            ) 
+                exc.__context__ = ve_exc 
+                raise exc 
+        finally: 
+            # ensure all variables that could hold an exception are destroyed 
+            exc = None 
+            ve_exc = None 
 
     def _generate_next_value_(name, start, count, last_values):
-        """
-        Generate the next value when not given.
-
-        name: the name of the member
-        start: the initial start value or None
-        count: the number of existing members
-        last_value: the last value assigned or None
-        """
+        """ 
+        Generate the next value when not given. 
+ 
+        name: the name of the member 
+        start: the initial start value or None 
+        count: the number of existing members 
+        last_value: the last value assigned or None 
+        """ 
         for last_value in reversed(last_values):
             try:
                 return last_value + 1
@@ -731,7 +731,7 @@ class Enum(metaclass=EnumMeta):
 
     @classmethod
     def _missing_(cls, value):
-        return None
+        return None 
 
     def __repr__(self):
         return "<%s.%s: %r>" % (
@@ -741,28 +741,28 @@ class Enum(metaclass=EnumMeta):
         return "%s.%s" % (self.__class__.__name__, self._name_)
 
     def __dir__(self):
-        """
-        Returns all members and all public methods
-        """
+        """ 
+        Returns all members and all public methods 
+        """ 
         added_behavior = [
                 m
                 for cls in self.__class__.mro()
                 for m in cls.__dict__
                 if m[0] != '_' and m not in self._member_map_
-                ] + [m for m in self.__dict__ if m[0] != '_']
+                ] + [m for m in self.__dict__ if m[0] != '_'] 
         return (['__class__', '__doc__', '__module__'] + added_behavior)
 
     def __format__(self, format_spec):
-        """
-        Returns format using actual value type unless __str__ has been overridden.
-        """
+        """ 
+        Returns format using actual value type unless __str__ has been overridden. 
+        """ 
         # mixed-in Enums should use the mixed-in type's __format__, otherwise
         # we can get strange results with the Enum name showing up instead of
         # the value
 
-        # pure Enum branch, or branch with __str__ explicitly overridden
-        str_overridden = type(self).__str__ not in (Enum.__str__, Flag.__str__)
-        if self._member_type_ is object or str_overridden:
+        # pure Enum branch, or branch with __str__ explicitly overridden 
+        str_overridden = type(self).__str__ not in (Enum.__str__, Flag.__str__) 
+        if self._member_type_ is object or str_overridden: 
             cls = str
             val = str(self)
         # mix-in branch
@@ -803,16 +803,16 @@ def _reduce_ex_by_name(self, proto):
     return self.name
 
 class Flag(Enum):
-    """
-    Support for flags
-    """
+    """ 
+    Support for flags 
+    """ 
 
     def _generate_next_value_(name, start, count, last_values):
         """
         Generate the next value when not given.
 
         name: the name of the member
-        start: the initial start value or None
+        start: the initial start value or None 
         count: the number of existing members
         last_value: the last value assigned or None
         """
@@ -828,9 +828,9 @@ class Flag(Enum):
 
     @classmethod
     def _missing_(cls, value):
-        """
-        Returns member (possibly creating it) if one can be found for value.
-        """
+        """ 
+        Returns member (possibly creating it) if one can be found for value. 
+        """ 
         original_value = value
         if value < 0:
             value = ~value
@@ -849,7 +849,7 @@ class Flag(Enum):
             # verify all bits are accounted for
             _, extra_flags = _decompose(cls, value)
             if extra_flags:
-                raise ValueError("%r is not a valid %s" % (value, cls.__qualname__))
+                raise ValueError("%r is not a valid %s" % (value, cls.__qualname__)) 
             # construct a singleton enum pseudo-member
             pseudo_member = object.__new__(cls)
             pseudo_member._name_ = None
@@ -860,13 +860,13 @@ class Flag(Enum):
         return pseudo_member
 
     def __contains__(self, other):
-        """
-        Returns True if self has at least the same flags set as other.
-        """
+        """ 
+        Returns True if self has at least the same flags set as other. 
+        """ 
         if not isinstance(other, self.__class__):
-            raise TypeError(
-                "unsupported operand type(s) for 'in': '%s' and '%s'" % (
-                    type(other).__qualname__, self.__class__.__qualname__))
+            raise TypeError( 
+                "unsupported operand type(s) for 'in': '%s' and '%s'" % ( 
+                    type(other).__qualname__, self.__class__.__qualname__)) 
         return other._value_ & self._value_ == other._value_
 
     def __repr__(self):
@@ -921,25 +921,25 @@ class Flag(Enum):
 
 
 class IntFlag(int, Flag):
-    """
-    Support for integer-based Flags
-    """
+    """ 
+    Support for integer-based Flags 
+    """ 
 
     @classmethod
     def _missing_(cls, value):
-        """
-        Returns member (possibly creating it) if one can be found for value.
-        """
+        """ 
+        Returns member (possibly creating it) if one can be found for value. 
+        """ 
         if not isinstance(value, int):
-            raise ValueError("%r is not a valid %s" % (value, cls.__qualname__))
+            raise ValueError("%r is not a valid %s" % (value, cls.__qualname__)) 
         new_member = cls._create_pseudo_member_(value)
         return new_member
 
     @classmethod
     def _create_pseudo_member_(cls, value):
-        """
-        Create a composite member iff value contains only members.
-        """
+        """ 
+        Create a composite member iff value contains only members. 
+        """ 
         pseudo_member = cls._value2member_map_.get(value, None)
         if pseudo_member is None:
             need_to_create = [value]
@@ -994,15 +994,15 @@ class IntFlag(int, Flag):
 
 
 def _high_bit(value):
-    """
-    returns index of highest bit, or -1 if value is zero or negative
-    """
+    """ 
+    returns index of highest bit, or -1 if value is zero or negative 
+    """ 
     return value.bit_length() - 1
 
 def unique(enumeration):
-    """
-    Class decorator for enumerations ensuring unique member values.
-    """
+    """ 
+    Class decorator for enumerations ensuring unique member values. 
+    """ 
     duplicates = []
     for name, member in enumeration.__members__.items():
         if name != member.name:
@@ -1015,26 +1015,26 @@ def unique(enumeration):
     return enumeration
 
 def _decompose(flag, value):
-    """
-    Extract all members from the value.
-    """
+    """ 
+    Extract all members from the value. 
+    """ 
     # _decompose is only called if the value is not named
     not_covered = value
     negative = value < 0
     members = []
-    for member in flag:
-        member_value = member.value
+    for member in flag: 
+        member_value = member.value 
         if member_value and member_value & value == member_value:
             members.append(member)
             not_covered &= ~member_value
-    if not negative:
-        tmp = not_covered
-        while tmp:
-            flag_value = 2 ** _high_bit(tmp)
-            if flag_value in flag._value2member_map_:
-                members.append(flag._value2member_map_[flag_value])
-                not_covered &= ~flag_value
-            tmp &= ~flag_value
+    if not negative: 
+        tmp = not_covered 
+        while tmp: 
+            flag_value = 2 ** _high_bit(tmp) 
+            if flag_value in flag._value2member_map_: 
+                members.append(flag._value2member_map_[flag_value]) 
+                not_covered &= ~flag_value 
+            tmp &= ~flag_value 
     if not members and value in flag._value2member_map_:
         members.append(flag._value2member_map_[value])
     members.sort(key=lambda m: m._value_, reverse=True)