ripple-down-rules 0.0.15__py3-none-any.whl → 0.1.1__py3-none-any.whl

ripple_down_rules/rdr.py

@@ -8,13 +8,13 @@ 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)
@@ -129,9 +126,27 @@ 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
+                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:
@@ -158,22 +173,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):
@@ -200,7 +208,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             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"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
             self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4)
 
     @property
@@ -221,6 +229,11 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         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 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"
         return imports
 
     def get_rdr_classifier_from_python_file(self, package_name) -> Callable[[Any], Any]:
@@ -232,11 +245,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
     @property
     def generated_python_file_name(self) -> str:
-        return f"{self.conclusion_type.__name__.lower()}_{self.__class__.__name__}"
-
-    @property
-    def python_file_name(self):
-        return f"{self.start_rule.conclusion.__name__.lower()}_rdr"
+        return f"{self.start_rule.corner_case._name.lower()}_{self.attribute_name}_rdr"
 
     @property
     def case_type(self) -> Type:
@@ -244,7 +253,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)
 
@@ -260,6 +269,13 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
                 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):
 
@@ -274,23 +290,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]:
         """
@@ -388,44 +401,41 @@ 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],
@@ -458,19 +468,19 @@ 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
+            self.start_rule.conclusion_name = case_query.attribute_name
 
     @property
     def last_top_rule(self) -> Optional[MultiClassTopRule]:
@@ -482,35 +492,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:
@@ -537,37 +546,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]:
         """
@@ -641,20 +653,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
@@ -662,7 +685,7 @@ class GeneralRDR(RippleDownRules):
     @start_rule.setter
     def start_rule(self, value: Union[SingleClassRDR, MultiClassRDR]):
         if value:
-            self.start_rules_dict[value.conclusion_type] = value
+            self.start_rules_dict[value.attribute_name] = value
 
     @property
     def start_rules(self) -> List[Union[SingleClassRule, MultiClassTopRule]]:
@@ -679,8 +702,8 @@ class GeneralRDR(RippleDownRules):
         return self._classify(self.start_rules_dict, case)
 
     @staticmethod
-    def _classify(classifiers_dict: Dict[Type, Union[ModuleType, RippleDownRules]],
-                  case: Union[Case, SQLTable]) -> Optional[List[Any]]:
+    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.
@@ -689,21 +712,31 @@ class GeneralRDR(RippleDownRules):
         :param case: The case to classify.
         :return: The categories that the case belongs to.
         """
-        conclusions = []
+        conclusions = {}
         case_cp = copy_case(case)
         while True:
-            added_attributes = False
-            for cat_type, rdr in classifiers_dict.items():
-                if GeneralRDR.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
 
@@ -728,103 +761,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:
@@ -833,7 +842,6 @@ 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)
 
@@ -849,12 +857,12 @@ class GeneralRDR(RippleDownRules):
         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 t, rdr in self.start_rules_dict.items():
-                f.write(f"classifiers_dict[{t.__name__}] = {t.__name__.lower()}_classifier\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"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
             f.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
 
     @property
@@ -863,7 +871,7 @@ class GeneralRDR(RippleDownRules):
         :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)
 
@@ -876,7 +884,7 @@ class GeneralRDR(RippleDownRules):
 
     @property
     def generated_python_file_name(self) -> str:
-        return f"{self.case_type.__name__.lower()}_grdr"
+        return f"{self.start_rule.corner_case._name.lower()}_rdr"
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -892,10 +900,20 @@ class GeneralRDR(RippleDownRules):
         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 conclusion_type in self.start_rules_dict.keys():
-            imports += f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
+        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 conclusion_type, rdr in self.start_rules_dict.items():
+        for rdr_key, rdr in self.start_rules_dict.items():
             imports += (f"from {file_path.strip('./')}"
-                        f" import {rdr.generated_python_file_name} as {conclusion_type.__name__.lower()}_classifier\n")
+                        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"