ripple-down-rules 0.5.5__py3-none-any.whl → 0.5.8__py3-none-any.whl

ripple_down_rules/rdr.py

@@ -1,18 +1,16 @@
 from __future__ import annotations
 
-import copyreg
 import importlib
 import os
-
-from . import logger
-import sys
 from abc import ABC, abstractmethod
 from copy import copy
-from io import TextIOWrapper
-from types import ModuleType
+
+from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
+from . import logger
 
 try:
     from matplotlib import pyplot as plt
+
     Figure = plt.Figure
 except ImportError as e:
     logger.debug(f"{e}: matplotlib is not installed")
@@ -28,16 +26,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
+from .helpers import is_matching, general_rdr_classify
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
+
 try:
     from .user_interface.gui import RDRCaseViewer
 except ImportError as e:
     RDRCaseViewer = None
-from .utils import draw_tree, make_set, copy_case, \
-    SubclassJSONSerializer, make_list, get_type_from_string, \
-    is_conflicting, update_case, get_imports_from_scope, extract_function_source, extract_imports, get_full_class_name, \
-    is_iterable, str_to_snake_case
+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_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -76,16 +74,18 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     """
     The name of the model. If None, the model name will be the generated python file name.
     """
+    mutually_exclusive: Optional[bool] = None
+    """
+    Whether the output of the classification of this rdr allows only one possible conclusion or not.
+    """
 
     def __init__(self, start_rule: Optional[Rule] = None, viewer: Optional[RDRCaseViewer] = None,
-                 save_dir: Optional[str] = None, ask_always: bool = True, model_name: Optional[str] = None):
+                 save_dir: Optional[str] = None, model_name: Optional[str] = None):
         """
         :param start_rule: The starting rule for the classifier.
         :param viewer: The viewer gui to use for the classifier. If None, no viewer is used.
         :param save_dir: The directory to save the classifier to.
-        :param ask_always: Whether to always ask the expert (True) or only ask when classification fails (False).
         """
-        self.ask_always: bool = ask_always
         self.model_name: Optional[str] = model_name
         self.save_dir = save_dir
         self.start_rule = start_rule
@@ -94,13 +94,15 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         if self.viewer is not None:
             self.viewer.set_save_function(self.save)
 
-    def save(self, save_dir: Optional[str] = None, model_name: Optional[str] = None) -> str:
+    def save(self, save_dir: Optional[str] = None, model_name: Optional[str] = None,
+             package_name: Optional[str] = None) -> str:
         """
         Save the classifier to a file.
 
         :param save_dir: The directory to save the classifier to.
         :param model_name: The name of the model to save. If None, a default name is generated.
-        :param postfix: The postfix to add to the file name.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         :return: The name of the saved model.
         """
         save_dir = save_dir or self.save_dir
@@ -110,7 +112,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:
@@ -120,31 +122,40 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         json_dir = os.path.join(model_dir, self.metadata_folder)
         os.makedirs(json_dir, exist_ok=True)
         self.to_json_file(os.path.join(json_dir, self.model_name))
-        self._write_to_python(model_dir)
+        self._write_to_python(model_dir, package_name=package_name)
         return self.model_name
 
     @classmethod
-    def load(cls, load_dir: str, model_name: str) -> Self:
+    def load(cls, load_dir: str, model_name: str,
+             package_name: Optional[str] = None) -> Self:
         """
         Load the classifier from a file.
 
         :param load_dir: The path to the model directory to load the classifier from.
         :param model_name: The name of the model to load.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         """
         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, package_name=package_name)
+        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
 
     @abstractmethod
-    def _write_to_python(self, model_dir: str):
+    def _write_to_python(self, model_dir: str, package_name: Optional[str] = None):
         """
         Write the tree of rules as source code to a file.
 
         :param model_dir: The path to the directory to write the source code to.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         """
         pass
 
@@ -213,18 +224,24 @@ 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
 
-    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
+    def fit_case(self, case_query: CaseQuery,
+                 expert: Optional[Expert] = None,
+                 update_existing_rules: bool = True,
+                 scenario: Optional[Callable] = None,
+                 **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
         Fit the classifier to a case and ask the expert for refinements or alternatives if the classification is
@@ -232,6 +249,9 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
         :param case_query: The query containing the case to classify and the target category to compare the case with.
         :param expert: The expert to ask for differentiating features as new rule conditions.
+        :param update_existing_rules: Whether to update the existing same conclusion type rules that already gave
+        some conclusions with the type required by the case query.
+        :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:
@@ -240,13 +260,15 @@ 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(answers_save_path=self.save_dir + '/expert_answers' if self.save_dir else None)
-
+        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)
-            if self.ask_always or conclusions is None or is_iterable(conclusions) and len(conclusions) == 0:
+            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
             if case_query.target is None:
