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

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

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

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

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections import UserDict
+from copy import copy, deepcopy
 from dataclasses import dataclass
 from enum import Enum
 
@@ -9,7 +10,8 @@ from sqlalchemy import MetaData
 from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColumn, registry
 from typing_extensions import Any, Optional, Dict, Type, Set, Hashable, Union, List, TYPE_CHECKING
 
-from ..utils import make_set, row_to_dict, table_rows_as_str, get_value_type_from_type_hint, SubclassJSONSerializer
+from ..utils import make_set, row_to_dict, table_rows_as_str, get_value_type_from_type_hint, SubclassJSONSerializer, \
+    get_full_class_name, get_type_from_string
 
 if TYPE_CHECKING:
     from ripple_down_rules.rules import Rule
@@ -76,11 +78,17 @@ class Case(UserDict, SubclassJSONSerializer):
     def _to_json(self) -> Dict[str, Any]:
         serializable = {k: v for k, v in self.items() if not k.startswith("_")}
         serializable["_id"] = self._id
+        for k, v in serializable.items():
+            if isinstance(v, set):
+                serializable[k] = {'_type': get_full_class_name(set), 'value': list(v)}
         return {k: v.to_json() if isinstance(v, SubclassJSONSerializer) else v for k, v in serializable.items()}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Case:
         id_ = data.pop("_id")
+        for k, v in data.items():
+            if isinstance(v, dict) and "_type" in v:
+                data[k] = SubclassJSONSerializer.from_json(v)
         return cls(_id=id_, **data)
 
 

{ripple_down_rules-0.0.12 → ripple_down_rules-0.0.14}/src/ripple_down_rules/rdr.py

@@ -14,10 +14,10 @@ from .datastructures import Case, MCRDRMode, CallableExpression, CaseAttribute,
 from .experts import Expert, Human
 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
+    get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list, get_full_class_name, get_type_from_string
 
 
-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 = ""):
@@ -260,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]:
@@ -353,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]:
@@ -614,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):
     """
@@ -795,3 +801,17 @@ class GeneralRDR(RippleDownRules):
         Get all the types of categories that the GRDR can classify.
         """
         return list(self.start_rules_dict.keys())
+
+    def _to_json(self) -> Dict[str, Any]:
+        return {"start_rules": {get_full_class_name(t): rdr.to_json() for t, rdr in self.start_rules_dict.items()}}
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> GeneralRDR:
+        """
+        Create an instance of the class from a json
+        """
+        start_rules_dict = {}
+        for k, v in data["start_rules"].items():
+            k = get_type_from_string(k)
+            start_rules_dict[k] = get_type_from_string(v['_type']).from_json(v)
+        return cls(start_rules_dict)

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

@@ -8,7 +8,7 @@ from typing_extensions import List, Optional, Self, Union, Dict, Any
 
 from .datastructures import CallableExpression, Case, SQLTable
 from .datastructures.enums import RDREdge, Stop
-from .utils import SubclassJSONSerializer
+from .utils import SubclassJSONSerializer, is_iterable, get_full_class_name
 
 
 class Rule(NodeMixin, SubclassJSONSerializer, ABC):
@@ -102,8 +102,17 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         pass
 
     def _to_json(self) -> Dict[str, Any]:
+        def conclusion_to_json(conclusion):
+            if is_iterable(conclusion):
+                conclusions = {'_type': get_full_class_name(type(conclusion)), 'value': []}
+                for c in conclusion:
+                    conclusions['value'].append(conclusion_to_json(c))
+            else:
+                conclusions = conclusion.to_json()
+            return conclusions
+
         json_serialization = {"conditions": self.conditions.to_json(),
-                              "conclusion": self.conclusion.to_json(),
+                              "conclusion": conclusion_to_json(self.conclusion),
                               "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}
@@ -265,14 +274,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 +324,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.12 → ripple_down_rules-0.0.14}/src/ripple_down_rules/utils.py

