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

ripple_down_rules/__init__.py

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

ripple_down_rules/datastructures/dataclasses.py

@@ -5,9 +5,11 @@ import typing
 from dataclasses import dataclass, field
 
 import typing_extensions
+from omegaconf import MISSING
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, get_origin, Set
+from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, get_origin, Set, Callable
 
+from ..utils import get_method_name, get_function_import_data, get_function_representation
 from .callable_expression import CallableExpression
 from .case import create_case, Case
 from ..utils import copy_case, make_list, make_set, get_origin_and_args_from_type_hint, get_value_type_from_type_hint, \
@@ -37,6 +39,24 @@ class CaseQuery:
     """
     Whether the attribute can only take one value (i.e. True) or multiple values (i.e. False).
     """
+    case_factory: Optional[Callable[[], Any]] = None
+    """
+    The factory method that can be used to recreate the original case.
+    """
+    case_factory_idx: Optional[int] = None
+    """
+    This is used when the case factory is a list of cases, this index is used to select the case from the list.
+    """
+    case_conf: Optional[CaseConf] = None
+    """
+    The case configuration that is used to (re)create the original case, recommended to be used when you want to 
+    the case to persist in the rule base, this would allow it to be used for merging with other similar conclusion RDRs.
+    """
+    scenario: Optional[Callable] = None
+    """
+    The executable scenario is the root callable that recreates the situation that the case is 
+    created in, for example, when the case is created from a test function, this would be the test function itself.
+    """
     _target: Optional[CallableExpression] = None
     """
     The target expression of the attribute.
@@ -225,4 +245,43 @@ class CaseQuery:
                          self.mutually_exclusive, _target=self.target, default_value=self.default_value,
                          scope=self.scope, _case=copy_case(self.case), _target_value=self.target_value,
                          conditions=self.conditions, is_function=self.is_function,
-                         function_args_type_hints=self.function_args_type_hints)
+                         function_args_type_hints=self.function_args_type_hints,
+                         case_factory=self.case_factory, case_factory_idx=self.case_factory_idx,
+                         case_conf=self.case_conf, scenario=self.scenario)
+
+
+@dataclass
+class CaseConf:
+    factory_method: Callable[[Any], Any] = MISSING
+
+    def create(self) -> Any:
+        return self.factory_method()
+
+
+@dataclass
+class CaseFactoryMetaData:
+    factory_method: Optional[Callable[[Optional[CaseConf]], Any]] = None
+    factory_idx: Optional[int] = None
+    case_conf: Optional[CaseConf] = None
+    scenario: Optional[Callable] = None
+
+    @classmethod
+    def from_case_query(cls, case_query: CaseQuery) -> CaseFactoryMetaData:
+        return cls(factory_method=case_query.case_factory, factory_idx=case_query.case_factory_idx,
+                   case_conf=case_query.case_conf, scenario=case_query.scenario)
+
+    def __repr__(self):
+        factory_method_repr = None
+        scenario_repr = None
+        if self.factory_method is not None:
+            factory_method_repr = get_function_representation(self.factory_method)
+        if self.scenario is not None:
+            scenario_repr = get_function_representation(self.scenario)
+        return (f"CaseFactoryMetaData("
+                f"factory_method={factory_method_repr}, "
+                f"factory_idx={self.factory_idx}, "
+                f"case_conf={self.case_conf},"
+                f" scenario={scenario_repr})")
+
+    def __str__(self):
+        return self.__repr__()

ripple_down_rules/helpers.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import os
 from types import ModuleType
 
+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
@@ -15,7 +17,8 @@ if TYPE_CHECKING:
 
 
 def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
-                         case: Any, modify_original_case: bool = False) -> Dict[str, Any]:
+                         case: Any, modify_original_case: bool = False,
+                         case_query: Optional[CaseQuery] = None) -> 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.
@@ -23,6 +26,7 @@ def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDow
     :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.
+    :param case_query: The case query to extract metadata from if needed.
     :return: The categories that the case belongs to.
     """
     conclusions = {}
@@ -31,7 +35,7 @@ def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDow
     while True:
         new_conclusions = {}
         for attribute_name, rdr in classifiers_dict.items():
-            pred_atts = rdr.classify(case_cp)
+            pred_atts = rdr.classify(case_cp, case_query=case_query)
             if pred_atts is None:
                 continue
             if rdr.mutually_exclusive:
@@ -49,8 +53,8 @@ def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDow
                         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)
+                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:
             break
     return conclusions

ripple_down_rules/rdr.py

@@ -4,6 +4,8 @@ import copyreg
 import importlib
 import os
 
+from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
+
 from . import logger
 import sys
 from abc import ABC, abstractmethod
@@ -37,7 +39,7 @@ except ImportError as e:
 from .utils import draw_tree, make_set, copy_case, \
     SubclassJSONSerializer, make_list, get_type_from_string, \
     is_conflicting, get_imports_from_scope, extract_function_source, extract_imports, get_full_class_name, \
-    is_iterable, str_to_snake_case
+    is_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -112,7 +114,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         if not os.path.exists(save_dir + '/__init__.py'):
             os.makedirs(save_dir, exist_ok=True)
             with open(save_dir + '/__init__.py', 'w') as f:
-                f.write("# This is an empty __init__.py file to make the directory a package.\n")
+                f.write("from . import *\n")
         if model_name is not None:
             self.model_name = model_name
         elif self.model_name is None:
@@ -136,7 +138,11 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         model_dir = os.path.join(load_dir, model_name)
         json_file = os.path.join(model_dir, cls.metadata_folder, model_name)
         rdr = cls.from_json_file(json_file)
-        rdr.update_from_python(model_dir)
+        try:
+            rdr.update_from_python(model_dir)
+        except (FileNotFoundError, ValueError) as e:
+            logger.warning(f"Could not load the python file for the model {model_name} from {model_dir}. "
+                           f"Make sure the file exists and is valid.")
         rdr.save_dir = load_dir
         rdr.model_name = model_name
         return rdr
@@ -215,13 +221,15 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         return self.classify(case)
 
     @abstractmethod
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False) \
+    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.
 
         :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.
         """
         pass
@@ -229,6 +237,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     def fit_case(self, case_query: CaseQuery,
                  expert: Optional[Expert] = None,
                  update_existing_rules: bool = True,
+                 scenario: Optional[Callable] = None,
                  **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
@@ -239,6 +248,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :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.
+        :param scenario: The scenario at which the case was created, this is used to recreate the case if needed.
         :return: The category that the case belongs to.
         """
         if case_query is None:
@@ -247,14 +257,14 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         self.name = case_query.attribute_name if self.name is None else self.name
         self.case_type = case_query.case_type if self.case_type is None else self.case_type
         self.case_name = case_query.case_name if self.case_name is None else self.case_name
+        case_query.scenario = scenario if case_query.scenario is None else case_query.scenario
 
         expert = expert or Human(viewer=self.viewer,
                                  answers_save_path=self.save_dir + '/expert_answers'
                                  if self.save_dir else None)
-
         if case_query.target is None:
             case_query_cp = copy(case_query)
-            conclusions = self.classify(case_query_cp.case, modify_case=True)
+            conclusions = self.classify(case_query_cp.case, modify_case=True, case_query=case_query_cp)
             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
@@ -389,13 +399,11 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :return: The module that contains the rdr classifier function.
         """
         # remove from imports if exists first
-        name = f"{package_name.strip('./').replace('/', '.')}.{self.generated_python_file_name}"
-        try:
-            module = importlib.import_module(name)
-            del sys.modules[name]
-        except ModuleNotFoundError:
-            pass
-        return importlib.import_module(name).classify
+        package_name = get_import_path_from_path(package_name)
+        name = f"{package_name}.{self.generated_python_file_name}" if package_name else self.generated_python_file_name
+        module = importlib.import_module(name)
+        importlib.reload(module)
+        return module.classify
 
 
 class RDRWithCodeWriter(RippleDownRules, ABC):
@@ -411,6 +419,10 @@ 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
         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)
         # get the scope from the imports in the file
         scope = extract_imports(filepath)
@@ -418,13 +430,17 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             if rule.conditions is not None:
                 rule.conditions.user_input = functions_source[f"conditions_{rule.uid}"]
                 rule.conditions.scope = scope
+                if os.path.exists(cases_path):
+                    module = importlib.import_module(cases_import_path)
+                    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}"]
                 rule.conclusion.scope = scope
 
     @abstractmethod
     def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = "",
-                                           defs_file: Optional[str] = None):
+                                           defs_file: Optional[str] = None, cases_file: Optional[str] = None):
         """
         Write the rules as source code to a file.
 
@@ -432,6 +448,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         :param file: The file to write the source code to.
         :param parent_indent: The indentation of the parent rule.
         :param defs_file: The file to write the definitions to.
+        :param cases_file: The file to write the cases to.
         """
         pass
 
@@ -444,14 +461,19 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         os.makedirs(model_dir, exist_ok=True)
         if not os.path.exists(model_dir + '/__init__.py'):
             with open(model_dir + '/__init__.py', 'w') as f:
-                f.write("# This is an empty __init__.py file to make the directory a package.\n")
-        func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
+                f.write("from . import *\n")
+        func_def = f"def classify(case: {self.case_type.__name__}, **kwargs) -> {self.conclusion_type_hint}:\n"
         file_name = model_dir + f"/{self.generated_python_file_name}.py"
         defs_file_name = model_dir + f"/{self.generated_python_defs_file_name}.py"
+        cases_file_name = model_dir + f"/{self.generated_python_cases_file_name}.py"
         imports, defs_imports = self._get_imports()
         # clear the files first
         with open(defs_file_name, "w") as f:
             f.write(defs_imports + "\n\n")
+        case_factory_import = get_imports_from_types([CaseFactoryMetaData])
+        with open(cases_file_name, "w") as cases_f:
+            cases_f.write("# This file contains the corner cases for the rules.\n")
+            cases_f.write('\n'.join(case_factory_import) + "\n\n\n")
         with open(file_name, "w") as f:
             imports += f"from .{self.generated_python_defs_file_name} import *\n"
             f.write(imports + "\n\n")
@@ -461,7 +483,8 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             f.write(f"\n\n{func_def}")
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
-            self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4, defs_file=defs_file_name)
+        self.write_rules_as_source_code_to_file(self.start_rule, file_name, " " * 4, defs_file=defs_file_name,
+                                                cases_file=cases_file_name)
 
     @property
     @abstractmethod
@@ -510,6 +533,10 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
     def generated_python_defs_file_name(self) -> str:
         return f"{self.generated_python_file_name}_defs"
 
+    @property
+    def generated_python_cases_file_name(self) -> str:
+        return f"{self.generated_python_file_name}_cases"
+
 
     @property
     def conclusion_type(self) -> Tuple[Type]:
@@ -592,7 +619,7 @@ class SingleClassRDR(RDRWithCodeWriter):
         pred = self.evaluate(case_query.case)
         if pred.conclusion(case_query.case) != case_query.target_value:
             expert.ask_for_conditions(case_query, pred)
-            pred.fit_rule(case_query.case, case_query.target, conditions=case_query.conditions)
+            pred.fit_rule(case_query)
 
         return self.classify(case_query.case)
 
@@ -605,18 +632,24 @@ class SingleClassRDR(RDRWithCodeWriter):
         """
         if not self.start_rule:
             expert.ask_for_conditions(case_query)
-            self.start_rule = SingleClassRule(case_query.conditions, case_query.target, corner_case=case_query.case,
-                                              conclusion_name=case_query.attribute_name)
+            self.start_rule = SingleClassRule.from_case_query(case_query)
 
-    def classify(self, case: Case, modify_case: bool = False) -> 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.
 
         :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 and the target category to compare the case with.
         """
         pred = self.evaluate(case)
-        return pred.conclusion(case) if pred is not None and pred.fired else self.default_conclusion
+        conclusion = pred.conclusion(case) if pred is not None else None
+        if pred is not None and pred.fired and case_query is not None:
+            if pred.corner_case_metadata is None and conclusion is not None\
+                    and type(conclusion) in case_query.core_attribute_type:
+                pred.corner_case_metadata = CaseFactoryMetaData.from_case_query(case_query)
+        return conclusion if pred is not None and pred.fired else self.default_conclusion
 
     def evaluate(self, case: Case) -> SingleClassRule:
         """
@@ -631,23 +664,27 @@ class SingleClassRDR(RDRWithCodeWriter):
             with open(model_dir + f"/{self.generated_python_file_name}.py", "a") as f:
                 f.write(f"{' ' * 4}else:\n{' ' * 8}return {self.default_conclusion}\n")
 
-    def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file: TextIOWrapper, parent_indent: str = "",
-                                           defs_file: Optional[str] = None):
+    def write_rules_as_source_code_to_file(self, rule: SingleClassRule, filename: str, parent_indent: str = "",
+                                           defs_file: Optional[str] = None, cases_file: Optional[str] = None):
         """
         Write the rules as source code to a file.
         """
         if rule.conditions:
+            rule.write_corner_case_as_source_code(cases_file)
             if_clause = rule.write_condition_as_source_code(parent_indent, defs_file)
-            file.write(if_clause)
+            with open(filename, "a") as file:
+                file.write(if_clause)
             if rule.refinement:
-                self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
-                                                        defs_file=defs_file)
+                self.write_rules_as_source_code_to_file(rule.refinement, filename, parent_indent + "    ",
+                                                        defs_file=defs_file, cases_file=cases_file)
 
             conclusion_call = rule.write_conclusion_as_source_code(parent_indent, defs_file)
-            file.write(conclusion_call)
+            with open(filename, "a") as file:
+                file.write(conclusion_call)
 
             if rule.alternative:
-                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file)
+                self.write_rules_as_source_code_to_file(rule.alternative, filename, parent_indent, defs_file=defs_file,
+                                                        cases_file=cases_file)
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -699,13 +736,19 @@ 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) -> 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:
             next_rule = evaluated_rule(case)
             if evaluated_rule.fired:
-                self.add_conclusion(evaluated_rule, case)
+                rule_conclusion = evaluated_rule.conclusion(case)
+                if evaluated_rule.corner_case_metadata is None and case_query is not None:
+                    if rule_conclusion is not None and len(make_list(rule_conclusion)) > 0\
+                            and any(ct in case_query.core_attribute_type for ct in map(type, make_list(rule_conclusion))):
+                        evaluated_rule.corner_case_metadata = CaseFactoryMetaData.from_case_query(case_query)
+                self.add_conclusion(rule_conclusion)
             evaluated_rule = next_rule
         return make_set(self.conclusions)
 
@@ -733,7 +776,7 @@ class MultiClassRDR(RDRWithCodeWriter):
                     self.stop_wrong_conclusion_else_add_it(case_query, expert, evaluated_rule)
                 else:
                     # Rule fired and target is correct or there is no target to compare
-                    self.add_conclusion(evaluated_rule, case_query.case)
+                    self.add_conclusion(rule_conclusion)
 
             if not next_rule:
                 if not make_set(target_value).issubset(make_set(self.conclusions)):
@@ -745,24 +788,31 @@ class MultiClassRDR(RDRWithCodeWriter):
         return self.conclusions
 
     def write_rules_as_source_code_to_file(self, rule: Union[MultiClassTopRule, MultiClassStopRule],
-                                           file, parent_indent: str = "", defs_file: Optional[str] = None):
+                                           filename: str, parent_indent: str = "", defs_file: Optional[str] = None,
+                                           cases_file: Optional[str] = None):
         if rule == self.start_rule:
-            file.write(f"{parent_indent}conclusions = set()\n")
+            with open(filename, "a") as file:
+                file.write(f"{parent_indent}conclusions = set()\n")
         if rule.conditions:
+            rule.write_corner_case_as_source_code(cases_file)
             if_clause = rule.write_condition_as_source_code(parent_indent, defs_file)
-            file.write(if_clause)
+            with open(filename, "a") as file:
+                file.write(if_clause)
             conclusion_indent = parent_indent
             if hasattr(rule, "refinement") and rule.refinement:
-                self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
-                                                        defs_file=defs_file)
+                self.write_rules_as_source_code_to_file(rule.refinement, filename, parent_indent + "    ",
+                                                        defs_file=defs_file, cases_file=cases_file)
                 conclusion_indent = parent_indent + " " * 4
-                file.write(f"{conclusion_indent}else:\n")
+                with open(filename, "a") as file:
+                    file.write(f"{conclusion_indent}else:\n")
 
             conclusion_call = rule.write_conclusion_as_source_code(conclusion_indent, defs_file)
-            file.write(conclusion_call)
+            with open(filename, "a") as file:
+                file.write(conclusion_call)
 
             if rule.alternative:
-                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file)
+                self.write_rules_as_source_code_to_file(rule.alternative, filename, parent_indent, defs_file=defs_file,
+                                                        cases_file=cases_file)
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -788,8 +838,7 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         if not self.start_rule:
             conditions = expert.ask_for_conditions(case_query)
-            self.start_rule = MultiClassTopRule(conditions, case_query.target, corner_case=case_query.case,
-                                                conclusion_name=case_query.attribute_name)
+            self.start_rule = MultiClassTopRule.from_case_query(case_query)
 
     @property
     def last_top_rule(self) -> Optional[MultiClassTopRule]:
@@ -810,7 +859,7 @@ class MultiClassRDR(RDRWithCodeWriter):
         if is_conflicting(rule_conclusion, case_query.target_value):
             self.stop_conclusion(case_query, expert, evaluated_rule)
         else:
-            self.add_conclusion(evaluated_rule, case_query.case)
+            self.add_conclusion(rule_conclusion)
 
     def stop_conclusion(self, case_query: CaseQuery,
                         expert: Expert, evaluated_rule: MultiClassTopRule):
@@ -822,12 +871,13 @@ class MultiClassRDR(RDRWithCodeWriter):
         :param evaluated_rule: The evaluated rule to ask the expert about.
         """
         conditions = expert.ask_for_conditions(case_query, evaluated_rule)
-        evaluated_rule.fit_rule(case_query.case, case_query.target, conditions=conditions)
+        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)
-            self.add_top_rule(new_top_rule_conditions, case_query.target, case_query.case)
+            case_query.conditions = new_top_rule_conditions
+            self.add_top_rule(case_query)
 
     def add_rule_for_case(self, case_query: CaseQuery, expert: Expert):
         """
@@ -839,19 +889,19 @@ class MultiClassRDR(RDRWithCodeWriter):
         if self.stop_rule_conditions and self.mode == MCRDRMode.StopPlusRule:
             conditions = self.stop_rule_conditions
             self.stop_rule_conditions = None
+            case_query.conditions = conditions
         else:
             conditions = expert.ask_for_conditions(case_query)
-        self.add_top_rule(conditions, case_query.target, case_query.case)
+        self.add_top_rule(case_query)
 
-    def add_conclusion(self, evaluated_rule: Rule, case: Case) -> None:
+    def add_conclusion(self, rule_conclusion: List[Any]) -> None:
         """
         Add the conclusion of the evaluated rule to the list of conclusions.
 
-        :param evaluated_rule: The evaluated rule to add the conclusion of.
-        :param case: The case to add the conclusion for.
+        :param rule_conclusion: The conclusion of the evaluated rule, which can be a single conclusion
+         or a set of conclusions.
         """
         conclusion_types = [type(c) for c in self.conclusions]
-        rule_conclusion = evaluated_rule.conclusion(case)
         if type(rule_conclusion) not in conclusion_types:
             self.conclusions.extend(make_list(rule_conclusion))
         else:
@@ -864,15 +914,13 @@ class MultiClassRDR(RDRWithCodeWriter):
                 self.conclusions.remove(c)
             self.conclusions.extend(make_list(combined_conclusion))
 
-    def add_top_rule(self, conditions: CallableExpression, conclusion: Any, corner_case: Union[Case, SQLTable]):
+    def add_top_rule(self, case_query: CaseQuery):
         """
         Add a top rule to the classifier, which is a rule that is always checked and is part of the start_rules list.
 
-        :param conditions: The conditions of the rule.
-        :param conclusion: The conclusion of the rule.
-        :param corner_case: The corner case of the rule.
+        :param case_query: The case query to add the top rule for.
         """
-        self.start_rule.alternative = MultiClassTopRule(conditions, conclusion, corner_case=corner_case)
+        self.start_rule.alternative = MultiClassTopRule.from_case_query(case_query)
 
     @staticmethod
     def start_rule_type() -> Type[Rule]:
@@ -933,16 +981,19 @@ 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) -> 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.
 
         :param case: The case to classify.
         :param modify_case: Whether to modify the original case or create a copy and modify it.
+        :param case_query: The case query containing the case and the target category to compare the case with.
         :return: The categories that the case belongs to.
         """
-        return general_rdr_classify(self.start_rules_dict, case, modify_original_case=modify_case)
+        return general_rdr_classify(self.start_rules_dict, case, modify_original_case=modify_case,
+                                    case_query=case_query)
 
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Dict[str, Any]:
@@ -1029,7 +1080,7 @@ class GeneralRDR(RippleDownRules):
         """
         for rdr in self.start_rules_dict.values():
             rdr._write_to_python(model_dir)
-        func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
+        func_def = f"def classify(case: {self.case_type.__name__}, **kwargs) -> {self.conclusion_type_hint}:\n"
         with open(model_dir + f"/{self.generated_python_file_name}.py", "w") as f:
             f.write(self._get_imports() + "\n\n")
             f.write("classifiers_dict = dict()\n")
@@ -1039,7 +1090,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 general_rdr_classify(classifiers_dict, case)\n")
+            f.write(f"{' ' * 4}return general_rdr_classify(classifiers_dict, case, **kwargs)\n")
 
     @property
     def _default_generated_python_file_name(self) -> Optional[str]:

ripple_down_rules/rdr_decorators.py

@@ -6,17 +6,18 @@ of the RDRs.
 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, Sequence
 
-from ripple_down_rules.datastructures.case import create_case, Case
+from ripple_down_rules.datastructures.case import 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.rdr import GeneralRDR
+try:
+    from ripple_down_rules.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, \
-    get_method_class_if_exists, get_method_name, str_to_snake_case
+    get_method_class_if_exists, str_to_snake_case
 
 
 class RDRDecorator:

ripple_down_rules/rules.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 import re
 from abc import ABC, abstractmethod
+from pathlib import Path
 from uuid import uuid4
 
 from anytree import NodeMixin
@@ -11,8 +12,9 @@ from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple
 
 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
+from .utils import SubclassJSONSerializer, conclusion_to_json, get_full_class_name, get_imports_from_types
 
 
 class Rule(NodeMixin, SubclassJSONSerializer, ABC):
@@ -27,7 +29,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                  corner_case: Optional[Union[Case, SQLTable]] = None,
                  weight: Optional[str] = None,
                  conclusion_name: Optional[str] = None,
-                 uid: Optional[str] = None):
+                 uid: Optional[str] = None,
+                 corner_case_metadata: Optional[CaseFactoryMetaData] = None):
         """
         A rule in the ripple down rules classifier.
 
@@ -38,10 +41,13 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         :param weight: The weight of the rule, which is the type of edge connecting the rule to its parent.
         :param conclusion_name: The name of the conclusion of the rule.
         :param uid: The unique id of the rule.
+        :param corner_case_metadata: Metadata about the corner case, such as the factory that created it or the
+         scenario it is based on.
         """
         super(Rule, self).__init__()
         self.conclusion = conclusion
         self.corner_case = corner_case
+        self.corner_case_metadata: Optional[CaseFactoryMetaData] = corner_case_metadata
         self.parent = parent
         self.weight: Optional[str] = weight
         self.conditions = conditions if conditions else None
@@ -51,6 +57,20 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         # generate a unique id for the rule using uuid4
         self.uid: str = uid if uid else str(uuid4().int)
 
+    @classmethod
+    def from_case_query(cls, case_query: CaseQuery) -> Rule:
+        """
+        Create a SingleClassRule from a CaseQuery.
+
+        :param case_query: The CaseQuery to create the rule from.
+        :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_metadata=corner_case_metadata,
+                   conclusion_name=case_query.attribute_name)
+
     def _post_detach(self, parent):
         """
         Called after this node is detached from the tree, useful when drawing the tree.
@@ -82,6 +102,26 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         """
         pass
 
+    def write_corner_case_as_source_code(self, cases_file: Path) -> None:
+        """
+        Write the source code representation of the corner case of the rule to a file.
+
+        :param cases_file: The file to write the corner case to if it is a definition.
+        """
+        if self.corner_case_metadata is None:
+            return
+        types_to_import = set()
+        if self.corner_case_metadata.factory_method is not None:
+            types_to_import.add(self.corner_case_metadata.factory_method)
+        if self.corner_case_metadata.scenario is not None:
+            types_to_import.add(self.corner_case_metadata.scenario)
+        if self.corner_case_metadata.case_conf is not None:
+            types_to_import.add(self.corner_case_metadata.case_conf)
+        imports = get_imports_from_types(list(types_to_import))
+        with open(cases_file, 'a') as f:
+            f.write("\n".join(imports) + "\n\n\n")
+            f.write(f"corner_case_{self.uid} = {self.corner_case_metadata}" + "\n\n\n")
+
     def write_conclusion_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
         """
         Get the source code representation of the conclusion of the rule.
@@ -282,9 +322,12 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
             returned_rule = self.alternative(x) if self.alternative else self
         return returned_rule if returned_rule.fired else self
 
-    def fit_rule(self, x: Case, target: CallableExpression, conditions: CallableExpression):
-        new_rule = SingleClassRule(conditions, target,
-                                   corner_case=x, parent=self)
+    def fit_rule(self, case_query: CaseQuery):
+        corner_case_metadata = CaseFactoryMetaData.from_case_query(case_query)
+        new_rule = SingleClassRule(case_query.conditions, case_query.target,
+                                   corner_case=case_query.case, parent=self,
+                                   corner_case_metadata=corner_case_metadata,
+                                   )
         if self.fired:
             self.refinement = new_rule
         else:
@@ -368,11 +411,12 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
         elif self.alternative:  # Here alternative refers to next rule in MultiClassRDR
             return self.alternative
 
-    def fit_rule(self, x: Case, target: CallableExpression, conditions: CallableExpression):
-        if self.fired and target != self.conclusion:
-            self.refinement = MultiClassStopRule(conditions, corner_case=x, parent=self)
+    def fit_rule(self, case_query: CaseQuery):
+        if self.fired and case_query.target != self.conclusion:
+            self.refinement = MultiClassStopRule(case_query.conditions, corner_case=case_query.case, parent=self)
         elif not self.fired:
-            self.alternative = MultiClassTopRule(conditions, target, corner_case=x, parent=self)
+            self.alternative = MultiClassTopRule(case_query.conditions, case_query.target,
+                                                 corner_case=case_query.case, parent=self)
 
     def _to_json(self) -> Dict[str, Any]:
         self.json_serialization = {**Rule._to_json(self),

ripple_down_rules/utils.py

@@ -14,11 +14,13 @@ from collections import UserDict, defaultdict
 from copy import deepcopy, copy
 from dataclasses import is_dataclass, fields
 from enum import Enum
+from os.path import dirname
 from textwrap import dedent
 from types import NoneType
 
 from sqlalchemy.exc import NoInspectionAvailable
 
+
 try:
     import matplotlib
     from matplotlib import pyplot as plt
@@ -157,7 +159,7 @@ def extract_function_source(file_path: str,
                             return_line_numbers: bool = False,
                             include_signature: bool = True) \
         -> Union[Dict[str, Union[str, List[str]]],
-        Tuple[Dict[str, Union[str, List[str]]], List[Tuple[int, int]]]]:
+        Tuple[Dict[str, Union[str, List[str]]], Dict[str, Tuple[int, int]]]]:
     """
     Extract the source code of a function from a file.
 
@@ -176,7 +178,7 @@ def extract_function_source(file_path: str,
     tree = ast.parse(source)
     function_names = make_list(function_names)
     functions_source: Dict[str, Union[str, List[str]]] = {}
-    line_numbers = []
+    line_numbers: Dict[str, Tuple[int, int]] = {}
     for node in tree.body:
         if isinstance(node, ast.FunctionDef) and (node.name in function_names or len(function_names) == 0):
             # Get the line numbers of the function
@@ -184,7 +186,7 @@ def extract_function_source(file_path: str,
             func_lines = lines[node.lineno - 1:node.end_lineno]
             if not include_signature:
                 func_lines = func_lines[1:]
-            line_numbers.append((node.lineno, node.end_lineno))
+            line_numbers[node.name] = (node.lineno, node.end_lineno)
             functions_source[node.name] = dedent("\n".join(func_lines)) if join_lines else func_lines
             if (len(functions_source) >= len(function_names)) and (not len(function_names) == 0):
                 break
@@ -773,6 +775,64 @@ def get_types_to_import_from_type_hints(hints: List[Type]) -> Set[Type]:
     return to_import
 
 
+def get_import_path_from_path(path: str) -> Optional[str]:
+    """
+    Convert a file system path to a Python import path.
+
+    :param path: The file system path to convert.
+    :return: The Python import path.
+    """
+    package_name = os.path.abspath(path)
+    formated_package_name = package_name.strip('./').replace('/', '.')
+    parent_package_idx = 0
+    packages = formated_package_name.split('.')
+    for i, possible_pacakge in enumerate(reversed(packages)):
+        if i == 0:
+            current_path = package_name
+        else:
+            current_path = '/' + '/'.join(packages[:-i])
+        if os.path.exists(os.path.join(current_path, '__init__.py')):
+            parent_package_idx -= 1
+        else:
+            break
+    package_name = '.'.join(packages[parent_package_idx:]) if parent_package_idx < 0 else None
+    return package_name
+
+
+def get_function_import_data(func: Callable) -> Tuple[str, str]:
+    """
+    Get the import path of a function.
+
+    :param func: The function to get the import path for.
+    :return: The import path of the function.
+    """
+    func_name = get_method_name(func)
+    func_class_name = get_method_class_name_if_exists(func)
+    func_file_path = get_method_file_name(func)
+    func_file_name = func_file_path.split('/')[-1].split('.')[0]  # Get the file name without extension
+    func_import_path = get_import_path_from_path(dirname(func_file_path))
+    func_import_path = f"{func_import_path}.{func_file_name}" if func_import_path else func_file_name
+    if func_class_name and func_class_name != func_name:
+        func_import_name = func_class_name
+    else:
+        func_import_name = func_name
+    return func_import_path, func_import_name
+
+
+def get_function_representation(func: Callable) -> str:
+    """
+    Get a string representation of a function, including its module and class if applicable.
+
+    :param func: The function to represent.
+    :return: A string representation of the function.
+    """
+    func_name = get_method_name(func)
+    func_class_name = get_method_class_name_if_exists(func)
+    if func_class_name and func_class_name != func_name:
+        return f"{func_class_name}.{func_name}"
+    return func_name
+
+
 def get_imports_from_types(type_objs: List[Type]) -> List[str]:
     """
     Format import lines from type objects.
@@ -781,11 +841,14 @@ def get_imports_from_types(type_objs: List[Type]) -> List[str]:
     """
 
     module_to_types = defaultdict(list)
+    other_imports = []
     for tp in type_objs:
         try:
             if isinstance(tp, type) or is_typing_type(tp):
                 module = tp.__module__
                 name = tp.__qualname__
+            elif callable(tp):
+                module, name = get_function_import_data(tp)
             elif hasattr(type(tp), "__module__"):
                 module = type(tp).__module__
                 name = type(tp).__qualname__
@@ -801,6 +864,8 @@ def get_imports_from_types(type_objs: List[Type]) -> List[str]:
     for module, names in module_to_types.items():
         joined = ", ".join(sorted(set(names)))
         lines.append(f"from {module} import {joined}")
+    if other_imports:
+        lines.extend(other_imports)
     return sorted(lines)
 
 
@@ -838,7 +903,9 @@ def get_method_class_name_if_exists(method: Callable) -> Optional[str]:
     :return: The class name of the method.
     """
     if hasattr(method, "__self__"):
-        if hasattr(method.__self__, "__class__"):
+        if hasattr(method.__self__, "__name__"):
+            return method.__self__.__name__
+        elif hasattr(method.__self__, "__class__"):
             return method.__self__.__class__.__name__
     return method.__qualname__.split('.')[0] if hasattr(method, "__qualname__") else None
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.64
+Version: 0.5.75
 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
@@ -694,6 +694,7 @@ Requires-Dist: pygments
 Requires-Dist: sqlalchemy
 Requires-Dist: pandas
 Requires-Dist: pyparsing>=3.2.3
+Requires-Dist: omegaconf
 Provides-Extra: viz
 Requires-Dist: networkx>=3.1; extra == "viz"
 Requires-Dist: matplotlib>=3.7.5; extra == "viz"

{ripple_down_rules-0.5.64.dist-info → ripple_down_rules-0.5.75.dist-info}/RECORD

@@ -1,15 +1,15 @@
-ripple_down_rules/__init__.py,sha256=5qEoRYuRIypGXWagthsMrLJNOpvkBokzNKBjmYbRyEo,100
+ripple_down_rules/__init__.py,sha256=6Ze00N3Py1dmFEMGBz3jz63qsUVLz8WzFn7qx3lJnfM,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/helpers.py,sha256=v4oE7C5PfQUVJfSUs1FfLHEwrJXEHJLn4vJhJMvyCR8,4453
+ripple_down_rules/rdr.py,sha256=Mqh7lDjQu6wZUcJiJ57CZ3P0-hM4WfhFuV4s1jZnRv8,51833
+ripple_down_rules/rdr_decorators.py,sha256=0sk7izDB53lTKSB9fm33vQahmY_05FyCOWljyQOMB0U,9072
+ripple_down_rules/rules.py,sha256=ctf9yREG5l99HPFcYosjppKXTOwplZmzQbm4R1DMVaA,20107
 ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=LtZ21VSB3Au27Wf23wpDdSJMv3ABQgE1dRc2kzzQj-c,54605
+ripple_down_rules/utils.py,sha256=iwfpTlsxUqLHWpYqSKwrDnEEa_FYFHYb2LugEVDH_kk,57132
 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/dataclasses.py,sha256=qoTFHV8Hi-X8VtfC9VdvH4tif73YjF3dUe8dyHXTYts,10993
 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
@@ -17,8 +17,8 @@ ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=Jrf7NxOdlrwGXH0X
 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.75.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.75.dist-info/METADATA,sha256=M1N-k7Zp8qzOsGlF8K4n889agx_bLu_rWO9_c-cEViQ,48214
+ripple_down_rules-0.5.75.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.5.75.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.75.dist-info/RECORD,,