ripple-down-rules 0.0.11__tar.gz → 0.0.13__tar.gz

{ripple_down_rules-0.0.11 → ripple_down_rules-0.0.13}/PKG-INFO

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

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

@@ -17,7 +17,7 @@ from .utils import draw_tree, make_set, get_attribute_by_type, copy_case, \
     get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list
 
 
-class RippleDownRules(ABC):
+class RippleDownRules(SubclassJSONSerializer, ABC):
     """
     The abstract base class for the ripple down rules classifiers.
     """
@@ -175,10 +175,7 @@ class RippleDownRules(ABC):
             return conclusion_type in case
 
 
-RDR = RippleDownRules
-
-
-class RDRWithCodeWriter(RDR, ABC):
+class RDRWithCodeWriter(RippleDownRules, ABC):
 
     @abstractmethod
     def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = ""):
@@ -199,7 +196,7 @@ class RDRWithCodeWriter(RDR, ABC):
         """
         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())
+            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""")
@@ -222,7 +219,6 @@ class RDRWithCodeWriter(RDR, 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"
-        imports += "\n\n"
         return imports
 
     def get_rdr_classifier_from_python_file(self, package_name) -> Callable[[Any], Any]:
@@ -261,7 +257,7 @@ class RDRWithCodeWriter(RDR, ABC):
             return type(self.start_rule.conclusion)
 
 
-class SingleClassRDR(RDRWithCodeWriter, SubclassJSONSerializer):
+class SingleClassRDR(RDRWithCodeWriter):
 
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Union[CaseAttribute, CallableExpression]:
@@ -354,17 +350,15 @@ class MultiClassRDR(RDRWithCodeWriter):
     The conditions of the stopping rule if needed.
     """
 
-    def __init__(self, start_rules: Optional[List[Rule]] = None,
+    def __init__(self, start_rule: Optional[Rule] = None,
                  mode: MCRDRMode = MCRDRMode.StopOnly, session: Optional[Session] = None):
         """
-        :param start_rules: The starting rules for the classifier, these are the rules that are at the top of the tree
-        and are always checked, in contrast to the refinement and alternative rules which are only checked if the
-        starting rules fire or not.
+        :param start_rule: The starting rules for the classifier.
         :param mode: The mode of the classifier, either StopOnly or StopPlusRule, or StopPlusRuleCombined.
         :param session: The sqlalchemy orm session.
         """
-        self.start_rules = [MultiClassTopRule()] if not start_rules else start_rules
-        super(MultiClassRDR, self).__init__(self.start_rules[0], session=session)
+        start_rule = MultiClassTopRule() if not start_rule else start_rule
+        super(MultiClassRDR, self).__init__(start_rule, session=session)
         self.mode: MCRDRMode = mode
 
     def classify(self, case: Union[Case, SQLTable]) -> List[Any]:
@@ -452,8 +446,8 @@ class MultiClassRDR(RDRWithCodeWriter):
         return f"Set[{self.conclusion_type.__name__}]"
 
     def _get_imports(self) -> str:
-        imports = super()._get_imports().strip('\n')
-        imports += "\nfrom typing_extensions import Set\n\n"
+        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):
@@ -615,6 +609,17 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         self.start_rule.alternative = MultiClassTopRule(conditions, conclusion, corner_case=corner_case)
 
+    def _to_json(self) -> Dict[str, Any]:
+        return {"start_rule": self.start_rule.to_json()}
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> Self:
+        """
+        Create an instance of the class from a json
+        """
+        start_rule = SingleClassRule.from_json(data["start_rule"])
+        return cls(start_rule)
+
 
 class GeneralRDR(RippleDownRules):
     """

{ripple_down_rules-0.0.11 → ripple_down_rules-0.0.13}/src/ripple_down_rules/rules.py

@@ -265,14 +265,17 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
 
     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 = super(MultiClassStopRule, cls)._from_json(data)
+        # The following is done to prevent re-initialization of the top rule,
+        # so the top rule that is already initialized is passed in the data instead of its json serialization.
+        loaded_rule.top_rule = data['top_rule']
+        if data['alternative'] is not None:
+            data['alternative']['top_rule'] = data['top_rule']
         loaded_rule.alternative = MultiClassStopRule.from_json(data["alternative"])
         return loaded_rule
 
@@ -312,7 +315,11 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> MultiClassTopRule:
-        loaded_rule = Rule._from_json(data)
+        loaded_rule = super(MultiClassTopRule, cls)._from_json(data)
+        # The following is done to prevent re-initialization of the top rule,
+        # so the top rule that is already initialized is passed in the data instead of its json serialization.
+        if data['refinement'] is not None:
+            data['refinement']['top_rule'] = loaded_rule
         loaded_rule.refinement = MultiClassStopRule.from_json(data["refinement"])
         loaded_rule.alternative = MultiClassTopRule.from_json(data["alternative"])
         return loaded_rule

{ripple_down_rules-0.0.11 → ripple_down_rules-0.0.13}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.11
+Version: 0.0.13
 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.11 → ripple_down_rules-0.0.13}/test/test_json_serialization.py

