ripple-down-rules 0.6.23__py3-none-any.whl → 0.6.25__py3-none-any.whl

ripple_down_rules/__init__.py

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

ripple_down_rules/datastructures/callable_expression.py

@@ -95,7 +95,7 @@ class CallableExpression(SubclassJSONSerializer):
     encapsulating_function_name: str = "_get_value"
 
     def __init__(self, user_input: Optional[str] = None,
-                 conclusion_type: Optional[Tuple[Type]] = None,
+                 conclusion_type: Optional[Tuple[Type, ...]] = None,
                  expression_tree: Optional[AST] = None,
                  scope: Optional[Dict[str, Any]] = None,
                  conclusion: Optional[Any] = None,
@@ -176,7 +176,8 @@ class CallableExpression(SubclassJSONSerializer):
         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)
+        return CallableExpression(new_user_input, conclusion_type=self.conclusion_type,
+         mutually_exclusive=self.mutually_exclusive)
 
     def update_user_input_from_file(self, file_path: str, function_name: str):
         """

ripple_down_rules/datastructures/dataclasses.py

@@ -31,7 +31,7 @@ class CaseQuery:
     """
     The name of the attribute.
     """
-    _attribute_types: Tuple[Type]
+    _attribute_types: Tuple[Type, ...]
     """
     The type(s) of the attribute.
     """
@@ -139,7 +139,7 @@ class CaseQuery:
             attribute_types_str = f"Union[{', '.join([t.__name__ for t in self.core_attribute_type])}]"
         else:
             attribute_types_str = self.core_attribute_type[0].__name__
-        if all(t in self.attribute_type for t in [list, set]) and len(self.core_attribute_type) > 2:
+        if not self.mutually_exclusive:
             return f"List[{attribute_types_str}]"
         else:
             return attribute_types_str

ripple_down_rules/datastructures/enums.py

@@ -196,7 +196,10 @@ class RDREdge(Enum):
     """
     Next edge, the edge that represents the next rule to be evaluated.
     """
-
+    Filter = "filter if"
+    """
+    Filter edge, the edge that represents the filter condition.
+    """
 
 class ValueType(Enum):
     Unary = auto()

ripple_down_rules/experts.py

@@ -41,14 +41,14 @@ class Expert(ABC):
     A flag to indicate if the expert should use loaded answers or not.
     """
 
-    def __init__(self, use_loaded_answers: bool = True,
+    def __init__(self, use_loaded_answers: bool = False,
                  append: bool = False,
                  answers_save_path: Optional[str] = None):
         self.all_expert_answers = []
         self.use_loaded_answers = use_loaded_answers
         self.append = append
         self.answers_save_path = answers_save_path
-        if answers_save_path is not None:
+        if answers_save_path is not None and os.path.exists(answers_save_path + '.py'):
             if use_loaded_answers:
                 self.load_answers(answers_save_path)
             else:

ripple_down_rules/helpers.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 
 import os
 from types import ModuleType
+from typing import Tuple
 
-from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
-
-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 .datastructures.case import create_case, Case
+from .datastructures.dataclasses import CaseQuery
 from .utils import calculate_precision_and_recall
+from .utils import get_func_rdr_model_name, copy_case, make_set, update_case
 
 if TYPE_CHECKING:
     from .rdr import RippleDownRules
@@ -55,12 +54,14 @@ def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDow
             if attribute_name in new_conclusions:
                 temp_case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, rdr.mutually_exclusive)
                 update_case(temp_case_query, new_conclusions)
-        if len(new_conclusions) == 0 or len(classifiers_dict) == 1 and list(classifiers_dict.values())[0].mutually_exclusive:
+        if len(new_conclusions) == 0 or len(classifiers_dict) == 1 and list(classifiers_dict.values())[
+            0].mutually_exclusive:
             break
     return conclusions
 
 
-def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+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.
@@ -95,3 +96,23 @@ def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDow
     else:
         rdr = rdr_type(**rdr_kwargs)
     return rdr
+
+
+def get_an_updated_case_copy(case: Case, conclusion: Callable, attribute_name: str, conclusion_type: Tuple[Type, ...],
+                             mutually_exclusive: bool) -> Case:
+    """
+    :param case: The case to copy and update.
+    :param conclusion: The conclusion to add to the case.
+    :param attribute_name: The name of the attribute to update.
+    :param conclusion_type: The type of the conclusion to update.
+    :param mutually_exclusive: Whether the rule belongs to a mutually exclusive RDR.
+    :return: A copy of the case updated with the given conclusion.
+    """
+    case_cp = copy_case(case)
+    temp_case_query = CaseQuery(case_cp, attribute_name, conclusion_type,
+                                mutually_exclusive=mutually_exclusive)
+    output = conclusion(case_cp)
+    if not isinstance(output, Dict):
+        output = {attribute_name: output}
+    update_case(temp_case_query, output)
+    return case_cp

ripple_down_rules/rdr.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import importlib
+import json
 import os
 from abc import ABC, abstractmethod
 from copy import copy
+from dataclasses import is_dataclass
 from types import NoneType
 
 from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
@@ -27,15 +29,16 @@ 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, general_rdr_classify
-from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
+from .helpers import is_matching, general_rdr_classify, get_an_updated_case_copy
+from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule, MultiClassRefinementRule, \
+    MultiClassFilterRule
 
 try:
     from .user_interface.gui import RDRCaseViewer
 except ImportError as e:
     RDRCaseViewer = None
 from .utils import draw_tree, make_set, SubclassJSONSerializer, make_list, get_type_from_string, \
-    is_conflicting, extract_function_source, extract_imports, get_full_class_name, \
+    is_value_conflicting, extract_function_source, extract_imports, get_full_class_name, \
     is_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types, render_tree
 
 
@@ -97,11 +100,12 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 self.viewer = RDRCaseViewer.instances[0]
                 logger.error("No viewer was provided, but there is already an existing viewer. "
                              "Using the existing viewer.")
+        self.input_node: Optional[Rule] = None
 
     @property
     def viewer(self):
         return self._viewer
-    
+
     @viewer.setter
     def viewer(self, value):
         self._viewer = value
