ripple-down-rules 0.0.10__tar.gz → 0.0.12__tar.gz

{ripple_down_rules-0.0.10 → ripple_down_rules-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.10
+Version: 0.0.12
 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.0.10 → ripple_down_rules-0.0.12}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.0.10"
+version = "0.0.12"
 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.0.10 → ripple_down_rules-0.0.12}/src/ripple_down_rules/rdr.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
 
+import importlib
 from abc import ABC, abstractmethod
 from copy import copy, deepcopy
+from types import ModuleType
 
 from matplotlib import pyplot as plt
 from ordered_set import OrderedSet
 from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
-from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple
+from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple, Callable
 
 from .datastructures import Case, MCRDRMode, CallableExpression, CaseAttribute, CaseQuery
 from .experts import Expert, Human
-from .rules import Rule, SingleClassRule, MultiClassTopRule
+from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 from .utils import draw_tree, make_set, get_attribute_by_type, copy_case, \
     get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list
 
@@ -176,7 +178,89 @@ class RippleDownRules(ABC):
 RDR = RippleDownRules
 
 
-class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
+class RDRWithCodeWriter(RDR, ABC):
+
+    @abstractmethod
+    def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = ""):
+        """
+        Write the rules as source code to a file.
+
+        :param rule: The rule to write as source code.
+        :param file: The file to write the source code to.
+        :param parent_indent: The indentation of the parent rule.
+        """
+        pass
+
+    def write_to_python_file(self, file_path: str):
+        """
+        Write the tree of rules as source code to a file.
+
+        :param file_path: The path to the file to write the source code to.
+        """
+        func_def = f"def classify(case: {self.case_type.__name__}) -> {self._get_conclusion_type_hint()}:\n"
+        with open(file_path + f"/{self.generated_python_file_name}.py", "w") as f:
+            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""")
+            self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4)
+
+    @abstractmethod
+    def _get_conclusion_type_hint(self) -> str:
+        """
+        :return: The type hint of the conclusion of the rdr as a string.
+        """
+        pass
+
+    def _get_imports(self) -> str:
+        """
+        :return: The imports for the generated python file of the RDR as a string.
+        """
+        imports = ""
+        if self.case_type.__module__ != "builtins":
+            imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
+        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"
+        return imports
+
+    def get_rdr_classifier_from_python_file(self, package_name) -> Callable[[Any], Any]:
+        """
+        :param package_name: The name of the package that contains the RDR classifier function.
+        :return: The module that contains the rdr classifier function.
+        """
+        return importlib.import_module(f"{package_name.strip('./')}.{self.generated_python_file_name}").classify
+
+    @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"
+
+    @property
+    def case_type(self) -> Type:
+        """
+        :return: The type of the case (input) to the RDR classifier.
+        """
+        if isinstance(self.start_rule.corner_case, Case):
+            return self.start_rule.corner_case._type
+        else:
+            return type(self.start_rule.corner_case)
+
+    @property
+    def conclusion_type(self) -> Type:
+        """
+        :return: The type of the conclusion of the RDR classifier.
+        """
+        if isinstance(self.start_rule.conclusion, CallableExpression):
+            return self.start_rule.conclusion.conclusion_type
+        else:
+            return type(self.start_rule.conclusion)
+
+
+class SingleClassRDR(RDRWithCodeWriter, SubclassJSONSerializer):
 
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Union[CaseAttribute, CallableExpression]:
@@ -221,43 +305,6 @@ class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
         matched_rule = self.start_rule(case)
         return matched_rule if matched_rule else self.start_rule
 
-    def write_to_python_file(self, filename: str):
-        """
-        Write the tree of rules as source code to a file.
-        """
-        case = self.start_rule.corner_case
-        if isinstance(case, Case):
-            case_type = case._type
-        else:
-            case_type = type(case)
-        case_module = case_type.__module__
-        conclusion = self.start_rule.conclusion
-        if isinstance(conclusion, CallableExpression):
-            conclusion_types = [conclusion.conclusion_type]
-        elif isinstance(conclusion, CaseAttribute):
-            conclusion_types = list(conclusion._value_range)
-        else:
-            conclusion_types = [type(conclusion)]
-        imports = ""
-        if case_module != "builtins":
-            imports += f"from {case_module} import {case_type.__name__}\n"
-        if len(conclusion_types) > 1:
-            conclusion_name = "Union[" + ", ".join([c.__name__ for c in conclusion_types]) + "]"
-        else:
-            conclusion_name = conclusion_types[0].__name__
-        for conclusion_type in conclusion_types:
-            if conclusion_type.__module__ != "builtins":
-                imports += f"from {conclusion_type.__module__} import {conclusion_name}\n"
-        imports += "from ripple_down_rules.datastructures import Case, create_case\n"
-        imports += "\n\n"
-        func_def = f"def classify_{conclusion_name.lower()}(case: {case_type.__name__}) -> {conclusion_name}:\n"
-        with open(filename, "w") as f:
-            f.write(imports)
-            f.write(func_def)
-            f.write(f"{' '*4}if not isinstance(case, Case):\n"
-                    f"{' '*4}    case = create_case(case, recursion_idx=3)\n""")
-            self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4)
-
     def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file, parent_indent: str = ""):
         """
         Write the rules as source code to a file.
@@ -272,6 +319,9 @@ class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent)
 
+    def _get_conclusion_type_hint(self) -> str:
+        return self.conclusion_type.__name__
+
     def _to_json(self) -> Dict[str, Any]:
         return {"start_rule": self.start_rule.to_json()}
 
@@ -284,7 +334,7 @@ class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
         return cls(start_rule)
 
 
-class MultiClassRDR(RippleDownRules):
+class MultiClassRDR(RDRWithCodeWriter):
     """
     A multi class ripple down rules classifier, which can draw multiple conclusions for a case.
     This is done by going through all rules and checking if they fire or not, and adding stopping rules if needed,
