1 files changed, 489 insertions, 0 deletions
diff --git a/venv/Lib/site-packages/aenum/CHANGES b/venv/Lib/site-packages/aenum/CHANGES
new file mode 100644
index 00000000..e8799f6d
--- /dev/null
+++ b/venv/Lib/site-packages/aenum/CHANGES
@@ -0,0 +1,489 @@
+3.1.8
+=====
+
+recalculate bits used after all flags created (sometimes needed when a custom
+`__new__` is in place.
+
+
+3.1.7
+=====
+
+update flag creation to (possibly) add bitwise operator methods to newly
+created flags
+
+update extend_enum() to work with 3.11 flags
+
+
+3.1.6
+=====
+
+Update `dir()` on mixed enums to include mixed data type methods and
+attributes.
+
+Rename `enum_property` to `property` to match stdlib.  Recommended usage is
+`aenum.property` (prefix with module name).
+
+Remove quadritic creation behavior.
+
+
+BREAKING CHANGE BUG FIX that won't affect most people
+
+Enums with a custom `__new__` that:
+
+- use the enum machinery to generate the values; AND
+- have keyword arguments set to a default (like `None`)
+
+will fail to generate a missing value.  To fix: remove the default value and
+instead specify it on the member creation line.
+
+BREAKING CHANGE
+
+In Python 3.11 the `str()` of mixed enums will now match its `format()` which
+will be the normal `str()` of the data type -- so for an IntEnum you'll see
+`5` instead of `Perm.R|X`.  This affects IntEnum, StrEnum, and IntFlag.
+
+
+3.1.5
+=====
+
+fix support of `auto()` kwds
+
+
+3.1.3
+=====
+
+rename `aenum.property` to `aenum.enum_property`
+
+fix `enum_property` to work with `_init_` attributes
+
+
+3.1.2
+=====
+
+fix `extend_enum()` for unhashable values
+
+
+3.1.1
+=====
+
+fix `extend_enum()` for most cases
+
+
+3.1.0
+=====
+
+AddValue is similar to the old AutoNumber: it will always activate, but
+uses _generate_next_value_ to get the next value (so the user has some
+control over the return data type instead of always getting an int).
+
+
+BREAKING CHANGES
+
+AutoValue is gone.  It was superflous and its removal simplified the code.
+Simply put the fields needed in an `_init_` and `_generate_next_value_`
+will be called to supply the missing values (this is probably already what
+is happening).
+
+
+
+3.0.0
+=====
+
+standard Enum usage is unchanged
+
+BREAKING CHANGES
+
+Enum
+- the more esoteric method of creating Enums have been modified or removed
+  - AutoNumber setting is gone, inherit from AutoNumberEnum instead
+  - creating members without specifying anything is removed (if you don't
+    know what this means, you weren't doing it)
+
+Flag
+- unique flags are canonical (i.e. flags with powers of two values such as
+  1, 2, 4, 8, 16, etc.)
+- non-unique flags are aliases (i.e. values such as 3 or 7)
+- iteration of Flag and flag members only uses canonical flags
+
+
+ENHANCEMENTS
+
+Member creation has been redone to match Python 3.10's methods.  This also
+allows all supported Pythons (2.7, 3.3+) to use the __set_name__ and
+__init_subclass__ protocols (more robustly than in aenum 2.2.5)
+
+
+CHANGES
+
+enum_property() has been renamed to property() (old name still available, but
+deprecated).
+
+bin() replacement shows negative integers in twos-complement
+
+
+
+
+2.2.5
+=====
+
+call __init_subclass__ after members have been added, and in Pythons < 3.6
+call __set_name__ in Pythons < 3.6
+do not convert/disallow private names
+add iteration/len support to NamedConstant
+
+
+2.2.4
+=====
+
+add support to Constant to retrieve members by value
+
+    --> class K(Constant):
+    ...     one = 1
+    ...     two = 2
+
+    --> K.one
+    <K.one: 1>
+
+    --> K(1)
+    <K.one: 1>
+
+add pickle/deepcopy support to Constant
+
+add support for Constant to use other Constant values
+  (resulting members /are not/ the same)
+
+    --> class C(Constant)
+    ...     one = K.one
+    ...     three = 3
+
+    --> C.one == K.one
+    True
+
+    --> C.one is K.one
+    False
+
+AutoNumber and auto() now work together
+
+Enum members are now added to the class as enum_property, which supports
+unshadowing of parent class attributes when called on an Enum member:
+
+    --> class StrEnum(str, Enum):
+    ...     lower = 'lower'
+    ...     upper = 'upper'
+    ...     mixed = 'mixed'
+    
+    --> StrEnum.lower
+    <StrEnum.lower: 'lower'>
+
+    --> StrEnum.lower.upper()
+    'LOWER'
+
+    --> StrEnum.upper
+    <StrEnum.upper: 'upper'>
+
+    --> StrEnum.upper.upper()
+    'UPPER'
+
+
+2.2.3
+=====
+
+use members' type's methods __str__, __repr__, __format__, and
+__reduce_ex__ if directly assigned in Enum class body; i.e.:
+
+    --> class Color(str, Enum):
+    ...     red = 'red'
+    ...     green = 'green'
+    ...     blue = 'blue'
+    ...     __str__ = str.__str__
+
+    --> print(repr(Color.green))
+    <Color.green: 'green'>
+
+    --> print(Color.green)
+    green
+
+
+2.2.2
+=====
+
+replace _RouteClassAttributeToGetattr with enum_property (it is still
+available as an alias)
+
+support constant() and auto() being used together:
+
+    --> class Fruit(Flag):
+    ...    _order_ = 'apple banana lemon orange'
+    ...    apple = auto()
+    ...    banana = auto()
+    ...    lemon = auto()
+    ...    orange = auto()
+    ...    CitrusTypes = constant(lemon | orange)
+
+    --> list(Fruit)
+    [Fruit.apple, Fruit.banana, Fruit.lemon, Fruit.orange]
+
+    --> list(Fruit.CitrusTypes)
+    [Fruit.orange, Fruit.lemon]
+
+    --> Fruit.orange in Fruit.CitrusTypes
+    True
+
+
+2.2.1
+=====
+
+allow Enums to be called without a value
+
+    class Color(Enum):
+        black = 0
+        red = 1
+        green = 2
+        blue = 3
+        #
+        @classmethod
+        def _missing_value_(cls, value):
+            if value is no_arg:
+                return cls.black
+
+    >>> Color()
+    <Color.black: 0>
+
+allow Enum name use while constructing Enum (Python 3.4+ only)
+
+    --> class Color(Enum):
+    ...     _order_ = 'BLACK WHITE'
+    ...     BLACK = Color('black', '#000')
+    ...     WHITE = Color('white', '#fff')
+    ...     #
+    ...     def __init__(self, label, hex):
+    ...         self.label = label
+    ...         self.hex = hex
+
+
+2.2.0
+=====
+
+BREAKING CHANGE
+---------------
+In Python 3+ classes defined inside an Enum no longer become members by
+default; in Python 2 they still become members, but see below.
+
+For cross-compatibility and full control two decorators are provided:
+
+- @member  --> forces item to become a member
+- @nonmember  --> excludes item from becoming a member
+
+So to have an Enum that behaves the same in Python 2 and 3, use the
+decorators (and other compatibility shims):
+
+    class Color(Enum):
+
+        _order_ = 'red green blue'
+
+        red = 1
+        green = 2
+        blue = 3
+
+        @nonmember
+        class Shades(Enum):
+
+            _order_ = 'light medium dark'
+
+            light = 1
+            medium = 2
+            dark = 3
+
+
+2.1.4
+=====
+
+EnumMeta:
+- change __member_new__ to __new_member__ (as the stdlib enum does)
+- assign member name to enum() instances (an Enum helper for defining members)
+- handle empty iterables when using functional API
+- make auto() work with previous enum members
+- keep searching mixins until base class is found
+
+Enum:
+- fix bug in Flag checks (ensure it is a Flag before checking the name)
+- add multiple mixin support
+- do not allow blank names (functional API)
+- raise TypeError if _missing_* returns wrong type
+- fix __format__ to honor custom __str__
+
+extend_enum:
+- support stdlib Enums
+- use _generate_next_value_ if value not provided
+
+general:
+- standardize exception formatting
+- use getfullargspec() in Python 3 (avoids deprecation warnings)
+
+
+2.1.2
+=====
+
+when order is callable, save it for subclass use
+
+
+2.1.1
+=====
+
+correctly raise TypeError for non-Enum containment checks
+support combining names with | for Flag key access
+support _order_ being a callable
+
+
+2.1.0
+=====
+
+support Flags being combined with other data types:
+- add _create_pseudo_member_values_ 
+- add default __new__ and temporary _init_ 
+
+
+2.0.10
+======
+
+ensure _ignore_ is set when _settings_ specified in body which includes
+AutoValue
+
+make Flag members iterable
+
+
+2.0.9
+=====
+
+fix missing comma in __all__
+fix extend_enum with custom __new__ methods
+fix MultiValue with AutoNumber without _init_
+
+
+2.0.8
+=====
+
+extend_enum now handles aliases and multivalues correctly
+
+
+2.0.7
+=====
+
+support mixin types with extend_enum
+init and AutoNumber can now work together
+add test for new Enum using EnumMeta
+add tests for variations of multivalue and init
+prevent deletion of NamedConstant.constant
+
+
+2.0.6
+=====
+
+constants cannot be deleted (they already couldn't be changed)
+constants can be used to define other constants
+
+
+2.0.5
+=====
+
+_init_ and MultiValue can now work together
+
+
+2.0.4
+=====
+
+_init_ and AutoValue (and _generate_next_value_) can now work together to
+supply missing values even when some of the required values per member are
+absent
+
+
+2.0.3
+=====
+
+add _missing_value_ and _missing_name_ methods, deprecate _missing_
+make enum instances comparable
+
+
+2.0.2
+=====
+
+both EnumMeta.__getattr__ and Enum.__new__ fall back to _missing_
+
+
+2.0.1
+=====
+
+auto() now works with other data types
+AutoNumber supports legacy Enums (fixed regression)
+
+
+2.0.0
+=====
+
+Flag and IntFlag added.
+
+
+1.4.7
+=====
+
+fix %-interpolation bug
+defined SqlLiteEnum only if sqlite exists
+support pyflakes
+
+
+1.4.6
+=====
+
+version numbering error
+
+
+1.4.5
+=====
+
+revert AutoNumberEnum to custom __new__ instead of AutoNumber
+use _ignore_ to shield against AutoNumber magic
+inherit start and init settings from base Enums
+
+
+1.4.4
+=====
+
+enabled export as a decorator
+enabled _order_ to replace __order__
+enabled python2 support for settings, init, and start
+
+
+1.4.3
+=====
+
+support _ignore_ for dynamically creating class bodies
+
+
+1.4.2
+=====
+
+MultiValue, NoAlias, Unique, and init now work with Python 2
+
+
+1.4.1
+=====
+
+Py3: added Enum creation flags: Auto, MultiValue, NoAlias, Unique
+
+fixed extend_enum to honor Enum flags
+
+
+1.4.0
+=====
+
+When possible aenum inherits from Python's own enum.
+
+Breaking change: enum members now default to evaluating as True to maintain
+compatibility with the stdlib.
+
+Add your own __bool__ (__nonzero__ in Python 2) if need this behavior:
+
+    def __bool__(self):
+        return bool(self.value)
+    __nonzero__ = __bool__
+