ripple-down-rules 0.0.14__py3-none-any.whl → 0.1.0__py3-none-any.whl

ripple_down_rules/rdr.py

@@ -2,19 +2,19 @@ from __future__ import annotations
 
 import importlib
 from abc import ABC, abstractmethod
-from copy import copy, deepcopy
+from copy import copy
 from types import ModuleType
 
 from matplotlib import pyplot as plt
 from ordered_set import OrderedSet
 from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
-from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple, Callable
+from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple, Callable, Set
 
 from .datastructures import Case, MCRDRMode, CallableExpression, CaseAttribute, CaseQuery
 from .experts import Expert, Human
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
-from .utils import draw_tree, make_set, get_attribute_by_type, copy_case, \
-    get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list, get_full_class_name, get_type_from_string
+from .utils import draw_tree, make_set, copy_case, \
+    get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list, get_type_from_string
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -80,7 +80,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :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.target for case in case_queries]
+        targets = [{case_query.attribute_name: case_query.target} for case_query in case_queries]
         if animate_tree:
             plt.ion()
         i = 0
@@ -91,11 +91,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             if not targets:
                 targets = [None] * len(cases)
             for case_query in case_queries:
-                case = case_query.case
-                target = case_query.target
-                if not target:
-                    conclusions = self.classify(case) if self.start_rule and self.start_rule.conditions else []
-                    target = expert.ask_for_conclusion(case_query, conclusions)
+                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 not match:
@@ -105,8 +101,9 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                     num_rules = self.start_rule.size
                     self.update_figures()
             i += 1
-            all_predictions = [1 if self.is_matching(self.classify(case), target) else 0
-                               for case, target in zip(cases, targets)]
+            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_pred = sum(all_predictions)
             print(f"Accuracy: {all_pred}/{len(targets)}")
             all_predicted = targets and all_pred == len(targets)
@@ -120,7 +117,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             plt.show()
 
     @staticmethod
-    def calculate_precision_and_recall(pred_cat: List[CaseAttribute], target: List[CaseAttribute]) -> Tuple[List[bool], List[bool]]:
+    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.
@@ -128,9 +126,33 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         pred_cat = pred_cat if is_iterable(pred_cat) else [pred_cat]
         target = target if is_iterable(target) else [target]
-        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]
+        recall = []
+        precision = []
+        if isinstance(pred_cat, dict):
+            for pred_key, pred_value in pred_cat.items():
+                if pred_key not in target:
+                    continue
+                # if is_iterable(pred_value):
+                #     print(pred_value, target[pred_key])
+                #     precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
+                precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
+                # else:
+                #     precision.append(pred_value == target[pred_key])
+            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])
+            print(f"Precision: {precision}, Recall: {recall}")
+        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:
@@ -157,22 +179,15 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             draw_tree(self.start_rule, self.fig)
 
     @staticmethod
-    def case_has_conclusion(case: Union[Case, SQLTable], conclusion_type: Type) -> bool:
+    def case_has_conclusion(case: Union[Case, SQLTable], conclusion_name: str) -> bool:
         """
         Check if the case has a conclusion.
 
         :param case: The case to check.
-        :param conclusion_type: The target category type to compare the case with.
+        :param conclusion_name: The target category name to compare the case with.
         :return: Whether the case has a conclusion or not.
         """
-        if isinstance(case, SQLTable):
-            prop_name, prop_value = get_attribute_by_type(case, conclusion_type)
-            if hasattr(prop_value, "__iter__") and not isinstance(prop_value, str):
-                return len(prop_value) > 0
-            else:
-                return prop_value is not None
-        else:
-            return conclusion_type in case
+        return hasattr(case, conclusion_name) and getattr(case, conclusion_name) is not None
 
 
 class RDRWithCodeWriter(RippleDownRules, ABC):
@@ -194,16 +209,17 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
         :param file_path: The path to the file to write the source code to.
         """
-        func_def = f"def classify(case: {self.case_type.__name__}) -> {self._get_conclusion_type_hint()}:\n"
+        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")
             f.write(func_def)
-            f.write(f"{' '*4}if not isinstance(case, Case):\n"
-                    f"{' '*4}    case = create_case(case, recursion_idx=3)\n""")
+            f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
+                    f"{' ' * 4}    case = create_case(case, recursion_idx=3)\n""")
             self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4)
 
+    @property
     @abstractmethod
