ripple-down-rules 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

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/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/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/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.dist-info → ripple_down_rules-0.0.14.dist-info}/METADATA

@@ -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.dist-info → ripple_down_rules-0.0.14.dist-info}/RECORD

@@ -3,16 +3,16 @@ ripple_down_rules/datasets.py,sha256=qYX7IF7ACm0VRbaKfEgQ32j0YbUUyt2GfGU5Lo42CqI
 ripple_down_rules/experts.py,sha256=wg1uY0ox9dUMR4s1RdGjzpX1_WUqnCa060r1U9lrKYI,11214
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/prompt.py,sha256=QAmxg4ssrGUAlK7lbyKw2nuRczTZColpjc9uMC1ts3I,4210
-ripple_down_rules/rdr.py,sha256=pczC9h5jgT810U1QYGnavqUzbbdRMGqJ9DBnyeGZxGE,37443
-ripple_down_rules/rules.py,sha256=PaQMPhMZFlwQnx9Iz4TFonldsSFX8fz4-SKxtAMulbA,13080
-ripple_down_rules/utils.py,sha256=pmjIPjF9wq6dmCHCoUKFRsJmSaI0b-hRLn375WHgWgQ,18010
+ripple_down_rules/rdr.py,sha256=Z-Zu8dH1kdlwOzTVT3DrDdqkMXk6xFQze-Mtz1YZ320,38142
+ripple_down_rules/rules.py,sha256=Gi_GRYDvnwxPIHEh_aP1NmN9cL2pHZbwbaiO6M7YdU0,14044
+ripple_down_rules/utils.py,sha256=32gU9NHIcxQpfS4zPSAtn63np5SdVvS9VuyoYiyKZbc,18664
 ripple_down_rules/datastructures/__init__.py,sha256=zpmiYm4WkwNHaGdTIfacS7llN5d2xyU6U-saH_TpydI,103
 ripple_down_rules/datastructures/callable_expression.py,sha256=TN6bi4VYjyLlSLTEA3dRo5ENfEdQYc8Fjj5nbnsz-C0,9058
-ripple_down_rules/datastructures/case.py,sha256=UYHz-Ag7TjwP9MRQuUTVH0nmph6ddutTSZMEXGFkxf4,13676
+ripple_down_rules/datastructures/case.py,sha256=0EV69VBzsBTHQ3Ots7fkP09g1tyJ20xW9kSm0nZGy40,14071
 ripple_down_rules/datastructures/dataclasses.py,sha256=EVQ1jBKW7K7q7_JNgikHX9fm3EmQQKA74sNjEQ4rXn8,2449
 ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
-ripple_down_rules-0.0.12.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.0.12.dist-info/METADATA,sha256=7h-kRihJGfF19iAvIZJa_iy7esfmmP982yO_AsYeXFo,42519
-ripple_down_rules-0.0.12.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ripple_down_rules-0.0.12.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.0.12.dist-info/RECORD,,
+ripple_down_rules-0.0.14.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.0.14.dist-info/METADATA,sha256=VHKBkYFWhQvidy3vV2Td6kyLLjrwkYMv18ROs_dbb2o,42519
+ripple_down_rules-0.0.14.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ripple_down_rules-0.0.14.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.0.14.dist-info/RECORD,,