@@ -110,23 +114,24 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
     def render_evaluated_rule_tree(self, filename: str, show_full_tree: bool = False) -> None:
         if show_full_tree:
-            render_tree(self.start_rule, use_dot_exporter=True, filename=filename)
+            start_rule = self.start_rule if self.input_node is None else self.input_node
+            render_tree(start_rule, use_dot_exporter=True, filename=filename)
         else:
             evaluated_rules = self.get_evaluated_rule_tree()
             if evaluated_rules is not None and len(evaluated_rules) > 0:
                 render_tree(evaluated_rules[0], use_dot_exporter=True, filename=filename,
                             only_nodes=evaluated_rules)
 
-    def get_evaluated_rule_tree(self) -> List[Rule]:
+    def get_evaluated_rule_tree(self) -> Optional[List[Rule]]:
         """
         Get the evaluated rule tree of the classifier.
 
         :return: The evaluated rule tree.
         """
         if self.start_rule is None:
-            return
-            # raise ValueError("The start rule is not set. Please set the start rule before getting the evaluated rule tree.")
-        evaluated_rule_tree = [r for r in [self.start_rule] + list(self.start_rule.descendants) if r.evaluated]
+            return None
+        start_rule = self.start_rule
+        evaluated_rule_tree = [r for r in [start_rule] + list(start_rule.descendants) if r.evaluated]
         return evaluated_rule_tree
 
     def save(self, save_dir: Optional[str] = None, model_name: Optional[str] = None,
@@ -260,9 +265,38 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     def __call__(self, case: Union[Case, SQLTable]) -> Union[CallableExpression, Dict[str, CallableExpression]]:
         return self.classify(case)
 
+    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False, case_query: Optional[CaseQuery] = None) \
+            -> Optional[Union[CallableExpression, Dict[str, CallableExpression]]]:
+        """
+        Classify a case using the RDR classifier.
+
+        :param case: The case to classify.
+        :param modify_case: Whether to modify the original case attributes with the conclusion or not.
+        :param case_query: The case query containing the case to classify and the target category to compare the case with.
+        :return: The category that the case belongs to.
+        """
+        if self.start_rule is not None:
+            for rule in [self.start_rule] + list(self.start_rule.descendants):
+                rule.evaluated = False
+                rule.fired = False
+        if self.start_rule is not None and self.start_rule.parent is None:
+            if self.input_node is None:
+                self.input_node = type(self.start_rule)(parent=None, uid='0')
+                self.input_node.evaluated = False
+                self.input_node.fired = False
+            self.start_rule.parent = self.input_node
+            self.start_rule.weight = ""
+        if self.input_node is not None:
+            data = case.__dict__ if is_dataclass(case) else case
+            if hasattr(case, "items"):
+                self.input_node.name = json.dumps({k: str(v) for k, v in data.items()}, indent=4)
+            else:
+                self.input_node.name = str(data)
+        return self._classify(case, modify_case=modify_case, case_query=case_query)
+
     @abstractmethod
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) \
+    def _classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) \
             -> Optional[Union[CallableExpression, Dict[str, CallableExpression]]]:
         """
         Classify a case.
@@ -467,25 +501,51 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         conclusion_func_names = [f'conclusion_{rid}' for rid in rules_dict.keys()
                                  if not isinstance(rules_dict[rid], MultiClassStopRule)]
         all_func_names = condition_func_names + conclusion_func_names
+        rule_tree_file_path = f"{model_dir}/{self.generated_python_file_name}.py"
         filepath = f"{model_dir}/{self.generated_python_defs_file_name}.py"
         cases_path = f"{model_dir}/{self.generated_python_cases_file_name}.py"
         cases_import_path = get_import_path_from_path(model_dir)
         cases_import_path = f"{cases_import_path}.{self.generated_python_cases_file_name}" if cases_import_path \
             else self.generated_python_cases_file_name
         functions_source = extract_function_source(filepath, all_func_names, include_signature=False)
+        python_rule_tree_source = ""
+        with open(rule_tree_file_path, "r") as rule_tree_source:
+            python_rule_tree_source = rule_tree_source.read()
         # get the scope from the imports in the file
         scope = extract_imports(filepath, package_name=package_name)
+        rules_not_found = set()
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             if rule.conditions is not None:
-                rule.conditions.user_input = functions_source[f"conditions_{rule.uid}"]
+                conditions_name = rule.generated_conditions_function_name
+                if conditions_name not in functions_source or conditions_name not in python_rule_tree_source:
+                    rules_not_found.add(rule)
+                    continue
+                rule.conditions.user_input = functions_source[conditions_name]
                 rule.conditions.scope = scope
                 if os.path.exists(cases_path):
                     module = importlib.import_module(cases_import_path, package=package_name)
                     importlib.reload(module)
                     rule.corner_case_metadata = module.__dict__.get(f"corner_case_{rule.uid}", None)
-            if rule.conclusion is not None and not isinstance(rule, MultiClassStopRule):
-                rule.conclusion.user_input = functions_source[f"conclusion_{rule.uid}"]
+            if not isinstance(rule, MultiClassStopRule):
+                conclusion_name = rule.generated_conclusion_function_name
+                if conclusion_name not in functions_source or conclusion_name not in python_rule_tree_source:
+                    rules_not_found.add(rule)
+                rule.conclusion.user_input = functions_source[conclusion_name]
                 rule.conclusion.scope = scope
+        for rule in rules_not_found:
+            if isinstance(rule, MultiClassTopRule):
+                import pdb; pdb.set_trace()
+                rule.parent.set_immediate_alternative(rule.alternative)
+                if rule.refinement is not None:
+                    ref_rules = [ref_rule for ref_rule in [rule.refinement] + list(rule.refinement.descendants)]
+                    for ref_rule in ref_rules:
+                        del ref_rule
+            else:
+                rule.parent.refinement = rule.alternative
+            if rule.alternative is not None:
+                rule.alternative = None
+            rule.parent = None
+            del rule
 
     @abstractmethod
     def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = "",
@@ -564,7 +624,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         pass
 
-    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+    def _get_types_to_import(self) -> Tuple[Set[Union[Type, Callable]], Set[Type], Set[Type]]:
         """
         :return: The types of the main, defs, and corner cases files of the RDR classifier that will be imported.
         """
@@ -703,8 +763,8 @@ class SingleClassRDR(RDRWithCodeWriter):
             expert.ask_for_conditions(case_query)
             self.start_rule = SingleClassRule.from_case_query(case_query)
 
-    def classify(self, case: Case, modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Optional[Any]:
+    def _classify(self, case: Case, modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> Optional[Any]:
         """
         Classify a case by recursively evaluating the rules until a rule fires or the last rule is reached.
 
