ripple-down-rules 0.1.0__tar.gz → 0.1.2__tar.gz

{ripple_down_rules-0.1.0 → ripple_down_rules-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.0
+Version: 0.1.2
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{ripple_down_rules-0.1.0 → ripple_down_rules-0.1.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.0"
+version = "0.1.2"
 description = "Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning."
 readme = "README.md"
 authors = [{ name = "Abdelrhman Bassiouny", email = "abassiou@uni-bremen.de" }]

{ripple_down_rules-0.1.0 → ripple_down_rules-0.1.2}/src/ripple_down_rules/datastructures/case.py

@@ -214,6 +214,7 @@ def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
     :param parent_is_iterable: Boolean indicating whether the parent object is iterable or not.
     :return: The case that represents the object.
     """
+    obj_name = obj_name or obj.__class__.__name__
     if isinstance(obj, DataFrame):
         return create_cases_from_dataframe(obj, obj_name)
     if isinstance(obj, Case):

{ripple_down_rules-0.1.0 → ripple_down_rules-0.1.2}/src/ripple_down_rules/rdr.py

@@ -132,12 +132,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             for pred_key, pred_value in pred_cat.items():
                 if pred_key not in target:
                     continue
-                # if is_iterable(pred_value):
-                #     print(pred_value, target[pred_key])
-                #     precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
                 precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
-                # else:
-                #     precision.append(pred_value == target[pred_key])
             for target_key, target_value in target.items():
                 if target_key not in pred_cat:
                     recall.append(False)
@@ -146,7 +141,6 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                     recall.extend([v in pred_cat[target_key] for v in target_value])
                 else:
                     recall.append(target_value == pred_cat[target_key])
-            print(f"Precision: {precision}, Recall: {recall}")
         else:
             if isinstance(target, dict):
                 target = list(target.values())
@@ -169,9 +163,9 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         Update the figures of the classifier.
         """
         if isinstance(self, GeneralRDR):
-            for i, (_type, rdr) in enumerate(self.start_rules_dict.items()):
+            for i, (rdr_name, rdr) in enumerate(self.start_rules_dict.items()):
                 if not rdr.fig:
-                    rdr.fig = plt.figure(f"Rule {i}: {_type.__name__}")
+                    rdr.fig = plt.figure(f"Rule {i}: {rdr_name}")
                 draw_tree(rdr.start_rule, rdr.fig)
         else:
             if not self.fig:
@@ -214,7 +208,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             f.write(self._get_imports() + "\n\n")
             f.write(func_def)
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
-                    f"{' ' * 4}    case = create_case(case, recursion_idx=3)\n""")
+                    f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
             self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4)
 
     @property
@@ -235,6 +229,11 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         if self.conclusion_type.__module__ != "builtins":
             imports += f"from {self.conclusion_type.__module__} import {self.conclusion_type.__name__}\n"
         imports += "from ripple_down_rules.datastructures import Case, create_case\n"
+        for rule in [self.start_rule] + list(self.start_rule.descendants):
+            if rule.conditions:
+                if rule.conditions.scope is not None and len(rule.conditions.scope) > 0:
+                    for k, v in rule.conditions.scope.items():
+                        imports += f"from {v.__module__} import {v.__name__}\n"
         return imports
 
     def get_rdr_classifier_from_python_file(self, package_name) -> Callable[[Any], Any]:
@@ -246,11 +245,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
     @property
     def generated_python_file_name(self) -> str:
-        return f"{self.conclusion_type.__name__.lower()}_{self.__class__.__name__}"
-
-    @property
-    def python_file_name(self):
-        return f"{self.start_rule.conclusion.__name__.lower()}_rdr"
+        return f"{self.start_rule.corner_case._name.lower()}_{self.attribute_name}_rdr"
 
     @property
     def case_type(self) -> Type:
@@ -485,6 +480,7 @@ class MultiClassRDR(RDRWithCodeWriter):
             self.start_rule.conditions = conditions
             self.start_rule.conclusion = case_query.target
             self.start_rule.corner_case = case_query.case
