ripple-down-rules 0.1.66__tar.gz → 0.1.68__tar.gz

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/PKG-INFO

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.66"
+version = "0.1.68"
 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.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules/datasets.py

@@ -125,7 +125,7 @@ class HabitatTable(MappedAsDataclass, Base):
         return hash(self.habitat)
 
     def __str__(self):
-        return self.habitat.value
+        return f"{HabitatTable.__name__}({Habitat.__name__}.{self.habitat.name})"
 
     def __repr__(self):
         return self.__str__()

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 import ast
 import logging
 from _ast import AST
+from enum import Enum
 
 from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 
 from .case import create_case, Case
-from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable
+from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable, \
+    build_user_input_from_conclusion, encapsulate_user_input
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -88,6 +90,7 @@ class CallableExpression(SubclassJSONSerializer):
     """
     A callable that is constructed from a string statement written by an expert.
     """
+    encapsulating_function: str = "def _get_value(case):"
 
     def __init__(self, user_input: Optional[str] = None, conclusion_type: Optional[Tuple[Type]] = None,
                  expression_tree: Optional[AST] = None,
@@ -103,8 +106,10 @@ class CallableExpression(SubclassJSONSerializer):
         """
         if user_input is None and conclusion is None:
             raise ValueError("Either user_input or conclusion must be provided.")
+        if user_input is None:
+            user_input = build_user_input_from_conclusion(conclusion)
         self.conclusion: Optional[Any] = conclusion
-        self.user_input: str = user_input
+        self.user_input: str = encapsulate_user_input(user_input, self.encapsulating_function)
         if conclusion_type is not None:
             if is_iterable(conclusion_type):
                 conclusion_type = tuple(conclusion_type)
@@ -112,12 +117,11 @@ class CallableExpression(SubclassJSONSerializer):
                 conclusion_type = (conclusion_type,)
         self.conclusion_type = conclusion_type
         self.scope: Optional[Dict[str, Any]] = scope if scope is not None else {}
-        if conclusion is None:
-            self.scope = get_used_scope(self.user_input, self.scope)
-            self.expression_tree: AST = expression_tree if expression_tree else parse_string_to_expression(self.user_input)
-            self.code = compile_expression_to_code(self.expression_tree)
-            self.visitor = VariableVisitor()
-            self.visitor.visit(self.expression_tree)
+        self.scope = get_used_scope(self.user_input, self.scope)
+        self.expression_tree: AST = expression_tree if expression_tree else parse_string_to_expression(self.user_input)
+        self.code = compile_expression_to_code(self.expression_tree)
+        self.visitor = VariableVisitor()
+        self.visitor.visit(self.expression_tree)
 
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
@@ -145,7 +149,11 @@ class CallableExpression(SubclassJSONSerializer):
         """
         Combine this callable expression with another callable expression using the 'and' operator.
         """
-        new_user_input = f"({self.user_input}) and ({other.user_input})"
+        cond1_user_input = self.user_input.replace(self.encapsulating_function, "def _cond1(case):")
+        cond2_user_input = other.user_input.replace(self.encapsulating_function, "def _cond2(case):")
+        new_user_input = (f"{cond1_user_input}\n"
+                          f"{cond2_user_input}\n"
+                          f"return _cond1(case) and _cond2(case)")
         return CallableExpression(new_user_input, conclusion_type=self.conclusion_type)
 
     def __eq__(self, other):

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules/datastructures/case.py

@@ -11,7 +11,7 @@ from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColum
 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, \
-    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass
+    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass, dataclass_to_dict
 
 if TYPE_CHECKING:
     from ripple_down_rules.rules import Rule
@@ -99,8 +99,7 @@ class Case(UserDict, SubclassJSONSerializer):
         obj_type = get_type_from_string(data.pop("_obj_type"))
         name = data.pop("_name")
         for k, v in data.items():
-            if isinstance(v, dict) and "_type" in v:
-                data[k] = SubclassJSONSerializer.from_json(v)
+            data[k] = SubclassJSONSerializer.from_json(v)
         return cls(_obj_type=obj_type, _id=id_, _name=name, **data)
 
 
@@ -219,7 +218,7 @@ def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
     obj_name = obj_name or obj.__class__.__name__
     if isinstance(obj, DataFrame):
         return create_cases_from_dataframe(obj, obj_name)
-    if isinstance(obj, Case):
+    if isinstance(obj, Case) or (is_dataclass(obj) and not isinstance(obj, SQLTable)):
         return obj
     if ((recursion_idx > max_recursion_idx) or (obj.__class__.__module__ == "builtins")
             or (obj.__class__ in [MetaData, registry])):
@@ -318,6 +317,10 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
         case_dict = row_to_dict(case)
         if last_evaluated_rule and last_evaluated_rule.fired:
             corner_row_dict = row_to_dict(last_evaluated_rule.corner_case)
+    elif is_dataclass(case):
+        case_dict = dataclass_to_dict(case)
+        if last_evaluated_rule and last_evaluated_rule.fired:
+            corner_row_dict = dataclass_to_dict(last_evaluated_rule.corner_case)
     else:
         case_dict = case
         if last_evaluated_rule and last_evaluated_rule.fired:

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -120,7 +120,7 @@ class CaseQuery:
         """
         :return: The target expression of the attribute.
         """
-        if self._target is not None and not isinstance(self._target, CallableExpression):
+        if (self._target is not None) and (not isinstance(self._target, CallableExpression)):
             self._target = CallableExpression(conclusion=self._target, conclusion_type=self.attribute_type,
                                               scope=self.scope)
         return self._target

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules/prompt.py

@@ -80,16 +80,10 @@ class IPythonShell:
             self.user_input = None
         else:
             self.all_code_lines = extract_dependencies(self.shell.all_lines)
-            if len(self.all_code_lines) == 1:
-                if self.all_code_lines[0].strip() == '':
-                    self.user_input = None
-                else:
-                    self.user_input = self.all_code_lines[0].replace('return', '').strip()
+            if len(self.all_code_lines) == 1 and self.all_code_lines[0].strip() == '':
+                self.user_input = None
             else:
-                self.user_input = f"def _get_value(case):\n    "
-                for cl in self.all_code_lines:
-                    sub_code_lines = cl.split('\n')
-                    self.user_input += '\n    '.join(sub_code_lines) + '\n    '
+                self.user_input = '\n'.join(self.all_code_lines)
 
 
 def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, prompt_str: Optional[str] = None)\

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules/rdr.py

@@ -211,17 +211,17 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
         file_name = file_path + f"/{self.generated_python_file_name}.py"
         defs_file_name = file_path + f"/{self.generated_python_defs_file_name}.py"
-        imports = self._get_imports()
+        imports, defs_imports = self._get_imports()
         # clear the files first
         with open(defs_file_name, "w") as f:
-            f.write(imports + "\n\n")
+            f.write(defs_imports + "\n\n")
         with open(file_name, "w") as f:
             imports += f"from .{self.generated_python_defs_file_name} import *\n"
             imports += f"from ripple_down_rules.rdr import {self.__class__.__name__}\n"
             f.write(imports + "\n\n")
-            f.write(f"conclusion_type = ({', '.join([ct.__name__ for ct in self.conclusion_type])},)\n\n")
-            f.write(f"type_ = {self.__class__.__name__}\n\n")
-            f.write(func_def)
+            f.write(f"conclusion_type = ({', '.join([ct.__name__ for ct in self.conclusion_type])},)\n")
+            f.write(f"type_ = {self.__class__.__name__}\n")
+            f.write(f"\n\n{func_def}")
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
             self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4, defs_file=defs_file_name)
@@ -234,17 +234,11 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         pass
 
-    def _get_imports(self) -> str:
+    def _get_imports(self) -> Tuple[str, str]:
         """
         :return: The imports for the generated python file of the RDR as a string.
         """
-        imports = ""
-        if self.case_type.__module__ != "builtins":
-            imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
-        for conclusion_type in self.conclusion_type:
-            if conclusion_type.__module__ != "builtins":
-                imports += f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
-        imports += "from ripple_down_rules.datastructures.case import Case, create_case\n"
+        defs_imports = ""
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             if not rule.conditions:
                 continue
@@ -255,10 +249,21 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
                     if not hasattr(v, "__module__") or not hasattr(v, "__name__"):
                         continue
                     new_imports = f"from {v.__module__} import {v.__name__}\n"
-                    if new_imports in imports:
+                    if new_imports in defs_imports:
                         continue
-                    imports += new_imports
-        return imports
+                    defs_imports += new_imports
+        imports = ""
+        if self.case_type.__module__ != "builtins":
+            new_import = f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
+            if new_import not in defs_imports:
+                imports += new_import
+        for conclusion_type in self.conclusion_type:
+            if conclusion_type.__module__ != "builtins":
+                new_import = f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
+                if new_import not in defs_imports:
+                    imports += new_import
+        imports += "from ripple_down_rules.datastructures.case import Case, create_case\n"
+        return imports, defs_imports
 
     def get_rdr_classifier_from_python_file(self, package_name: str) -> Callable[[Any], Any]:
         """
@@ -293,7 +298,11 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         :return: The default generated python file name.
         """
-        return f"{self.start_rule.corner_case._name.lower()}_{self.attribute_name}_{self.acronym.lower()}"
+        if isinstance(self.start_rule.corner_case, Case):
+            name = self.start_rule.corner_case._name
+        else:
+            name = self.start_rule.corner_case.__class__.__name__
+        return f"{name.lower()}_{self.attribute_name}_{self.acronym.lower()}"
 
     @property
     def generated_python_defs_file_name(self) -> str:
@@ -539,13 +548,21 @@ class MultiClassRDR(RDRWithCodeWriter):
 
     @property
     def conclusion_type_hint(self) -> str:
-        return f"Set[Union[{', '.join([ct.__name__ for ct in self.conclusion_type if ct not in [list, set]])}]]"
+        conclusion_types = [ct.__name__ for ct in self.conclusion_type if ct not in [list, set]]
+        if len(conclusion_types) == 1:
+            return f"Set[{conclusion_types[0]}]"
+        else:
+            return f"Set[Union[{', '.join(conclusion_types)}]]"
 
-    def _get_imports(self) -> str:
-        imports = super()._get_imports()
-        imports += "from typing_extensions import Set, Union\n"
+    def _get_imports(self) -> Tuple[str, str]:
+        imports, defs_imports = super()._get_imports()
+        conclusion_types = [ct for ct in self.conclusion_type if ct not in [list, set]]
+        if len(conclusion_types) == 1:
+            imports += f"from typing_extensions import Set\n"
+        else:
+            imports += "from typing_extensions import Set, Union\n"
         imports += "from ripple_down_rules.utils import make_set\n"
-        return imports
+        return imports, defs_imports
 
     def update_start_rule(self, case_query: CaseQuery, expert: Expert):
         """
@@ -715,7 +732,7 @@ class GeneralRDR(RippleDownRules):
 
     @staticmethod
     def _classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
-                  case: Any, modify_original_case: bool = True) -> Dict[str, Any]:
+                  case: Any, modify_original_case: bool = False) -> Dict[str, 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.
@@ -867,7 +884,11 @@ class GeneralRDR(RippleDownRules):
         """
         :return: The default generated python file name.
         """
-        return f"{self.start_rule.corner_case._name.lower()}_rdr"
+        if isinstance(self.start_rule.corner_case, Case):
+            name = self.start_rule.corner_case._name
+        else:
+            name = self.start_rule.corner_case.__class__.__name__
+        return f"{name}_rdr".lower()
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -882,17 +903,12 @@ class GeneralRDR(RippleDownRules):
         """
         imports = ""
         # add type hints
-        imports += f"from typing_extensions import Dict, Any, Union, Set\n"
+        imports += f"from typing_extensions import Dict, Any\n"
         # import rdr type
         imports += f"from ripple_down_rules.rdr import GeneralRDR\n"
         # add case type
         imports += f"from ripple_down_rules.datastructures.case import Case, create_case\n"
         imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
-        # add conclusion type imports
-        for rdr in self.start_rules_dict.values():
-            for conclusion_type in rdr.conclusion_type:
-                if conclusion_type.__module__ != "builtins":
-                    imports += f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
         # add rdr python generated functions.
         for rdr_key, rdr in self.start_rules_dict.items():
             imports += (f"from {file_path.strip('./')}"

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules/rules.py

@@ -93,7 +93,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         conclusion_func, conclusion_func_call = self._conclusion_source_code(conclusion, parent_indent=parent_indent)
         if conclusion_func is not None:
             with open(defs_file, 'a') as f:
-                f.write(conclusion_func + "\n\n")
+                f.write(conclusion_func.strip() + "\n\n\n")
         return conclusion_func_call
 
     @abstractmethod
@@ -120,7 +120,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             conditions_lines[0] = re.sub(r"def (\w+)", new_function_name, conditions_lines[0])
             def_code = "\n".join(conditions_lines)
             with open(defs_file, 'a') as f:
-                f.write(def_code + "\n\n")
+                f.write(def_code.strip() + "\n\n\n")
             return f"\n{parent_indent}{if_clause} {new_function_name.replace('def ', '')}(case):\n"
 
     @abstractmethod
@@ -131,7 +131,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         json_serialization = {"conditions": self.conditions.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,
+                              "corner_case": SubclassJSONSerializer.to_json_static(self.corner_case),
                               "conclusion_name": self.conclusion_name,
                               "weight": self.weight}
         return json_serialization
@@ -270,11 +270,11 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
 
     def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
         conclusion = str(conclusion)
-        indent = parent_indent + " " * 4
-        if '\n' not in conclusion:
-            return None, f"{indent}return {conclusion}\n"
-        else:
-            return get_rule_conclusion_as_source_code(self, conclusion, parent_indent=parent_indent)
+        # indent = parent_indent + " " * 4
+        # if '\n' not in conclusion:
+        #     return None, f"{indent}return {conclusion}\n"
+        # else:
+        return get_rule_conclusion_as_source_code(self, conclusion, parent_indent=parent_indent)
 
     def _if_statement_source_code_clause(self) -> str:
         return "elif" if self.weight == RDREdge.Alternative.value else "if"
@@ -367,15 +367,15 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
     def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[str, str]:
         conclusion_str = str(conclusion)
         indent = parent_indent + " " * 4
-        if '\n' not in conclusion_str:
-            func = None
-            if is_iterable(conclusion):
-                conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
-            else:
-                conclusion_str = "{" + str(conclusion) + "}"
-        else:
-            func, func_call = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
-            conclusion_str = func_call.replace("return ", "").strip()
+        # if '\n' not in conclusion_str:
+        #     func = None
+        #     if is_iterable(conclusion):
+        #         conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
+        #     else:
+        #         conclusion_str = "{" + str(conclusion) + "}"
+        # else:
+        func, func_call = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
+        conclusion_str = func_call.replace("return ", "").strip()
 
         statement = f"{indent}conclusions.update(make_set({conclusion_str}))\n"
         if self.alternative is None:

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules/utils.py

@@ -7,9 +7,11 @@ import json
 import logging
 import os
 import re
+import uuid
 from collections import UserDict
 from copy import deepcopy
 from dataclasses import is_dataclass, fields
+from enum import Enum
 from types import NoneType
 
 import matplotlib
@@ -34,6 +36,58 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def encapsulate_user_input(user_input: str, func_signature: str) -> str:
+    """
+    Encapsulate the user input string with a function definition.
+
+    :param user_input: The user input string.
+    :param func_signature: The function signature to use for encapsulation.
+    :return: The encapsulated user input string.
+    """
+    if func_signature not in user_input:
+        new_user_input = func_signature + "\n    "
+        if "return " not in user_input:
+            if '\n' not in user_input:
+                new_user_input += f"return {user_input}"
+            else:
+                raise ValueError("User input must contain a return statement or be a single line.")
+        else:
+            for cl in user_input.split('\n'):
+                sub_code_lines = cl.split('\n')
+                new_user_input += '\n    '.join(sub_code_lines) + '\n    '
+    else:
+        new_user_input = user_input
+    return new_user_input
+
+
+def build_user_input_from_conclusion(conclusion: Any) -> str:
+    """
+    Build a user input string from the conclusion.
+
+    :param conclusion: The conclusion to use for the callable expression.
+    :return: The user input string.
+    """
+
+    # set user_input to the string representation of the conclusion
+    if isinstance(conclusion, set):
+        user_input = '{' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + '}'
+    elif isinstance(conclusion, list):
+        user_input = '[' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + ']'
+    elif isinstance(conclusion, tuple):
+        user_input = '(' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + ')'
+    else:
+        user_input = conclusion_to_str(conclusion)
+
+    return user_input
+
+
+def conclusion_to_str(conclusion_: Any) -> str:
+    if isinstance(conclusion_, Enum):
+        return type(conclusion_).__name__ + '.' + conclusion_.name
+    else:
+        return str(conclusion_)
+
+
 def update_case(case_query: CaseQuery, conclusions: Dict[str, Any]):
     """
     Update the case with the conclusions.
@@ -269,7 +323,7 @@ def extract_dependencies(code_lines):
     return required_lines
 
 
-def serialize_dataclass(obj: Any) -> Union[Dict, Any]:
+def serialize_dataclass(obj: Any, seen=None) -> Any:
     """
     Recursively serialize a dataclass to a dictionary. If the dataclass contains any nested dataclasses, they will be
     serialized as well. If the object is not a dataclass, it will be returned as is.
@@ -277,24 +331,44 @@ def serialize_dataclass(obj: Any) -> Union[Dict, Any]:
     :param obj: The dataclass to serialize.
     :return: The serialized dataclass as a dictionary or the object itself if it is not a dataclass.
     """
-
-    def recursive_convert(obj):
-        if is_dataclass(obj):
-            return {
-                "__dataclass__": f"{obj.__class__.__module__}.{obj.__class__.__qualname__}",
-                "fields": {f.name: recursive_convert(getattr(obj, f.name)) for f in fields(obj)}
-            }
-        elif isinstance(obj, list):
-            return [recursive_convert(item) for item in obj]
-        elif isinstance(obj, dict):
-            return {k: recursive_convert(v) for k, v in obj.items()}
-        else:
+    if seen is None:
+        seen = {}
+
+    obj_id = id(obj)
+    if obj_id in seen:
+        return {'$ref': seen[obj_id]}
+
+    if is_dataclass(obj):
+        uid = str(uuid.uuid4())
+        seen[obj_id] = uid
+        result = {
+            '$id': uid,
+            "__dataclass__": f"{obj.__class__.__module__}.{obj.__class__.__qualname__}",
+            'fields': {}
+        }
+        for f in fields(obj):
+            value = getattr(obj, f.name)
+            result['fields'][f.name] = serialize_dataclass(value, seen)
+        return result
+    elif isinstance(obj, list):
+        return [serialize_dataclass(v, seen) for v in obj]
+    elif isinstance(obj, dict):
+        return {k: serialize_dataclass(v, seen) for k, v in obj.items()}
+    else:
+        try:
+            json.dumps(obj)  # Check if the object is JSON serializable
             return obj
+        except TypeError:
+            return None
 
-    return recursive_convert(obj)
 
+def deserialize_dataclass(data: Any, refs: Optional[Dict[str, Any]] = None) -> Any:
+    refs = {} if refs is None else refs
+    preloaded = preload_serialized_objects(data, refs)
+    return resolve_refs(preloaded, refs)
 
-def deserialize_dataclass(data: dict) -> Any:
+
+def preload_serialized_objects(data: Any, refs: Dict[str, Any] = None) -> Any:
     """
     Recursively deserialize a dataclass from a dictionary, if the dictionary contains a key "__dataclass__" (Most likely
     created by the serialize_dataclass function), it will be treated as a dataclass and deserialized accordingly,
@@ -303,25 +377,81 @@ def deserialize_dataclass(data: dict) -> Any:
     :param data: The dictionary to deserialize.
     :return: The deserialized dataclass.
     """
+    if refs is None:
+        refs = {}
+
+    if isinstance(data, dict):
+
+        if '$ref' in data:
+            ref_id = data['$ref']
+            if ref_id not in refs:
+                return {'$ref': data['$ref']}
+            return refs[ref_id]
+
+        elif '$id' in data and '__dataclass__' in data and 'fields' in data:
+            cls_path = data['__dataclass__']
+            module_name, class_name = cls_path.rsplit('.', 1)
+            cls = getattr(importlib.import_module(module_name), class_name)
+
+            dummy_instance = cls.__new__(cls)  # Don't call __init__ yet
+            refs[data['$id']] = dummy_instance
+
+            for f in fields(cls):
+                raw_value = data['fields'].get(f.name)
+                value = preload_serialized_objects(raw_value, refs)
+                setattr(dummy_instance, f.name, value)
+
+            return dummy_instance
 
-    def recursive_load(obj):
-        if isinstance(obj, dict) and "__dataclass__" in obj:
-            module_name, class_name = obj["__dataclass__"].rsplit(".", 1)
-            module = importlib.import_module(module_name)
-            cls: Type = getattr(module, class_name)
-            field_values = {
-                k: recursive_load(v)
-                for k, v in obj["fields"].items()
-            }
-            return cls(**field_values)
-        elif isinstance(obj, list):
-            return [recursive_load(item) for item in obj]
-        elif isinstance(obj, dict):
-            return {k: recursive_load(v) for k, v in obj.items()}
         else:
-            return obj
+            return {k: preload_serialized_objects(v, refs) for k, v in data.items()}
+
+    elif isinstance(data, list):
+        return [preload_serialized_objects(item, refs) for item in data]
+    elif isinstance(data, dict):
+        return {k: preload_serialized_objects(v, refs) for k, v in data.items()}
+
+    return data  # Primitive
+
+
+def resolve_refs(obj, refs, seen=None):
+    if seen is None:
+        seen = {}
+
+    obj_id = id(obj)
+    if obj_id in seen:
+        return seen[obj_id]
 
-    return recursive_load(data)
+    # Resolve if dict with $ref
+    if isinstance(obj, dict) and '$ref' in obj:
+        ref_id = obj['$ref']
+        if ref_id not in refs:
+            raise KeyError(f"$ref to unknown ID: {ref_id}")
+        return refs[ref_id]
+
+    elif is_dataclass(obj):
+        seen[obj_id] = obj  # Mark before diving deeper
+        for f in fields(obj):
+            val = getattr(obj, f.name)
+            resolved = resolve_refs(val, refs, seen)
+            setattr(obj, f.name, resolved)
+        return obj
+
+    elif isinstance(obj, list):
+        resolved_list = []
+        seen[obj_id] = resolved_list
+        for item in obj:
+            resolved_list.append(resolve_refs(item, refs, seen))
+        return resolved_list
+
+    elif isinstance(obj, dict):
+        resolved_dict = {}
+        seen[obj_id] = resolved_dict
+        for k, v in obj.items():
+            resolved_dict[k] = resolve_refs(v, refs, seen)
+        return resolved_dict
+
+    return obj  # Primitive
 
 
 def typing_to_python_type(typing_hint: Type) -> Type:
@@ -494,6 +624,7 @@ class SubclassJSONSerializer:
     Classes that inherit from this class can be serialized and deserialized automatically by calling this classes
     'from_json' method.
     """
+    data_class_refs = {}
 
     def to_json_file(self, filename: str):
         """
@@ -507,8 +638,14 @@ class SubclassJSONSerializer:
             json.dump(data, f, indent=4)
         return data
 
+    @staticmethod
+    def to_json_static(obj) -> Dict[str, Any]:
+        if is_dataclass(obj):
+            return serialize_dataclass(obj)
+        return {"_type": get_full_class_name(obj.__class__), **obj._to_json()}
+
     def to_json(self) -> Dict[str, Any]:
-        return {"_type": get_full_class_name(self.__class__), **self._to_json()}
+        return self.to_json_static(self)
 
     def _to_json(self) -> Dict[str, Any]:
         """
@@ -529,7 +666,7 @@ class SubclassJSONSerializer:
         raise NotImplementedError()
 
     @classmethod
-    def from_json_file(cls, filename: str):
+    def from_json_file(cls, filename: str) -> Any:
         """
         Create an instance of the subclass from the data in the given json file.
 
@@ -539,7 +676,9 @@ class SubclassJSONSerializer:
             filename += ".json"
         with open(filename, "r") as f:
             scrdr_json = json.load(f)
-        return cls.from_json(scrdr_json)
+        deserialized_obj = cls.from_json(scrdr_json)
+        cls.data_class_refs.clear()
+        return deserialized_obj
 
     @classmethod
     def from_json(cls, data: Dict[str, Any]) -> Self:
@@ -551,11 +690,17 @@ class SubclassJSONSerializer:
         """
         if data is None:
             return None
-        if not isinstance(data, dict) or ('_type' not in data):
+        if isinstance(data, list):
+            # if the data is a list, deserialize it
+            return [cls.from_json(d) for d in data]
+        elif isinstance(data, dict):
+            if '__dataclass__' in data:
+                # if the data is a dataclass, deserialize it
+                return deserialize_dataclass(data, cls.data_class_refs)
+            elif '_type' not in data:
+                return {k: cls.from_json(v) for k, v in data.items()}
+        elif not isinstance(data, dict):
             return data
-        if '__dataclass__' in data:
-            # if the data is a dataclass, deserialize it
-            return deserialize_dataclass(data)
 
         # check if type module is builtins
         data_type = get_type_from_string(data["_type"])
@@ -704,6 +849,19 @@ def row_to_dict(obj):
     }
 
 
+def dataclass_to_dict(obj):
+    """
+    Convert a dataclass to a dictionary.
+
+    :param obj: The dataclass to convert.
+    :return: The dictionary representation of the dataclass.
+    """
+    if is_dataclass(obj):
+        return {f.name: getattr(obj, f.name) for f in fields(obj) if not f.name.startswith("_")}
+    else:
+        raise ValueError(f"Object {obj} is not a dataclass.")
+
+
 def get_attribute_name(obj: Any, attribute: Optional[Any] = None, attribute_type: Optional[Type] = None,
                        possible_value: Optional[Any] = None) -> Optional[str]:
     """

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.66
+Version: 0.1.68
 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.1.66 → ripple_down_rules-0.1.68}/test/test_rdr_world.py