@@ -378,6 +428,33 @@ class MultiClassRDR(RippleDownRules):
                 evaluated_rule = next_rule
         return self.conclusions
 
+    def write_rules_as_source_code_to_file(self, rule: Union[MultiClassTopRule, MultiClassStopRule],
+                                           file, parent_indent: str = ""):
+        """
+        Write the rules as source code to a file.
+        """
+        if rule == self.start_rule:
+            file.write(f"{parent_indent}conclusions = set()\n")
+        if rule.conditions:
+            file.write(rule.write_condition_as_source_code(parent_indent))
+            conclusion_indent = parent_indent
+            if hasattr(rule, "refinement") and rule.refinement:
+                self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ")
+                conclusion_indent = parent_indent + " "*4
+                file.write(f"{conclusion_indent}else:\n")
+            file.write(rule.write_conclusion_as_source_code(conclusion_indent))
+
+            if rule.alternative:
+                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent)
+
+    def _get_conclusion_type_hint(self) -> str:
+        return f"Set[{self.conclusion_type.__name__}]"
+
+    def _get_imports(self) -> str:
+        imports = super()._get_imports()
+        imports += "from typing_extensions import Set\n"
+        return imports
+
     def update_start_rule(self, case: Union[Case, SQLTable], target: Any, expert: Expert):
         """
         Update the starting rule of the classifier.

{ripple_down_rules-0.0.10 → ripple_down_rules-0.0.12}/src/ripple_down_rules/rules.py

@@ -70,6 +70,54 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         """
         pass
 