@@ -818,8 +878,8 @@ class MultiClassRDR(RDRWithCodeWriter):
         super(MultiClassRDR, self).__init__(start_rule, **kwargs)
         self.mode: MCRDRMode = mode
 
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Set[Any]:
+    def _classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> Set[Any]:
         evaluated_rule = self.start_rule
         self.conclusions = []
         while evaluated_rule:
@@ -897,6 +957,9 @@ class MultiClassRDR(RDRWithCodeWriter):
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, filename, parent_indent, defs_file=defs_file,
                                                         cases_file=cases_file, package_name=package_name)
+            elif isinstance(rule, MultiClassTopRule):
+                with open(filename, "a") as file:
+                    file.write(f"{parent_indent}return conclusions\n")
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -906,8 +969,9 @@ class MultiClassRDR(RDRWithCodeWriter):
         else:
             return f"Set[Union[{', '.join(conclusion_types)}]]"
 
-    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+    def _get_types_to_import(self) -> Tuple[Set[Union[Type, Callable]], Set[Type], Set[Type]]:
         main_types, defs_types, cases_types = super()._get_types_to_import()
+        main_types.add(get_an_updated_case_copy)
         main_types.update({Set, make_set})
         defs_types.update({List, Set})
         return main_types, defs_types, cases_types
@@ -939,28 +1003,43 @@ class MultiClassRDR(RDRWithCodeWriter):
         Stop a wrong conclusion by adding a stopping rule.
         """
         rule_conclusion = evaluated_rule.conclusion(case_query.case)
-        if is_conflicting(rule_conclusion, case_query.target_value):
-            self.stop_conclusion(case_query, expert, evaluated_rule)
-        else:
+        stop: bool = False
+        add_filter_rule: bool = False
+        if is_value_conflicting(rule_conclusion, case_query.target_value):
+            if make_set(case_query.target_value).issubset(rule_conclusion):
+                add_filter_rule = True
+            else:
+                stop = True
+        elif make_set(case_query.core_attribute_type).issubset(make_set(evaluated_rule.conclusion.conclusion_type)):
+            if make_set(case_query.target_value).issubset(rule_conclusion):
+                add_filter_rule = True
+
+        if not stop:
             self.add_conclusion(rule_conclusion)
+        if stop or add_filter_rule:
+            refinement_type = MultiClassStopRule if stop else MultiClassFilterRule
+            self.stop_or_filter_conclusion(case_query, expert, evaluated_rule, refinement_type=refinement_type)
 
-    def stop_conclusion(self, case_query: CaseQuery,
-                        expert: Expert, evaluated_rule: MultiClassTopRule):
+    def stop_or_filter_conclusion(self, case_query: CaseQuery,
+                                  expert: Expert, evaluated_rule: MultiClassTopRule,
+                                  refinement_type: Type[MultiClassRefinementRule] = MultiClassStopRule):
         """
         Stop a conclusion by adding a stopping rule.
 
         :param case_query: The case query to stop the conclusion for.
         :param expert: The expert to ask for differentiating features as new rule conditions.
         :param evaluated_rule: The evaluated rule to ask the expert about.
+        :param refinement_type: The refinement type to use.
         """
         conditions = expert.ask_for_conditions(case_query, evaluated_rule)
-        evaluated_rule.fit_rule(case_query)
-        if self.mode == MCRDRMode.StopPlusRule:
-            self.stop_rule_conditions = conditions
-        if self.mode == MCRDRMode.StopPlusRuleCombined:
-            new_top_rule_conditions = conditions.combine_with(evaluated_rule.conditions)
-            case_query.conditions = new_top_rule_conditions
-            self.add_top_rule(case_query)
+        evaluated_rule.fit_rule(case_query, refinement_type=refinement_type)
+        if refinement_type is MultiClassStopRule:
+            if self.mode == MCRDRMode.StopPlusRule:
+                self.stop_rule_conditions = conditions
+            if self.mode == MCRDRMode.StopPlusRuleCombined:
+                new_top_rule_conditions = conditions.combine_with(evaluated_rule.conditions)
+                case_query.conditions = new_top_rule_conditions
+                self.add_top_rule(case_query)
 
     def add_rule_for_case(self, case_query: CaseQuery, expert: Expert):
         """
@@ -1064,8 +1143,8 @@ class GeneralRDR(RippleDownRules):
     def start_rules(self) -> List[Union[SingleClassRule, MultiClassTopRule]]:
         return [rdr.start_rule for rdr in self.start_rules_dict.values()]
 
-    def classify(self, case: Any, modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Optional[Dict[str, Any]]:
+    def _classify(self, case: Any, modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> Optional[Dict[str, Any]]:
         """
         Classify a case by going through all RDRs and adding the categories that are classified, and then restarting
         the classification until no more categories can be added.

ripple_down_rules/rdr_decorators.py

@@ -8,15 +8,16 @@ from functools import wraps
 
 from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union, Sequence
 
-from ripple_down_rules.datastructures.case import Case
-from ripple_down_rules.datastructures.dataclasses import CaseQuery
-from ripple_down_rules.experts import Expert, Human
-from ripple_down_rules.rdr import GeneralRDR
+from .datastructures.case import Case
+from .datastructures.dataclasses import CaseQuery
+from .experts import Expert, Human
+from .rdr import GeneralRDR
+from . import logger
 try:
-    from ripple_down_rules.user_interface.gui import RDRCaseViewer
+    from .user_interface.gui import RDRCaseViewer
 except ImportError:
     RDRCaseViewer = None
-from ripple_down_rules.utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
+from .utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
     get_method_class_if_exists, str_to_snake_case
 
 

ripple_down_rules/rules.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import logging
 import re
 from abc import ABC, abstractmethod
-from pathlib import Path
 from types import NoneType
 from uuid import uuid4
 
@@ -15,7 +14,8 @@ from .datastructures.callable_expression import CallableExpression
 from .datastructures.case import Case
 from .datastructures.dataclasses import CaseFactoryMetaData, CaseQuery
 from .datastructures.enums import RDREdge, Stop
-from .utils import SubclassJSONSerializer, conclusion_to_json, get_full_class_name, get_imports_from_types
+from .utils import SubclassJSONSerializer, conclusion_to_json, get_full_class_name, get_type_from_string
+from .helpers import get_an_updated_case_copy
 
 
 class Rule(NodeMixin, SubclassJSONSerializer, ABC):
@@ -23,6 +23,10 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
     """
     Whether the rule has fired or not.
     """
+    mutually_exclusive: bool
+    """
+    Whether the rule is mutually exclusive with other rules.
+    """
 
     def __init__(self, conditions: Optional[CallableExpression] = None,
                  conclusion: Optional[CallableExpression] = None,
@@ -60,6 +64,14 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         self.evaluated: bool = False
         self._user_defined_name: Optional[str] = None
 
+    def get_an_updated_case_copy(self, case: Case) -> Case:
+        """
+        :param case: The case to copy and update.
+        :return: A copy of the case updated with this rule conclusion.
+        """
+        return get_an_updated_case_copy(case, self.conclusion, self.conclusion_name, self.conclusion.conclusion_type,
+                                        self.mutually_exclusive)
+
     @property
     def color(self) -> str:
         if self.evaluated:
@@ -78,22 +90,27 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         if self._user_defined_name is None:
             if self.conditions and self.conditions.user_input and "def " in self.conditions.user_input:
                 # If the conditions have a user input, use it as the name
-                self._user_defined_name = self.conditions.user_input.split('(')[0].replace('def ', '').strip()
+                func_name = self.conditions.user_input.split('(')[0].replace('def ', '').strip()
+                if func_name == self.conditions.encapsulating_function_name:
+                    self._user_defined_name = str(self.conditions)
+                else:
+                    self._user_defined_name = func_name
             else:
                 self._user_defined_name = f"Rule_{self.uid}"
         return self._user_defined_name
 
     @classmethod
-    def from_case_query(cls, case_query: CaseQuery) -> Rule:
+    def from_case_query(cls, case_query: CaseQuery, parent: Optional[Rule] = None) -> Rule:
         """
         Create a SingleClassRule from a CaseQuery.
 
         :param case_query: The CaseQuery to create the rule from.
+        :param parent: The parent rule of this rule.
         :return: A SingleClassRule instance.
         """
         corner_case_metadata = CaseFactoryMetaData.from_case_query(case_query)
         return cls(conditions=case_query.conditions, conclusion=case_query.target,
-                   corner_case=case_query.case, parent=None,
+                   corner_case=case_query.case, parent=parent,
                    corner_case_metadata=corner_case_metadata,
                    conclusion_name=case_query.attribute_name)
 
@@ -116,9 +133,6 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         :param x: The case to evaluate the rule on.
         :return: The rule that fired or the last evaluated rule if no rule fired.
         """
-        if self.root is self:
-            for descendant in self.descendants:
-                descendant.evaluated = False
         self.evaluated = True
         if not self.conditions:
             raise ValueError("Rule has no conditions")
@@ -178,6 +192,14 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                 f.write(conclusion_func.strip() + "\n\n\n")
         return conclusion_func_call
 
+    @property
+    def generated_conclusion_function_name(self) -> str:
+        return f"conclusion_{self.uid}"
+
+    @property
+    def generated_conditions_function_name(self) -> str:
+        return f"conditions_{self.uid}"
+
     def get_conclusion_as_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
         """
         Convert the conclusion of a rule to source code.
@@ -190,23 +212,24 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             # This means the conclusion is a definition that should be written and then called
             conclusion_lines = conclusion.split('\n')
             # use regex to replace the function name
-            new_function_name = f"def conclusion_{self.uid}"
+            new_function_name = f"def {self.generated_conclusion_function_name}"
             conclusion_lines[0] = re.sub(r"def (\w+)", new_function_name, conclusion_lines[0])
             # add type hint
-            if len(self.conclusion.conclusion_type) == 1:
-                hint = self.conclusion.conclusion_type[0].__name__
+            if not self.conclusion.mutually_exclusive:
+                type_names = [t.__name__ for t in self.conclusion.conclusion_type if t not in [list, set]]
+                if len(type_names) == 1:
+                    hint = f"List[{type_names[0]}]"
+                else:
+                    hint = f"List[Union[{', '.join(type_names)}]]"
             else:
-                if (all(t in self.conclusion.conclusion_type for t in [list, set])
-                        and len(self.conclusion.conclusion_type) > 2):
-                    type_names = [t.__name__ for t in self.conclusion.conclusion_type if t not in [list, set]]
-                    hint = f"List[{', '.join(type_names)}]"
+                if NoneType in self.conclusion.conclusion_type:
+                    type_names = [t.__name__ for t in self.conclusion.conclusion_type if t is not NoneType]
+                    hint = f"Optional[{', '.join(type_names)}]"
+                elif len(self.conclusion.conclusion_type) == 1:
+                    hint = self.conclusion.conclusion_type[0].__name__
                 else:
-                    if NoneType in self.conclusion.conclusion_type:
-                        type_names = [t.__name__ for t in self.conclusion.conclusion_type if t is not NoneType]
-                        hint = f"Optional[{', '.join(type_names)}]"
-                    else:
-                        type_names = [t.__name__ for t in self.conclusion.conclusion_type]
-                        hint = f"Union[{', '.join(type_names)}]"
+                    type_names = [t.__name__ for t in self.conclusion.conclusion_type]
+                    hint = f"Union[{', '.join(type_names)}]"
             conclusion_lines[0] = conclusion_lines[0].replace("):", f") -> {hint}:")
             func_call = f"{parent_indent}    return {new_function_name.replace('def ', '')}(case)\n"
             return "\n".join(conclusion_lines).strip(' '), func_call
@@ -228,7 +251,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             # This means the conditions are a definition that should be written and then called
             conditions_lines = self.conditions.user_input.split('\n')
             # use regex to replace the function name
-            new_function_name = f"def conditions_{self.uid}"
+            new_function_name = f"def {self.generated_conditions_function_name}"
             conditions_lines[0] = re.sub(r"def (\w+)", new_function_name, conditions_lines[0])
             # add type hint
             conditions_lines[0] = conditions_lines[0].replace('):', ') -> bool:')
@@ -310,10 +333,11 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         Get the name of the expression, which is the user input of the expression if it exists,
         otherwise it is the conclusion or conditions of the rule.
         """
-        if expression.user_defined_name is not None:
+        if expression.user_defined_name is not None and expression.user_defined_name != expression.encapsulating_function_name:
             return expression.user_defined_name.strip()
-        elif expression.user_input and "def " in expression.user_input:
-            return expression.user_input.split('(')[0].replace('def ', '').strip()
+        func_name = expression.user_input.split('(')[0].replace('def ', '').strip() if "def " in expression.user_input else None
+        if func_name is not None and func_name != expression.encapsulating_function_name:
+            return func_name
         elif expression.user_input:
             return expression.user_input.strip()
         else:
@@ -350,6 +374,9 @@ class HasAlternativeRule:
     def alternative(self) -> Optional[Rule]:
         return self._alternative
 
+    def set_immediate_alternative(self, alternative: Optional[Rule]):
+        self._alternative = alternative
+
     @alternative.setter
     def alternative(self, new_rule: Rule):
         """
@@ -385,12 +412,11 @@ class HasRefinementRule:
         """
         if new_rule is None:
             return
-        new_rule.top_rule = self
         if self.refinement:
             self.refinement.alternative = new_rule
         else:
             new_rule.parent = self
-            new_rule.weight = RDREdge.Refinement.value
+            new_rule.weight = RDREdge.Refinement.value if not isinstance(new_rule, MultiClassFilterRule) else new_rule.weight
             self._refinement = new_rule
 
 
@@ -399,6 +425,8 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
     A rule in the SingleClassRDR classifier, it can have a refinement or an alternative rule or both.
     """
 
+    mutually_exclusive: bool = True
+
     def evaluate_next_rule(self, x: Case) -> SingleClassRule:
         if self.fired:
             returned_rule = self.refinement(x) if self.refinement else self
@@ -434,28 +462,15 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
         return "elif" if self.weight == RDREdge.Alternative.value else "if"
 
 
-class MultiClassStopRule(Rule, HasAlternativeRule):
+class MultiClassRefinementRule(Rule, HasAlternativeRule, ABC):
     """
-    A rule in the MultiClassRDR classifier, it can have an alternative rule and a top rule,
-    the conclusion of the rule is a Stop category meant to stop the parent conclusion from being made.
+    A rule in the MultiClassRDR classifier, it can have an alternative rule and a top rule.
     """
     top_rule: Optional[MultiClassTopRule] = None
     """
     The top rule of the rule, which is the nearest ancestor that fired and this rule is a refinement of.
     """
-
-    def __init__(self, *args, **kwargs):
-        super(MultiClassStopRule, self).__init__(*args, **kwargs)
-        self.conclusion = CallableExpression(conclusion_type=(Stop,), conclusion=Stop.stop)
-
-    def evaluate_next_rule(self, x: Case) -> Optional[Union[MultiClassStopRule, MultiClassTopRule]]:
-        if self.fired:
-            self.top_rule.fired = False
-            return self.top_rule.alternative
-        elif self.alternative:
-            return self.alternative(x)
-        else:
-            return self.top_rule.alternative
+    mutually_exclusive: bool = False
 
     def _to_json(self) -> Dict[str, Any]:
         self.json_serialization = {**Rule._to_json(self),
@@ -463,27 +478,106 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
         return self.json_serialization
 
     @classmethod
-    def _from_json(cls, data: Dict[str, Any]) -> MultiClassStopRule:
-        loaded_rule = super(MultiClassStopRule, cls)._from_json(data)
+    def _from_json(cls, data: Dict[str, Any]) -> MultiClassRefinementRule:
+        loaded_rule = super(MultiClassRefinementRule, cls)._from_json(data)
         # The following is done to prevent re-initialization of the top rule,
         # so the top rule that is already initialized is passed in the data instead of its json serialization.
         loaded_rule.top_rule = data['top_rule']
         if data['alternative'] is not None:
             data['alternative']['top_rule'] = data['top_rule']
-        loaded_rule.alternative = MultiClassStopRule.from_json(data["alternative"])
+            loaded_rule.alternative = SubclassJSONSerializer.from_json(data["alternative"])
         return loaded_rule
 
+    def _if_statement_source_code_clause(self) -> str:
+        return "elif" if self.weight == RDREdge.Alternative.value else "if"
+
+
+class MultiClassStopRule(MultiClassRefinementRule):
+    """
+    A rule in the MultiClassRDR classifier, it can have an alternative rule and a top rule,
+    the conclusion of the rule is a Stop category meant to stop the parent conclusion from being made.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(MultiClassRefinementRule, self).__init__(*args, **kwargs)
+        self.conclusion = CallableExpression(conclusion_type=(Stop,), conclusion=Stop.stop)
+
+    def evaluate_next_rule(self, x: Case) -> Optional[Union[MultiClassRefinementRule, MultiClassTopRule]]:
+        if self.fired:
+            self.top_rule.fired = False
+            return self.top_rule.alternative
+        elif self.alternative:
+            return self.alternative(x)
+        else:
+            return self.top_rule.alternative
+
     def get_conclusion_as_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[None, str]:
         return None, f"{parent_indent}{' ' * 4}pass\n"
 
-    def _if_statement_source_code_clause(self) -> str:
-        return "elif" if self.weight == RDREdge.Alternative.value else "if"
+
+class MultiClassFilterRule(MultiClassRefinementRule, HasRefinementRule):
+    """
+    A rule in the MultiClassRDR classifier, it can have an alternative rule and a top rule,
+    the conclusion of the rule is a Filter category meant to filter the parent conclusion.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(MultiClassRefinementRule, self).__init__(*args, **kwargs)
+        self.weight = RDREdge.Filter.value
+
+    def evaluate_next_rule(self, x: Case) -> Optional[Union[MultiClassRefinementRule, MultiClassTopRule]]:
+        if self.fired:
+            if self.refinement:
+                case_cp = x
+                if isinstance(self.refinement, MultiClassFilterRule):
+                    case_cp = self.get_an_updated_case_copy(case_cp)
+                return self.refinement(case_cp)
+            else:
+                return self.top_rule.alternative
+        elif self.alternative:
+            return self.alternative(x)
+        else:
+            return self.top_rule.alternative
+
+    def get_conclusion_as_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[None, str]:
+        func, func_call = super().get_conclusion_as_source_code(str(conclusion), parent_indent=parent_indent)
+        conclusion_str = func_call.replace("return ", "").strip()
+        conclusion_str = conclusion_str.replace("(case)", "(case_cp)")
+
+        parent_to_filter = self.get_parent_to_filter()
+        statement = (
+            f"\n{parent_indent}    case_cp = get_an_updated_case_copy(case, {parent_to_filter.generated_conclusion_function_name},"
+            f" attribute_name, conclusion_type, mutually_exclusive)")
+        statement += f"\n{parent_indent}    conclusions.update(make_set({conclusion_str}))\n"
+        return func, statement
+
+    def get_parent_to_filter(self, parent: Union[None, MultiClassRefinementRule, MultiClassTopRule] = None) \
+            -> Union[MultiClassFilterRule, MultiClassTopRule]:
+        parent = self.parent if parent is None else parent
+        if isinstance(parent, (MultiClassFilterRule, MultiClassTopRule)) and parent.fired:
+            return parent
+        else:
+            return parent.parent
+
+    def _to_json(self) -> Dict[str, Any]:
+        self.json_serialization = super(MultiClassFilterRule, self)._to_json()
+        self.json_serialization['refinement'] = self.refinement.to_json() if self.refinement is not None else None
+        return self.json_serialization
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> MultiClassFilterRule:
+        loaded_rule = super(MultiClassFilterRule, cls)._from_json(data)
+        if data['refinement'] is not None:
+            data['refinement']['top_rule'] = data['top_rule']
+        loaded_rule.refinement = cls.from_json(data["refinement"]) if data["refinement"] is not None else None
+        return loaded_rule
 
 
 class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
     """
     A rule in the MultiClassRDR classifier, it can have a refinement and a next rule.
     """
+    mutually_exclusive: bool = False
 
     def __init__(self, *args, **kwargs):
         super(MultiClassTopRule, self).__init__(*args, **kwargs)
@@ -491,16 +585,27 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
 
     def evaluate_next_rule(self, x: Case) -> Optional[Union[MultiClassStopRule, MultiClassTopRule]]:
         if self.fired and self.refinement:
-            return self.refinement(x)
+            case_cp = x
+            if isinstance(self.refinement, MultiClassFilterRule):
+                case_cp = self.get_an_updated_case_copy(case_cp)
+            return self.refinement(case_cp)
         elif self.alternative:  # Here alternative refers to next rule in MultiClassRDR
             return self.alternative
+        return None
 
-    def fit_rule(self, case_query: CaseQuery):
+    def fit_rule(self, case_query: CaseQuery, refinement_type: Optional[Type[MultiClassRefinementRule]] = None):
         if self.fired and case_query.target != self.conclusion:
-            self.refinement = MultiClassStopRule(case_query.conditions, corner_case=case_query.case, parent=self)
+            if refinement_type in [None, MultiClassStopRule]:
+                new_rule = MultiClassStopRule(case_query.conditions, corner_case=case_query.case,
+                                                     parent=self)
+            elif refinement_type is MultiClassFilterRule:
+                new_rule = MultiClassFilterRule.from_case_query(case_query, parent=self)
+            else:
+                raise ValueError(f"Unknown refinement type {refinement_type}")
+            new_rule.top_rule = self
+            self.refinement = new_rule
         elif not self.fired:
-            self.alternative = MultiClassTopRule(case_query.conditions, case_query.target,
-                                                 corner_case=case_query.case, parent=self)
+            self.alternative = MultiClassTopRule.from_case_query(case_query, parent=self)
 
     def _to_json(self) -> Dict[str, Any]:
         self.json_serialization = {**Rule._to_json(self),
@@ -515,7 +620,8 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
         # so the top rule that is already initialized is passed in the data instead of its json serialization.
         if data['refinement'] is not None:
             data['refinement']['top_rule'] = loaded_rule
-        loaded_rule.refinement = MultiClassStopRule.from_json(data["refinement"])
+            data_type = get_type_from_string(data["refinement"]["_type"])
+            loaded_rule.refinement = data_type.from_json(data["refinement"])
         loaded_rule.alternative = MultiClassTopRule.from_json(data["alternative"])
         return loaded_rule
 
@@ -524,8 +630,6 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
         conclusion_str = func_call.replace("return ", "").strip()
 
         statement = f"{parent_indent}    conclusions.update(make_set({conclusion_str}))\n"
-        if self.alternative is None:
-            statement += f"{parent_indent}return conclusions\n"
         return func, statement
 
     def _if_statement_source_code_clause(self) -> str:

ripple_down_rules/user_interface/prompt.py

@@ -50,6 +50,7 @@ class UserPrompt:
         :return: A callable expression that takes a case and executes user expression on it.
         """
         prev_user_input: Optional[str] = None
+        user_input_to_modify: Optional[str] = None
         callable_expression: Optional[CallableExpression] = None
         while True:
             with self.shell_lock:
@@ -69,12 +70,14 @@ class UserPrompt:
             conclusion_type = bool if prompt_for == PromptFor.Conditions else case_query.attribute_type
             callable_expression = CallableExpression(user_input, conclusion_type, expression_tree=expression_tree,
                                                      scope=case_query.scope,
-                                                      mutually_exclusive=case_query.mutually_exclusive)
+                                                     mutually_exclusive=case_query.mutually_exclusive)
             try:
                 result = callable_expression(case_query.case)
-                if len(make_list(result)) == 0:
+                if len(make_list(result)) == 0 and (user_input_to_modify is not None
+                                                    and (prev_user_input != user_input_to_modify)):
+                    user_input_to_modify = prev_user_input
                     self.print_func(f"{Fore.YELLOW}The given expression gave an empty result for case {case_query.name}."
-                          f" Please modify!{Style.RESET_ALL}")
+                          f" Please accept or modify!{Style.RESET_ALL}")
                     continue
                 break
             except Exception as e:

ripple_down_rules/utils.py

@@ -8,6 +8,7 @@ import json
 import logging
 import os
 import re
+import shutil
 import sys
 import threading
 import uuid
@@ -24,6 +25,7 @@ from types import NoneType
 
 import six
 from sqlalchemy.exc import NoInspectionAvailable
+from src.pycram.ros import logwarn
 
 try:
     import matplotlib
@@ -44,12 +46,12 @@ except ImportError as e:
 
 import requests
 from anytree import Node, RenderTree, PreOrderIter
-from anytree.exporter import DotExporter
 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, ForwardRef, Iterable
+from . import logger
 
 if TYPE_CHECKING:
     from .datastructures.case import Case
@@ -180,8 +182,8 @@ def extract_function_source(file_path: str,
             if (len(functions_source) >= len(function_names)) and (not len(function_names) == 0):
                 break
     if len(functions_source) < len(function_names):
-        raise ValueError(f"Could not find all functions in {file_path}: {function_names} not found,"
-                         f"functions not found: {set(function_names) - set(functions_source.keys())}")
+        logwarn(f"Could not find all functions in {file_path}: {function_names} not found, "
+                f"functions not found: {set(function_names) - set(functions_source.keys())}")
     if return_line_numbers:
         return functions_source, line_numbers
     return functions_source
@@ -285,7 +287,7 @@ def update_case(case_query: CaseQuery, conclusions: Dict[str, Any]):
         case_query.case.update(conclusions)
 
 
-def is_conflicting(conclusion: Any, target: Any) -> bool:
+def is_value_conflicting(conclusion: Any, target: Any) -> bool:
     """
     :param conclusion: The conclusion to check.
     :param target: The target to compare the conclusion with.
@@ -845,10 +847,12 @@ def get_relative_import(target_file_path, imported_module_path: Optional[str] =
     imported_file_name = Path(imported_module_path).name
     target_file_name = Path(target_file_path).name
     if package_name is not None:
-        target_path = Path(get_path_starting_from_latest_encounter_of(str(target_path), package_name, [target_file_name]))
+        target_path = Path(
+            get_path_starting_from_latest_encounter_of(str(target_path), package_name, [target_file_name]))
     imported_path = Path(imported_module_path).resolve()
     if package_name is not None:
-        imported_path = Path(get_path_starting_from_latest_encounter_of(str(imported_path), package_name, [imported_file_name]))
+        imported_path = Path(
+            get_path_starting_from_latest_encounter_of(str(imported_path), package_name, [imported_file_name]))
 
     # Compute relative path from target to imported module
     rel_path = os.path.relpath(imported_path.parent, target_path.parent)
@@ -925,8 +929,8 @@ def get_imports_from_types(type_objs: Iterable[Type],
                 continue
             if name == "NoneType":
                 module = "types"
-            if module is None or module == 'builtins' or module.startswith('_')\
-                or module in sys.builtin_module_names or module in excluded_modules or "<" in module \
+            if module is None or module == 'builtins' or module.startswith('_') \
+                    or module in sys.builtin_module_names or module in excluded_modules or "<" in module \
                     or name in exclueded_names:
                 continue
             if module == "typing":
@@ -1216,7 +1220,8 @@ class SubclassJSONSerializer:
             return cls._from_json(data)
         for subclass in recursive_subclasses(SubclassJSONSerializer):
             if get_full_class_name(subclass) == data["_type"]:
-                subclass_data = deepcopy(data)
+                # subclass_data = deepcopy(data)
+                subclass_data = data
                 subclass_data.pop("_type")
                 return subclass._from_json(subclass_data)
 
@@ -1408,7 +1413,11 @@ def table_rows_as_str(row_dicts: List[Dict[str, Any]], columns_per_row: int = 20
     row_values = [list(map(lambda v: v[:max_line_sze] + '...' if len(v) > max_line_sze else v, row)) for row in
                   row_values]
     row_values = [list(map(lambda v: v.lower() if v in ["True", "False"] else v, row)) for row in row_values]
-    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=[max_line_sze] * 2)
+    # Step 1: Get terminal size
+    terminal_width = shutil.get_terminal_size((80, 20)).columns
+    # Step 2: Dynamically calculate max width per column (simple approximation)
+    max_col_width = terminal_width // len(row_values[0])
+    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=max_col_width)  # [max_line_sze] * 2)
     all_table_rows.append(table)
     return "\n".join(all_table_rows)
 
@@ -1628,12 +1637,14 @@ def edge_attr_setter(parent, child):
     """
     Set the edge attributes for the dot exporter.
     """
-    if child and hasattr(child, "weight") and child.weight:
+    if child and hasattr(child, "weight") and child.weight is not None:
         return f'style="bold", label=" {child.weight}"'
     return ""
 
 
 _RE_ESC = re.compile(r'["\\]')
+
+
 class FilteredDotExporter(object):
 
     def __init__(self, node, include_nodes=None, graph="digraph", name="tree", options=None,
@@ -1913,7 +1924,7 @@ class FilteredDotExporter(object):
 
 
 def render_tree(root: Node, use_dot_exporter: bool = False,
-                filename: str = "scrdr", only_nodes: List[Node] = None):
+                filename: str = "scrdr", only_nodes: List[Node] = None, show_in_console: bool = False):
     """
     Render the tree using the console and optionally export it to a dot file.
 
@@ -1921,12 +1932,16 @@ def render_tree(root: Node, use_dot_exporter: bool = False,
     :param use_dot_exporter: Whether to export the tree to a dot file.
     :param filename: The name of the file to export the tree to.
     :param only_nodes: A list of nodes to include in the dot export.
+    :param show_in_console: Whether to print the tree to the console.
     """
     if not root:
-        logging.warning("No rules to render")
+        logger.warning("No rules to render")
         return
-    # for pre, _, node in RenderTree(root):
-    #     print(f"{pre}{node.weight if hasattr(node, 'weight') and node.weight else ''} {node.__str__()}")
+    if show_in_console:
+        for pre, _, node in RenderTree(root):
+            if only_nodes is not None and node not in only_nodes:
+                continue
+            print(f"{pre}{node.weight if hasattr(node, 'weight') and node.weight else ''} {node.__str__()}")
     if use_dot_exporter:
         unique_node_names = get_unique_node_names_func(root)
 

{ripple_down_rules-0.6.23.dist-info → ripple_down_rules-0.6.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.23
+Version: 0.6.25
 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.6.25.dist-info/RECORD

@@ -0,0 +1,24 @@
+ripple_down_rules/__init__.py,sha256=hhuChAaI4pksG6FgW6-mLaJhifqkw_2Dy21ccjHfIFs,100
+ripple_down_rules/experts.py,sha256=MYK1-vuvU1Stp82YZa8TcwOzvriIiYb0WrPFpWUNnXc,13005
+ripple_down_rules/helpers.py,sha256=X1psHOqrb4_xYN4ssQNB8S9aRKKsqgihAyWJurN0dqk,5499
+ripple_down_rules/rdr.py,sha256=avufEkijvJQCji1S5O1zaDSS7aIoP7Yjefy_4uK1TII,62125
+ripple_down_rules/rdr_decorators.py,sha256=TRhbaB_ZIXN0n8Up19NI43_mMjmTm24qo8axAAOzbxM,11728
+ripple_down_rules/rules.py,sha256=N4dEx-xyqxGZpoEYzRd9P5u97_DcDEVLY_UiNhZ4E7g,28726
+ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
+ripple_down_rules/utils.py,sha256=CD-J33gKHUSGU-hZdVvlGtCvsuID7b1pirv5ejpkEP0,73891
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=P3o-z54Jt4rtIczeFWiuHFTNqMzYEOm94OyOP535D6Q,13378
+ripple_down_rules/datastructures/case.py,sha256=PJ7_-AdxYic6BO5z816piFODj6nU5J6Jt1YzTFH-dds,15510
+ripple_down_rules/datastructures/dataclasses.py,sha256=kI3Kv8GiVR8igMgA_BlKN6djUYxC2mLecvyh19pqQQA,10998
+ripple_down_rules/datastructures/enums.py,sha256=R9AkhMKTDErOSZ8J6gEdh2lQ0Bjsxs22eMBtCPrXosI,5804
+ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/user_interface/gui.py,sha256=druufu9cVeVUajPW-RqGW3ZiEbgdgNBQD2CLhadQo18,27486
+ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=yp-F8YRWGhj1PLB33HE6vJkdYWFN5Zn2244S2DUWRTM,6576
+ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
+ripple_down_rules/user_interface/prompt.py,sha256=e5FzVfiIagwKTK3WCKsHvWaWZ4kb8FP8X-SgieTln6E,9156
+ripple_down_rules/user_interface/template_file_creator.py,sha256=kwBbFLyN6Yx2NTIHPSwOoytWgbJDYhgrUOVFw_jkDQ4,13522
+ripple_down_rules-0.6.25.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.6.25.dist-info/METADATA,sha256=OCHGDEQ_jkpOq8iUIZONmvsMGXHPdsfzfuTSZOJUb_k,48294
+ripple_down_rules-0.6.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.6.25.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.6.25.dist-info/RECORD,,

ripple_down_rules-0.6.23.dist-info/RECORD

@@ -1,24 +0,0 @@
-ripple_down_rules/__init__.py,sha256=Y8dJbmLSU5jLm9E0jiReo5eIcp03jmLvx6sNfRfi49M,100
-ripple_down_rules/experts.py,sha256=4-dMIVeMzFXCLYl_XBG_P7_Xs4sZih9-vZxCIPri6dA,12958
-ripple_down_rules/helpers.py,sha256=RUdfiSWMZjGwCxuCy44TcEJf2UNAFlPJusgHzuAs6qI,4583
-ripple_down_rules/rdr.py,sha256=sibe0amvb2MuVFRGjADgel6a-K0bp8fpJQRLnRuYW-k,57803
-ripple_down_rules/rdr_decorators.py,sha256=0xVM-yRZJ6BrpyMfQNBuFUKT_-me6tbd4UTgG5Exx2g,11809
-ripple_down_rules/rules.py,sha256=2d2Fgo5urVvUoIJWdRyaojcFBj_lfhLZaBVrXwb5KLA,23764
-ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=VM8vrshOJIqXAY48dghu86KSGpYQoGGDMEiq3GrLXsQ,73319
-ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=ysK-4JmZ4oSUTJC7zpo_o77g4ONxPDEcIpSWggsnx3c,13320
-ripple_down_rules/datastructures/case.py,sha256=PJ7_-AdxYic6BO5z816piFODj6nU5J6Jt1YzTFH-dds,15510
-ripple_down_rules/datastructures/dataclasses.py,sha256=D-nrVEW_27njmDGkyiHRnq5lmqEdO8RHKnLb1mdnwrA,11054
-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=druufu9cVeVUajPW-RqGW3ZiEbgdgNBQD2CLhadQo18,27486
-ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=yp-F8YRWGhj1PLB33HE6vJkdYWFN5Zn2244S2DUWRTM,6576
-ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
-ripple_down_rules/user_interface/prompt.py,sha256=JceEUGYsd0lIvd-v2y3D3swoo96_C0lxfp3CxM7Vfts,8900
-ripple_down_rules/user_interface/template_file_creator.py,sha256=kwBbFLyN6Yx2NTIHPSwOoytWgbJDYhgrUOVFw_jkDQ4,13522
-ripple_down_rules-0.6.23.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.6.23.dist-info/METADATA,sha256=5B9P3h5EyJEZvyuj7CtFVNeJxQOg8kjG7pQJfoVlAqs,48294
-ripple_down_rules-0.6.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.6.23.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.6.23.dist-info/RECORD,,