enumerific 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

enumerific/__init__.py

@@ -2,7 +2,14 @@ from enum import *
 
 from .logging import logger
 
-from .exceptions import EnumValueError
+from .exceptions import (
+    EnumValueError,
+    EnumerationError,
+    EnumerationOptionError,
+    EnumerationSubclassingError,
+    EnumerationExtensibilityError,
+    EnumerationNonUniqueError,
+)
 
 from .extensible import (
     Enumeration,

enumerific/exceptions.py

@@ -14,5 +14,9 @@ class EnumerationSubclassingError(EnumerationError):
     pass
 
 
+class EnumerationExtensibilityError(EnumerationError):
+    pass
+
+
 class EnumerationNonUniqueError(EnumerationError):
     pass

enumerific/extensible.py

@@ -9,6 +9,7 @@ from enumerific.exceptions import (
     EnumerationError,
     EnumerationOptionError,
     EnumerationSubclassingError,
+    EnumerationExtensibilityError,
     EnumerationNonUniqueError,
 )
 
@@ -196,10 +197,12 @@ class EnumerationConfiguration(object):
     """The EnumerationConfiguration class holds the Enumeration configuration options"""
 
     _unique: bool = None
-    _aliased: bool = False
+    _aliased: bool = None
+    _backfill: bool = None
     _overwritable: bool = None
     _removable: bool = None
     _subclassable: bool = None
+    _extensible: bool = None
     _raises: bool = None
     _flags: bool = None
     _start: int = None
@@ -211,9 +214,11 @@ class EnumerationConfiguration(object):
         self,
         unique: bool = None,
         aliased: bool = None,
+        backfill: bool = None,
         overwritable: bool = None,
         removable: bool = None,
         subclassable: bool = None,
+        extensible: bool = None,
         raises: bool = None,
         flags: bool = None,
         start: int = None,
@@ -223,9 +228,11 @@ class EnumerationConfiguration(object):
     ):
         self.unique = unique
         self.aliased = aliased
+        self.backfill = backfill
         self.overwritable = overwritable
         self.removable = removable
         self.subclassable = subclassable
+        self.extensible = extensible
         self.raises = raises
         self.flags = flags
         self.start = start
@@ -237,9 +244,11 @@ class EnumerationConfiguration(object):
         return [
             "unique",
             "aliased",
+            "backfill",
             "overwritable",
             "removable",
             "subclassable",
+            "extensible",
             "raises",
             "flags",
             "start",
@@ -310,6 +319,20 @@ class EnumerationConfiguration(object):
             )
         self._aliased = aliased
 
+    @property
+    def backfill(self) -> bool | None:
+        return self._backfill
+
+    @backfill.setter
+    def backfill(self, backfill: bool | None):
+        if backfill is None:
+            pass
+        elif not isinstance(backfill, bool):
+            raise TypeError(
+                "The 'backfill' argument, if specified, must have a boolean value!"
+            )
+        self._backfill = backfill
+
     @property
     def overwritable(self) -> bool | None:
         return self._overwritable
@@ -352,6 +375,20 @@ class EnumerationConfiguration(object):
             )
         self._subclassable = subclassable
 
+    @property
+    def extensible(self) -> bool | None:
+        return self._extensible
+
+    @extensible.setter
+    def extensible(self, extensible: bool | None):
+        if extensible is None:
+            pass
+        elif not isinstance(extensible, bool):
+            raise TypeError(
+                "The 'extensible' argument, if specified, must have a boolean value!"
+            )
+        self._extensible = extensible
+
     @property
     def raises(self) -> bool | None:
         return self._raises
@@ -463,8 +500,10 @@ class EnumerationMetaClass(type):
         bases: tuple[type],
         unique: bool = None,
         aliased: bool = None,
+        backfill: bool = None,
         overwritable: bool = None,
         subclassable: bool = None,
+        extensible: bool = None,
         removable: bool = None,
         raises: bool = None,
         flags: bool = None,
@@ -481,14 +520,16 @@ class EnumerationMetaClass(type):
         any other keyword arguments that are included in the class signature call."""
 
         logger.debug(
-            "[EnumerationMetaClass] %s.__prepare__(name: %s, bases: %s, unique: %s, aliased: %s, overwritable: %s, subclassable: %s, removable: %s, raises: %s, flags: %s, start: %s, steps: %s, times: %s, typecast: %s, kwargs: %s)",
+            "[EnumerationMetaClass] %s.__prepare__(name: %s, bases: %s, unique: %s, aliased: %s, backfill: %s, overwritable: %s, subclassable: %s, extensible: %s, removable: %s, raises: %s, flags: %s, start: %s, steps: %s, times: %s, typecast: %s, kwargs: %s)",
             name,
             name,
             bases,
             unique,
             aliased,
+            backfill,
             overwritable,
             subclassable,
+            extensible,
             removable,
             raises,
             flags,
@@ -581,8 +622,10 @@ class EnumerationMetaClass(type):
         *args,
         unique: bool = None,  # True
         aliased: bool = None,  # False
+        backfill: bool = None,  # False
         overwritable: bool = None,  # False
         subclassable: bool = None,  # True
+        extensible: bool = None,  # True
         removable: bool = None,  # False
         raises: bool = None,  # False
         flags: bool = None,  # False
@@ -613,6 +656,13 @@ class EnumerationMetaClass(type):
                 "The 'aliased' argument, if specified, must have a boolean value!"
             )
 
+        if backfill is None:
+            pass
+        elif not isinstance(backfill, bool):
+            raise TypeError(
+                "The 'backfill' argument, if specified, must have a boolean value!"
+            )
+
         if overwritable is None:
             pass
         elif not isinstance(overwritable, bool):
@@ -627,6 +677,13 @@ class EnumerationMetaClass(type):
                 "The 'subclassable' argument, if specified, must have a boolean value!"
             )
 
+        if extensible is None:
+            pass
+        elif not isinstance(extensible, bool):
+            raise TypeError(
+                "The 'extensible' argument, if specified, must have a boolean value!"
+            )
+
         if removable is None:
             pass
         elif not isinstance(removable, bool):
@@ -679,8 +736,10 @@ class EnumerationMetaClass(type):
         configuration = EnumerationConfiguration(
             unique=unique,
             aliased=aliased,
+            backfill=backfill,
             overwritable=overwritable,
             subclassable=subclassable,
+            extensible=extensible,
             removable=removable,
             raises=raises,
             flags=flags,
@@ -746,12 +805,18 @@ class EnumerationMetaClass(type):
                         logger.debug(
                             " >>> aliased      => %s", base_configuration.aliased
                         )
+                        logger.debug(
+                            " >>> backfill     => %s", base_configuration.backfill
+                        )
                         logger.debug(
                             " >>> overwritable => %s", base_configuration.overwritable
                         )
                         logger.debug(
                             " >>> subclassable => %s", base_configuration.subclassable
                         )
+                        logger.debug(
+                            " >>> extensible   => %s", base_configuration.extensible
+                        )
                         logger.debug(
                             " >>> removable    => %s", base_configuration.removable
                         )
@@ -774,9 +839,12 @@ class EnumerationMetaClass(type):
                             " >>> typecast     => %s", base_configuration.typecast
                         )
 
-                        if base_configuration.subclassable is False:
+                        if (
+                            base_configuration.subclassable is False
+                            or base_configuration.extensible is False
+                        ):
                             raise EnumerationSubclassingError(
-                                "The '%s' enumeration class cannot be subclassed when the keyword argument 'subclassable=False' was passed to the class constructor!"
+                                "The '%s' enumeration class cannot be subclassed when the keyword arguments 'subclassable=False' or 'extensible=False` are passed to the class constructor!"
                                 % (base.__name__)
                             )
 
@@ -791,6 +859,9 @@ class EnumerationMetaClass(type):
                         logger.debug(
                             " >>> (updated) aliased      => %s", configuration.aliased
                         )
+                        logger.debug(
+                            " >>> (updated) backfill     => %s", configuration.backfill
+                        )
                         logger.debug(
                             " >>> (updated) overwritable => %s",
                             configuration.overwritable,
@@ -799,6 +870,10 @@ class EnumerationMetaClass(type):
                             " >>> (updated) subclassable => %s",
                             configuration.subclassable,
                         )
+                        logger.debug(
+                            " >>> (updated) extensible => %s",
+                            configuration.extensible,
+                        )
                         logger.debug(
                             " >>> (updated) removable    => %s", configuration.removable
                         )
@@ -824,7 +899,6 @@ class EnumerationMetaClass(type):
                     # logger.debug(" >>> found base (%s) that is an instance of EnumerationMetaClass and a subclass of Enumeration" % (base))
 
                     if not (base is Enumeration or Enumeration in base.__bases__):
-                        # enumerations = base._enumerations  # reference to the _enumerations dictionary
                         _enumerations = base._enumerations
 
                     logger.debug("  >>> enumerations => %s" % (base._enumerations))
@@ -846,8 +920,10 @@ class EnumerationMetaClass(type):
         configuration.defaults(
             unique=True,
             aliased=False,
+            backfill=False,
             overwritable=False,
             subclassable=True,
+            extensible=True,
             removable=False,
             raises=False,
             flags=False,
@@ -859,12 +935,14 @@ class EnumerationMetaClass(type):
 
         logger.debug(" >>> (after defaults) unique       => %s", configuration.unique)
         logger.debug(" >>> (after defaults) aliased      => %s", configuration.aliased)
+        logger.debug(" >>> (after defaults) backfill     => %s", configuration.backfill)
         logger.debug(
             " >>> (after defaults) overwritable => %s", configuration.overwritable
         )
         logger.debug(
             " >>> (after defaults) subclassable => %s", configuration.subclassable
         )
+        logger.debug(" >>> (after defaults) extensible => %s", configuration.extensible)
         logger.debug(
             " >>> (after defaults) removable    => %s", configuration.removable
         )
@@ -998,28 +1076,20 @@ class EnumerationMetaClass(type):
 
         logger.debug(" >>> bases         => %s", [base for base in bases])
 
-        # if "EnumerationInteger" in globals():
-        #     if EnumerationInteger in bases and EnumerationFlag in bases:
-        #         bases = tuple([base for base in bases if not EnumerationInteger])
-
         args: tuple[object] = (name, bases, attributes)
 
         # Create the new enumeration class instance
         instance = super().__new__(cls, *args, **kwargs)
 
-        # logger.debug(
-        # " >>> metaclass => %s (base: %s, type: %s, bases: %s)\n"
-        # % (enumclass, instance, type(instance), instance.__bases__)
-        # )
-        # logger.debug(" >>> metaclass => %s (base: %s, type: %s, bases: %s)\n" % (enumclass, instance, type(instance), instance.__bases__))
-
         logger.debug(" >>> baseclass     => %s", baseclass)
         logger.debug(" >>> instance      => %s", instance)
 
         logger.debug(" >>> unique        => %s", configuration.unique)
         logger.debug(" >>> aliased       => %s", configuration.aliased)
+        logger.debug(" >>> backfill      => %s", configuration.backfill)
         logger.debug(" >>> overwritable  => %s", configuration.overwritable)
         logger.debug(" >>> subclassable  => %s", configuration.subclassable)
+        logger.debug(" >>> extensible    => %s", configuration.extensible)
         logger.debug(" >>> removable     => %s", configuration.removable)
         logger.debug(" >>> raises        => %s", configuration.raises)
         logger.debug(" >>> flags         => %s", configuration.flags)
@@ -1048,7 +1118,16 @@ class EnumerationMetaClass(type):
         )
 
         if isinstance(base_enumerations := attributes.get("base_enumerations"), dict):
-            self._enumerations: dict[str, Enumeration] = base_enumerations
+            if (
+                self._configuration.backfill is True
+                and self._configuration.extensible is True
+            ):
+                self._enumerations: dict[str, Enumeration] = base_enumerations
+            else:
+                self._enumerations: dict[str, Enumeration] = {}
+
+                for enumeration_name, enumeration in base_enumerations.items():
+                    self._enumerations[enumeration_name] = enumeration
         else:
             self._enumerations: dict[str, Enumeration] = {}
 
@@ -1131,16 +1210,19 @@ class EnumerationMetaClass(type):
             )
 
     def __dir__(self) -> list[str]:
-        members: list[str] = []
-
-        for name, enumeration in self._enumerations.items():
-            members.append(name)
+        members: set[str] = set()
 
         for member in object.__dir__(self):
             if member.startswith("_") or member in self._special:
-                members.append(member)
+                members.add(member)
+
+        for name, enumeration in self._enumerations.items():
+            members.add(name)
 
-        return members
+        for member in vars(self):
+            members.add(member)
+
+        return list(members)
 
     def __contains__(self, other: Enumeration | object) -> bool:
         logger.debug(
@@ -1326,6 +1408,12 @@ class EnumerationMetaClass(type):
             value,
         )
 
+        if self.configuration.extensible is False:
+            raise EnumerationExtensibilityError(
+                "The '%s' enumeration class has been configured to prevent extensibility, so cannot be extended with new options either through registration or subclassing, so the '%s' option cannot be registered!"
+                % (self.__name__, name)
+            )
+
         if self.configuration.overwritable is False and name in self._enumerations:
             raise EnumerationNonUniqueError(
                 "The '%s' enumeration class already has an option named '%s', so a new option with the same name cannot be created unless the 'overwritable=True' argument is passed during class construction!"
@@ -1430,6 +1518,14 @@ class EnumerationMetaClass(type):
                     )
                 )
 
+        # When an enumeration option is reconciled, it may be defined in another class
+        # but have been accessed through a subclass; in order for attribute lookups to
+        # work within the subclass, we need to provide the current lookup context to the
+        # reconciled enumeration option, so that any attribute access on this object can
+        # perform their lookup in the correct part of the class hierarchy
+        if isinstance(reconciled, Enumeration):
+            reconciled._context = self
+
         return reconciled
 
     def validate(self, value: Enumeration | object = None, name: str = None) -> bool:
@@ -1449,6 +1545,7 @@ class Enumeration(metaclass=EnumerationMetaClass):
     """The Enumeration class is the subclass of all enumerations and their subtypes."""
 
     _metaclass: EnumerationMetaClass = None
+    _context: EnumerationMetaClass = None
     _enumeration: Enumeration = None
     _enumerations: dict[str, Enumeration] = None
     _annotations: anno = None
@@ -1609,6 +1706,8 @@ class Enumeration(metaclass=EnumerationMetaClass):
             return self._enumerations[name]
         elif self._annotations and name in self._annotations:
             return self._annotations[name]
+        elif self._context and name in dir(self._context):
+            return object.__getattribute__(self._context, name)
         else:
             # EnumerationOptionError subclasses AttributeError so we adhere to convention
             raise EnumerationOptionError(

enumerific/version.txt

@@ -1 +1 @@
-1.0.2
+1.0.3

{enumerific-1.0.2.dist-info → enumerific-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: enumerific
-Version: 1.0.2
+Version: 1.0.3
 Summary: Simplifies working with Python enums.
 Author: Daniel Sissman
 License-Expression: MIT
@@ -41,8 +41,9 @@ The Enumerific library's `Enumeration` class offers the following features:
  * Enumerific enumerations options can be added after an `Enumeration` class has been created either through extending an existing enumerations class by subclassing or by registering new options directly on an existing enumerations class via the `.register()` method; this is especially useful for cases where enumeration options may not all be known prior to runtime;
  * Enumerific enumerations options can be removed after an `Enumeration` class has been created via the `.unregister()` method; this specialised behaviour is prevented by default, but can be enabled for advanced use cases;
  * Enforcement of unique values for all options within an enumeration, unless overridden;
- * Support for aliasing enumeration options;
- * Support for redefining enumeration options;
+ * Support for aliasing enumeration options, and control over this behaviour;
+ * Support for backfilling enumeration options on a superclass when subclassing, and control over this behaviour
+ * Support for redefining enumeration options, and control over this behaviour;
  * Support for automatically generating unique number sequences for enumeration options, including powers of two for bitwise enumeration flags, as well as other sequences such as powers of other numbers and factoring;
  * Support for annotating enumeration options with additional arbitrary key-value pairs, which can be particularly useful for associating additional data with a given enumeration option, which may be accessed later anywhere in code that the enumeration option is available;
  * Simple one-line reconciliation of `Enumeration` class options to the corresponding `enums.Enum` class instance that represents the corresponding option; reconciliation by enumeration option name, value and enumeration class instance reference are all supported through the `.reconcile()` class method;
@@ -253,7 +254,7 @@ for value in Colors.values():
     print(value)
 ```
 
-#### Example 8: Registering New Option
+#### Example 8: Registering New Options
 
 ```python
 from enumerific import Enumeration
@@ -264,11 +265,17 @@ class Colors(Enumeration):
     BLUE = 3
 
 Colors.register("PURPLE", 4)
+Colors.register("GOLD", 5)
 
 assert "PURPLE" in Colors
 assert Colors.PURPLE.name == "PURPLE"
 assert Colors.PURPLE.value == 4
 assert Colors.PURPLE == 4
+
+assert "GOLD" in Colors
+assert Colors.GOLD.name == "GOLD"
+assert Colors.GOLD.value == 5
+assert Colors.GOLD == 5
 ```
 
 #### Example 9: Subclassing
@@ -281,27 +288,64 @@ class Colors(Enumeration):
     GREEN = 2
     BLUE = 3
 
+# Ensure that Colors has the expected options
+assert "RED" in Colors
+assert "GREEN" in Colors
+assert "BLUE" in Colors
+
+# Create a subclass of Colors, inheriting its options
 class MoreColors(Colors):
     PURPLE = 4
     GOLD = 5
 
+# Ensure that MoreColors inherited the options from Colors, as well as adding its own
+assert "RED" in MoreColors
+assert "GREEN" in MoreColors
+assert "BLUE" in MoreColors
+assert "PURPLE" in MoreColors
+assert "GOLD" in MoreColors
+
+# As backfilling is off by default subclass options won't be available on the superclass
+assert not "PURPLE" in Colors
+assert not "GOLD" in Colors
+```
+
+#### Example 10: Subclassing with Backfilling
+
+```python
+from enumerific import Enumeration
+
+# To override the default behaviour and to allow backfilling of options from subclasses,
+# the `backfill` keyword argument can be set to `True` when creating the class. This
+# effectively creates another way to extend an existing enumeration class through
+# subclassing and its side-effect of backfilling, compared to using the `.register()`
+# method to add new options to an existing enumeration class:
+class Colors(Enumeration, backfill=True):
+    RED = 1
+    GREEN = 2
+    BLUE = 3
+
+assert "RED" in Colors
+assert "GREEN" in Colors
 assert "BLUE" in Colors
-assert Colors.BLUE.name == "BLUE"
-assert Colors.BLUE.value == 3
-assert Colors.BLUE == 3
 
+class MoreColors(Colors):
+    PURPLE = 4
+    GOLD = 5
+
+assert "RED" in MoreColors
+assert "GREEN" in MoreColors
+assert "BLUE" in MoreColors
 assert "PURPLE" in MoreColors
-assert MoreColors.PURPLE.name == "PURPLE"
-assert MoreColors.PURPLE.value == 4
-assert MoreColors.PURPLE == 4
+assert "GOLD" in MoreColors
 
+# As backfilling has been enabled for the superclass, subclass options are available on
+# both the subclass as seen above as well as on the superclass through backfilling:
+assert "PURPLE" in Colors
 assert "GOLD" in Colors
-assert Colors.GOLD.name == "GOLD"
-assert Colors.GOLD.value == 5
-assert Colors.GOLD == 5
 ```
 
-#### Example 10: Subclassing Over
+#### Example 11: Subclassing Over
 
 ```python
 from enumerific import Enumeration
@@ -311,29 +355,34 @@ class Colors(Enumeration):
     GREEN = 2
     BLUE = 3
 
-# Subclassed Enumerations can have the same name as the parent class
-# The subclass will inherit the enumeration options of its parent
+assert "RED" in Colors
+assert Colors.RED == 1
+
+assert "GREEN" in Colors
+assert Colors.GREEN == 2
+
+assert "BLUE" in Colors
+assert Colors.BLUE == 3
+
+# Subclasses of Enumerations classes can be given the same name as the parent class, so
+# within this scope, the subclass shadows the superclass; the subclass inherits all the
+# enumeration options of its parent(s) superclasses:
 class Colors(Colors):
     PURPLE = 4
     GOLD = 5
 
+assert "RED" in Colors
+assert "GREEN" in Colors
 assert "BLUE" in Colors
-assert Colors.BLUE.name == "BLUE"
-assert Colors.BLUE.value == 3
-assert Colors.BLUE == 3
 
 assert "PURPLE" in Colors
-assert Colors.PURPLE.name == "PURPLE"
-assert Colors.PURPLE.value == 4
 assert Colors.PURPLE == 4
 
 assert "GOLD" in Colors
-assert Colors.GOLD.name == "GOLD"
-assert Colors.GOLD.value == 5
 assert Colors.GOLD == 5
 ```
 
-#### Example 11: Unregistering Existing Option
+#### Example 12: Unregistering Existing Option
 
 ```python
 from enumerific import Enumeration
@@ -352,7 +401,26 @@ assert "GREEN" not in Colors
 assert "BLUE" in Colors
 ```
 
-#### Example 12: Aliasing Options
+#### Example 13: Preventing Subclassing of Enumeration Classes
+
+```python
+from enumerific import Enumeration, EnumerationSubclassingError
+import pytest
+
+# To prevent an enumeration class from being extended through subclassing, the
+# `subclassable` keyword argument can be set when creating the class; this will
+# result in an `EnumerationSubclassingError` exception being raised on subclassing:
+class Colors(Enumeration, subclassable=False):
+    RED = 1
+    GREEN = 2
+    BLUE = 3
+
+with pytest.raises(EnumerationSubclassingError):
+    class MoreColors(Colors):
+        PURPLE = 4
+```
+
+#### Example 14: Aliasing Options
 
 ```python
 from enumerific import Enumeration
@@ -402,7 +470,7 @@ assert Colors.GREEN.aliases == [Colors.VERTE]
 assert Colors.BLUE.aliases == []  # BLUE has not been aliased
 ```
 
-#### Example 13: Non-Unique Options
+#### Example 15: Non-Unique Options
 
 ```python
 from enumerific import Enumeration
@@ -441,7 +509,7 @@ assert Colors.RED == Colors.GREEN
 assert Colors.BLUE != Colors.RED
 ```
 
-#### Example 14: Bit Wise Flags
+#### Example 16: Bit Wise Flags
 
 ```python
 from enumerific import Enumeration
@@ -513,7 +581,7 @@ assert Permissions.DELETE in permissions
 assert str(permissions) == "Permissions.READ|WRITE|DELETE"
 ```
 
-#### Example 15: Annotating Enumeration Option Values
+#### Example 17: Annotating Enumeration Option Values
 
 ```python
 from enumerific import Enumeration, anno
@@ -557,7 +625,7 @@ assert Colors.PURPLE.rgb == (255, 0, 255)
 assert Colors.PURPLE.primary is False
 ```
 
-#### Example 16: Annotating Enumeration Option Values with Automatic Sequencing
+#### Example 18: Annotating Enumeration Option Values with Automatic Sequencing
 
 ```python
 from enumerific import Enumeration, auto

enumerific-1.0.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+enumerific/__init__.py,sha256=K9iFirgxSkrHgXfhocOvgRkskGe0VfWRgxEvppnVWBM,587
+enumerific/exceptions.py,sha256=lvfcH1cz43hDjzSUpgm1-OZjKzxo--fyZ8UsBS-GiZA,359
+enumerific/extensible.py,sha256=AS9rU-luPjfau_PHFa52r-rlaDWpbxiF4qgnh4BdH9o,84320
+enumerific/logging.py,sha256=zz1Phnot1BFWMoxwvZ0FlZDsiYZZYhz-_S4IzgPYc40,97
+enumerific/standard.py,sha256=xQhhwlcYZ6-8DmgscbV38g2Ol5Z8_vvBwonz-Ww0I40,3254
+enumerific/version.txt,sha256=INLLCW0atBpBQCRtEvB79rjLdD_UgSK3JTLAPUTFwUo,5
+enumerific-1.0.3.dist-info/licenses/LICENSE.md,sha256=j1XidOCGUhPx7CyXA31uC0XGKDRnvUcZpMp161qHI6g,1077
+enumerific-1.0.3.dist-info/METADATA,sha256=EEriXyK6TOyNDx0_juEMGnyf4h5NKP_o2JNWncNssgY,32990
+enumerific-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+enumerific-1.0.3.dist-info/top_level.txt,sha256=hyemsMgPYZgSx71XHmFRF-gvc_2Y4rDAESR8e0hbYHU,11
+enumerific-1.0.3.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+enumerific-1.0.3.dist-info/RECORD,,

enumerific-1.0.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-enumerific/__init__.py,sha256=Qe_3I0e4a_eA4quVKz05eufYtX4soq1Ku-pnXiQxxAQ,429
-enumerific/exceptions.py,sha256=u0-efY2ufY__DZPs56L_SblvhnFZjUb2AcMjL_AxtKw,293
-enumerific/extensible.py,sha256=YSYyVi8oUzQuNUBmdJcqtMd-Fs15cjvMqEMHi2F4JcA,80452
-enumerific/logging.py,sha256=zz1Phnot1BFWMoxwvZ0FlZDsiYZZYhz-_S4IzgPYc40,97
-enumerific/standard.py,sha256=xQhhwlcYZ6-8DmgscbV38g2Ol5Z8_vvBwonz-Ww0I40,3254
-enumerific/version.txt,sha256=v-wuNFg62n5q8stzmT-3Wj9xR6bJQ-X_X1xClPxXe5A,5
-enumerific-1.0.2.dist-info/licenses/LICENSE.md,sha256=j1XidOCGUhPx7CyXA31uC0XGKDRnvUcZpMp161qHI6g,1077
-enumerific-1.0.2.dist-info/METADATA,sha256=F632r_SiMpT5u4nskU8K_c4fDDxDbaOgrIoiGYZfNmA,30755
-enumerific-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-enumerific-1.0.2.dist-info/top_level.txt,sha256=hyemsMgPYZgSx71XHmFRF-gvc_2Y4rDAESR8e0hbYHU,11
-enumerific-1.0.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-enumerific-1.0.2.dist-info/RECORD,,