@@ -113,6 +113,14 @@ class TestRDRWorld(TestCase):
     def test_view_rdr(self):
         self.get_view_rdr(use_loaded_answers=True, save_answers=False, append=False)
 
+    def test_save_and_load_view_rdr(self):
+        view_rdr = self.get_view_rdr(use_loaded_answers=True, save_answers=False, append=False)
+        filename = os.path.join(os.getcwd(), "test_results/world_views_rdr")
+        view_rdr.save(filename)
+        loaded_rdr = GeneralRDR.load(filename)
+        self.assertEqual(view_rdr.classify(self.world), loaded_rdr.classify(self.world))
+        self.assertEqual(self.world.bodies, loaded_rdr.start_rules[0].corner_case.bodies)
+
     def test_write_view_rdr_to_python_file(self):
         rdrs_dir = "./test_generated_rdrs"
         view_rdr = self.get_view_rdr()

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/test/test_relational_rdr.py

@@ -54,6 +54,7 @@ class RelationalRDRTestCase(TestCase):
     part_d: Part
     part_e: Part
     part_f: Part
+    target: List[PhysicalObject]
 
     @classmethod
     def setUpClass(cls):
@@ -71,8 +72,8 @@ class RelationalRDRTestCase(TestCase):
         cls.part_d.contained_objects = [cls.part_e]
         cls.part_e.contained_objects = [cls.part_f]
         cls.robot: Robot = robot
