commit b9253fb9a45491a29bbf9ed891217f25d305c9ff Author: Jean-Sebastien Bevilacqua Date: Thu Dec 29 08:34:01 2016 +0100 Make enum.py pep8 compliant The enum module contains unused imports, too long lines, bad visual indents. This patch fix these warning. diff --git a/Lib/enum.py b/Lib/enum.py index 3f5ecbb..d3d1c93 100644 --- a/Lib/enum.py +++ b/Lib/enum.py @@ -1,7 +1,7 @@ import sys from types import MappingProxyType, DynamicClassAttribute from functools import reduce -from operator import or_ as _or_, and_ as _and_, xor, neg +from operator import or_ as _or_ # try _collections first to reduce startup cost try: @@ -40,6 +40,7 @@ def _is_sunder(name): name[-2:-1] != '_' and len(name) > 2) + def _make_class_unpicklable(cls): """Make the given class un-picklable.""" def _break_on_call_reduce(self, proto): @@ -47,7 +48,10 @@ def _make_class_unpicklable(cls): cls.__reduce_ex__ = _break_on_call_reduce cls.__module__ = '' + _auto_null = object() + + class auto: """ Instances are replaced with an appropriate value in Enum class suites. @@ -96,7 +100,8 @@ 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[:]) + value.value = self._generate_next_value( + key, 1, len(self._member_names), self._last_values[:]) value = value.value self._member_names.append(key) self._last_values.append(value) @@ -118,7 +123,8 @@ class EnumMeta(type): # inherit previous flags and _generate_next_value_ function member_type, first_enum = metacls._get_mixins_(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): @@ -127,8 +133,8 @@ class EnumMeta(type): # inherited __new__ unless a new __new__ is defined (or the resulting # class will fail). member_type, first_enum = metacls._get_mixins_(bases) - __new__, save_new, use_args = metacls._find_new_(classdict, member_type, - first_enum) + __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 @@ -151,8 +157,8 @@ class EnumMeta(type): # create our new Enum type enum_class = super().__new__(metacls, cls, bases, classdict) - enum_class._member_names_ = [] # names in definition order - enum_class._member_map_ = OrderedDict() # name->value map + enum_class._member_names_ = [] # names in definition order + enum_class._member_map_ = OrderedDict() # name->value map enum_class._member_type_ = member_type # save attributes from super classes so we know if we can take @@ -175,7 +181,7 @@ class EnumMeta(type): if '__reduce_ex__' not in classdict: if member_type is not object: methods = ('__getnewargs_ex__', '__getnewargs__', - '__reduce_ex__', '__reduce__') + '__reduce_ex__', '__reduce__') if not any(m in member_type.__dict__ for m in methods): _make_class_unpicklable(enum_class) @@ -222,9 +228,9 @@ class EnumMeta(type): # 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. + # 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 @@ -262,7 +268,8 @@ class EnumMeta(type): """ return True - def __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1): + 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. This method is used both when an enum class is given a value to match @@ -274,7 +281,8 @@ class EnumMeta(type): `value` will be the name of the new class. `names` should be either a string of white-space/comma delimited names - (values will start at `start`), or an iterator/mapping of name, value pairs. + (values will start at `start`), or an iterator/mapping of name, value + pairs. `module` should be set to the module this class is being created in; if it is not set, an attempt to find that module will be made, but if @@ -290,7 +298,8 @@ 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): return isinstance(member, cls) and member._name_ in cls._member_map_ @@ -346,7 +355,8 @@ class EnumMeta(type): return "" % cls.__name__ def __reversed__(cls): - return (cls._member_map_[name] for name in reversed(cls._member_names_)) + return (cls._member_map_[name] + for name in reversed(cls._member_names_)) def __setattr__(cls, name, value): """Block attempts to reassign Enum members. @@ -361,14 +371,16 @@ class EnumMeta(type): raise AttributeError('Cannot reassign members.') super().__setattr__(name, value) - def _create_(cls, class_name, names=None, *, module=None, qualname=None, type=None, start=1): + def _create_(cls, class_name, names=None, *, module=None, qualname=None, + type=None, start=1): """Convenience method to create a new Enum class. `names` can be: * A string containing member names, separated either with spaces or commas. Values are incremented by 1 from `start`. - * An iterable of member names. Values are incremented by 1 from `start`. + * An iterable of member names. Values are incremented + by 1 from `start`. * An iterable of (member name, value) pairs. * A mapping of member name -> value pairs. @@ -385,7 +397,8 @@ class EnumMeta(type): original_names, names = names, [] last_values = [] for count, name in enumerate(original_names): - value = first_enum._generate_next_value_(name, start, count, last_values[:]) + value = first_enum._generate_next_value_(name, start, count, + last_values[:]) last_values.append(value) names.append((name, value)) @@ -430,14 +443,14 @@ class EnumMeta(type): # type has been mixed in so we can use the correct __new__ member_type = first_enum = None for base in bases: - if (base is not Enum and - issubclass(base, Enum) and - base._member_names_): + if (base is not Enum and + issubclass(base, Enum) and + base._member_names_): raise TypeError("Cannot extend enumerations") # base is now the last base in bases if not issubclass(base, Enum): raise TypeError("new enumerations must be created as " - "`ClassName([mixin_type,] enum_type)`") + "`ClassName([mixin_type,] enum_type)`") # get correct mix-in type (either mix-in type of Enum subclass, or # first base if last base is Enum) @@ -602,7 +615,8 @@ class Enum(metaclass=EnumMeta): @classmethod def _convert(cls, name, module, filter, source=None): """ - Create a new Enum subclass that replaces a collection of global constants + 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 @@ -643,6 +657,7 @@ class IntEnum(int, Enum): def _reduce_ex_by_name(self, proto): return self.name + class Flag(Enum): """Support for flags""" @@ -662,7 +677,8 @@ class Flag(Enum): high_bit = _high_bit(last_value) break except Exception: - raise TypeError('Invalid Flag value: %r' % last_value) from None + raise TypeError('Invalid Flag value: %r' % last_value) \ + from None return 2 ** (high_bit+1) @classmethod @@ -685,7 +701,8 @@ 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.__name__)) + raise ValueError("%r is not a valid %s" % + (value, cls.__name__)) # construct a singleton enum pseudo-member pseudo_member = object.__new__(cls) pseudo_member._name_ = None @@ -773,8 +790,7 @@ class IntFlag(int, Flag): bit = _high_bit(extra_flags) flag_value = 2 ** bit if (flag_value not in cls._value2member_map_ and - flag_value not in need_to_create - ): + flag_value not in need_to_create): need_to_create.append(flag_value) if extra_flags == -flag_value: extra_flags = 0 @@ -817,6 +833,7 @@ def _high_bit(value): """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.""" duplicates = [] @@ -827,9 +844,10 @@ def unique(enumeration): alias_details = ', '.join( ["%s -> %s" % (alias, name) for (alias, name) in duplicates]) raise ValueError('duplicate values found in %r: %s' % - (enumeration, alias_details)) + (enumeration, alias_details)) return enumeration + def _decompose(flag, value): """Extract all members from the value.""" # _decompose is only called if the value is not named @@ -862,6 +880,7 @@ def _decompose(flag, value): members.pop(0) return members, not_covered + def _power_of_two(value): if value < 1: return False