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

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

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

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

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import importlib
 from abc import ABC, abstractmethod
-from copy import copy, deepcopy
+from copy import copy
 from types import ModuleType
 
 from matplotlib import pyplot as plt
@@ -14,7 +14,7 @@ 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(SubclassJSONSerializer, ABC):
@@ -120,7 +120,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             plt.show()
 
     @staticmethod
-    def calculate_precision_and_recall(pred_cat: List[CaseAttribute], target: List[CaseAttribute]) -> Tuple[List[bool], List[bool]]:
+    def calculate_precision_and_recall(pred_cat: List[CaseAttribute], target: List[CaseAttribute]) -> Tuple[
+        List[bool], List[bool]]:
         """
         :param pred_cat: The predicted category.
         :param target: The target category.
@@ -194,16 +195,17 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
         :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"
+        func_def = f"def classify(case: {self.case_type.__name__}) -> {self.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""")
+            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)
 
+    @property
     @abstractmethod
-    def _get_conclusion_type_hint(self) -> str:
+    def conclusion_type_hint(self) -> str:
         """
         :return: The type hint of the conclusion of the rdr as a string.
         """
@@ -254,6 +256,8 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         if isinstance(self.start_rule.conclusion, CallableExpression):
             return self.start_rule.conclusion.conclusion_type
         else:
+            if isinstance(self.start_rule.conclusion, set):
+                return type(list(self.start_rule.conclusion)[0])
             return type(self.start_rule.conclusion)
 
 
@@ -316,7 +320,8 @@ class SingleClassRDR(RDRWithCodeWriter):
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent)
 
-    def _get_conclusion_type_hint(self) -> str:
+    @property
+    def conclusion_type_hint(self) -> str:
         return self.conclusion_type.__name__
 
     def _to_json(self) -> Dict[str, Any]:
@@ -427,6 +432,8 @@ class MultiClassRDR(RDRWithCodeWriter):
                                            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")
@@ -435,14 +442,15 @@ class MultiClassRDR(RDRWithCodeWriter):
             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
+                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:
+    @property
+    def conclusion_type_hint(self) -> str:
         return f"Set[{self.conclusion_type.__name__}]"
 
     def _get_imports(self) -> str:
@@ -654,7 +662,7 @@ class GeneralRDR(RippleDownRules):
     @start_rule.setter
     def start_rule(self, value: Union[SingleClassRDR, MultiClassRDR]):
         if value:
-            self.start_rules_dict[type(value.start_rule.conclusion)] = value
+            self.start_rules_dict[value.conclusion_type] = value
 
     @property
     def start_rules(self) -> List[Union[SingleClassRule, MultiClassTopRule]]:
@@ -665,6 +673,19 @@ class GeneralRDR(RippleDownRules):
         Classify a case by going through all RDRs and adding the categories that are classified, and then restarting
         the classification until no more categories can be added.
 