@@ -6,7 +6,9 @@ from typing_extensions import List
 from ripple_down_rules.datasets import load_zoo_dataset
 from ripple_down_rules.datastructures import CaseQuery, Case
 from ripple_down_rules.experts import Human
-from ripple_down_rules.rdr import SingleClassRDR
+from ripple_down_rules.rdr import SingleClassRDR, MultiClassRDR
+from ripple_down_rules.utils import make_set
+from test_helpers.helpers import get_fit_mcrdr, get_fit_scrdr
 
 
 class TestJSONSerialization(TestCase):
@@ -20,7 +22,7 @@ class TestJSONSerialization(TestCase):
         cls.all_cases, cls.targets = load_zoo_dataset(cls.cache_dir + "/zoo_dataset.pkl")
 
     def test_scrdr_json_serialization(self):
-        scrdr = self.get_fit_scrdr()
+        scrdr = get_fit_scrdr(self.all_cases, self.targets)
         filename = f"{self.cache_dir}/scrdr.json"
         scrdr.save(filename)
         scrdr = SingleClassRDR.load(filename)
@@ -28,16 +30,11 @@ class TestJSONSerialization(TestCase):
             cat = scrdr.classify(case)
             self.assertEqual(cat, target)
 
-    def get_fit_scrdr(self, draw_tree=False) -> SingleClassRDR:
-        filename = self.expert_answers_dir + "/scrdr_expert_answers_fit"
-        expert = Human(use_loaded_answers=True)
-        expert.load_answers(filename)
-
-        scrdr = SingleClassRDR()
-        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)
+    def test_mcrdr_json_serialization(self):
+        mcrdr = get_fit_mcrdr(self.all_cases, self.targets)
+        filename = f"{self.cache_dir}/mcrdr.json"
+        mcrdr.save(filename)
+        mcrdr = MultiClassRDR.load(filename)
         for case, target in zip(self.all_cases, self.targets):
-            cat = scrdr.classify(case)
-            self.assertEqual(cat, target)
-        return scrdr
+            cat = mcrdr.classify(case)
+            self.assertEqual(make_set(cat), make_set(target))

{ripple_down_rules-0.0.11 → ripple_down_rules-0.0.13}/test/test_rdr.py

@@ -11,6 +11,7 @@ from ripple_down_rules.datastructures import Case, MCRDRMode, \
 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, make_set
+from test_helpers.helpers import get_fit_scrdr, get_fit_mcrdr
 
 
 class TestRDR(TestCase):
@@ -71,7 +72,7 @@ class TestRDR(TestCase):
             expert.save_answers(file)
 
     def test_write_scrdr_to_python_file(self):
-        scrdr = self.get_fit_scrdr()
+        scrdr = get_fit_scrdr(self.all_cases,self.targets)
         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):
@@ -79,13 +80,12 @@ class TestRDR(TestCase):
             self.assertEqual(cat, target)
 
     def test_write_mcrdr_to_python_file(self):
-        mcrdr = self.get_fit_mcrdr()
+        mcrdr = get_fit_mcrdr(self.all_cases, self.targets)
         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 in self.all_cases:
-            cat_1 = mcrdr.classify(case)
-            cat_2 = classify_species_mcrdr(case)
-            self.assertEqual(make_set(cat_1), make_set(cat_2))
+        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
@@ -115,7 +115,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])
@@ -259,7 +259,7 @@ class TestRDR(TestCase):
         if use_loaded_answers:
             expert.load_answers(filename)
 
-        fit_scrdr = self.get_fit_scrdr(draw_tree=False)
+        fit_scrdr = get_fit_scrdr(self.all_cases, self.targets, draw_tree=False)
 
         grdr = GeneralRDR({type(fit_scrdr.start_rule.conclusion): fit_scrdr})
 
@@ -310,7 +310,7 @@ class TestRDR(TestCase):
         if use_loaded_answers:
             expert.load_answers(filename)
 
-        fit_scrdr = self.get_fit_scrdr(draw_tree=False)
+        fit_scrdr = get_fit_scrdr(self.all_cases, self.targets, draw_tree=False)
 
         grdr = GeneralRDR({type(fit_scrdr.start_rule.conclusion): fit_scrdr})
 
@@ -327,23 +327,3 @@ class TestRDR(TestCase):
             cwd = os.getcwd()
             file = os.path.join(cwd, filename)
             expert.save_answers(file)
-
-    def get_fit_scrdr(self, draw_tree=False) -> SingleClassRDR:
-        filename = self.expert_answers_dir + "/scrdr_expert_answers_fit"
-        expert = Human(use_loaded_answers=True)
-        expert.load_answers(filename)
-
-        scrdr = SingleClassRDR()
-        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)
-        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, n_iter=1)
-        return mcrdr