ripple-down-rules 0.5.62__py3-none-any.whl → 0.5.64__py3-none-any.whl

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/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/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/helpers.py

@@ -1,18 +1,61 @@
 from __future__ import annotations
 
 import os
+from types import ModuleType
 
+from .datastructures.case import create_case
 from .datastructures.dataclasses import CaseQuery
-from sqlalchemy.orm import Session
-from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING
+from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING, Union
 
-from .utils import get_func_rdr_model_path
+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.
@@ -32,20 +75,19 @@ def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_ca
 
 
 def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDownRules],
-                                  session: Optional[Session] = None, **rdr_kwargs) -> 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 session: The SQLAlchemy session to use.
     :param rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
     """
-    model_path = get_func_rdr_model_path(func, model_dir)
+    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(model_path)
-        rdr.session = session
+        rdr = rdr_type.load(load_dir=model_dir, model_name=model_name)
     else:
-        rdr = rdr_type(session=session, **rdr_kwargs)
+        rdr = rdr_type(**rdr_kwargs)
     return rdr

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/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/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/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/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/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):

ripple_down_rules/user_interface/template_file_creator.py

@@ -8,13 +8,13 @@ from functools import cached_property
 from textwrap import indent, dedent
 
 from colorama import Fore, Style
-from typing_extensions import Optional, Type, List, Callable, Tuple, Dict
+from typing_extensions import Optional, Type, List, Callable, Tuple, Dict, Any, Union
 
 from ..datastructures.case import Case
 from ..datastructures.dataclasses import CaseQuery
 from ..datastructures.enums import Editor, PromptFor
-from ..utils import str_to_snake_case, get_imports_from_scope, make_list, typing_hint_to_str, \
-    get_imports_from_types, extract_function_source, extract_imports
+from ..utils import str_to_snake_case, get_imports_from_scope, make_list, stringify_hint, \
+    get_imports_from_types, extract_function_source, extract_imports, get_types_to_import_from_type_hints
 
 
 def detect_available_editor() -> Optional[Editor]:
@@ -84,6 +84,7 @@ class TemplateFileCreator:
         self.func_doc: str = self.get_func_doc()
         self.function_signature: str = self.get_function_signature()
         self.editor: Optional[Editor] = detect_available_editor()
+        self.editor_cmd: Optional[str] = os.environ.get("RDR_EDITOR_CMD")
         self.workspace: str = os.environ.get("RDR_EDITOR_WORKSPACE", os.path.dirname(self.case_query.scope['__file__']))
         self.temp_file_path: str = os.path.join(self.workspace, "edit_code_here.py")
 
@@ -98,7 +99,7 @@ class TemplateFileCreator:
         return make_list(output_type) if output_type is not None else None
 
     def edit(self):
-        if self.editor is None:
+        if self.editor is None and self.editor_cmd is None:
             self.print_func(
                 f"{Fore.RED}ERROR:: No editor found. Please install PyCharm, VSCode or code-server.{Style.RESET_ALL}")
             return
@@ -112,7 +113,11 @@ class TemplateFileCreator:
         """
         Open the file in the available editor.
         """
-        if self.editor == Editor.Pycharm:
+        if self.editor_cmd is not None:
+            subprocess.Popen([self.editor_cmd, self.temp_file_path],
+                             stdout=subprocess.DEVNULL,
+                             stderr=subprocess.DEVNULL)
+        elif self.editor == Editor.Pycharm:
             subprocess.Popen(["pycharm", "--line", str(self.user_edit_line), self.temp_file_path],
                              stdout=subprocess.DEVNULL,
                              stderr=subprocess.DEVNULL)
@@ -172,7 +177,7 @@ class TemplateFileCreator:
             for k, v in self.case_query.case.items():
                 if (self.case_query.function_args_type_hints is not None
                         and k in self.case_query.function_args_type_hints):
-                    func_args[k] = typing_hint_to_str(self.case_query.function_args_type_hints[k])[0]
+                    func_args[k] = stringify_hint(self.case_query.function_args_type_hints[k])
                 else:
                     func_args[k] = type(v).__name__ if not isinstance(v, type) else f"Type[{v.__name__}]"
             func_args = ', '.join([f"{k}: {v}" if str(v) not in ["NoneType", "None"] else str(k)
@@ -202,30 +207,25 @@ class TemplateFileCreator:
             for k, v in self.case_query.case.items():
                 if (self.case_query.function_args_type_hints is not None
                         and k in self.case_query.function_args_type_hints):
-                    hint_list = typing_hint_to_str(self.case_query.function_args_type_hints[k])[1]
-                    for hint in hint_list:
-                        hint_split = hint.split('.')
-                        if len(hint_split) > 1:
-                            case_type_imports.append(f"from {'.'.join(hint_split[:-1])} import {hint_split[-1]}")
+                    types_to_import = get_types_to_import_from_type_hints([self.case_query.function_args_type_hints[k]])
+                    case_type_imports.extend(list(types_to_import))
                 else:
-                    if isinstance(v, type):
-                        case_type_imports.append(f"from {v.__module__} import {v.__name__}")
-                    elif hasattr(v, "__module__") and not v.__module__.startswith("__"):
-                        case_type_imports.append(f"\nfrom {type(v).__module__} import {type(v).__name__}")
+                    case_type_imports.append(v)
         else:
-            case_type_imports.append(f"from {self.case_type.__module__} import {self.case_type.__name__}")
+            case_type_imports.append(self.case_type)
         if self.output_type is None:
-            output_type_imports = [f"from typing_extensions import Any"]
+            output_type_imports = [Any]
         else:
-            output_type_imports = get_imports_from_types(self.output_type)
+            output_type_imports = self.output_type
             if len(self.output_type) > 1:
-                output_type_imports.append("from typing_extensions import Union")
+                output_type_imports.append(Union)
             if list in self.output_type:
-                output_type_imports.append("from typing_extensions import List")
-        imports = get_imports_from_scope(self.case_query.scope)
-        imports = [i for i in imports if ("get_ipython" not in i)]
-        imports.extend(case_type_imports)
-        imports.extend([oti for oti in output_type_imports if oti not in imports])
+                output_type_imports.append(List)
+        import_types = list(self.case_query.scope.values())
+        # imports = [i for i in imports if ("get_ipython" not in i)]
+        import_types.extend(case_type_imports)
+        import_types.extend(output_type_imports)
+        imports = get_imports_from_types(import_types)
         imports = set(imports)
         return '\n'.join(imports)
 

ripple_down_rules/utils.py

@@ -10,14 +10,14 @@ import os
 import re
 import threading
 import uuid
-from collections import UserDict
+from collections import UserDict, defaultdict
 from copy import deepcopy, copy
 from dataclasses import is_dataclass, fields
 from enum import Enum
 from textwrap import dedent
 from types import NoneType
-from typing import List
 
+from sqlalchemy.exc import NoInspectionAvailable
 
 try:
     import matplotlib
@@ -42,8 +42,7 @@ from sqlalchemy import MetaData, inspect
 from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQLTable, Session
 from tabulate import tabulate
 from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get_type_hints, \
-    get_origin, get_args, Tuple, Optional, List, Union, Self
-
+    get_origin, get_args, Tuple, Optional, List, Union, Self, ForwardRef
 
 if TYPE_CHECKING:
     from .datastructures.case import Case
@@ -82,7 +81,7 @@ def are_results_subclass_of_types(result_types: List[Any], types_: List[Type]) -
     return True
 
 
-def get_imports_from_types(types: List[Type]) -> List[str]:
+def _get_imports_from_types(types: List[Type]) -> List[str]:
     """
     Get the import statements for a list of types.
 