+        :param case: The case to classify.
+        :return: The categories that the case belongs to.
+        """
+        return self._classify(self.start_rules_dict, case)
+
+    @staticmethod
+    def _classify(classifiers_dict: Dict[Type, Union[ModuleType, RippleDownRules]],
+                  case: Union[Case, SQLTable]) -> Optional[List[Any]]:
+        """
+        Classify a case by going through all classifiers and adding the categories that are classified,
+         and then restarting the classification until no more categories can be added.
+
+        :param classifiers_dict: A dictionary mapping conclusion types to the classifiers that produce them.
         :param case: The case to classify.
         :return: The categories that the case belongs to.
         """
@@ -672,8 +693,8 @@ class GeneralRDR(RippleDownRules):
         case_cp = copy_case(case)
         while True:
             added_attributes = False
-            for cat_type, rdr in self.start_rules_dict.items():
-                if self.case_has_conclusion(case_cp, cat_type):
+            for cat_type, rdr in classifiers_dict.items():
+                if GeneralRDR.case_has_conclusion(case_cp, cat_type):
                     continue
                 pred_atts = rdr.classify(case_cp)
                 if pred_atts:
@@ -733,7 +754,7 @@ class GeneralRDR(RippleDownRules):
                         conclusions = rdr.classify(case_cp)
                     else:
                         conclusions = self.start_rules_dict[target_type].fit_case(case_query_cp,
-                                                                                   expert, **kwargs)
+                                                                                  expert, **kwargs)
                     self.update_case(case_cp, conclusions, rdr_type)
 
         return self.classify(case)
@@ -801,3 +822,80 @@ 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)
+
+    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.
+        """
+        for rdr in self.start_rules_dict.values():
+            rdr.write_to_python_file(file_path)
+        func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
+        with open(file_path + f"/{self.generated_python_file_name}.py", "w") as f:
+            f.write(self._get_imports(file_path) + "\n\n")
+            f.write("classifiers_dict = dict()\n")
+            for t, rdr in self.start_rules_dict.items():
+                f.write(f"classifiers_dict[{t.__name__}] = {t.__name__.lower()}_classifier\n")
+            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.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
+
+    @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)
+
+    def get_rdr_classifier_from_python_file(self, file_path: str):
+        """
+        :param file_path: The path to the file that contains the RDR classifier function.
+        :return: The module that contains the rdr classifier function.
+        """
+        return importlib.import_module(f"{file_path.strip('./')}.{self.generated_python_file_name}").classify
+
+    @property
+    def generated_python_file_name(self) -> str:
+        return f"{self.case_type.__name__.lower()}_grdr"
+
+    @property
+    def conclusion_type_hint(self) -> str:
+        return f"List[Union[{', '.join([rdr.conclusion_type_hint for rdr in self.start_rules_dict.values()])}]]"
+
+    def _get_imports(self, file_path: str) -> str:
+        imports = ""
+        # add type hints
+        imports += f"from typing_extensions import List, Union, Set\n"
+        # import rdr type
+        imports += f"from ripple_down_rules.rdr import GeneralRDR\n"
+        # add case type
+        imports += f"from ripple_down_rules.datastructures import Case, create_case\n"
+        imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
+        # add conclusion type imports
+        for conclusion_type in self.start_rules_dict.keys():
+            imports += f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
+        # add rdr python generated functions.
+        for conclusion_type, rdr in self.start_rules_dict.items():
+            imports += (f"from {file_path.strip('./')}"
+                        f" import {rdr.generated_python_file_name} as {conclusion_type.__name__.lower()}_classifier\n")
+        return imports

{ripple_down_rules-0.0.13 → ripple_down_rules-0.0.15}/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}
@@ -325,7 +334,11 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
         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 is_iterable(conclusion):
+            conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
+        else:
+            conclusion_str = "{" + str(conclusion) + "}"
+        statement = f"{parent_indent}{' ' * 4}conclusions.update({conclusion_str})\n"
         if self.alternative is None:
             statement += f"{parent_indent}return conclusions\n"
         return statement

{ripple_down_rules-0.0.13 → ripple_down_rules-0.0.15}/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.13 → ripple_down_rules-0.0.15}/src/ripple_down_rules.egg-info/PKG-INFO

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

@@ -6,9 +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, MultiClassRDR
-from ripple_down_rules.utils import make_set
-from test_helpers.helpers import get_fit_mcrdr, get_fit_scrdr
+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):
@@ -38,3 +38,14 @@ class TestJSONSerialization(TestCase):
         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.13 → ripple_down_rules-0.0.15}/test/test_rdr.py

@@ -10,8 +10,8 @@ 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, make_set
-from test_helpers.helpers import get_fit_scrdr, get_fit_mcrdr
+from ripple_down_rules.utils import render_tree, get_all_subclasses, make_set, flatten_list
+from test_helpers.helpers import get_fit_scrdr, get_fit_mcrdr, get_fit_grdr
 
 
 class TestRDR(TestCase):
@@ -87,6 +87,16 @@ class TestRDR(TestCase):
             cat = classify_species_mcrdr(case)
             self.assertEqual(make_set(cat), make_set(target))
 
+    def test_write_grdr_to_python_file(self):
+        grdr, all_targets = get_fit_grdr(self.all_cases, self.targets)
+        grdr.write_to_python_file(self.generated_rdrs_dir)
+        classify_animal_grdr = grdr.get_rdr_classifier_from_python_file(self.generated_rdrs_dir)
+        for case, case_targets in zip(self.all_cases[:len(all_targets)], all_targets):
+            cat = classify_animal_grdr(case)
+            cat = flatten_list(cat)
+            case_targets = flatten_list(case_targets)
+            self.assertEqual(make_set(cat), make_set(case_targets))
+
     def test_classify_mcrdr(self):
         use_loaded_answers = True
         save_answers = False