@@ -25,6 +25,16 @@ if TYPE_CHECKING:
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def flatten_list(a: List):
+    a_flattened = []
+    for c in a:
+        if is_iterable(c):
+            a_flattened.extend(list(c))
+        else:
+            a_flattened.append(c)
+    return a_flattened
+
+
 def make_list(value: Any) -> List:
     """
     Make a list from a value.
@@ -97,15 +107,13 @@ class SubclassJSONSerializer:
     def to_json(self) -> Dict[str, Any]:
         return {"_type": get_full_class_name(self.__class__), **self._to_json()}
 
-    @abstractmethod
     def _to_json(self) -> Dict[str, Any]:
         """
         Create a json dict from the object.
         """
-        pass
+        raise NotImplementedError()
 
     @classmethod
-    @abstractmethod
     def _from_json(cls, data: Dict[str, Any]) -> Self:
         """
         Create a variable from a json dict.
@@ -140,7 +148,16 @@ class SubclassJSONSerializer:
         """
         if data is None:
             return None
+        if not isinstance(data, dict) or ('_type' not in data):
+            return data
+        # check if type module is builtins
+        data_type = get_type_from_string(data["_type"])
+        if data_type.__module__ == 'builtins':
+            if is_iterable(data['value']) and not isinstance(data['value'], dict):
+                return data_type([cls.from_json(d) for d in data['value']])
+            return data_type(data["value"])
         if get_full_class_name(cls) == data["_type"]:
+            data.pop("_type")
             return cls._from_json(data)
         for subclass in recursive_subclasses(SubclassJSONSerializer):
             if get_full_class_name(subclass) == data["_type"]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.12
+Version: 0.0.14
 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.14/test/test_json_serialization.py

@@ -0,0 +1,51 @@
+import json
+from unittest import TestCase
+
+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, MultiClassRDR, GeneralRDR
+from ripple_down_rules.utils import make_set, flatten_list
+from test_helpers.helpers import get_fit_mcrdr, get_fit_scrdr, get_fit_grdr
+
+
+class TestJSONSerialization(TestCase):
+    all_cases: List[Case]
+    targets: List[str]
+    cache_dir: str = "./test_results"
+    expert_answers_dir: str = "./test_expert_answers"
+
+    @classmethod
+    def setUpClass(cls):
+        cls.all_cases, cls.targets = load_zoo_dataset(cls.cache_dir + "/zoo_dataset.pkl")
+
+    def test_scrdr_json_serialization(self):
+        scrdr = get_fit_scrdr(self.all_cases, self.targets)
+        filename = f"{self.cache_dir}/scrdr.json"
+        scrdr.save(filename)
+        scrdr = SingleClassRDR.load(filename)
+        for case, target in zip(self.all_cases, self.targets):
+            cat = scrdr.classify(case)
+            self.assertEqual(cat, target)
+
+    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 = mcrdr.classify(case)
+            self.assertEqual(make_set(cat), make_set(target))
+
+    def test_grdr_json_serialization(self):
+        grdr, all_targets = get_fit_grdr(self.all_cases, self.targets)
+        filename = f"{self.cache_dir}/grdr.json"
+        grdr.save(filename)
+        grdr = GeneralRDR.load(filename)
+        for case, case_targets in zip(self.all_cases[:len(all_targets)], all_targets):
+            cat = grdr.classify(case)
+            cat = flatten_list(cat)
+            case_targets = flatten_list(case_targets)
+            self.assertEqual(make_set(cat), make_set(case_targets))

{ripple_down_rules-0.0.12 → ripple_down_rules-0.0.14}/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,7 +80,7 @@ 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, target in zip(self.all_cases, self.targets):
@@ -258,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})
 
@@ -309,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})
 
@@ -326,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)
-        return mcrdr

ripple_down_rules-0.0.12/test/test_json_serialization.py

@@ -1,43 +0,0 @@
-import json
-from unittest import TestCase
-
-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
-
-
-class TestJSONSerialization(TestCase):
-    all_cases: List[Case]
-    targets: List[str]
-    cache_dir: str = "./test_results"
-    expert_answers_dir: str = "./test_expert_answers"
-
-    @classmethod
-    def setUpClass(cls):
-        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()
-        filename = f"{self.cache_dir}/scrdr.json"
-        scrdr.save(filename)
-        scrdr = SingleClassRDR.load(filename)
-        for case, target in zip(self.all_cases, self.targets):
-            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)
-        for case, target in zip(self.all_cases, self.targets):
-            cat = scrdr.classify(case)
-            self.assertEqual(cat, target)
-        return scrdr