@@ -660,56 +659,149 @@ def get_func_rdr_model_name(func: Callable, include_file_name: bool = False) ->
     return model_name
 
 
-def extract_bracket_arguments(val: str) -> List[str]:
-    """
-    Extract arguments inside brackets into a list.
-
-    :param val: The string containing brackets.
-    :return: List of arguments inside brackets.
-    """
-    if '[' not in val:
-        return [val]
-    args_start = val.find('[')
-    args_end = val.rfind(']')
-    if args_end == -1:
-        return [val]
-    base_type = val[:args_start]
-    args = val[args_start + 1:args_end].split(',')
-    args = [arg.strip() for arg in args]
-    return [base_type] + args
-
-
-def typing_hint_to_str(type_hint: Any) -> Tuple[str, List[str]]:
-    """
-    Convert a typing hint to a string.
-
-    :param type_hint: The typing hint to convert.
-    :return: The string representation of the typing hint.
-    """
-    val = (str(type_hint).strip("<>")
-           .replace("class ", "")
-           # .replace("typing.", "")
-           .replace("'", ""))
-    all_args = []
-    if '[' in val:
-        args = extract_bracket_arguments(val)
-        args_with_brackets = [arg for arg in args if '[' in arg]
-        all_args.extend([arg for arg in args if '[' not in arg])
-        while args_with_brackets:
-            for arg in args:
-                if '[' in arg:
-                    sub_args = extract_bracket_arguments(arg)
-                    args_with_brackets.remove(arg)
-                    all_args.extend([sarg for sarg in sub_args if '[' not in sarg])
-                    args_with_brackets.extend([sarg for sarg in sub_args if '[' in sarg])
-                elif arg not in all_args:
-                    all_args.append(arg)
-            args = args_with_brackets
-        for arg in all_args:
-            val = val.replace(arg, arg.split('.')[-1])
-    else:
-        val = val.split('.')[-1]
-    return val, all_args
+def stringify_hint(tp):
+    """Recursively convert a type hint to a string."""
+    if isinstance(tp, str):
+        return tp
+
+    # Handle ForwardRef (string annotations not yet evaluated)
+    if isinstance(tp, ForwardRef):
+        return tp.__forward_arg__
+
+    # Handle typing generics like List[int], Dict[str, List[int]], etc.
+    origin = get_origin(tp)
+    args = get_args(tp)
+
+    if origin is not None:
+        origin_str = getattr(origin, '__name__', str(origin)).capitalize()
+        args_str = ", ".join(stringify_hint(arg) for arg in args)
+        return f"{origin_str}[{args_str}]"
+
+    # Handle built-in types like int, str, etc.
+    if isinstance(tp, type):
+        if tp.__module__ == 'builtins':
+            return tp.__name__
+        return f"{tp.__qualname__}"
+
+    return str(tp)
+
+
+def is_builtin_type(tp):
+    return isinstance(tp, type) and tp.__module__ == "builtins"
+
+
+def is_typing_type(tp):
+    return tp.__module__ == "typing"
+
+origin_type_to_hint = {
+    list: List,
+    set: Set,
+    dict: Dict,
+    tuple: Tuple,
+}
+
+def extract_types(tp, seen: Set = None) -> Set[type]:
+    """Recursively extract all base types from a type hint."""
+    if seen is None:
+        seen = set()
+
+    if tp in seen or isinstance(tp, str):
+        return seen
+
+    # seen.add(tp)
+
+    if isinstance(tp, ForwardRef):
+        # Can't resolve until evaluated
+        return seen
+
+    origin = get_origin(tp)
+    args = get_args(tp)
+
+    if origin:
+        if origin in origin_type_to_hint:
+            seen.add(origin_type_to_hint[origin])
+        else:
+            seen.add(origin)
+        for arg in args:
+            extract_types(arg, seen)
+
+    elif isinstance(tp, type):
+        seen.add(tp)
+
+    return seen
+
+
+def get_types_to_import_from_func_type_hints(func: Callable) -> Set[Type]:
+    """
+    Extract importable types from a function's annotations.
+
+    :param func: The function to extract type hints from.
+    """
+    hints = get_type_hints(func)
+
+    sig = inspect.signature(func)
+    all_hints = list(hints.values())
+    if sig.return_annotation != inspect.Signature.empty:
+        all_hints.append(sig.return_annotation)
+
+    for param in sig.parameters.values():
+        if param.annotation != inspect.Parameter.empty:
+            all_hints.append(param.annotation)
+
+    return get_types_to_import_from_type_hints(all_hints)
+
+
+def get_types_to_import_from_type_hints(hints: List[Type]) -> Set[Type]:
+    """
+    Extract importable types from a list of type hints.
+
+    :param hints: A list of type hints to extract types from.
+    :return: A set of types that need to be imported.
+    """
+    seen_types = set()
+    for hint in hints:
+        extract_types(hint, seen_types)
+
+    # Filter out built-in and internal types
+    to_import = set()
+    for tp in seen_types:
+        if isinstance(tp, ForwardRef) or isinstance(tp, str):
+            continue
+        if not is_builtin_type(tp):
+            to_import.add(tp)
+
+    return to_import
+
+
+def get_imports_from_types(type_objs: List[Type]) -> List[str]:
+    """
+    Format import lines from type objects.
+
+    :param type_objs: A list of type objects to format.
+    """
+
+    module_to_types = defaultdict(list)
+    for tp in type_objs:
+        try:
+            if isinstance(tp, type) or is_typing_type(tp):
+                module = tp.__module__
+                name = tp.__qualname__
+            elif hasattr(type(tp), "__module__"):
+                module = type(tp).__module__
+                name = type(tp).__qualname__
+            else:
+                continue
+            if module is None or module == 'builtins' or module.startswith('_'):
+                continue
+            module_to_types[module].append(name)
+        except AttributeError:
+            continue
+
+    lines = []
+    for module, names in module_to_types.items():
+        joined = ", ".join(sorted(set(names)))
+        lines.append(f"from {module} import {joined}")
+    return sorted(lines)
 
 
 def get_method_args_as_dict(method: Callable, *args, **kwargs) -> Dict[str, Any]:
@@ -865,6 +957,8 @@ class SubclassJSONSerializer:
     def to_json_static(obj, seen=None) -> Any:
         if isinstance(obj, SubclassJSONSerializer):
             return {"_type": get_full_class_name(obj.__class__), **obj._to_json()}
+        elif isinstance(obj, type):
+            return {"_type": get_full_class_name(obj)}
         elif is_dataclass(obj):
             return serialize_dataclass(obj, seen)
         elif isinstance(obj, list):
@@ -1017,13 +1111,20 @@ def copy_orm_instance(instance: SQLTable) -> SQLTable:
     :param instance: The instance to copy.
     :return: The copied instance.
     """
-    session: Session = inspect(instance).session
+    try:
+        session: Session = inspect(instance).session
+    except NoInspectionAvailable:
+        session = None
     if session is not None:
         session.expunge(instance)
         new_instance = deepcopy(instance)
         session.add(instance)
     else:
-        new_instance = instance
+        try:
+            new_instance = deepcopy(instance)
+        except Exception as e:
+            logging.debug(e)
+            new_instance = instance
     return new_instance
 
 
@@ -1037,8 +1138,12 @@ def copy_orm_instance_with_relationships(instance: SQLTable) -> SQLTable:
     instance_cp = copy_orm_instance(instance)
     for rel in class_mapper(instance.__class__).relationships:
         related_obj = getattr(instance, rel.key)
+        related_obj_cp = copy_orm_instance(related_obj)
         if related_obj is not None:
-            setattr(instance_cp, rel.key, related_obj)
+            try:
+                setattr(instance_cp, rel.key, related_obj_cp)
+            except Exception as e:
+                logging.debug(e)
     return instance_cp
 
 
@@ -1049,7 +1154,17 @@ def get_value_type_from_type_hint(attr_name: str, obj: Any) -> Type:
     :param attr_name: The name of the attribute.
     :param obj: The object to get the attributes from.
     """