+    def write_conclusion_as_source_code(self, parent_indent: str = "") -> str:
+        """
+        Get the source code representation of the conclusion of the rule.
+
+        :param parent_indent: The indentation of the parent rule.
+        """
+        if isinstance(self.conclusion, CallableExpression):
+            conclusion = self.conclusion.parsed_user_input
+        elif isinstance(self.conclusion, Enum):
+            conclusion = str(self.conclusion)
+        else:
+            conclusion = self.conclusion
+        return self._conclusion_source_code_clause(conclusion, parent_indent=parent_indent)
+
+    @abstractmethod
+    def _conclusion_source_code_clause(self, conclusion: Any, parent_indent: str = "") -> str:
+        pass
+
+    def write_condition_as_source_code(self, parent_indent: str = "") -> str:
+        """
+        Get the source code representation of the conditions of the rule.
+
+        :param parent_indent: The indentation of the parent rule.
+        """
+        if_clause = self._if_statement_source_code_clause()
+        return f"{parent_indent}{if_clause} {self.conditions.parsed_user_input}:\n"
+
+    @abstractmethod
+    def _if_statement_source_code_clause(self) -> str:
+        pass
+
+    def _to_json(self) -> Dict[str, Any]:
+        json_serialization = {"conditions": self.conditions.to_json(),
+                              "conclusion": self.conclusion.to_json(),
+                              "parent": self.parent.json_serialization if self.parent else None,
+                              "corner_case": self.corner_case.to_json() if self.corner_case else None,
+                              "weight": self.weight}
+        return json_serialization
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> Rule:
+        loaded_rule = cls(conditions=CallableExpression.from_json(data["conditions"]),
+                          conclusion=CallableExpression.from_json(data["conclusion"]),
+                          parent=cls.from_json(data["parent"]),
+                          corner_case=Case.from_json(data["corner_case"]),
+                          weight=data["weight"])
+        return loaded_rule
+
     @property
     def name(self):
         """
@@ -172,50 +220,25 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
         else:
             self.alternative = new_rule
 
-    def write_conclusion_as_source_code(self, parent_indent: str = "") -> str:
-        """
-        Get the source code representation of the conclusion of the rule.
-
-        :param parent_indent: The indentation of the parent rule.
-        """
-        if isinstance(self.conclusion, CallableExpression):
-            conclusion = self.conclusion.parsed_user_input
-        elif isinstance(self.conclusion, Enum):
-            conclusion = str(self.conclusion)
-        else:
-            conclusion = self.conclusion
-        return f"{parent_indent}{' ' * 4}return {conclusion}\n"
-
-    def write_condition_as_source_code(self, parent_indent: str = "") -> str:
-        """
-        Get the source code representation of the conditions of the rule.
-
-        :param parent_indent: The indentation of the parent rule.
-        """
-        if_clause = "elif" if self.weight == RDREdge.Alternative.value else "if"
-        return f"{parent_indent}{if_clause} {self.conditions.parsed_user_input}:\n"
-
     def _to_json(self) -> Dict[str, Any]:
-        self.json_serialization = {"conditions": self.conditions.to_json(),
-                                   "conclusion": self.conclusion.to_json(),
-                                   "parent": self.parent.json_serialization if self.parent else None,
-                                   "corner_case": self.corner_case.to_json() if self.corner_case else None,
-                                   "weight": self.weight,
+        self.json_serialization = {**super(SingleClassRule, self)._to_json(),
                                    "refinement": self.refinement.to_json() if self.refinement is not None else None,
                                    "alternative": self.alternative.to_json() if self.alternative is not None else None}
         return self.json_serialization
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> SingleClassRule:
-        loaded_rule = cls(conditions=CallableExpression.from_json(data["conditions"]),
-                          conclusion=CallableExpression.from_json(data["conclusion"]),
-                          parent=SingleClassRule.from_json(data["parent"]),
-                          corner_case=Case.from_json(data["corner_case"]),
-                          weight=data["weight"])
+        loaded_rule = super(SingleClassRule, cls)._from_json(data)
         loaded_rule.refinement = SingleClassRule.from_json(data["refinement"])
         loaded_rule.alternative = SingleClassRule.from_json(data["alternative"])
         return loaded_rule
 
+    def _conclusion_source_code_clause(self, conclusion: Any, parent_indent: str = "") -> str:
+        return f"{parent_indent}{' ' * 4}return {conclusion}\n"
+
+    def _if_statement_source_code_clause(self) -> str:
+        return "elif" if self.weight == RDREdge.Alternative.value else "if"
+
 
 class MultiClassStopRule(Rule, HasAlternativeRule):
     """
@@ -240,6 +263,25 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
         else:
             return self.top_rule.alternative
 