-        cls.case_query = CaseQuery(robot, "contained_objects", (PhysicalObject,), False,
-                                   _target=[cls.part_b, cls.part_c, cls.part_d, cls.part_e])
+        cls.case_query = CaseQuery(robot, "contained_objects", (PhysicalObject,), False)
+        cls.target = [cls.part_b, cls.part_c, cls.part_d, cls.part_e]
 
     def test_classify_scrdr(self):
         use_loaded_answers = True
@@ -86,7 +87,7 @@ class RelationalRDRTestCase(TestCase):
         cat = scrdr.fit_case(CaseQuery(self.robot, "contained_objects", (PhysicalObject,), False), expert=expert)
         render_tree(scrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + "/relational_scrdr_classify")
-        assert cat == self.case_query.target(self.case_query.case)
+        assert cat == self.target
 
         if save_answers:
             cwd = os.getcwd()
@@ -105,4 +106,4 @@ class RelationalRDRTestCase(TestCase):
         conclusion = CallableExpression(user_input, list)
         print(conclusion)
         print(conclusion(self.robot))
-        assert conclusion(self.robot) == self.case_query.target(self.case_query.case)
+        assert conclusion(self.robot) == self.target

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.68}/test/test_relational_rdr_alchemy.py

@@ -108,6 +108,7 @@ class RelationalRDRTestCase(TestCase):
     part_f: PhysicalObject
     rob_has_parts: List[HasPart]
     containments: List[ContainsObject]