-    hint, origin, args = get_hint_for_attribute(attr_name, obj)
+    # check first if obj is a function object
+    if hasattr(obj, '__code__'):
+        func_type_hints = get_type_hints(obj)
+        if attr_name in func_type_hints:
+            hint = func_type_hints[attr_name]
+            origin = get_origin(hint)
+            args = get_args(hint)
+        else:
+            raise ValueError(f"Unknown type hint: {attr_name}")
+    else:
+        hint, origin, args = get_hint_for_attribute(attr_name, obj)
     if not origin and not hint:
         if hasattr(obj, attr_name):
             attr_value = getattr(obj, attr_name)

{ripple_down_rules-0.5.62.dist-info → ripple_down_rules-0.5.64.dist-info}/METADATA

@@ -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.64.dist-info/RECORD

@@ -0,0 +1,24 @@
+ripple_down_rules/__init__.py,sha256=5qEoRYuRIypGXWagthsMrLJNOpvkBokzNKBjmYbRyEo,100
+ripple_down_rules/experts.py,sha256=bwozulI1rv0uyaMZQqEgapDO-s8wvW0D6Jqxmvu5fik,12610
+ripple_down_rules/helpers.py,sha256=fRBjtknjhszsZAlFLWjiz_n-YOWOXa8LHQNSl-FjsQI,4203
+ripple_down_rules/rdr.py,sha256=jhDL-a_nLSzAR-KQfKxFBoLhMZbazs_lTB_z-ebw-X0,48369
+ripple_down_rules/rdr_decorators.py,sha256=pEVupcFqtHzPCaxZoxphHWlrSN6vCishdwUQ1hXiWtc,9193
+ripple_down_rules/rules.py,sha256=2yFpbu6DUgYTKFJsuAod3YSM6MBMyYkiBsgKu4BgxZM,17794
+ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
+ripple_down_rules/utils.py,sha256=LtZ21VSB3Au27Wf23wpDdSJMv3ABQgE1dRc2kzzQj-c,54605
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=f3wUPTrLa1INO-1qfgVz87ryrCABronfyq0_JKWoZCs,12800
+ripple_down_rules/datastructures/case.py,sha256=1zSaXUljaH6z3SgMGzYPoDyjotNam791KpYgvxuMh90,15463
+ripple_down_rules/datastructures/dataclasses.py,sha256=uIrEcvV0oJeMZM9ewGdSO7lIyZgza-4UA3L7gCy-lQk,8542
+ripple_down_rules/datastructures/enums.py,sha256=ce7tqS0otfSTNAOwsnXlhsvIn4iW_Y_N3TNebF3YoZs,5700
+ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/user_interface/gui.py,sha256=_lgZAUXxxaBUFQJAHjA5TBPp6XEvJ62t-kSN8sPsocE,27379
+ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=Jrf7NxOdlrwGXH0Xyz3vzQprY-PNx9etfePOTpm2Gu8,6479
+ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
+ripple_down_rules/user_interface/prompt.py,sha256=AkkltdDIaioN43lkRKDPKSjJcmdSSGZDMYz7AL7X9lE,8082
+ripple_down_rules/user_interface/template_file_creator.py,sha256=VLS9Nxg6gPNa-YYliJ_VNsTvLPlZ003EVkJ2t8zuDgE,13563
+ripple_down_rules-0.5.64.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.64.dist-info/METADATA,sha256=s4rz2kIRehE7aDcErKUI0uifjq6wbOU6khX09EMXtF4,48189
+ripple_down_rules-0.5.64.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.5.64.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.64.dist-info/RECORD,,