@@ -262,6 +284,34 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
         return fit_case_result
 
+    @staticmethod
+    def should_i_ask_the_expert_for_a_target(conclusions: Union[Any, Dict[str, Any]],
+                                             case_query: CaseQuery,
+                                             update_existing: bool) -> bool:
+        """
+        Determine if the rdr should ask the expert for the target of a given case query.
+
+        :param conclusions: The conclusions of the case.
+        :param case_query: The query containing the case to classify.
+        :param update_existing: Whether to update rules that gave the required type of conclusions.
+        :return: True if the rdr should ask the expert, False otherwise.
+        """
+        if conclusions is None:
+            return True
+        elif is_iterable(conclusions) and len(conclusions) == 0:
+            return True
+        elif isinstance(conclusions, dict):
+            if case_query.attribute_name not in conclusions:
+                return True
+            conclusions = conclusions[case_query.attribute_name]
+        conclusion_types = map(type, make_list(conclusions))
+        if not any(ct in case_query.core_attribute_type for ct in conclusion_types):
+            return True
+        elif update_existing:
+            return True
+        else:
+            return False
+
     @abstractmethod
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
@@ -326,11 +376,13 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         pass
 
     @abstractmethod
-    def update_from_python(self, model_dir: str):
+    def update_from_python(self, model_dir: str, package_name: Optional[str] = None):
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the generated python file is located.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         """
         pass
 
@@ -352,42 +404,53 @@ 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):
 
-    def update_from_python(self, model_dir: str):
+    def update_from_python(self, model_dir: str, package_name: Optional[str] = None):
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the generated python file is located.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         """
-        rules_dict = {r.uid: r for r in [self.start_rule] + list(self.start_rule.descendants) if r.conditions is not None}
+        rules_dict = {r.uid: r for r in [self.start_rule] + list(self.start_rule.descendants)
+                      if r.conditions is not None}
         condition_func_names = [f'conditions_{rid}' for rid in rules_dict.keys()]
-        conclusion_func_names = [f'conclusion_{rid}' for rid in rules_dict.keys() if not isinstance(rules_dict[rid], MultiClassStopRule)]
+        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)
+        scope = extract_imports(filepath, package_name=package_name)
         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}"]
                 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}"]
                 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,
+                                           package_name: Optional[str] = None):
         """
         Write the rules as source code to a file.
 
@@ -395,37 +458,63 @@ 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.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         """
         pass
 
-    def _write_to_python(self, model_dir: str):
+    def _write_to_python(self, model_dir: str, package_name: Optional[str] = None):
         """
         Write the tree of rules as source code to a file.
 
         :param model_dir: The path to the directory to write the source code to.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         """
+        # Make sure the model directory exists and create an __init__.py file if it doesn't exist
         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")
+
+        # Set the file names for the generated python files
         file_name = model_dir + f"/{self.generated_python_file_name}.py"
         defs_file_name = model_dir + f"/{self.generated_python_defs_file_name}.py"
-        imports, defs_imports = self._get_imports()
-        # clear the files first
+        cases_file_name = model_dir + f"/{self.generated_python_cases_file_name}.py"
+
+        # Get the required imports for the main file and the defs file
+        main_types, defs_types, corner_cases_types = self._get_types_to_import()
+        imports = get_imports_from_types(main_types, file_name, package_name)
+        defs_imports = get_imports_from_types(defs_types, defs_file_name, package_name)
+        corner_cases_imports = get_imports_from_types(corner_cases_types, cases_file_name, package_name)
+
+        # Add the imports to the defs file
         with open(defs_file_name, "w") as f:
-            f.write(defs_imports + "\n\n")
+            f.write('\n'.join(defs_imports) + "\n\n\n")
+
+        # Add the imports to the cases file
+        case_factory_import = get_imports_from_types([CaseFactoryMetaData], cases_file_name, package_name)
+        corner_cases_imports.extend(case_factory_import)
+        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(corner_cases_imports) + "\n\n\n")
+
+        # Add the imports, the attributes, and the function definition to the main file
+        func_def = f"def classify(case: {self.case_type.__name__}, **kwargs) -> {self.conclusion_type_hint}:\n"
         with open(file_name, "w") as f:
-            imports += f"from .{self.generated_python_defs_file_name} import *\n"
-            imports += f"from ripple_down_rules.rdr import {self.__class__.__name__}\n"
-            f.write(imports + "\n\n")
+            imports.append(f"from .{self.generated_python_defs_file_name} import *")
+            f.write('\n'.join(imports) + "\n\n\n")
             f.write(f"attribute_name = '{self.attribute_name}'\n")
             f.write(f"conclusion_type = ({', '.join([ct.__name__ for ct in self.conclusion_type])},)\n")
-            f.write(f"type_ = {self.__class__.__name__}\n")
+            f.write(f"mutually_exclusive = {self.mutually_exclusive}\n")
             f.write(f"\n\n{func_def}")
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
-            self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4, defs_file=defs_file_name)
+
+        # Write the rules as source code to the main file
+        self.write_rules_as_source_code_to_file(self.start_rule, file_name, " " * 4, defs_file=defs_file_name,
+                                                cases_file=cases_file_name, package_name=package_name)
 
     @property
     @abstractmethod
@@ -435,31 +524,27 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         pass
 
-    def _get_imports(self) -> Tuple[str, str]:
+    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
         """
-        :return: The imports for the generated python file of the RDR as a string.
+        :return: The types of the main, defs, and corner cases files of the RDR classifier that will be imported.
         """
-        defs_imports_list = []
+        defs_types = set()
+        cases_types = set()
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             if not rule.conditions:
                 continue
             for scope in [rule.conditions.scope, rule.conclusion.scope]:
                 if scope is None:
                     continue
-                defs_imports_list.extend(get_imports_from_scope(scope))
-        if self.case_type.__module__ != "builtins":
-            defs_imports_list.append(f"from {self.case_type.__module__} import {self.case_type.__name__}")
-        defs_imports = "\n".join(set(defs_imports_list)) + "\n"
-        imports = []
-        if self.case_type.__module__ != "builtins":
-            imports.append(f"from {self.case_type.__module__} import {self.case_type.__name__}")
-        for conclusion_type in self.conclusion_type:
-            if conclusion_type.__module__ != "builtins":
-                imports.append(f"from {conclusion_type.__module__} import {conclusion_type.__name__}")
-        imports.append("from ripple_down_rules.datastructures.case import Case, create_case")
-        imports = set(imports).difference(defs_imports_list)
-        imports = "\n".join(imports) + "\n"
-        return imports, defs_imports
+                defs_types.update(make_set(scope.values()))
+            cases_types.update(rule.get_corner_case_types_to_import())
+        defs_types.add(self.case_type)
+        main_types = set()
+        main_types.add(self.case_type)
+        main_types.update(make_set(self.conclusion_type))
+        main_types.update({Case, create_case})
+        main_types = main_types.difference(defs_types)
+        return main_types, defs_types, cases_types
 
     @property
     def _default_generated_python_file_name(self) -> Optional[str]:
@@ -474,6 +559,9 @@ 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]:
@@ -493,7 +581,8 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         return self.start_rule.conclusion_name
 
     def _to_json(self) -> Dict[str, Any]:
-        return {"start_rule": self.start_rule.to_json(),  "generated_python_file_name": self.generated_python_file_name,
+        return {"start_rule": self.start_rule.to_json(),
+                "generated_python_file_name": self.generated_python_file_name,
                 "name": self.name,
                 "case_type": get_full_class_name(self.case_type) if self.case_type is not None else None,
                 "case_name": self.case_name}
@@ -525,6 +614,10 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
 
 class SingleClassRDR(RDRWithCodeWriter):
+    mutually_exclusive: bool = True
+    """
+    The output of the classification of this rdr negates all other possible outputs, there can only be one true value.
+    """
 
     def __init__(self, default_conclusion: Optional[Any] = None, **kwargs):
         """
@@ -550,7 +643,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)
 
@@ -563,18 +656,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:
         """
@@ -583,29 +682,35 @@ class SingleClassRDR(RDRWithCodeWriter):
         matched_rule = self.start_rule(case) if self.start_rule is not None else None
         return matched_rule if matched_rule is not None else self.start_rule
 
-    def _write_to_python(self, model_dir: str):
-        super()._write_to_python(model_dir)
+    def _write_to_python(self, model_dir: str, package_name: Optional[str] = None):
+        super()._write_to_python(model_dir, package_name=package_name)
         if self.default_conclusion is not None:
             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,
+                                           package_name: Optional[str] = None):
         """
         Write the rules as source code to a file.
         """
         if rule.conditions:
+            rule.write_corner_case_as_source_code(cases_file, package_name=package_name)
             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,
+                                                        package_name=package_name)
 
             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, package_name=package_name)
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -643,23 +748,34 @@ class MultiClassRDR(RDRWithCodeWriter):
     """
     The conditions of the stopping rule if needed.
     """
+    mutually_exclusive: bool = False
+    """
+    The output of the classification of this rdr allows for more than one true value as conclusion.
+    """
 
     def __init__(self, start_rule: Optional[MultiClassTopRule] = None,
-                 mode: MCRDRMode = MCRDRMode.StopOnly):
+                 mode: MCRDRMode = MCRDRMode.StopOnly, **kwargs):
         """
         :param start_rule: The starting rules for the classifier.
         :param mode: The mode of the classifier, either StopOnly or StopPlusRule, or StopPlusRuleCombined.
         """
-        super(MultiClassRDR, self).__init__(start_rule)
+        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)
 
@@ -687,7 +803,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)):
@@ -699,24 +815,32 @@ 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, package_name: 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, package_name=package_name)
             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,
+                                                        package_name=package_name)
                 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, package_name=package_name)
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -726,12 +850,11 @@ class MultiClassRDR(RDRWithCodeWriter):
         else:
             return f"Set[Union[{', '.join(conclusion_types)}]]"
 
-    def _get_imports(self) -> Tuple[str, str]:
-        imports, defs_imports = super()._get_imports()
-        imports += f"from typing_extensions import Set, Union\n"
-        imports += "from ripple_down_rules.utils import make_set\n"
-        defs_imports += "from typing_extensions import Union\n"
-        return imports, defs_imports
+    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+        main_types, defs_types, cases_types = super()._get_types_to_import()
+        main_types.update({Set, Union, make_set})
+        defs_types.add(Union)
+        return main_types, defs_types, cases_types
 
     def update_start_rule(self, case_query: CaseQuery, expert: Expert):
         """
@@ -742,8 +865,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]:
@@ -764,7 +886,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):
@@ -776,12 +898,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):
         """
@@ -793,19 +916,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:
@@ -818,15 +941,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]:
@@ -887,59 +1008,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 self._classify(self.start_rules_dict, case, modify_original_case=modify_case)
-
-    @staticmethod
-    def _classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
-                  case: Any, modify_original_case: bool = False) -> Dict[str, Any]:
-        """
-        Classify a case by going through all classifiers and adding the categories that are classified,
-         and then restarting the classification until no more categories can be added.
-
-        :param classifiers_dict: A dictionary mapping conclusion types to the classifiers that produce them.
-        :param case: The case to classify.
-        :param modify_original_case: Whether to modify the original case or create a copy and modify it.
-        :return: The categories that the case belongs to.
-        """
-        conclusions = {}
-        case = case if isinstance(case, (Case, SQLTable)) else create_case(case)
-        case_cp = copy_case(case) if not modify_original_case else case
-        while True:
-            new_conclusions = {}
-            for attribute_name, rdr in classifiers_dict.items():
-                pred_atts = rdr.classify(case_cp)
-                if pred_atts is None:
-                    continue
-                if rdr.type_ is SingleClassRDR:
-                    if attribute_name not in conclusions or \
-                            (attribute_name in conclusions and conclusions[attribute_name] != pred_atts):
-                        conclusions[attribute_name] = pred_atts
-                        new_conclusions[attribute_name] = pred_atts
-                else:
-                    pred_atts = make_set(pred_atts)
-                    if attribute_name in conclusions:
-                        pred_atts = {p for p in pred_atts if p not in conclusions[attribute_name]}
-                    if len(pred_atts) > 0:
-                        new_conclusions[attribute_name] = pred_atts
-                        if attribute_name not in conclusions:
-                            conclusions[attribute_name] = set()
-                        conclusions[attribute_name].update(pred_atts)
-                if attribute_name in new_conclusions:
-                    mutually_exclusive = True if rdr.type_ is SingleClassRDR else False
-                    case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, mutually_exclusive)
-                    update_case(case_query, new_conclusions)
-            if len(new_conclusions) == 0:
-                break
-        return conclusions
+        return general_rdr_classify(self.start_rules_dict, case, modify_original_case=modify_case,
+                                    case_query=case_query)
 
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Dict[str, Any]:
@@ -985,7 +1066,7 @@ class GeneralRDR(RippleDownRules):
 
     def _to_json(self) -> Dict[str, Any]:
         return {"start_rules": {name: rdr.to_json() for name, rdr in self.start_rules_dict.items()}
-                , "generated_python_file_name": self.generated_python_file_name,
+            , "generated_python_file_name": self.generated_python_file_name,
                 "name": self.name,
                 "case_type": get_full_class_name(self.case_type) if self.case_type is not None else None,
                 "case_name": self.case_name}