+            self.start_rule.conclusion_name = case_query.attribute_name
 
     @property
     def last_top_rule(self) -> Optional[MultiClassTopRule]:
@@ -866,7 +862,7 @@ class GeneralRDR(RippleDownRules):
             f.write("\n\n")
             f.write(func_def)
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
-                    f"{' ' * 4}    case = create_case(case, recursion_idx=3)\n""")
+                    f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
             f.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
 
     @property
@@ -888,7 +884,7 @@ class GeneralRDR(RippleDownRules):
 
     @property
     def generated_python_file_name(self) -> str:
-        return f"{self.case_type.__name__.lower()}_grdr"
+        return f"{self.start_rule.corner_case._name.lower()}_rdr"
 
     @property
     def conclusion_type_hint(self) -> str:

{ripple_down_rules-0.1.0 → ripple_down_rules-0.1.2}/src/ripple_down_rules/utils.py

@@ -27,7 +27,14 @@ if TYPE_CHECKING:
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
-def serialize_dataclass(obj: Any) -> Dict:
+def serialize_dataclass(obj: Any) -> Union[Dict, Any]:
+    """
+    Recursively serialize a dataclass to a dictionary. If the dataclass contains any nested dataclasses, they will be
+    serialized as well. If the object is not a dataclass, it will be returned as is.
+
+    :param obj: The dataclass to serialize.
+    :return: The serialized dataclass as a dictionary or the object itself if it is not a dataclass.
+    """
 
     def recursive_convert(obj):
         if is_dataclass(obj):
@@ -39,8 +46,6 @@ def serialize_dataclass(obj: Any) -> Dict:
             return [recursive_convert(item) for item in obj]
         elif isinstance(obj, dict):
             return {k: recursive_convert(v) for k, v in obj.items()}
-        elif hasattr(obj, "__module__") and hasattr(obj, "__name__"):
-            return {'_type': get_full_class_name(obj.__class__)}
         else:
             return obj
 
@@ -48,6 +53,14 @@ def serialize_dataclass(obj: Any) -> Dict:
 
 
 def deserialize_dataclass(data: dict) -> Any:
+    """
+    Recursively deserialize a dataclass from a dictionary, if the dictionary contains a key "__dataclass__" (Most likely
+    created by the serialize_dataclass function), it will be treated as a dataclass and deserialized accordingly,
+    otherwise it will be returned as is.
+
+    :param data: The dictionary to deserialize.
+    :return: The deserialized dataclass.
+    """
     def recursive_load(obj):
         if isinstance(obj, dict) and "__dataclass__" in obj:
             module_name, class_name = obj["__dataclass__"].rsplit(".", 1)

{ripple_down_rules-0.1.0 → ripple_down_rules-0.1.2}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.0
+Version: 0.1.2
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{ripple_down_rules-0.1.0 → ripple_down_rules-0.1.2}/test/test_on_mutagenic.py

@@ -166,7 +166,7 @@ def get_two_molecules_model(draw_tree=False, load_answers=True, save_answers=Fal
                     CaseQuery(molecule_2, attribute_name="mutagenic", target=molecule_2.mutagenic), ]
 
     rdr = SingleClassRDR()
-    rdr.fit(case_queries, expert=expert, draw_tree=draw_tree)
+    rdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
 
     for case_query in case_queries:
         r = rdr.classify(case_query.case)
@@ -196,5 +196,15 @@ def test_serialize_two_molecules_model():
     assert rdr.classify(make_molecule_2()) == loaded_rdr.classify(make_molecule_2())
 
 
+def test_write_two_molecules_model_to_python():
+    rdr = get_two_molecules_model()
+    filename = "./test_generated_rdrs"
+    rdr.write_to_python_file(filename)
+    loaded_rdr = rdr.get_rdr_classifier_from_python_file(filename)
+    assert rdr.classify(make_molecule_1()) == loaded_rdr(make_molecule_1())
+    assert rdr.classify(make_molecule_2()) == loaded_rdr(make_molecule_2())
+
+
 if __name__ == '__main__':
-    test_two_molecules()
+    # test_two_molecules()
+    test_write_two_molecules_model_to_python()