+    def _to_json(self) -> Dict[str, Any]:
+        self.json_serialization = {**Rule._to_json(self),
+                                   "top_rule": self.top_rule.to_json(),
+                                   "alternative": self.alternative.to_json() if self.alternative is not None else None}
+        return self.json_serialization
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> MultiClassStopRule:
+        loaded_rule = Rule._from_json(data)
+        loaded_rule.top_rule = MultiClassTopRule.from_json(data["top_rule"])
+        loaded_rule.alternative = MultiClassStopRule.from_json(data["alternative"])
+        return loaded_rule
+
+    def _conclusion_source_code_clause(self, conclusion: Any, parent_indent: str = "") -> str:
+        return f"{parent_indent}{' ' * 4}pass\n"
+
+    def _if_statement_source_code_clause(self) -> str:
+        return "elif" if self.weight == RDREdge.Alternative.value else "if"
+
 
 class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
     """
@@ -261,3 +303,25 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
             self.refinement = MultiClassStopRule(conditions, corner_case=x, parent=self)
         elif not self.fired:
             self.alternative = MultiClassTopRule(conditions, target, corner_case=x, parent=self)
+
+    def _to_json(self) -> Dict[str, Any]:
+        self.json_serialization = {**Rule._to_json(self),
+                                   "refinement": self.refinement.to_json() if self.refinement is not None else None,
+                                   "alternative": self.alternative.to_json() if self.alternative is not None else None}
+        return self.json_serialization
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> MultiClassTopRule:
+        loaded_rule = Rule._from_json(data)
+        loaded_rule.refinement = MultiClassStopRule.from_json(data["refinement"])
+        loaded_rule.alternative = MultiClassTopRule.from_json(data["alternative"])
+        return loaded_rule
+
+    def _conclusion_source_code_clause(self, conclusion: Any, parent_indent: str = "") -> str:
+        statement = f"{parent_indent}{' ' * 4}conclusions.add({conclusion})\n"
+        if self.alternative is None:
+            statement += f"{parent_indent}return conclusions\n"
+        return statement
+
+    def _if_statement_source_code_clause(self) -> str:
+        return "if"

{ripple_down_rules-0.0.10 → ripple_down_rules-0.0.12}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.10
+Version: 0.0.12
 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.0.10 → ripple_down_rules-0.0.12}/test/test_rdr.py

@@ -1,3 +1,4 @@
+import importlib
 import os
 from unittest import TestCase, skip
 
@@ -9,7 +10,7 @@ from ripple_down_rules.datastructures import Case, MCRDRMode, \
     Case, CaseAttribute, Category, CaseQuery
 from ripple_down_rules.experts import Human
 from ripple_down_rules.rdr import SingleClassRDR, MultiClassRDR, GeneralRDR
-from ripple_down_rules.utils import render_tree, get_all_subclasses
+from ripple_down_rules.utils import render_tree, get_all_subclasses, make_set
 
 
 class TestRDR(TestCase):
@@ -58,7 +59,6 @@ class TestRDR(TestCase):
         case_queries = [CaseQuery(case, target=target) for case, target in zip(self.all_cases, self.targets)]
         scrdr.fit(case_queries, expert=expert,
                   animate_tree=draw_tree)
-        scrdr.write_to_python_file(self.generated_rdrs_dir + "/scrdr.py")
         render_tree(scrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/scrdr")
 
@@ -70,6 +70,22 @@ class TestRDR(TestCase):
             file = os.path.join(cwd, filename)
             expert.save_answers(file)
 
+    def test_write_scrdr_to_python_file(self):
+        scrdr = self.get_fit_scrdr()
+        scrdr.write_to_python_file(self.generated_rdrs_dir)
+        classify_species_scrdr = scrdr.get_rdr_classifier_from_python_file(self.generated_rdrs_dir)
+        for case, target in zip(self.all_cases, self.targets):
+            cat = classify_species_scrdr(case)
+            self.assertEqual(cat, target)
+
+    def test_write_mcrdr_to_python_file(self):
+        mcrdr = self.get_fit_mcrdr()
+        mcrdr.write_to_python_file(self.generated_rdrs_dir)
+        classify_species_mcrdr = mcrdr.get_rdr_classifier_from_python_file(self.generated_rdrs_dir)
+        for case, target in zip(self.all_cases, self.targets):
+            cat = classify_species_mcrdr(case)
+            self.assertEqual(make_set(cat), make_set(target))
+
     def test_classify_mcrdr(self):
         use_loaded_answers = True
         save_answers = False
@@ -98,7 +114,7 @@ class TestRDR(TestCase):
             expert.load_answers(filename)
         mcrdr = MultiClassRDR()
         case_queries = [CaseQuery(case, target=target) for case, target in zip(self.all_cases, self.targets)]
-        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree, n_iter=1)
+        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
         render_tree(mcrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/mcrdr_stop_only")
         cats = mcrdr.classify(self.all_cases[50])
@@ -321,3 +337,12 @@ class TestRDR(TestCase):
         scrdr.fit(case_queries, expert=expert,
                   animate_tree=draw_tree)
         return scrdr
+
+    def get_fit_mcrdr(self, draw_tree: bool = False):
+        filename = self.expert_answers_dir + "/mcrdr_expert_answers_stop_only_fit"
+        expert = Human(use_loaded_answers=True)
+        expert.load_answers(filename)
+        mcrdr = MultiClassRDR()
+        case_queries = [CaseQuery(case, target=target) for case, target in zip(self.all_cases, self.targets)]
+        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
+        return mcrdr