ripple-down-rules 0.1.21__py3-none-any.whl → 0.1.62__py3-none-any.whl

ripple_down_rules/rdr.py

@@ -1,20 +1,28 @@
 from __future__ import annotations
 
 import importlib
+import sys
 from abc import ABC, abstractmethod
 from copy import copy
+from dataclasses import is_dataclass
+from io import TextIOWrapper
 from types import ModuleType
 
 from matplotlib import pyplot as plt
 from ordered_set import OrderedSet
-from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
+from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple, Callable, Set
 
-from .datastructures import Case, MCRDRMode, CallableExpression, CaseAttribute, CaseQuery
+from .datastructures.callable_expression import CallableExpression
+from .datastructures.case import Case, CaseAttribute, create_case
+from .datastructures.dataclasses import CaseQuery
+from .datastructures.enums import MCRDRMode, PromptFor
 from .experts import Expert, Human
+from .helpers import is_matching
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 from .utils import draw_tree, make_set, copy_case, \
-    get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list, get_type_from_string
+    SubclassJSONSerializer, is_iterable, make_list, get_type_from_string, \
+    get_case_attribute_type, is_conflicting
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -29,14 +37,16 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     """
     The conclusions that the expert has accepted, such that they are not asked again.
     """
+    _generated_python_file_name: Optional[str] = None
+    """
+    The name of the generated python file.
+    """
 
-    def __init__(self, start_rule: Optional[Rule] = None, session: Optional[Session] = None):
+    def __init__(self, start_rule: Optional[Rule] = None):
         """
         :param start_rule: The starting rule for the classifier.
-        :param session: The sqlalchemy orm session.
         """
         self.start_rule = start_rule
-        self.session = session
         self.fig: Optional[plt.Figure] = None
 
     def __call__(self, case: Union[Case, SQLTable]) -> CaseAttribute:
@@ -79,31 +89,29 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param animate_tree: Whether to draw the tree while fitting the classifier.
         :param kwargs_for_fit_case: The keyword arguments to pass to the fit_case method.
         """
-        cases = [case_query.case for case_query in case_queries]
-        targets = [{case_query.attribute_name: case_query.target} for case_query in case_queries]
+        targets = []
         if animate_tree:
             plt.ion()
         i = 0
         stop_iterating = False
         num_rules: int = 0
         while not stop_iterating:
-            all_pred = 0
-            if not targets:
-                targets = [None] * len(cases)
             for case_query in case_queries:
-                target = {case_query.attribute_name: case_query.target}
                 pred_cat = self.fit_case(case_query, expert=expert, **kwargs_for_fit_case)
-                match = self.is_matching(pred_cat, target)
+                if case_query.target is None:
+                    continue
+                target = {case_query.attribute_name: case_query.target(case_query.case)}
+                if len(targets) < len(case_queries):
+                    targets.append(target)
+                match = is_matching(self.classify, case_query, pred_cat)
                 if not match:
                     print(f"Predicted: {pred_cat} but expected: {target}")
-                all_pred += int(match)
                 if animate_tree and self.start_rule.size > num_rules:
                     num_rules = self.start_rule.size
                     self.update_figures()
             i += 1
-            all_predictions = [1 if self.is_matching(self.classify(case_query.case), {case_query.attribute_name:
-                                                                                          case_query.target}) else 0
-                               for case_query in case_queries]
+            all_predictions = [1 if is_matching(self.classify, case_query) else 0 for case_query in case_queries
+                               if case_query.target is not None]
             all_pred = sum(all_predictions)
             print(f"Accuracy: {all_pred}/{len(targets)}")
             all_predicted = targets and all_pred == len(targets)
@@ -116,48 +124,6 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             plt.ioff()
             plt.show()
 
-    @staticmethod
-    def calculate_precision_and_recall(pred_cat: List[CaseAttribute], target: List[CaseAttribute]) -> Tuple[
-        List[bool], List[bool]]:
-        """
-        :param pred_cat: The predicted category.
-        :param target: The target category.
-        :return: The precision and recall of the classifier.
-        """
-        pred_cat = pred_cat if is_iterable(pred_cat) else [pred_cat]
-        target = target if is_iterable(target) else [target]
-        recall = []
-        precision = []
-        if isinstance(pred_cat, dict):
-            for pred_key, pred_value in pred_cat.items():
-                if pred_key not in target:
-                    continue
-                precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
-            for target_key, target_value in target.items():
-                if target_key not in pred_cat:
-                    recall.append(False)
-                    continue
-                if is_iterable(target_value):
-                    recall.extend([v in pred_cat[target_key] for v in target_value])
-                else:
-                    recall.append(target_value == pred_cat[target_key])
-        else:
-            if isinstance(target, dict):
-                target = list(target.values())
-            recall = [not yi or (yi in pred_cat) for yi in target]
-            target_types = [type(yi) for yi in target]
-            precision = [(pred in target) or (type(pred) not in target_types) for pred in pred_cat]
-        return precision, recall
-
-    def is_matching(self, pred_cat: List[CaseAttribute], target: List[CaseAttribute]) -> bool:
-        """
-        :param pred_cat: The predicted category.
-        :param target: The target category.
-        :return: Whether the classifier is matching or not.
-        """
-        precision, recall = self.calculate_precision_and_recall(pred_cat, target)
-        return all(recall) and all(precision)
-
     def update_figures(self):
         """
         Update the figures of the classifier.
@@ -183,33 +149,51 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         return hasattr(case, conclusion_name) and getattr(case, conclusion_name) is not None
 
+    @property
+    def type_(self):
+        return self.__class__
+
 
 class RDRWithCodeWriter(RippleDownRules, ABC):
 
     @abstractmethod
-    def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = ""):
+    def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = "",
+                                           defs_file: Optional[str] = None):
         """
         Write the rules as source code to a file.
 
         :param rule: The rule to write as source code.
         :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.
         """
         pass
 
-    def write_to_python_file(self, file_path: str):
+    def write_to_python_file(self, file_path: str, postfix: str = ""):
         """
         Write the tree of rules as source code to a file.
 
         :param file_path: The path to the file to write the source code to.
+        :param postfix: The postfix to add to the file name.
         """
+        self.generated_python_file_name = self._default_generated_python_file_name + postfix
         func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
-        with open(file_path + f"/{self.generated_python_file_name}.py", "w") as f:
-            f.write(self._get_imports() + "\n\n")
+        file_name = file_path + f"/{self.generated_python_file_name}.py"
+        defs_file_name = file_path + f"/{self.generated_python_defs_file_name}.py"
+        imports = self._get_imports()
+        # clear the files first
+        with open(defs_file_name, "w") as f:
+            f.write(imports + "\n\n")
+        with open(file_name, "w") as f:
+            imports += f"from .{self.generated_python_defs_file_name} import *\n"
+            imports += f"from ripple_down_rules.rdr import {self.__class__.__name__}\n"
+            f.write(imports + "\n\n")
+            f.write(f"conclusion_type = ({', '.join([ct.__name__ for ct in self.conclusion_type])},)\n\n")
+            f.write(f"type_ = {self.__class__.__name__}\n\n")
             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""")
-            self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4)
+            self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4, defs_file=defs_file_name)
 
     @property
     @abstractmethod
@@ -226,26 +210,72 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         imports = ""
         if self.case_type.__module__ != "builtins":
             imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
-        if self.conclusion_type.__module__ != "builtins":
-            imports += f"from {self.conclusion_type.__module__} import {self.conclusion_type.__name__}\n"
-        imports += "from ripple_down_rules.datastructures import Case, create_case\n"
+        for conclusion_type in self.conclusion_type:
+            if conclusion_type.__module__ != "builtins":
+                imports += f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
+        imports += "from ripple_down_rules.datastructures.case import Case, create_case\n"
         for rule in [self.start_rule] + list(self.start_rule.descendants):
-            if rule.conditions:
-                if rule.conditions.scope is not None and len(rule.conditions.scope) > 0:
-                    for k, v in rule.conditions.scope.items():
-                        imports += f"from {v.__module__} import {v.__name__}\n"
+            if not rule.conditions:
+                continue
+            if rule.conditions.scope is None or len(rule.conditions.scope) == 0:
+                continue
+            for k, v in rule.conditions.scope.items():
+                new_imports = f"from {v.__module__} import {v.__name__}\n"
+                if new_imports in imports:
+                    continue
+                imports += new_imports
         return imports
 
-    def get_rdr_classifier_from_python_file(self, package_name) -> Callable[[Any], Any]:
+    def get_rdr_classifier_from_python_file(self, package_name: str) -> Callable[[Any], Any]:
         """
         :param package_name: The name of the package that contains the RDR classifier function.
         :return: The module that contains the rdr classifier function.
         """
-        return importlib.import_module(f"{package_name.strip('./')}.{self.generated_python_file_name}").classify
+        # remove from imports if exists first
+        name = f"{package_name.strip('./')}.{self.generated_python_file_name}"
+        try:
+            module = importlib.import_module(name)
+            del sys.modules[name]
+        except ModuleNotFoundError:
+            pass
+        return importlib.import_module(name).classify
 
     @property
     def generated_python_file_name(self) -> str:
-        return f"{self.start_rule.corner_case._name.lower()}_{self.attribute_name}_rdr"
+        if self._generated_python_file_name is None:
+            self._generated_python_file_name = self._default_generated_python_file_name
+        return self._generated_python_file_name
+
+    @generated_python_file_name.setter
+    def generated_python_file_name(self, value: str):
+        """
+        Set the generated python file name.
+        :param value: The new value for the generated python file name.
+        """
+        self._generated_python_file_name = value
+
+    @property
+    def _default_generated_python_file_name(self) -> str:
+        """
+        :return: The default generated python file name.
+        """
+        return f"{self.start_rule.corner_case._name.lower()}_{self.attribute_name}_{self.acronym.lower()}"
+
+    @property
+    def generated_python_defs_file_name(self) -> str:
+        return f"{self.generated_python_file_name}_defs"
+
+    @property
+    def acronym(self) -> str:
+        """
+        :return: The acronym of the classifier.
+        """
+        if self.__class__.__name__ == "GeneralRDR":
+            return "GRDR"
+        elif self.__class__.__name__ == "MultiClassRDR":
+            return "MCRDR"
+        else:
+            return "SCRDR"
 
     @property
     def case_type(self) -> Type:
@@ -258,16 +288,17 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             return type(self.start_rule.corner_case)
 
     @property
-    def conclusion_type(self) -> Type:
+    def conclusion_type(self) -> Tuple[Type]:
         """
         :return: The type of the conclusion of the RDR classifier.
         """
         if isinstance(self.start_rule.conclusion, CallableExpression):
             return self.start_rule.conclusion.conclusion_type
         else:
-            if isinstance(self.start_rule.conclusion, set):
-                return type(list(self.start_rule.conclusion)[0])
-            return type(self.start_rule.conclusion)
+            conclusion = self.start_rule.conclusion
+            if isinstance(conclusion, set):
+                return type(list(conclusion)[0]), set
+            return (type(conclusion),)
 
     @property
     def attribute_name(self) -> str:
@@ -279,8 +310,16 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
 class SingleClassRDR(RDRWithCodeWriter):
 
+    def __init__(self, start_rule: Optional[SingleClassRule] = None, default_conclusion: Optional[Any] = None):
+        """
+        :param start_rule: The starting rule for the classifier.
+        :param default_conclusion: The default conclusion for the classifier if no rules fire.
+        """
+        super(SingleClassRDR, self).__init__(start_rule)
+        self.default_conclusion: Optional[Any] = default_conclusion
+
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
-            -> Union[CaseAttribute, CallableExpression]:
+            -> Union[CaseAttribute, CallableExpression, None]:
         """
         Classify a case, and ask the user for refinements or alternatives if the classification is incorrect by
         comparing the case with the target category if provided.
@@ -289,28 +328,31 @@ class SingleClassRDR(RDRWithCodeWriter):
         :param expert: The expert to ask for differentiating features as new rule conditions.
         :return: The category that the case belongs to.
         """
-        expert = expert if expert else Human(session=self.session)
-        if case_query.target is None:
-            target = expert.ask_for_conclusion(case_query)
+        expert = expert if expert else Human()
+        if case_query.default_value is not None and self.default_conclusion != case_query.default_value:
+            self.default_conclusion = case_query.default_value
+        case = case_query.case
+        target = expert.ask_for_conclusion(case_query) if case_query.target is None else case_query.target
+        if target is None:
+            return self.classify(case)
         if not self.start_rule:
             conditions = expert.ask_for_conditions(case_query)
-            self.start_rule = SingleClassRule(conditions, case_query.target, corner_case=case_query.case,
+            self.start_rule = SingleClassRule(conditions, target, corner_case=case,
                                               conclusion_name=case_query.attribute_name)
 
         pred = self.evaluate(case_query.case)
-
-        if pred.conclusion != case_query.target:
+        if pred.conclusion(case) != target(case):
             conditions = expert.ask_for_conditions(case_query, pred)
-            pred.fit_rule(case_query.case, case_query.target, conditions=conditions)
+            pred.fit_rule(case_query.case, target, conditions=conditions)
 
         return self.classify(case_query.case)
 
-    def classify(self, case: Case) -> Optional[CaseAttribute]:
+    def classify(self, case: Case) -> Optional[Any]:
         """
         Classify a case by recursively evaluating the rules until a rule fires or the last rule is reached.
         """
         pred = self.evaluate(case)
-        return pred.conclusion if pred.fired else None
+        return pred.conclusion(case) if pred.fired else self.default_conclusion
 
     def evaluate(self, case: Case) -> SingleClassRule:
         """
@@ -319,23 +361,32 @@ class SingleClassRDR(RDRWithCodeWriter):
         matched_rule = self.start_rule(case)
         return matched_rule if matched_rule else self.start_rule
 
-    def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file, parent_indent: str = ""):
+    def write_to_python_file(self, file_path: str, postfix: str = ""):
+        super().write_to_python_file(file_path, postfix)
+        if self.default_conclusion is not None:
+            with open(file_path + 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):
         """
         Write the rules as source code to a file.
         """
         if rule.conditions:
-            file.write(rule.write_condition_as_source_code(parent_indent))
+            if_clause = rule.write_condition_as_source_code(parent_indent, defs_file)
+            file.write(if_clause)
             if rule.refinement:
-                self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ")
+                self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
+                                                        defs_file=defs_file)
 
             file.write(rule.write_conclusion_as_source_code(parent_indent))
 
             if rule.alternative:
-                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent)
+                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file)
 
     @property
     def conclusion_type_hint(self) -> str:
-        return self.conclusion_type.__name__
+        return self.conclusion_type[0].__name__
 
     def _to_json(self) -> Dict[str, Any]:
         return {"start_rule": self.start_rule.to_json()}
@@ -369,28 +420,27 @@ class MultiClassRDR(RDRWithCodeWriter):
     """
 
     def __init__(self, start_rule: Optional[Rule] = None,
-                 mode: MCRDRMode = MCRDRMode.StopOnly, session: Optional[Session] = None):
+                 mode: MCRDRMode = MCRDRMode.StopOnly):
         """
         :param start_rule: The starting rules for the classifier.
         :param mode: The mode of the classifier, either StopOnly or StopPlusRule, or StopPlusRuleCombined.
-        :param session: The sqlalchemy orm session.
         """
         start_rule = MultiClassTopRule() if not start_rule else start_rule
-        super(MultiClassRDR, self).__init__(start_rule, session=session)
+        super(MultiClassRDR, self).__init__(start_rule)
         self.mode: MCRDRMode = mode
 
-    def classify(self, case: Union[Case, SQLTable]) -> List[Any]:
+    def classify(self, case: Union[Case, SQLTable]) -> 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)
+                self.add_conclusion(evaluated_rule, case)
             evaluated_rule = next_rule
-        return self.conclusions
+        return make_set(self.conclusions)
 
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None,
-                 add_extra_conclusions: bool = False) -> List[Union[CaseAttribute, CallableExpression]]:
+                 add_extra_conclusions: bool = False) -> Set[Union[CaseAttribute, CallableExpression, None]]:
         """
         Classify a case, and ask the user for stopping rules or classifying rules if the classification is incorrect
          or missing by comparing the case with the target category if provided.
@@ -400,72 +450,76 @@ class MultiClassRDR(RDRWithCodeWriter):
         :param add_extra_conclusions: Whether to add extra conclusions after classification is done.
         :return: The conclusions that the case belongs to.
         """
-        expert = expert if expert else Human(session=self.session)
+        expert = expert if expert else Human()
+        if case_query.target is None:
+            expert.ask_for_conclusion(case_query)
         if case_query.target is None:
-            targets = expert.ask_for_conclusion(case_query)
+            return self.classify(case_query.case)
+        self.update_start_rule(case_query, expert)
         self.expert_accepted_conclusions = []
         user_conclusions = []
-        self.update_start_rule(case_query, expert)
         self.conclusions = []
         self.stop_rule_conditions = None
         evaluated_rule = self.start_rule
+        target = case_query.target(case_query.case)
         while evaluated_rule:
             next_rule = evaluated_rule(case_query.case)
-            good_conclusions = make_list(case_query.target) + user_conclusions + self.expert_accepted_conclusions
+            rule_conclusion = evaluated_rule.conclusion(case_query.case)
+            good_conclusions = make_list(target) + user_conclusions + self.expert_accepted_conclusions
             good_conclusions = make_set(good_conclusions)
 
             if evaluated_rule.fired:
-                if case_query.target and not make_set(evaluated_rule.conclusion).issubset(good_conclusions):
-                    # if self.case_has_conclusion(case, evaluated_rule.conclusion):
+                if target and not make_set(rule_conclusion).issubset(good_conclusions):
                     # Rule fired and conclusion is different from target
                     self.stop_wrong_conclusion_else_add_it(case_query, expert, evaluated_rule,
-                                                           add_extra_conclusions)
+                                                           len(user_conclusions) > 0)
                 else:
                     # Rule fired and target is correct or there is no target to compare
-                    self.add_conclusion(evaluated_rule)
+                    self.add_conclusion(evaluated_rule, case_query.case)
 
             if not next_rule:
-                if not make_set(case_query.target).intersection(make_set(self.conclusions)):
+                if not make_set(target).issubset(make_set(self.conclusions)):
                     # Nothing fired and there is a target that should have been in the conclusions
                     self.add_rule_for_case(case_query, expert)
                     # Have to check all rules again to make sure only this new rule fires
                     next_rule = self.start_rule
-                elif add_extra_conclusions and not user_conclusions:
+                elif add_extra_conclusions:
                     # No more conclusions can be made, ask the expert for extra conclusions if needed.
-                    user_conclusions.extend(self.ask_expert_for_extra_conclusions(expert, case_query.case))
-                    if user_conclusions:
+                    new_user_conclusions = self.ask_expert_for_extra_rules(expert, case_query)
+                    user_conclusions.extend(new_user_conclusions)
+                    if len(new_user_conclusions) > 0:
                         next_rule = self.last_top_rule
+                    else:
+                        add_extra_conclusions = False
             evaluated_rule = next_rule
         return self.conclusions
 
     def write_rules_as_source_code_to_file(self, rule: Union[MultiClassTopRule, MultiClassStopRule],
-                                           file, parent_indent: str = ""):
-        """
-        Write the rules as source code to a file.
-
-        :
-        """
+                                           file, parent_indent: str = "", defs_file: Optional[str] = None):
         if rule == self.start_rule:
             file.write(f"{parent_indent}conclusions = set()\n")
         if rule.conditions:
-            file.write(rule.write_condition_as_source_code(parent_indent))
+            if_clause = rule.write_condition_as_source_code(parent_indent, defs_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 + "    ")
+                self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
+                                                        defs_file=defs_file)
                 conclusion_indent = parent_indent + " " * 4
                 file.write(f"{conclusion_indent}else:\n")
             file.write(rule.write_conclusion_as_source_code(conclusion_indent))
 
             if rule.alternative:
-                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent)
+                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file)
 
     @property
     def conclusion_type_hint(self) -> str:
-        return f"Set[{self.conclusion_type.__name__}]"
+        return f"Set[{self.conclusion_type[0].__name__}]"
 
     def _get_imports(self) -> str:
         imports = super()._get_imports()
         imports += "from typing_extensions import Set\n"
+        imports += "from ripple_down_rules.utils import make_set\n"
         return imports
 
     def update_start_rule(self, case_query: CaseQuery, expert: Expert):
@@ -498,11 +552,12 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         Stop a wrong conclusion by adding a stopping rule.
         """
-        if self.is_same_category_type(evaluated_rule.conclusion, case_query.target) \
-                and self.is_conflicting_with_target(evaluated_rule.conclusion, case_query.target):
-            self.stop_conclusion(case_query, expert, evaluated_rule)
-        elif not self.conclusion_is_correct(case_query, expert, evaluated_rule, add_extra_conclusions):
-            self.stop_conclusion(case_query, expert, evaluated_rule)
+        rule_conclusion = evaluated_rule.conclusion(case_query.case)
+        if is_conflicting(rule_conclusion, case_query.target_value):
+            if self.conclusion_is_correct(case_query, expert, evaluated_rule, add_extra_conclusions):
+                return
+            else:
+                self.stop_conclusion(case_query, expert, evaluated_rule)
 
     def stop_conclusion(self, case_query: CaseQuery,
                         expert: Expert, evaluated_rule: MultiClassTopRule):
@@ -521,31 +576,6 @@ class MultiClassRDR(RDRWithCodeWriter):
             new_top_rule_conditions = conditions.combine_with(evaluated_rule.conditions)
             self.add_top_rule(new_top_rule_conditions, case_query.target, case_query.case)
 
-    @staticmethod
-    def is_conflicting_with_target(conclusion: Any, target: Any) -> bool:
-        """
-        Check if the conclusion is conflicting with the target category.
-
-        :param conclusion: The conclusion to check.
-        :param target: The target category to compare the conclusion with.
-        :return: Whether the conclusion is conflicting with the target category.
-        """
-        if hasattr(conclusion, "mutually_exclusive") and conclusion.mutually_exclusive:
-            return True
-        else:
-            return not make_set(conclusion).issubset(make_set(target))
-
-    @staticmethod
-    def is_same_category_type(conclusion: Any, target: Any) -> bool:
-        """
-        Check if the conclusion is of the same class as the target category.
-
-        :param conclusion: The conclusion to check.
-        :param target: The target category to compare the conclusion with.
-        :return: Whether the conclusion is of the same class as the target category but has a different value.
-        """
-        return conclusion.__class__ == target.__class__ and target.__class__ != CaseAttribute
-
     def conclusion_is_correct(self, case_query: CaseQuery,
                               expert: Expert, evaluated_rule: Rule,
                               add_extra_conclusions: bool) -> bool:
@@ -559,10 +589,10 @@ class MultiClassRDR(RDRWithCodeWriter):
         :return: Whether the conclusion is correct or not.
         """
         conclusions = {case_query.attribute_name: c for c in OrderedSet(self.conclusions)}
-        if (add_extra_conclusions and expert.ask_if_conclusion_is_correct(case_query.case, evaluated_rule.conclusion,
-                                                                          targets=case_query.target,
+        if (add_extra_conclusions and expert.ask_if_conclusion_is_correct(case_query.case,
+                                                                          evaluated_rule.conclusion(case_query.case),
                                                                           current_conclusions=conclusions)):
-            self.add_conclusion(evaluated_rule)
+            self.add_conclusion(evaluated_rule, case_query.case)
             self.expert_accepted_conclusions.append(evaluated_rule.conclusion)
             return True
         return False
@@ -581,38 +611,39 @@ class MultiClassRDR(RDRWithCodeWriter):
             conditions = expert.ask_for_conditions(case_query)
         self.add_top_rule(conditions, case_query.target, case_query.case)
 
-    def ask_expert_for_extra_conclusions(self, expert: Expert, case: Union[Case, SQLTable]) -> List[Any]:
+    def ask_expert_for_extra_rules(self, expert: Expert, case_query: CaseQuery) -> List[Any]:
         """
-        Ask the expert for extra conclusions when no more conclusions can be made.
+        Ask the expert for extra rules when no more conclusions can be made for a case.
 
         :param expert: The expert to ask for extra conclusions.
-        :param case: The case to ask extra conclusions for.
-        :return: The extra conclusions that the expert has provided.
+        :param case_query: The case query to ask the expert about.
+        :return: The extra conclusions for the rules that the expert has provided.
         """
         extra_conclusions = []
         conclusions = list(OrderedSet(self.conclusions))
         if not expert.use_loaded_answers:
             print("current conclusions:", conclusions)
-        extra_conclusions_dict = expert.ask_for_extra_conclusions(case, conclusions)
-        if extra_conclusions_dict:
-            for conclusion, conditions in extra_conclusions_dict.items():
-                self.add_top_rule(conditions, conclusion, case)
-                extra_conclusions.append(conclusion)
+        extra_rules = expert.ask_for_extra_rules(case_query)
+        for rule in extra_rules:
+            self.add_top_rule(rule[PromptFor.Conditions], rule[PromptFor.Conclusion], case_query.case)
+            extra_conclusions.extend(rule[PromptFor.Conclusion](case_query.case))
         return extra_conclusions
 
-    def add_conclusion(self, evaluated_rule: Rule) -> None:
+    def add_conclusion(self, evaluated_rule: Rule, case: Case) -> 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.
         """
         conclusion_types = [type(c) for c in self.conclusions]
-        if type(evaluated_rule.conclusion) not in conclusion_types:
-            self.conclusions.extend(make_list(evaluated_rule.conclusion))
+        rule_conclusion = evaluated_rule.conclusion(case)
+        if type(rule_conclusion) not in conclusion_types:
+            self.conclusions.extend(make_list(rule_conclusion))
         else:
-            same_type_conclusions = [c for c in self.conclusions if type(c) == type(evaluated_rule.conclusion)]
-            combined_conclusion = evaluated_rule.conclusion if isinstance(evaluated_rule.conclusion, set) \
-                else {evaluated_rule.conclusion}
+            same_type_conclusions = [c for c in self.conclusions if type(c) == type(rule_conclusion)]
+            combined_conclusion = rule_conclusion if isinstance(rule_conclusion, set) \
+                else {rule_conclusion}
             combined_conclusion = copy(combined_conclusion)
             for c in same_type_conclusions:
                 combined_conclusion.update(c if isinstance(c, set) else make_set(c))
@@ -713,6 +744,7 @@ class GeneralRDR(RippleDownRules):
         :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)
         while True:
             new_conclusions = {}
@@ -720,22 +752,24 @@ class GeneralRDR(RippleDownRules):
                 pred_atts = rdr.classify(case_cp)
                 if pred_atts is None:
                     continue
-                if isinstance(rdr, SingleClassRDR):
+                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_list(pred_atts)
+                    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]]
+                        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] = []
-                        conclusions[attribute_name].extend(pred_atts)
+                            conclusions[attribute_name] = set()
+                        conclusions[attribute_name].update(pred_atts)
                 if attribute_name in new_conclusions:
-                    GeneralRDR.update_case(case_cp, new_conclusions)
+                    mutually_exclusive = True if rdr.type_ is SingleClassRDR else False
+                    GeneralRDR.update_case(CaseQuery(case_cp, attribute_name, rdr.conclusion_type, mutually_exclusive),
+                                           new_conclusions)
             if len(new_conclusions) == 0:
                 break
         return conclusions
@@ -761,76 +795,103 @@ class GeneralRDR(RippleDownRules):
         case = case_queries[0].case
         assert all([case is case_query.case for case_query in case_queries]), ("fit_case requires only one case,"
                                                                                " for multiple cases use fit instead")
-        case_cp = copy(case_queries[0]).case
+        original_case_query_cp = copy(case_queries[0])
         for case_query in case_queries:
             case_query_cp = copy(case_query)
-            case_query_cp.case = case_cp
-            if case_query.target is None:
+            case_query_cp.case = original_case_query_cp.case
+            if case_query_cp.target is None:
                 conclusions = self.classify(case) if self.start_rule and self.start_rule.conditions else []
-                target = expert.ask_for_conclusion(case_query)
+                self.update_case(case_query_cp, conclusions)
+                expert.ask_for_conclusion(case_query_cp)
+                if case_query_cp.target is None:
+                    continue
+                case_query.target = case_query_cp.target
 
             if case_query.attribute_name not in self.start_rules_dict:
                 conclusions = self.classify(case)
-                self.update_case(case_cp, conclusions)
+                self.update_case(case_query_cp, conclusions)
 
-                new_rdr = self.initialize_new_rdr_for_attribute(case_query.attribute_name, case_cp, case_query.target)
+                new_rdr = self.initialize_new_rdr_for_attribute(case_query_cp)
                 self.add_rdr(new_rdr, case_query.attribute_name)
 
                 new_conclusions = new_rdr.fit_case(case_query_cp, expert, **kwargs)
-                self.update_case(case_cp, {case_query.attribute_name: new_conclusions})
+                self.update_case(case_query_cp, {case_query.attribute_name: new_conclusions})
             else:
                 for rdr_attribute_name, rdr in self.start_rules_dict.items():
                     if case_query.attribute_name != rdr_attribute_name:
-                        conclusions = rdr.classify(case_cp)
+                        conclusions = rdr.classify(case_query_cp.case)
                     else:
                         conclusions = self.start_rules_dict[rdr_attribute_name].fit_case(case_query_cp, expert,
                                                                                          **kwargs)
                     if conclusions is not None or (is_iterable(conclusions) and len(conclusions) > 0):
                         conclusions = {rdr_attribute_name: conclusions}
-                        self.update_case(case_cp, conclusions)
+                        case_query_cp.mutually_exclusive = True if isinstance(rdr, SingleClassRDR) else False
+                        self.update_case(case_query_cp, conclusions)
+            case_query.conditions = case_query_cp.conditions
 
         return self.classify(case)
 
     @staticmethod
-    def initialize_new_rdr_for_attribute(attribute_name: str, case: Union[Case, SQLTable], target: Any):
+    def initialize_new_rdr_for_attribute(case_query: CaseQuery):
         """
         Initialize the appropriate RDR type for the target.
         """
-        attribute = getattr(case, attribute_name) if hasattr(case, attribute_name) else target
+        if case_query.mutually_exclusive is not None:
+            return SingleClassRDR(default_conclusion=case_query.default_value) if case_query.mutually_exclusive \
+                else MultiClassRDR()
+        if case_query.attribute_type in [list, set]:
+            return MultiClassRDR()
+        attribute = getattr(case_query.case, case_query.attribute_name) \
+            if hasattr(case_query.case, case_query.attribute_name) else case_query.target(case_query.case)
         if isinstance(attribute, CaseAttribute):
-            return SingleClassRDR() if attribute.mutually_exclusive else MultiClassRDR()
+            return SingleClassRDR(default_conclusion=case_query.default_value) if attribute.mutually_exclusive \
+                else MultiClassRDR()
         else:
-            return MultiClassRDR() if is_iterable(attribute) or (attribute is None) else SingleClassRDR()
+            return MultiClassRDR() if is_iterable(attribute) or (attribute is None) \
+                else SingleClassRDR(default_conclusion=case_query.default_value)
 
     @staticmethod
-    def update_case(case: Union[Case, SQLTable], conclusions: Dict[str, Any]):
+    def update_case(case_query: CaseQuery, conclusions: Dict[str, Any]):
         """
         Update the case with the conclusions.
 
-        :param case: The case to update.
+        :param case_query: The case query that contains the case to update.
         :param conclusions: The conclusions to update the case with.
         """
         if not conclusions:
             return
         if len(conclusions) == 0:
             return
-        if isinstance(case, SQLTable):
+        if isinstance(case_query.original_case, SQLTable) or is_dataclass(case_query.original_case):
             for conclusion_name, conclusion in conclusions.items():
-                hint, origin, args = get_hint_for_attribute(conclusion_name, case)
-                attribute = getattr(case, conclusion_name)
-                if isinstance(attribute, set) or origin in {Set, set}:
-                    attribute = set() if attribute is None else attribute
+                attribute = getattr(case_query.case, conclusion_name)
+                if conclusion_name == case_query.attribute_name:
+                    attribute_type = case_query.attribute_type
+                else:
+                    attribute_type = (get_case_attribute_type(case_query.original_case, conclusion_name, attribute),)
+                if isinstance(attribute, set):
                     for c in conclusion:
                         attribute.update(make_set(c))
-                elif isinstance(attribute, list) or origin in {list, List}:
+                elif isinstance(attribute, list):
+                    attribute.extend(conclusion)
+                elif any(at in {List, list} for at in attribute_type):
                     attribute = [] if attribute is None else attribute
                     attribute.extend(conclusion)
-                elif (not is_iterable(conclusion) or (len(conclusion) == 1)) and hint == type(conclusion):
-                    setattr(case, conclusion_name, conclusion)
+                elif any(at in {Set, set} for at in attribute_type):
+                    attribute = set() if attribute is None else attribute
+                    for c in conclusion:
+                        attribute.update(make_set(c))
+                elif is_iterable(conclusion) and len(conclusion) == 1 \
+                        and any(at is type(list(conclusion)[0]) for at in attribute_type):
+                    setattr(case_query.case, conclusion_name, list(conclusion)[0])
+                elif not is_iterable(conclusion) and any(at is type(conclusion) for at in attribute_type):
+                    setattr(case_query.case, conclusion_name, conclusion)
                 else:
-                    raise ValueError(f"Cannot add multiple conclusions to attribute {conclusion_name}")
+                    raise ValueError(f"Unknown type or type mismatch for attribute {conclusion_name} with type "
+                                     f"{case_query.attribute_type} with conclusion "
+                                     f"{conclusion} of type {type(conclusion)}")
         else:
-            case.update(conclusions)
+            case_query.case.update(conclusions)
 
     def _to_json(self) -> Dict[str, Any]:
         return {"start_rules": {t: rdr.to_json() for t, rdr in self.start_rules_dict.items()}}
@@ -845,14 +906,16 @@ class GeneralRDR(RippleDownRules):
             start_rules_dict[k] = get_type_from_string(v['_type']).from_json(v)
         return cls(start_rules_dict)
 
-    def write_to_python_file(self, file_path: str):
+    def write_to_python_file(self, file_path: str, postfix: str = "") -> None:
         """
         Write the tree of rules as source code to a file.
 
         :param file_path: The path to the file to write the source code to.
+        :param postfix: The postfix to add to the file name.
         """
+        self.generated_python_file_name = self._default_generated_python_file_name + postfix
         for rdr in self.start_rules_dict.values():
-            rdr.write_to_python_file(file_path)
+            rdr.write_to_python_file(file_path, postfix=f"_of_grdr{postfix}")
         func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
         with open(file_path + f"/{self.generated_python_file_name}.py", "w") as f:
             f.write(self._get_imports(file_path) + "\n\n")
@@ -875,15 +938,29 @@ class GeneralRDR(RippleDownRules):
         else:
             return type(self.start_rule.corner_case)
 
-    def get_rdr_classifier_from_python_file(self, file_path: str):
+    def get_rdr_classifier_from_python_file(self, file_path: str) -> Callable[[Any], Any]:
         """
         :param file_path: The path to the file that contains the RDR classifier function.
+        :param postfix: The postfix to add to the file name.
         :return: The module that contains the rdr classifier function.
         """
         return importlib.import_module(f"{file_path.strip('./')}.{self.generated_python_file_name}").classify
 
     @property
     def generated_python_file_name(self) -> str:
+        if self._generated_python_file_name is None:
+            self._generated_python_file_name = self._default_generated_python_file_name
+        return self._generated_python_file_name
+
+    @generated_python_file_name.setter
+    def generated_python_file_name(self, value: str):
+        self._generated_python_file_name = value
+
+    @property
+    def _default_generated_python_file_name(self) -> str:
+        """
+        :return: The default generated python file name.
+        """
         return f"{self.start_rule.corner_case._name.lower()}_rdr"
 
     @property
@@ -891,17 +968,25 @@ class GeneralRDR(RippleDownRules):
         return f"List[Union[{', '.join([rdr.conclusion_type_hint for rdr in self.start_rules_dict.values()])}]]"
 
     def _get_imports(self, file_path: str) -> str:
+        """
+        Get the imports needed for the generated python file.
+
+        :param file_path: The path to the file that contains the RDR classifier function.
+        :return: The imports needed for the generated python file.
+        """
         imports = ""
         # add type hints
         imports += f"from typing_extensions import List, Union, Set\n"
         # import rdr type
         imports += f"from ripple_down_rules.rdr import GeneralRDR\n"
         # add case type
-        imports += f"from ripple_down_rules.datastructures import Case, create_case\n"
+        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"
         # add conclusion type imports
         for rdr in self.start_rules_dict.values():
-            imports += f"from {rdr.conclusion_type.__module__} import {rdr.conclusion_type.__name__}\n"
+            for conclusion_type in rdr.conclusion_type:
+                if conclusion_type.__module__ != "builtins":
+                    imports += f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
         # add rdr python generated functions.
         for rdr_key, rdr in self.start_rules_dict.items():
             imports += (f"from {file_path.strip('./')}"