-    def _get_conclusion_type_hint(self) -> str:
+    def conclusion_type_hint(self) -> str:
         """
         :return: The type hint of the conclusion of the rdr as a string.
         """
@@ -242,7 +258,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         :return: The type of the case (input) to the RDR classifier.
         """
         if isinstance(self.start_rule.corner_case, Case):
-            return self.start_rule.corner_case._type
+            return self.start_rule.corner_case._obj_type
         else:
             return type(self.start_rule.corner_case)
 
@@ -254,8 +270,17 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         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)
 
+    @property
+    def attribute_name(self) -> str:
+        """
+        :return: The name of the attribute that the classifier is classifying.
+        """
+        return self.start_rule.conclusion_name
+
 
 class SingleClassRDR(RDRWithCodeWriter):
 
@@ -270,23 +295,20 @@ class SingleClassRDR(RDRWithCodeWriter):
         :return: The category that the case belongs to.
         """
         expert = expert if expert else Human(session=self.session)
-        case, attribute = case_query.case, case_query.attribute
         if case_query.target is None:
             target = expert.ask_for_conclusion(case_query)
-        else:
-            target = case_query.target
-
         if not self.start_rule:
-            conditions = expert.ask_for_conditions(case, [target])
-            self.start_rule = SingleClassRule(conditions, target, corner_case=case)
+            conditions = expert.ask_for_conditions(case_query)
+            self.start_rule = SingleClassRule(conditions, case_query.target, corner_case=case_query.case,
+                                              conclusion_name=case_query.attribute_name)
 
-        pred = self.evaluate(case)
+        pred = self.evaluate(case_query.case)
 
-        if pred.conclusion != target:
-            conditions = expert.ask_for_conditions(case, [target], pred)
-            pred.fit_rule(case, target, conditions=conditions)
+        if pred.conclusion != case_query.target:
+            conditions = expert.ask_for_conditions(case_query, pred)
+            pred.fit_rule(case_query.case, case_query.target, conditions=conditions)
 
-        return self.classify(case)
+        return self.classify(case_query.case)
 
     def classify(self, case: Case) -> Optional[CaseAttribute]:
         """
@@ -316,7 +338,8 @@ class SingleClassRDR(RDRWithCodeWriter):
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent)
 
-    def _get_conclusion_type_hint(self) -> str:
+    @property
+    def conclusion_type_hint(self) -> str:
         return self.conclusion_type.__name__
 
     def _to_json(self) -> Dict[str, Any]:
@@ -383,50 +406,49 @@ class MultiClassRDR(RDRWithCodeWriter):
         :return: The conclusions that the case belongs to.
         """
         expert = expert if expert else Human(session=self.session)
-        case = case_query.case
         if case_query.target is None:
-            targets = [expert.ask_for_conclusion(case_query)]
-        else:
-            targets = [case_query.target]
+            targets = expert.ask_for_conclusion(case_query)
         self.expert_accepted_conclusions = []
         user_conclusions = []
