enumerific 1.0.6__tar.gz → 1.0.8__tar.gz

{enumerific-1.0.6/source/enumerific.egg-info → enumerific-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: enumerific
-Version: 1.0.6
+Version: 1.0.8
 Summary: Simplifies working with Python enums.
 Author: Daniel Sissman
 License-Expression: MIT
@@ -675,6 +675,42 @@ assert Colors.PURPLE.rgb == (255, 0, 255)
 assert Colors.PURPLE.primary is False
 ```
 
+#### Example 19: Reconciling Enumeration Options via Annotations
+
+```python
+from enumerific import Enumeration, auto
+
+class Colors(Enumeration):
+    """Create a test Color enumeration based on the Enumeration class"""
+
+    RED = auto(RGB=(255, 0, 0))
+    GREEN = auto(RGB=(0, 255, 0))
+    BLUE = auto(RGB=(0, 0, 255))
+
+# Ensure that the Colors enumeration subclass is of the expected types
+assert issubclass(Colors, Enumeration)
+
+# Attempt to reconcile a Color against one of its annotations (via annotation keyword)
+color = Colors.reconcile(RGB=(255, 0, 0))
+
+assert isinstance(color, Colors)
+assert isinstance(color, Enumeration)
+
+assert color.name == "RED"
+assert color.value == 1
+assert color.RGB == (255, 0, 0)
+
+# Attempt to reconcile a Color against one of its annotations (via annotation argument)
+color = Colors.reconcile(value=(0, 255, 0), annotation="RGB")
+
+assert isinstance(color, Colors)
+assert isinstance(color, Enumeration)
+
+assert color.name == "GREEN"
+assert color.value == 2
+assert color.RGB == (0, 255, 0)
+```
+
 # Enumerific Library Enumerations: Classes & Methods
 
 The Enumerific library's `Enumeration` class is a greenfield implementation of enumerations

{enumerific-1.0.6 → enumerific-1.0.8}/README.md

@@ -645,6 +645,42 @@ assert Colors.PURPLE.rgb == (255, 0, 255)
 assert Colors.PURPLE.primary is False
 ```
 
+#### Example 19: Reconciling Enumeration Options via Annotations
+
+```python
+from enumerific import Enumeration, auto
+
+class Colors(Enumeration):
+    """Create a test Color enumeration based on the Enumeration class"""
+
+    RED = auto(RGB=(255, 0, 0))
+    GREEN = auto(RGB=(0, 255, 0))
+    BLUE = auto(RGB=(0, 0, 255))
+
+# Ensure that the Colors enumeration subclass is of the expected types
+assert issubclass(Colors, Enumeration)
+
+# Attempt to reconcile a Color against one of its annotations (via annotation keyword)
+color = Colors.reconcile(RGB=(255, 0, 0))
+
+assert isinstance(color, Colors)
+assert isinstance(color, Enumeration)
+
+assert color.name == "RED"
+assert color.value == 1
+assert color.RGB == (255, 0, 0)
+
+# Attempt to reconcile a Color against one of its annotations (via annotation argument)
+color = Colors.reconcile(value=(0, 255, 0), annotation="RGB")
+
+assert isinstance(color, Colors)
+assert isinstance(color, Enumeration)
+
+assert color.name == "GREEN"
+assert color.value == 2
+assert color.RGB == (0, 255, 0)
+```
+
 # Enumerific Library Enumerations: Classes & Methods
 
 The Enumerific library's `Enumeration` class is a greenfield implementation of enumerations

{enumerific-1.0.6 → enumerific-1.0.8}/source/enumerific/extensible.py

@@ -1458,29 +1458,61 @@ class EnumerationMetaClass(type):
         value: Enumeration | object = None,
         name: str = None,
         caselessly: bool = False,
+        annotation: str = None,
+        **annotations: dict[str, object],
     ) -> Enumeration | None:
         """The 'reconcile' method can be used to reconcile Enumeration type, enumeration
         values, or enumeration names to their matching Enumeration type instances. If a
         match is found the Enumeration type instance will be returned otherwise None will
         be returned, unless the class is configured to raise an error for mismatches."""
 
-        if name is None and value is None:
+        if isinstance(annotation, str):
+            annotations[annotation] = value
+
+        if name is None and value is None and len(annotations) == 0:
             raise ValueError(
-                "Either the 'value' or 'name' argument must be specified when calling the 'reconcile' function!"
+                "Either a 'value', 'name' or annotation keyword argument must be specified when calling the 'reconcile' function!"
             )
 
         if not value is None and not isinstance(value, (Enumeration, object)):
             raise TypeError(
-                "The 'value' argument must reference an Enumeration type or have an enumeration value!"
+                "The 'value' argument, if specified, must reference an Enumeration type or have an enumeration value!"
             )
 
         if not name is None and not isinstance(name, str):
-            raise TypeError("The 'name' argument must have a string value!")
+            raise TypeError(
+                "The 'name' argument, if specified, must have a string value!"
+            )
 
         reconciled: Enumeration = None
 
         for attribute, enumeration in self._enumerations.items():
-            if isinstance(value, Enumeration):
+            if len(annotations) > 0:
+                comparisons: list[bool] = []
+
+                for annotation, value in annotations.items():
+                    if annotation in enumeration._annotations:
+                        if enumeration._annotations[annotation] is value:
+                            comparisons.append(True)
+                        elif enumeration._annotations[annotation] == value:
+                            comparisons.append(True)
+                        else:
+                            comparisons.append(False)
+                    else:
+                        comparisons.append(False)
+
+                        logger.debug(
+                            "The enumeration option, %s, has no '%s' annotation!"
+                            % (
+                                enumeration,
+                                annotation,
+                            )
+                        )
+
+                if len(comparisons) == len(annotations) and False not in comparisons:
+                    reconciled = enumeration
+                    break
+            elif isinstance(value, Enumeration):
                 if enumeration is value:
                     reconciled = enumeration
                     break

enumerific-1.0.8/source/enumerific/version.txt

@@ -0,0 +1 @@
+1.0.8

{enumerific-1.0.6 → enumerific-1.0.8/source/enumerific.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: enumerific
-Version: 1.0.6
+Version: 1.0.8
 Summary: Simplifies working with Python enums.
 Author: Daniel Sissman
 License-Expression: MIT
@@ -675,6 +675,42 @@ assert Colors.PURPLE.rgb == (255, 0, 255)
 assert Colors.PURPLE.primary is False
 ```
 
+#### Example 19: Reconciling Enumeration Options via Annotations
+
+```python
+from enumerific import Enumeration, auto
+
+class Colors(Enumeration):
+    """Create a test Color enumeration based on the Enumeration class"""
+
+    RED = auto(RGB=(255, 0, 0))
+    GREEN = auto(RGB=(0, 255, 0))
+    BLUE = auto(RGB=(0, 0, 255))
+
+# Ensure that the Colors enumeration subclass is of the expected types
+assert issubclass(Colors, Enumeration)
+
+# Attempt to reconcile a Color against one of its annotations (via annotation keyword)
+color = Colors.reconcile(RGB=(255, 0, 0))
+
+assert isinstance(color, Colors)
+assert isinstance(color, Enumeration)
+
+assert color.name == "RED"
+assert color.value == 1
+assert color.RGB == (255, 0, 0)
+
+# Attempt to reconcile a Color against one of its annotations (via annotation argument)
+color = Colors.reconcile(value=(0, 255, 0), annotation="RGB")
+
+assert isinstance(color, Colors)
+assert isinstance(color, Enumeration)
+
+assert color.name == "GREEN"
+assert color.value == 2
+assert color.RGB == (0, 255, 0)
+```
+
 # Enumerific Library Enumerations: Classes & Methods
 
 The Enumerific library's `Enumeration` class is a greenfield implementation of enumerations

{enumerific-1.0.6 → enumerific-1.0.8}/tests/test_extensible_enums.py

@@ -1613,8 +1613,8 @@ def test_membership_in_tuple():
     assert Colors.VIOLET not in colors
 
 
-def test_attribute_access():
-    """Test access to attributes (methods, properties, etc) on an Enumeration subclass"""
+def test_annotation_access():
+    """Test access to annotations (methods, properties, etc) on an Enumeration subclass"""
 
     class Colors(Enumeration, backfill=True):
         """Create a test Color enumeration based on the Enumeration class"""
@@ -1812,3 +1812,57 @@ def test_attribute_access():
     assert color.isMetallic() is False  # isMetallic() is defined on the Colors subclass
     assert color.HEX == "FF0000"  # HEX is a property defined on the Colors subclass
     assert color.count() == 8  # count() is a classmethod defined on the Colors subclass
+
+
+def test_annotation_reconciliation():
+    """Test reconciliation of enumeration options via their annotations."""
+
+    class Colors(Enumeration):
+        """Create a test Color enumeration based on the Enumeration class"""
+
+        RED = auto(RGB=(255, 0, 0), primary=True)
+        ORANGE = auto(RGB=(255, 165, 0))
+        YELLOW = auto(RGB=(255, 255, 0), primary=True)
+        GREEN = auto(RGB=(0, 255, 0))
+        BLUE = auto(RGB=(0, 0, 255), primary=True)
+        VIOLET = auto(RGB=(255, 0, 255))
+
+    # Ensure that the Colors enumeration subclass is of the expected types
+    assert issubclass(Colors, Enumeration)
+    assert issubclass(Colors, EnumerationInteger)
+
+    # Attempt to reconcile a Color against one of its annotations (via annotation keyword)
+    color = Colors.reconcile(RGB=(255, 0, 0))
+
+    assert isinstance(color, Colors)
+    assert isinstance(color, Enumeration)
+
+    assert color.name == "RED"
+    assert color.value == 1
+    assert color.RGB == (255, 0, 0)
+
+    # Attempt to reconcile a Color against two of its annotations (via annotation keywords)
+    color = Colors.reconcile(RGB=(255, 255, 0), primary=True)
+
+    assert isinstance(color, Colors)
+    assert isinstance(color, Enumeration)
+
+    assert color.name == "YELLOW"
+    assert color.value == 3
+    assert color.RGB == (255, 255, 0)
+
+    # Attempt to reconcile a Color against one of its annotations (via annotation argument)
+    color = Colors.reconcile(value=(0, 255, 0), annotation="RGB")
+
+    assert isinstance(color, Colors)
+    assert isinstance(color, Enumeration)
+
+    assert color.name == "GREEN"
+    assert color.value == 4
+    assert color.RGB == (0, 255, 0)
+
+    # Test reconciliation against a non-existent option
+    color = Colors.reconcile(RGB=(125, 125, 125))
+
+    # Ensure the return value is None when a matching enumeration option cannot be found
+    assert color is None

enumerific-1.0.6/source/enumerific/version.txt

@@ -1 +0,0 @@
-1.0.6