+    target: List[PhysicalObject]
 
     @classmethod
     def setUpClass(cls):
@@ -129,8 +130,8 @@ class RelationalRDRTestCase(TestCase):
         cls.containments.append(ContainsObject(left=cls.part_d, right=cls.part_e))
         cls.containments.append(ContainsObject(left=cls.part_e, right=cls.part_f))
         cls.robot: PhysicalObject = robot
-        cls.case_query = CaseQuery(robot, robot.contained_objects, (PhysicalObject,), False,
-                                   _target=[cls.part_b, cls.part_c, cls.part_d, cls.part_e])
+        cls.case_query = CaseQuery(robot, robot.contained_objects, (PhysicalObject,), False)
+        cls.target = [cls.part_b, cls.part_c, cls.part_d, cls.part_e]
 
     def test_setup(self):
         assert self.robot.parts == [self.part_a, self.part_b, self.part_c, self.part_d]
@@ -153,7 +154,7 @@ class RelationalRDRTestCase(TestCase):
         cat = scrdr.fit_case(CaseQuery(self.robot, "contained_objects", (PhysicalObject,), False), expert=expert)
         render_tree(scrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + "/relational_scrdr_classify")
-        assert cat == self.case_query.target(self.case_query.case)
+        assert cat == self.target
 
         if save_answers:
             cwd = os.getcwd()
@@ -172,4 +173,4 @@ class RelationalRDRTestCase(TestCase):
         conclusion = CallableExpression(user_input, list)
         print(conclusion)
         print(conclusion(self.robot))
-        assert conclusion(self.robot) == self.case_query.target(self.case_query.case)
+        assert conclusion(self.robot) == self.target