ripple_down_rules-0.5.62.dist-info/RECORD

@@ -1,24 +0,0 @@
-ripple_down_rules/__init__.py,sha256=MKeKdIBZpDHNeXgQzJQDmsXIXJUj5GFtP1tTx5ZbuwE,100
-ripple_down_rules/experts.py,sha256=bwozulI1rv0uyaMZQqEgapDO-s8wvW0D6Jqxmvu5fik,12610
-ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
-ripple_down_rules/rdr.py,sha256=4iobla4XmMwAOQsn_JZaZe2tWU0aMMvqgzP5WavIagI,49280
-ripple_down_rules/rdr_decorators.py,sha256=bmn4h4a7xujTVxu-ofECe71cM_6iiqZhLVFosEItid4,7602
-ripple_down_rules/rules.py,sha256=TPNVMqW9T-_46BS4WemrspLg5uG8kP6tsPvWWBAzJxg,17515
-ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=N5Rgz7wb9oKrVLZiJG2P-irnsjhy7VR3Vqyggf4Mq7I,51564
-ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=f3wUPTrLa1INO-1qfgVz87ryrCABronfyq0_JKWoZCs,12800
-ripple_down_rules/datastructures/case.py,sha256=r8kjL9xP_wk84ThXusspgPMrAoed2bGQmKi54fzhmH8,15258
-ripple_down_rules/datastructures/dataclasses.py,sha256=PuD-7zWqWT2p4FnGvnihHvZlZKg9A1ctnFgVYf2cs-8,8554
-ripple_down_rules/datastructures/enums.py,sha256=ce7tqS0otfSTNAOwsnXlhsvIn4iW_Y_N3TNebF3YoZs,5700
-ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/user_interface/gui.py,sha256=jRRyQxgU_RK2e_wgi2gPag_FB8UCYOAXicRTk8_JWgo,27232
-ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=24MIFwqnAhC6ofObEO6x5xRWRnyQmPpPmTvxbCKBrzM,6514
-ripple_down_rules/user_interface/object_diagram.py,sha256=tsB6iuLNEbHxp5lR2WjyejjWbnAX_nHF9xS8jNPOQVk,4548
-ripple_down_rules/user_interface/prompt.py,sha256=AkkltdDIaioN43lkRKDPKSjJcmdSSGZDMYz7AL7X9lE,8082
-ripple_down_rules/user_interface/template_file_creator.py,sha256=FGtLfYBfr4310c7Dfa9b2qiOWLNzHk1q3kdhD70Ilg4,13804
-ripple_down_rules-0.5.62.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.5.62.dist-info/METADATA,sha256=6s7Y4pSt63IEgGQu_87ZOAX6XcFK9i67rJkIDSTZfoU,48189
-ripple_down_rules-0.5.62.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.5.62.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.5.62.dist-info/RECORD,,