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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.13
+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.13 → 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.13"
+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.13 → 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.13 → ripple_down_rules-0.0.14}/src/ripple_down_rules/rdr.py

@@ -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):
@@ -801,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.13 → 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}

{ripple_down_rules-0.0.13 → 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.13 → 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.13
+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.13 → ripple_down_rules-0.0.14}/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))