ripple-down-rules 0.5.62__tar.gz → 0.5.64__tar.gz

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.62
+Version: 0.5.64
 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.5.62 → ripple_down_rules-0.5.64}/examples/part_containment_rdr/robot_rdr.py

@@ -1,5 +1,6 @@
 from typing_extensions import Dict, Any
-from ripple_down_rules.rdr import GeneralRDR
+
+from ripple_down_rules.helpers import general_rdr_classify
 from ripple_down_rules.datastructures.case import Case, create_case
 from __main__ import Robot
 from . import robot_contained_objects_mcrdr as contained_objects_classifier
@@ -12,4 +13,4 @@ classifiers_dict['contained_objects'] = contained_objects_classifier
 def classify(case: Robot) -> Dict[str, Any]:
     if not isinstance(case, Case):
         case = create_case(case, max_recursion_idx=3)
-    return GeneralRDR._classify(classifiers_dict, case)
+    return general_rdr_classify(classifiers_dict, case)

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.62"
+__version__ = "0.5.64"
 
 import logging
 logger = logging.Logger("rdr")

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/datastructures/case.py

@@ -84,7 +84,7 @@ 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
-        serializable["_obj_type"] = get_full_class_name(self._obj_type)
+        serializable["_obj_type"] = get_full_class_name(self._obj_type) if self._obj_type is not None else None
         serializable["_name"] = self._name
         for k, v in serializable.items():
             if isinstance(v, set):
@@ -96,7 +96,7 @@ class Case(UserDict, SubclassJSONSerializer):
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Case:
         id_ = data.pop("_id")
-        obj_type = get_type_from_string(data.pop("_obj_type"))
+        obj_type = get_type_from_string(data.pop("_obj_type")) if data["_obj_type"] is not None else None
         name = data.pop("_name")
         for k, v in data.items():
             data[k] = SubclassJSONSerializer.from_json(v)
@@ -308,7 +308,10 @@ def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, ob
     :return: A case attribute that represents the original iterable attribute.
     """
     values = list(attr_value.values()) if isinstance(attr_value, (dict, UserDict)) else attr_value
-    _type = type(list(values)[0]) if len(values) > 0 else get_value_type_from_type_hint(name, obj)
+    try:
+        _type = type(list(values)[0]) if len(values) > 0 else get_value_type_from_type_hint(name, obj)
+    except ValueError:
+        _type = None
     attr_case = Case(_type, _id=id(attr_value), _name=name, original_object=attr_value)
     case_attr = CaseAttribute(values)
     for idx, val in enumerate(values):
@@ -317,7 +320,10 @@ def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, ob
                                     obj_name=name, parent_is_iterable=True)
         attr_case.update(sub_attr_case)
     for sub_attr, val in attr_case.items():
-        setattr(case_attr, sub_attr, val)
+        try:
+            setattr(case_attr, sub_attr, val)
+        except AttributeError:
+            pass
     return case_attr
 
 

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -95,7 +95,7 @@ class CaseQuery:
         """
         if self._case is not None:
             return self._case
-        elif not isinstance(self.original_case, (Case, SQLTable)):
+        elif not isinstance(self.original_case, Case):
             self._case = create_case(self.original_case, max_recursion_idx=3)
         else:
             self._case = self.original_case

ripple_down_rules-0.5.64/src/ripple_down_rules/helpers.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import os
+from types import ModuleType
+
+from .datastructures.case import create_case
+from .datastructures.dataclasses import CaseQuery
+from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING, Union
+
+from .utils import get_func_rdr_model_name, copy_case, make_set, update_case
+from .utils import calculate_precision_and_recall
+
+if TYPE_CHECKING:
+    from .rdr import RippleDownRules
+
+
+def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
+                         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.
+
+    :param classifiers_dict: A dictionary mapping conclusion types to the classifiers that produce them.
+    :param case: The case to classify.
+    :param modify_original_case: Whether to modify the original case or create a copy and modify it.
+    :return: The categories that the case belongs to.
+    """
+    conclusions = {}
+    case = create_case(case)
+    case_cp = copy_case(case) if not modify_original_case else case
+    while True:
+        new_conclusions = {}
+        for attribute_name, rdr in classifiers_dict.items():
+            pred_atts = rdr.classify(case_cp)
+            if pred_atts is None:
+                continue
+            if rdr.mutually_exclusive:
+                if attribute_name not in conclusions or \
+                        (attribute_name in conclusions and conclusions[attribute_name] != pred_atts):
+                    conclusions[attribute_name] = pred_atts
+                    new_conclusions[attribute_name] = pred_atts
+            else:
+                pred_atts = make_set(pred_atts)
+                if attribute_name in conclusions:
+                    pred_atts = {p for p in pred_atts if p not in conclusions[attribute_name]}
+                if len(pred_atts) > 0:
+                    new_conclusions[attribute_name] = pred_atts
+                    if attribute_name not in conclusions:
+                        conclusions[attribute_name] = set()
+                    conclusions[attribute_name].update(pred_atts)
+            if attribute_name in new_conclusions:
+                case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, rdr.mutually_exclusive)
+                update_case(case_query, new_conclusions)
+        if len(new_conclusions) == 0:
+            break
+    return conclusions
+
+
+def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+    """
+    :param classifier: The RDR classifier to check the prediction of.
+    :param case_query: The case query to check.
+    :param pred_cat: The predicted category.
+    :return: Whether the classifier prediction is matching case_query target or not.
+    """
+    if case_query.target is None:
+        return False
+    if pred_cat is None:
+        pred_cat = classifier(case_query.case)
+    if not isinstance(pred_cat, dict):
+        pred_cat = {case_query.attribute_name: pred_cat}
+    target = {case_query.attribute_name: case_query.target_value}
+    precision, recall = calculate_precision_and_recall(pred_cat, target)
+    return all(recall) and all(precision)
+
+
+def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDownRules],
+                                  **rdr_kwargs) -> RippleDownRules:
+    """
+    Load the RDR model of the function if it exists, otherwise create a new one.
+
+    :param func: The function to load the model for.
+    :param model_dir: The directory where the model is stored.
+    :param rdr_type: The type of the RDR model to load.
+    :param rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
+    """
+    model_name = get_func_rdr_model_name(func)
+    model_path = os.path.join(model_dir, model_name, "rdr_metadata", f"{model_name}.json")
+    if os.path.exists(model_path):
+        rdr = rdr_type.load(load_dir=model_dir, model_name=model_name)
+    else:
+        rdr = rdr_type(**rdr_kwargs)
+    return rdr

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/rdr.py

@@ -28,7 +28,7 @@ from .datastructures.case import Case, CaseAttribute, create_case
 from .datastructures.dataclasses import CaseQuery
 from .datastructures.enums import MCRDRMode
 from .experts import Expert, Human
-from .helpers import is_matching
+from .helpers import is_matching, general_rdr_classify
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 try:
     from .user_interface.gui import RDRCaseViewer
@@ -36,7 +36,7 @@ except ImportError as e:
     RDRCaseViewer = None
 from .utils import draw_tree, make_set, copy_case, \
     SubclassJSONSerializer, make_list, get_type_from_string, \
-    is_conflicting, update_case, get_imports_from_scope, extract_function_source, extract_imports, get_full_class_name, \
+    is_conflicting, get_imports_from_scope, extract_function_source, extract_imports, get_full_class_name, \
     is_iterable, str_to_snake_case
 
 
@@ -76,16 +76,18 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     """
     The name of the model. If None, the model name will be the generated python file name.
     """
+    mutually_exclusive: Optional[bool] = None
+    """
+    Whether the output of the classification of this rdr allows only one possible conclusion or not.
+    """
 
     def __init__(self, start_rule: Optional[Rule] = None, viewer: Optional[RDRCaseViewer] = None,
-                 save_dir: Optional[str] = None, ask_always: bool = False, model_name: Optional[str] = None):
+                 save_dir: Optional[str] = None, model_name: Optional[str] = None):
         """
         :param start_rule: The starting rule for the classifier.
         :param viewer: The viewer gui to use for the classifier. If None, no viewer is used.
         :param save_dir: The directory to save the classifier to.
-        :param ask_always: Whether to always ask the expert (True) or only ask when classification fails (False).
         """
-        self.ask_always: bool = ask_always
         self.model_name: Optional[str] = model_name
         self.save_dir = save_dir
         self.start_rule = start_rule
@@ -224,7 +226,10 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         pass
 
-    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
+    def fit_case(self, case_query: CaseQuery,
+                 expert: Optional[Expert] = None,
+                 update_existing_rules: bool = True,
+                 **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
         Fit the classifier to a case and ask the expert for refinements or alternatives if the classification is
@@ -232,6 +237,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
         :param case_query: The query containing the case to classify and the target category to compare the case with.
         :param expert: The expert to ask for differentiating features as new rule conditions.
+        :param update_existing_rules: Whether to update the existing same conclusion type rules that already gave
+        some conclusions with the type required by the case query.
         :return: The category that the case belongs to.
         """
         if case_query is None:
@@ -248,11 +255,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         if case_query.target is None:
             case_query_cp = copy(case_query)
             conclusions = self.classify(case_query_cp.case, modify_case=True)
-            if (self.ask_always or conclusions is None
-                or is_iterable(conclusions) and len(conclusions) == 0
-                or (isinstance(conclusions, dict) and (case_query_cp.attribute_name not in conclusions
-                    or not any(type(c) in case_query_cp.core_attribute_type
-                               for c in make_list(conclusions[case_query_cp.attribute_name]))))):
+            if self.should_i_ask_the_expert_for_a_target(conclusions, case_query_cp, update_existing_rules):
                 expert.ask_for_conclusion(case_query_cp)
                 case_query.target = case_query_cp.target
             if case_query.target is None:
@@ -268,6 +271,34 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
         return fit_case_result
 
+    @staticmethod
+    def should_i_ask_the_expert_for_a_target(conclusions: Union[Any, Dict[str, Any]],
+                                             case_query: CaseQuery,
+                                             update_existing: bool) -> bool:
+        """
+        Determine if the rdr should ask the expert for the target of a given case query.
+
+        :param conclusions: The conclusions of the case.
+        :param case_query: The query containing the case to classify.
+        :param update_existing: Whether to update rules that gave the required type of conclusions.
+        :return: True if the rdr should ask the expert, False otherwise.
+        """
+        if conclusions is None:
+            return True
+        elif is_iterable(conclusions) and len(conclusions) == 0:
+            return True
+        elif isinstance(conclusions, dict):
+            if case_query.attribute_name not in conclusions:
+                return True
+            conclusions = conclusions[case_query.attribute_name]
+        conclusion_types = map(type, make_list(conclusions))
+        if not any(ct in case_query.core_attribute_type for ct in conclusion_types):
+            return True
+        elif update_existing:
+            return True
+        else:
+            return False
+
     @abstractmethod
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
@@ -423,11 +454,10 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             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"attribute_name = '{self.attribute_name}'\n")
             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"mutually_exclusive = {self.mutually_exclusive}\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""")
@@ -533,6 +563,11 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
 class SingleClassRDR(RDRWithCodeWriter):
 
+    mutually_exclusive: bool = True
+    """
+    The output of the classification of this rdr negates all other possible outputs, there can only be one true value.
+    """
+
     def __init__(self, default_conclusion: Optional[Any] = None, **kwargs):
         """
         :param start_rule: The starting rule for the classifier.
@@ -650,6 +685,10 @@ class MultiClassRDR(RDRWithCodeWriter):
     """
     The conditions of the stopping rule if needed.
     """
+    mutually_exclusive: bool = False
+    """
+    The output of the classification of this rdr allows for more than one true value as conclusion.
+    """
 
     def __init__(self, start_rule: Optional[MultiClassTopRule] = None,
                  mode: MCRDRMode = MCRDRMode.StopOnly, **kwargs):
@@ -903,50 +942,7 @@ class GeneralRDR(RippleDownRules):
         :param modify_case: Whether to modify the original case or create a copy and modify it.
         :return: The categories that the case belongs to.
         """
-        return self._classify(self.start_rules_dict, case, modify_original_case=modify_case)
-
-    @staticmethod
-    def _classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
-                  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.
-
-        :param classifiers_dict: A dictionary mapping conclusion types to the classifiers that produce them.
-        :param case: The case to classify.
-        :param modify_original_case: Whether to modify the original case or create a copy and modify it.
-        :return: The categories that the case belongs to.
-        """
-        conclusions = {}
-        case = case if isinstance(case, (Case, SQLTable)) else create_case(case)
-        case_cp = copy_case(case) if not modify_original_case else case
-        while True:
-            new_conclusions = {}
-            for attribute_name, rdr in classifiers_dict.items():
-                pred_atts = rdr.classify(case_cp)
-                if pred_atts is None:
-                    continue
-                if rdr.type_ is SingleClassRDR:
-                    if attribute_name not in conclusions or \
-                            (attribute_name in conclusions and conclusions[attribute_name] != pred_atts):
-                        conclusions[attribute_name] = pred_atts
-                        new_conclusions[attribute_name] = pred_atts
-                else:
-                    pred_atts = make_set(pred_atts)
-                    if attribute_name in conclusions:
-                        pred_atts = {p for p in pred_atts if p not in conclusions[attribute_name]}
-                    if len(pred_atts) > 0:
-                        new_conclusions[attribute_name] = pred_atts
-                        if attribute_name not in conclusions:
-                            conclusions[attribute_name] = set()
-                        conclusions[attribute_name].update(pred_atts)
-                if attribute_name in new_conclusions:
-                    mutually_exclusive = True if rdr.type_ is SingleClassRDR else False
-                    case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, mutually_exclusive)
-                    update_case(case_query, new_conclusions)
-            if len(new_conclusions) == 0:
-                break
-        return conclusions
+        return general_rdr_classify(self.start_rules_dict, case, modify_original_case=modify_case)
 
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Dict[str, Any]:
@@ -1043,7 +1039,7 @@ class GeneralRDR(RippleDownRules):
             f.write(func_def)
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
-            f.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
+            f.write(f"{' ' * 4}return general_rdr_classify(classifiers_dict, case)\n")
 
     @property
     def _default_generated_python_file_name(self) -> Optional[str]:
@@ -1068,7 +1064,7 @@ class GeneralRDR(RippleDownRules):
         # add type hints
         imports += f"from typing_extensions import Dict, Any\n"
         # import rdr type
-        imports += f"from ripple_down_rules.rdr import GeneralRDR\n"
+        imports += f"from ripple_down_rules.helpers import general_rdr_classify\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"

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/rdr_decorators.py

@@ -7,13 +7,14 @@ import os.path
 from functools import wraps
 
 from pyparsing.tools.cvt_pyparsing_pep8_names import camel_to_snake
-from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union
+from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union, Sequence
 
 from ripple_down_rules.datastructures.case import create_case, Case
 from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.datastructures.enums import Category
 from ripple_down_rules.experts import Expert, Human
 from ripple_down_rules.rdr import GeneralRDR, RippleDownRules
+from ripple_down_rules.user_interface.gui import RDRCaseViewer
 from ripple_down_rules.utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
     get_method_class_if_exists, get_method_name, str_to_snake_case
 
@@ -26,7 +27,10 @@ class RDRDecorator:
                  mutual_exclusive: bool,
                  output_name: str = "output_",
                  fit: bool = True,
-                 expert: Optional[Expert] = None):
+                 expert: Optional[Expert] = None,
+                 ask_always: bool = False,
+                 update_existing_rules: bool = True,
+                 viewer: Optional[RDRCaseViewer] = None):
         """
         :param models_dir: The directory to save/load the RDR models.
         :param output_type: The type of the output. This is used to create the RDR model.
@@ -38,6 +42,9 @@ class RDRDecorator:
             classification mode. This means that the RDR will classify the function's output based on the RDR model.
         :param expert: The expert that will be used to prompt the user for the correct output. If None, a Human
             expert will be used.
+        :param ask_always: If True, the function will ask the user for a target if it doesn't exist.
+        :param update_existing_rules: If True, the function will update the existing RDR rules
+         even if they gave an output.
         :return: A decorator to use a GeneralRDR as a classifier that monitors and modifies the function's output.
         """
         self.rdr_models_dir = models_dir
@@ -48,6 +55,9 @@ class RDRDecorator:
         self.output_name = output_name
         self.fit: bool = fit
         self.expert: Optional[Expert] = expert
+        self.ask_always = ask_always
+        self.update_existing_rules = update_existing_rules
+        self.viewer = viewer
         self.load()
 
     def decorator(self, func: Callable) -> Callable:
@@ -59,59 +69,77 @@ class RDRDecorator:
                 self.parsed_output_type = self.parse_output_type(func, self.output_type, *args)
             if self.model_name is None:
                 self.initialize_rdr_model_name_and_load(func)
+            if self.expert is None:
+                self.expert = Human(viewer=self.viewer,
+                                    answers_save_path=self.rdr_models_dir + f'/expert_answers')
+
+            func_output = {self.output_name: func(*args, **kwargs)}
 
             if self.fit:
-                case_query = self.create_case_query_from_method(func, self.parsed_output_type,
-                                                                self.mutual_exclusive, self.output_name,
+                case_query = self.create_case_query_from_method(func, func_output,
+                                                                self.parsed_output_type,
+                                                                self.mutual_exclusive,
                                                                 *args, **kwargs)
-                output = self.rdr.fit_case(case_query, expert=self.expert)
+                output = self.rdr.fit_case(case_query, expert=self.expert,
+                                           ask_always_for_target=self.ask_always,
+                                           update_existing_rules=self.update_existing_rules,
+                                           viewer=self.viewer)
+            else:
+                case, case_dict = self.create_case_from_method(func, func_output, *args, **kwargs)
+                output = self.rdr.classify(case)
+
+            if self.output_name in output:
                 return output[self.output_name]
             else:
-                case, case_dict = self.create_case_from_method(func, self.output_name, *args, **kwargs)
-                return self.rdr.classify(case)[self.output_name]
+                return func_output[self.output_name]
 
         return wrapper
 
     @staticmethod
-    def create_case_query_from_method(func: Callable, output_type, mutual_exclusive: bool,
-                                output_name: str = 'output_', *args, **kwargs) -> CaseQuery:
+    def create_case_query_from_method(func: Callable,
+                                      func_output: Dict[str, Any],
+                                      output_type: Sequence[Type],
+                                      mutual_exclusive: bool,
+                                      *args, **kwargs) -> CaseQuery:
         """
         Create a CaseQuery from the function and its arguments.
 
         :param func: The function to create a case from.
-        :param output_type: The type of the output.
+        :param func_output: The output of the function as a dictionary, where the key is the output name.
+        :param output_type: The type of the output as a sequence of types.
         :param mutual_exclusive: If True, the output types are mutually exclusive.
-        :param output_name: The name of the output in the case. Defaults to 'output_'.
         :param args: The positional arguments of the function.
         :param kwargs: The keyword arguments of the function.
         :return: A CaseQuery object representing the case.
         """
         output_type = make_set(output_type)
-        case, case_dict = RDRDecorator.create_case_from_method(func, output_name, *args, **kwargs)
+        case, case_dict = RDRDecorator.create_case_from_method(func, func_output, *args, **kwargs)
         scope = func.__globals__
         scope.update(case_dict)
         func_args_type_hints = get_type_hints(func)
+        output_name = list(func_output.keys())[0]
         func_args_type_hints.update({output_name: Union[tuple(output_type)]})
         return CaseQuery(case, output_name, Union[tuple(output_type)],
                          mutual_exclusive, scope=scope,
                          is_function=True, function_args_type_hints=func_args_type_hints)
 
     @staticmethod
-    def create_case_from_method(func: Callable, output_name: str = "output_", *args, **kwargs) -> Tuple[Case, Dict[str, Any]]:
+    def create_case_from_method(func: Callable,
+                                func_output: Dict[str, Any],
+                                *args, **kwargs) -> Tuple[Case, Dict[str, Any]]:
         """
         Create a Case from the function and its arguments.
 
         :param func: The function to create a case from.
-        :param output_name: The name of the output in the case. Defaults to 'output_'.
+        :param func_output: A dictionary containing the output of the function, where the key is the output name.
         :param args: The positional arguments of the function.
         :param kwargs: The keyword arguments of the function.
         :return: A Case object representing the case.
         """
         case_dict = get_method_args_as_dict(func, *args, **kwargs)
-        func_output = func(*args, **kwargs)
-        case_dict.update({output_name: func_output})
+        case_dict.update(func_output)
         case_name = get_func_rdr_model_name(func)
-        return create_case(case_dict, obj_name=case_name, max_recursion_idx=3), case_dict
+        return Case(dict, id(case_dict), case_name, case_dict, **case_dict), case_dict
 
     def initialize_rdr_model_name_and_load(self, func: Callable) -> None:
         model_file_name = get_func_rdr_model_name(func, include_file_name=True)
@@ -148,8 +176,10 @@ class RDRDecorator:
             model_path = os.path.join(self.rdr_models_dir, self.model_name + f"/rdr_metadata/{self.model_name}.json")
             if os.path.exists(os.path.join(self.rdr_models_dir, model_path)):
                 self.rdr = GeneralRDR.load(self.rdr_models_dir, self.model_name)
+                self.rdr.set_viewer(self.viewer)
         if self.rdr is None:
-            self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name)
+            self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name,
+                                  viewer=self.viewer)
 
     def update_from_python(self):
         """

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/rules.py

@@ -12,7 +12,7 @@ from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple
 from .datastructures.callable_expression import CallableExpression
 from .datastructures.case import Case
 from .datastructures.enums import RDREdge, Stop
-from .utils import SubclassJSONSerializer, conclusion_to_json
+from .utils import SubclassJSONSerializer, conclusion_to_json, get_full_class_name
 
 
 class Rule(NodeMixin, SubclassJSONSerializer, ABC):
@@ -150,11 +150,16 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         pass
 
     def _to_json(self) -> Dict[str, Any]:
-        json_serialization = {"conditions": self.conditions.to_json(),
+        try:
+            corner_case = SubclassJSONSerializer.to_json_static(self.corner_case) if self.corner_case else None
+        except Exception as e:
+            logging.debug("Failed to serialize corner case to json, setting it to None. Error: %s", e)
+            corner_case = None
+        json_serialization = {"_type": get_full_class_name(type(self)),
+                              "conditions": self.conditions.to_json(),
                               "conclusion": conclusion_to_json(self.conclusion),
                               "parent": self.parent.json_serialization if self.parent else None,
-                              "corner_case": SubclassJSONSerializer.to_json_static(self.corner_case)
-                              if self.corner_case else None,
+                              "corner_case": corner_case,
                               "conclusion_name": self.conclusion_name,
                               "weight": self.weight,
                               "uid": self.uid}

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/user_interface/gui.py

@@ -281,12 +281,14 @@ class RDRCaseViewer(QMainWindow):
     main_obj: Optional[Dict[str, Any]] = None
     user_input: Optional[str] = None
     attributes_widget: Optional[QWidget] = None
-    save_function: Optional[Callable[str], None] = None
+    save_function: Optional[Callable[str, str], None] = None
 
-
-    def __init__(self, parent=None, save_file: Optional[str] = None):
+    def __init__(self, parent=None,
+                 save_dir: Optional[str] = None,
+                 save_model_name: Optional[str] = None):
         super().__init__(parent)
-        self.save_file = save_file
+        self.save_dir = save_dir
+        self.save_model_name = save_model_name
 
         self.setWindowTitle("RDR Case Viewer")
 
@@ -323,17 +325,17 @@ class RDRCaseViewer(QMainWindow):
 
         # Add both to main layout
         main_layout.addWidget(self.attributes_widget, stretch=1)
-        main_layout.addWidget(middle_widget, stretch=2)
+        main_layout.addWidget(middle_widget, stretch=1)
         main_layout.addWidget(self.obj_diagram_viewer, stretch=2)
 
-    def set_save_function(self, save_function: Callable[[str], None]) -> None:
+    def set_save_function(self, save_function: Callable[[str, str], None]) -> None:
         """
         Set the function to save the file.
 
         :param save_function: The function to save the file.
         """
         self.save_function = save_function
-        self.save_btn.clicked.connect(lambda: self.save_function(self.save_file))
+        self.save_btn.clicked.connect(lambda: self.save_function(self.save_dir, self.save_model_name))
 
     def print(self, msg):
         """

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/user_interface/ipython_custom_shell.py

@@ -134,7 +134,7 @@ class IPythonShell:
         """
         Update the user input from the code lines captured in the shell.
         """
-        if len(self.shell.all_lines) == 1 and self.shell.all_lines[0].replace('return', '').strip() == '':
+        if self.shell.all_lines[0].replace('return', '').strip() == '':
             self.user_input = None
         else:
             self.all_code_lines = extract_dependencies(self.shell.all_lines)

{ripple_down_rules-0.5.62 → ripple_down_rules-0.5.64}/src/ripple_down_rules/user_interface/object_diagram.py

@@ -1,5 +1,9 @@
 import logging
 
+from ripple_down_rules.datastructures.case import Case
+from ripple_down_rules.datastructures.dataclasses import CaseQuery
+from ripple_down_rules.utils import SubclassJSONSerializer
+
 try:
     import graphviz
 except ImportError:
@@ -77,7 +81,11 @@ def generate_object_graph(obj, name='root', seen=None, graph=None, current_depth
         for attr in dir(obj):
             if attr.startswith('_'):
                 continue
-            if attr == 'scope':
+            if isinstance(obj, CaseQuery) and attr == 'scope':
+                continue
+            if isinstance(obj, Case) and attr in ['data']:
+                continue
+            if isinstance(obj, SubclassJSONSerializer) and attr == 'data_class_refs':
                 continue
             value = getattr(obj, attr)
             if callable(value):