-        for target in targets:
-            self.update_start_rule(case, target, expert)
-            self.conclusions = []
-            self.stop_rule_conditions = None
-            evaluated_rule = self.start_rule
-            while evaluated_rule:
-                next_rule = evaluated_rule(case)
-                good_conclusions = targets + user_conclusions + self.expert_accepted_conclusions
-
-                if evaluated_rule.fired:
-                    if target and evaluated_rule.conclusion not in good_conclusions:
-                        # if self.case_has_conclusion(case, evaluated_rule.conclusion):
-                        # Rule fired and conclusion is different from target
-                        self.stop_wrong_conclusion_else_add_it(case, target, expert, evaluated_rule,
-                                                               add_extra_conclusions)
-                    else:
-                        # Rule fired and target is correct or there is no target to compare
-                        self.add_conclusion(evaluated_rule)
-
-                if not next_rule:
-                    if not make_set(target).intersection(make_set(self.conclusions)):
-                        # Nothing fired and there is a target that should have been in the conclusions
-                        self.add_rule_for_case(case, target, 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:
-                        # 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))
-                        if user_conclusions:
-                            next_rule = self.last_top_rule
-                evaluated_rule = next_rule
+        self.update_start_rule(case_query, expert)
+        self.conclusions = []
+        self.stop_rule_conditions = None
+        evaluated_rule = self.start_rule
+        while evaluated_rule:
+            next_rule = evaluated_rule(case_query.case)
+            good_conclusions = make_list(case_query.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):
+                    # Rule fired and conclusion is different from target
+                    self.stop_wrong_conclusion_else_add_it(case_query, expert, evaluated_rule,
+                                                           add_extra_conclusions)
+                else:
+                    # Rule fired and target is correct or there is no target to compare
+                    self.add_conclusion(evaluated_rule)
+
+            if not next_rule:
+                if not make_set(case_query.target).intersection(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:
+                    # 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:
+                        next_rule = self.last_top_rule
+            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.
+
+        :
         """
         if rule == self.start_rule:
             file.write(f"{parent_indent}conclusions = set()\n")
@@ -435,14 +457,15 @@ class MultiClassRDR(RDRWithCodeWriter):
             conclusion_indent = parent_indent
             if hasattr(rule, "refinement") and rule.refinement:
                 self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ")
-                conclusion_indent = parent_indent + " "*4
+                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)
 
-    def _get_conclusion_type_hint(self) -> str:
+    @property
+    def conclusion_type_hint(self) -> str:
         return f"Set[{self.conclusion_type.__name__}]"
 
     def _get_imports(self) -> str:
@@ -450,19 +473,18 @@ class MultiClassRDR(RDRWithCodeWriter):
         imports += "from typing_extensions import Set\n"
         return imports
 
-    def update_start_rule(self, case: Union[Case, SQLTable], target: Any, expert: Expert):
+    def update_start_rule(self, case_query: CaseQuery, expert: Expert):
         """
         Update the starting rule of the classifier.
 
-        :param case: The case to classify.
-        :param target: The target category to compare the case with.
+        :param case_query: The case query to update the starting rule with.
         :param expert: The expert to ask for differentiating features as new rule conditions.
         """
         if not self.start_rule.conditions:
-            conditions = expert.ask_for_conditions(case, target)
+            conditions = expert.ask_for_conditions(case_query)
             self.start_rule.conditions = conditions
-            self.start_rule.conclusion = target
-            self.start_rule.corner_case = case
+            self.start_rule.conclusion = case_query.target
+            self.start_rule.corner_case = case_query.case
 
     @property
     def last_top_rule(self) -> Optional[MultiClassTopRule]:
@@ -474,35 +496,34 @@ class MultiClassRDR(RDRWithCodeWriter):
         else:
             return self.start_rule.furthest_alternative[-1]
 
-    def stop_wrong_conclusion_else_add_it(self, case: Union[Case, SQLTable], target: Any, expert: Expert,
+    def stop_wrong_conclusion_else_add_it(self, case_query: CaseQuery, expert: Expert,
                                           evaluated_rule: MultiClassTopRule,
                                           add_extra_conclusions: bool):
         """
         Stop a wrong conclusion by adding a stopping rule.
         """
-        if self.is_same_category_type(evaluated_rule.conclusion, target) \
-                and self.is_conflicting_with_target(evaluated_rule.conclusion, target):
-            self.stop_conclusion(case, target, expert, evaluated_rule)
-        elif not self.conclusion_is_correct(case, target, expert, evaluated_rule, add_extra_conclusions):
-            self.stop_conclusion(case, target, expert, evaluated_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)
 
-    def stop_conclusion(self, case: Union[Case, SQLTable], target: Any,
+    def stop_conclusion(self, case_query: CaseQuery,
                         expert: Expert, evaluated_rule: MultiClassTopRule):
         """
         Stop a conclusion by adding a stopping rule.
 
-        :param case: The case to classify.
-        :param target: The target category to compare the case with.
+        :param case_query: The case query to stop the conclusion for.
         :param expert: The expert to ask for differentiating features as new rule conditions.
         :param evaluated_rule: The evaluated rule to ask the expert about.
         """
-        conditions = expert.ask_for_conditions(case, target, evaluated_rule)
-        evaluated_rule.fit_rule(case, target, conditions=conditions)
+        conditions = expert.ask_for_conditions(case_query, evaluated_rule)
+        evaluated_rule.fit_rule(case_query.case, case_query.target, conditions=conditions)
         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, target, case)
+            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:
@@ -529,37 +550,40 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         return conclusion.__class__ == target.__class__ and target.__class__ != CaseAttribute
 
-    def conclusion_is_correct(self, case: Union[Case, SQLTable], target: Any, expert: Expert, evaluated_rule: Rule,
+    def conclusion_is_correct(self, case_query: CaseQuery,
+                              expert: Expert, evaluated_rule: Rule,
                               add_extra_conclusions: bool) -> bool:
         """
         Ask the expert if the conclusion is correct, and add it to the conclusions if it is.
 
-        :param case: The case to classify.
-        :param target: The target category to compare the case with.
+        :param case_query: The case query to ask the expert about.
         :param expert: The expert to ask for differentiating features as new rule conditions.
         :param evaluated_rule: The evaluated rule to ask the expert about.
         :param add_extra_conclusions: Whether adding extra conclusions after classification is allowed.
         :return: Whether the conclusion is correct or not.
         """
-        conclusions = list(OrderedSet(self.conclusions))
-        if (add_extra_conclusions and expert.ask_if_conclusion_is_correct(case, evaluated_rule.conclusion,
-                                                                          targets=target,
+        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,
                                                                           current_conclusions=conclusions)):
             self.add_conclusion(evaluated_rule)
             self.expert_accepted_conclusions.append(evaluated_rule.conclusion)
             return True
         return False
 
-    def add_rule_for_case(self, case: Union[Case, SQLTable], target: Any, expert: Expert):
+    def add_rule_for_case(self, case_query: CaseQuery, expert: Expert):
         """
         Add a rule for a case that has not been classified with any conclusion.
+
+        :param case_query: The case query to add the rule for.
+        :param expert: The expert to ask for differentiating features as new rule conditions.
         """
         if self.stop_rule_conditions and self.mode == MCRDRMode.StopPlusRule:
             conditions = self.stop_rule_conditions
             self.stop_rule_conditions = None
         else:
-            conditions = expert.ask_for_conditions(case, target)
-        self.add_top_rule(conditions, target, case)
+            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]:
         """
@@ -633,20 +657,31 @@ class GeneralRDR(RippleDownRules):
      gets called when the final rule fires.
     """
 
-    def __init__(self, category_rdr_map: Optional[Dict[Type, Union[SingleClassRDR, MultiClassRDR]]] = None):
+    def __init__(self, category_rdr_map: Optional[Dict[str, Union[SingleClassRDR, MultiClassRDR]]] = None):
         """
-        :param category_rdr_map: A map of categories to ripple down rules classifiers,
+        :param category_rdr_map: A map of case attribute names to ripple down rules classifiers,
         where each category is a parent category that has a set of mutually exclusive (in case of SCRDR) child
-        categories, e.g. {Species: SCRDR, Habitat: MCRDR}, where Species and Habitat are parent categories and SCRDR
-        and MCRDR are SingleClass and MultiClass ripple down rules classifiers. Species can have child categories like
-        Mammal, Bird, Fish, etc. which are mutually exclusive, and Habitat can have child categories like
-        Land, Water, Air, etc, which are not mutually exclusive due to some animals living more than one habitat.
+        categories, e.g. {'species': SCRDR, 'habitats': MCRDR}, where 'species' and 'habitats' are attribute names
+        for a case of type Animal, while SCRDR and MCRDR are SingleClass and MultiClass ripple down rules classifiers.
+        Species can have values like Mammal, Bird, Fish, etc. which are mutually exclusive, while Habitat can have
+        values like Land, Water, Air, etc., which are not mutually exclusive due to some animals living more than one
+        habitat.
         """
-        self.start_rules_dict: Dict[Type, Union[SingleClassRDR, MultiClassRDR]] \
+        self.start_rules_dict: Dict[str, Union[SingleClassRDR, MultiClassRDR]] \
             = category_rdr_map if category_rdr_map else {}
         super(GeneralRDR, self).__init__()
         self.all_figs: List[plt.Figure] = [sr.fig for sr in self.start_rules_dict.values()]
 
+    def add_rdr(self, rdr: Union[SingleClassRDR, MultiClassRDR], attribute_name: Optional[str] = None):
+        """
+        Add a ripple down rules classifier to the map of classifiers.
+
+        :param rdr: The ripple down rules classifier to add.
+        :param attribute_name: The name of the attribute that the classifier is classifying.
+        """
+        attribute_name = attribute_name if attribute_name else rdr.attribute_name
+        self.start_rules_dict[attribute_name] = rdr
+
     @property
     def start_rule(self) -> Optional[Union[SingleClassRule, MultiClassTopRule]]:
         return self.start_rules[0] if self.start_rules_dict else None
@@ -654,7 +689,7 @@ class GeneralRDR(RippleDownRules):
     @start_rule.setter
     def start_rule(self, value: Union[SingleClassRDR, MultiClassRDR]):
         if value:
-            self.start_rules_dict[type(value.start_rule.conclusion)] = value
+            self.start_rules_dict[value.attribute_name] = value
 
     @property
     def start_rules(self) -> List[Union[SingleClassRule, MultiClassTopRule]]:
@@ -668,21 +703,44 @@ class GeneralRDR(RippleDownRules):
         :param case: The case to classify.
         :return: The categories that the case belongs to.
         """
-        conclusions = []
+        return self._classify(self.start_rules_dict, case)
+
+    @staticmethod
+    def _classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
+                  case: Union[Case, SQLTable]) -> Optional[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.
+        :return: The categories that the case belongs to.
+        """
+        conclusions = {}
         case_cp = copy_case(case)
         while True:
-            added_attributes = False
-            for cat_type, rdr in self.start_rules_dict.items():
-                if self.case_has_conclusion(case_cp, cat_type):
-                    continue
+            new_conclusions = {}
+            for attribute_name, rdr in classifiers_dict.items():
                 pred_atts = rdr.classify(case_cp)
-                if pred_atts:
+                if pred_atts is None:
+                    continue
+                if isinstance(rdr, 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 = [p for p in pred_atts if p not in conclusions]
-                    added_attributes = True
-                    conclusions.extend(pred_atts)
-                    GeneralRDR.update_case(case_cp, pred_atts)
-            if not added_attributes:
+                    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] = []
+                        conclusions[attribute_name].extend(pred_atts)
+                if attribute_name in new_conclusions:
+                    GeneralRDR.update_case(case_cp, new_conclusions)
+            if len(new_conclusions) == 0:
                 break
         return conclusions
 
@@ -707,103 +765,79 @@ 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_query_cp = copy(case_queries[0])
-        case_cp = case_query_cp.case
+        case_cp = copy(case_queries[0]).case
         for case_query in case_queries:
-            target = case_query.target
-            if not target:
+            case_query_cp = copy(case_query)
+            case_query_cp.case = case_cp
+            if case_query.target is None:
+                conclusions = self.classify(case) if self.start_rule and self.start_rule.conditions else []
                 target = expert.ask_for_conclusion(case_query)
-            case_query_cp = CaseQuery(case_cp, attribute_name=case_query.attribute_name, target=target)
-            if is_iterable(target) and not isinstance(target, CaseAttribute):
-                target_type = type(make_list(target)[0])
-                assert all([type(t) is target_type for t in target]), ("All targets of a case query must be of the same"
-                                                                       " type")
-            else:
-                target_type = type(target)
-            if target_type not in self.start_rules_dict:
+
+            if case_query.attribute_name not in self.start_rules_dict:
                 conclusions = self.classify(case)
                 self.update_case(case_cp, conclusions)
-                new_rdr = self.initialize_new_rdr_for_attribute(target, case_cp)
+
+                new_rdr = self.initialize_new_rdr_for_attribute(case_query.attribute_name, case_cp, case_query.target)
+                self.add_rdr(new_rdr, case_query.attribute_name)
+
                 new_conclusions = new_rdr.fit_case(case_query_cp, expert, **kwargs)
-                self.start_rules_dict[target_type] = new_rdr
-                self.update_case(case_cp, new_conclusions, target_type)
-            elif not self.case_has_conclusion(case_cp, target_type):
-                for rdr_type, rdr in self.start_rules_dict.items():
-                    if target_type is not rdr_type:
+                self.update_case(case_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)
                     else:
-                        conclusions = self.start_rules_dict[target_type].fit_case(case_query_cp,
-                                                                                   expert, **kwargs)
-                    self.update_case(case_cp, conclusions, rdr_type)
+                        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)
 
         return self.classify(case)
 
     @staticmethod
-    def initialize_new_rdr_for_attribute(attribute: Any, case: Union[Case, SQLTable]):
+    def initialize_new_rdr_for_attribute(attribute_name: str, case: Union[Case, SQLTable], target: Any):
         """
         Initialize the appropriate RDR type for the target.
         """
-        if isinstance(case, SQLTable):
-            prop = get_attribute_by_type(case, type(attribute))
-            if hasattr(prop, "__iter__") and not isinstance(prop, str):
-                return MultiClassRDR()
-            else:
-                return SingleClassRDR()
-        elif isinstance(attribute, CaseAttribute):
+        attribute = getattr(case, attribute_name) if hasattr(case, attribute_name) else target
+        if isinstance(attribute, CaseAttribute):
             return SingleClassRDR() if attribute.mutually_exclusive else MultiClassRDR()
         else:
-            return MultiClassRDR() if is_iterable(attribute) else SingleClassRDR()
+            return MultiClassRDR() if is_iterable(attribute) or (attribute is None) else SingleClassRDR()
 
     @staticmethod
-    def update_case(case: Union[Case, SQLTable],
-                    conclusions: List[Any], attribute_type: Optional[Any] = None):
+    def update_case(case: Union[Case, SQLTable], conclusions: Dict[str, Any]):
         """
         Update the case with the conclusions.
 
         :param case: The case to update.
         :param conclusions: The conclusions to update the case with.
-        :param attribute_type: The type of the attribute to update.
         """
         if not conclusions:
             return
-        conclusions = [conclusions] if not isinstance(conclusions, list) else list(conclusions)
         if len(conclusions) == 0:
             return
         if isinstance(case, SQLTable):
-            conclusions_type = type(conclusions[0]) if not attribute_type else attribute_type
-            attr_name, attribute = get_attribute_by_type(case, conclusions_type)
-            hint, origin, args = get_hint_for_attribute(attr_name, case)
-            if isinstance(attribute, set) or origin == set:
-                attribute = set() if attribute is None else attribute
-                for c in conclusions:
-                    attribute.update(make_set(c))
-            elif isinstance(attribute, list) or origin == list:
-                attribute = [] if attribute is None else attribute
-                attribute.extend(conclusions)
-            elif len(conclusions) == 1 and hint == conclusions_type:
-                setattr(case, attr_name, conclusions.pop())
-            else:
-                raise ValueError(f"Cannot add multiple conclusions to attribute {attr_name}")
+            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
+                    for c in conclusion:
+                        attribute.update(make_set(c))
+                elif isinstance(attribute, list) or origin in {list, List}:
+                    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)
+                else:
+                    raise ValueError(f"Cannot add multiple conclusions to attribute {conclusion_name}")
         else:
-            for c in make_set(conclusions):
-                case.update(c.as_dict)
-
-    @property
-    def names_of_all_types(self) -> List[str]:
-        """
-        Get the names of all the types of categories that the GRDR can classify.
-        """
-        return [t.__name__ for t in self.start_rules_dict.keys()]
-
-    @property
-    def all_types(self) -> List[Type]:
-        """
-        Get all the types of categories that the GRDR can classify.
-        """
-        return list(self.start_rules_dict.keys())
+            case.update(conclusions)
 
     def _to_json(self) -> Dict[str, Any]:
-        return {"start_rules": {get_full_class_name(t): rdr.to_json() for t, rdr in self.start_rules_dict.items()}}
+        return {"start_rules": {t: rdr.to_json() for t, rdr in self.start_rules_dict.items()}}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> GeneralRDR:
@@ -812,6 +846,78 @@ class GeneralRDR(RippleDownRules):
         """
         start_rules_dict = {}
         for k, v in data["start_rules"].items():
-            k = get_type_from_string(k)
             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):
+        """
+        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.
+        """
+        for rdr in self.start_rules_dict.values():
+            rdr.write_to_python_file(file_path)
+        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")
+            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")
+            f.write("\n\n")
+            f.write(func_def)
+            f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
+                    f"{' ' * 4}    case = create_case(case, recursion_idx=3)\n""")
+            f.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
+
+    @property
+    def case_type(self) -> Type:
+        """
+        :return: The type of the case (input) to the RDR classifier.
+        """
+        if isinstance(self.start_rule.corner_case, Case):
+            return self.start_rule.corner_case._obj_type
+        else:
+            return type(self.start_rule.corner_case)
+
+    def get_rdr_classifier_from_python_file(self, file_path: str):
+        """
+        :param file_path: The path to the file that contains the RDR classifier function.
+        :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:
+        return f"{self.case_type.__name__.lower()}_grdr"
+
+    @property
+    def conclusion_type_hint(self) -> str:
+        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:
+        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 {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"
+        # add rdr python generated functions.
+        for rdr_key, rdr in self.start_rules_dict.items():
+            imports += (f"from {file_path.strip('./')}"
+                        f" import {rdr.generated_python_file_name} as {self.rdr_key_to_function_name(rdr_key)}\n")
+        return imports
+
+    @staticmethod
+    def rdr_key_to_function_name(rdr_key: str) -> str:
+        """
+        Convert the RDR key to a function name.
+
+        :param rdr_key: The RDR key to convert.
+        :return: The function name.
+        """
+        return rdr_key.replace(".", "_").lower() + "_classifier"