@@ -1009,26 +1090,30 @@ class GeneralRDR(RippleDownRules):
             new_rdr.case_name = data["case_name"]
         return new_rdr
 
-    def update_from_python(self, model_dir: str) -> None:
+    def update_from_python(self, model_dir: str, package_name: Optional[str] = None) -> None:
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the model is stored.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         """
         for rdr in self.start_rules_dict.values():
-            rdr.update_from_python(model_dir)
+            rdr.update_from_python(model_dir, package_name=package_name)
 
-    def _write_to_python(self, model_dir: str) -> None:
+    def _write_to_python(self, model_dir: str, package_name: Optional[str] = None) -> None:
         """
         Write the tree of rules as source code to a file.
 
         :param model_dir: The directory where the model is stored.
+        :param relative_imports: Whether to use relative imports in the generated python file.
         """
         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"
-        with open(model_dir + f"/{self.generated_python_file_name}.py", "w") as f:
-            f.write(self._get_imports() + "\n\n")
+            rdr._write_to_python(model_dir, package_name=package_name)
+        func_def = f"def classify(case: {self.case_type.__name__}, **kwargs) -> {self.conclusion_type_hint}:\n"
+        file_path = model_dir + f"/{self.generated_python_file_name}.py"
+        with open(file_path, "w") as f:
+            f.write(self._get_imports(file_path=file_path, package_name=package_name) + "\n\n")
             f.write("classifiers_dict = dict()\n")
             for rdr_key, rdr in self.start_rules_dict.items():
                 f.write(f"classifiers_dict['{rdr_key}'] = {self.rdr_key_to_function_name(rdr_key)}\n")
@@ -1036,7 +1121,7 @@ class GeneralRDR(RippleDownRules):
             f.write(func_def)
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
-            f.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
+            f.write(f"{' ' * 4}return general_rdr_classify(classifiers_dict, case, **kwargs)\n")
 
     @property
     def _default_generated_python_file_name(self) -> Optional[str]:
@@ -1051,25 +1136,29 @@ class GeneralRDR(RippleDownRules):
     def conclusion_type_hint(self) -> str:
         return f"Dict[str, Any]"
 
-    def _get_imports(self) -> str:
+    def _get_imports(self, file_path: Optional[str] = None, package_name: Optional[str] = None) -> str:
         """
         Get the imports needed for the generated python file.
 
+        :param file_path: The path to the file where the imports will be written, if None, the imports will be absolute.
+        :param package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
         :return: The imports needed for the generated python file.
         """
-        imports = ""
+        all_types = set()
         # add type hints
-        imports += f"from typing_extensions import Dict, Any\n"
+        all_types.update({Dict, Any})
         # import rdr type
-        imports += f"from ripple_down_rules.rdr import GeneralRDR\n"
+        all_types.add(general_rdr_classify)
         # add case type
-        imports += f"from ripple_down_rules.datastructures.case import Case, create_case\n"
-        imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
+        all_types.update({Case, create_case, self.case_type})
+        # get the imports from the types
+        imports = get_imports_from_types(all_types, target_file_path=file_path, package_name=package_name)
         # add rdr python generated functions.
         for rdr_key, rdr in self.start_rules_dict.items():
-            imports += (f"from ."
-                        f" import {rdr.generated_python_file_name} as {self.rdr_key_to_function_name(rdr_key)}\n")
-        return imports
+            imports.append(
+                f"from . import {rdr.generated_python_file_name} as {self.rdr_key_to_function_name(rdr_key)}")
+        return '\n'.join(imports)
 
     @staticmethod
     def rdr_key_to_function_name(rdr_key: str) -> str: