ripple-down-rules 0.1.63__tar.gz → 0.1.65__tar.gz

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.63
+Version: 0.1.65
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.63"
+version = "0.1.65"
 description = "Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning."
 readme = "README.md"
 authors = [{ name = "Abdelrhman Bassiouny", email = "abassiou@uni-bremen.de" }]

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -133,7 +133,7 @@ class CaseQuery:
         if value is not None and not isinstance(value, (CallableExpression, str)):
             raise ValueError("The target must be a CallableExpression or a string.")
         self._target = value
-        self._update_target_value()
+        self.update_target_value()
 
     @property
     def target_value(self) -> Any:
@@ -141,10 +141,10 @@ class CaseQuery:
         :return: The target value of the case query.
         """
         if self._target_value is None:
-            self._update_target_value()
+            self.update_target_value()
         return self._target_value
 
-    def _update_target_value(self):
+    def update_target_value(self):
         """
         Update the target value of the case query.
         """

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/src/ripple_down_rules/experts.py

@@ -32,10 +32,11 @@ class Expert(ABC):
     """
     A flag to indicate if the expert should use loaded answers or not.
     """
-    known_categories: Optional[Dict[str, Type[CaseAttribute]]] = None
-    """
-    The known categories (i.e. Column types) to use.
-    """
+
+    def __init__(self, use_loaded_answers: bool = False, append: bool = False):
+        self.all_expert_answers = []
+        self.use_loaded_answers = use_loaded_answers
+        self.append = append
 
     @abstractmethod
     def ask_for_conditions(self, case_query: CaseQuery, last_evaluated_rule: Optional[Rule] = None) \
@@ -51,28 +52,6 @@ class Expert(ABC):
         pass
 
     @abstractmethod
-    def ask_for_extra_rules(self, case_query: CaseQuery) -> List[Dict[PromptFor, CallableExpression]]:
-        """
-        Ask the expert to provide extra rules for a case by providing a pair of conclusion and conditions.
-
-        :param case_query: The case query containing the case to classify.
-        :return: The extra rules for the case as a list of dictionaries, where each dictionary contains the
-                    conclusion and conditions for the rule.
-        """
-        pass
-
-    @abstractmethod
-    def ask_if_conclusion_is_correct(self, case_query: CaseQuery, conclusion: Any,
-                                     current_conclusions: Any) -> bool:
-        """
-        Ask the expert if the conclusion is correct.
-
-        :param case_query: The case query about which the expert should answer.
-        :param conclusion: The conclusion to check.
-        :param current_conclusions: The current conclusions for the case.
-        """
-        pass
-
     def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
         """
         Ask the expert to provide a relational conclusion for the case.
@@ -87,18 +66,14 @@ class Human(Expert):
     The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
     """
 
-    def __init__(self, use_loaded_answers: bool = False):
-        self.all_expert_answers = []
-        self.use_loaded_answers = use_loaded_answers
-
-    def save_answers(self, path: str, append: bool = False):
+    def save_answers(self, path: str):
         """
         Save the expert answers to a file.
 
         :param path: The path to save the answers to.
         :param append: A flag to indicate if the answers should be appended to the file or not.
         """
-        if append:
+        if self.append:
             # read the file and append the new answers
             with open(path + '.json', "r") as f:
                 all_answers = json.load(f)
@@ -126,24 +101,6 @@ class Human(Expert):
                                           last_evaluated_rule=last_evaluated_rule)
         return self._get_conditions(case_query)
 
-    def ask_for_extra_rules(self, case_query: CaseQuery) -> List[Dict[PromptFor, CallableExpression]]:
-        """
-        Ask the expert to provide extra rules for a case by providing a pair of conclusion and conditions.
-
-        :param case_query: The case query containing the case to classify.
-        :return: The extra rules for the case as a list of dictionaries, where each dictionary contains the
-                    conclusion and conditions for the rule.
-        """
-        rules = []
-        while True:
-            conclusion = self.ask_for_conclusion(case_query)
-            if conclusion is None:
-                break
-            conditions = self._get_conditions(case_query)
-            rules.append({PromptFor.Conclusion: conclusion,
-                         PromptFor.Conditions: conditions})
-        return rules
-
     def _get_conditions(self, case_query: CaseQuery) \
             -> CallableExpression:
         """
@@ -154,6 +111,8 @@ class Human(Expert):
         :return: The differentiating features as new rule conditions.
         """
         user_input = None
+        if self.use_loaded_answers and len(self.all_expert_answers) == 0 and self.append:
+            self.use_loaded_answers = False
         if self.use_loaded_answers:
             user_input = self.all_expert_answers.pop(0)
         if user_input:
@@ -173,6 +132,8 @@ class Human(Expert):
         :return: The conclusion for the case as a callable expression.
         """
         expression: Optional[CallableExpression] = None
+        if self.use_loaded_answers and len(self.all_expert_answers) == 0 and self.append:
+            self.use_loaded_answers = False
         if self.use_loaded_answers:
             expert_input = self.all_expert_answers.pop(0)
             if expert_input is not None:
@@ -184,63 +145,3 @@ class Human(Expert):
             self.all_expert_answers.append(expert_input)
         case_query.target = expression
         return expression
-
-    def get_category_type(self, cat_name: str) -> Optional[Type[CaseAttribute]]:
-        """
-        Get the category type from the known categories.
-
-        :param cat_name: The name of the category.
-        :return: The category type.
-        """
-        cat_name = cat_name.lower()
-        self.known_categories = get_all_subclasses(
-            CaseAttribute) if not self.known_categories else self.known_categories
-        self.known_categories.update(CaseAttribute.registry)
-        category_type = None
-        if cat_name in self.known_categories:
-            category_type = self.known_categories[cat_name]
-        return category_type
-
-    def ask_if_category_is_mutually_exclusive(self, category_name: str) -> bool:
-        """
-        Ask the expert if the new category can have multiple values.
-
-        :param category_name: The name of the category to ask about.
-        """
-        question = f"Can a case have multiple values of the new category {category_name}? (y/n):"
-        return not self.ask_for_affirmation(question)
-
-    def ask_if_conclusion_is_correct(self, case_query: CaseQuery, conclusion: Any,
-                                     current_conclusions: Any) -> bool:
-        """
-        Ask the expert if the conclusion is correct.
-
-        :param case_query: The case query about which the expert should answer.
-        :param conclusion: The conclusion to check.
-        :param current_conclusions: The current conclusions for the case.
-        """
-        if not self.use_loaded_answers:
-            print(f"Current conclusions: {current_conclusions}")
-        return self.ask_for_affirmation(case_query,
-                                        f"Is the conclusion {conclusion} correct for the case (True/False):")
-
-    def ask_for_affirmation(self, case_query: CaseQuery, question: str) -> bool:
-        """
-        Ask the expert a yes or no question.
-
-        :param case_query: The case query about which the expert should answer.
-        :param question: The question to ask the expert.
-        :return: The answer to the question.
-        """
-        while True:
-            if self.use_loaded_answers:
-                answer = self.all_expert_answers.pop(0)
-            else:
-                _, expression = prompt_user_for_expression(case_query, PromptFor.Affirmation, question)
-                answer = expression(case_query.case)
-            if answer:
-                self.all_expert_answers.append(True)
-                return True
-            else:
-                self.all_expert_answers.append(False)
-                return False

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/src/ripple_down_rules/rdr.py

@@ -22,7 +22,7 @@ from .helpers import is_matching
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 from .utils import draw_tree, make_set, copy_case, \
     SubclassJSONSerializer, is_iterable, make_list, get_type_from_string, \
-    get_case_attribute_type, is_conflicting
+    get_case_attribute_type, is_conflicting, update_case
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -49,32 +49,6 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         self.start_rule = start_rule
         self.fig: Optional[plt.Figure] = None
 
-    def __call__(self, case: Union[Case, SQLTable]) -> CaseAttribute:
-        return self.classify(case)
-
-    @abstractmethod
-    def classify(self, case: Union[Case, SQLTable]) -> Optional[CaseAttribute]:
-        """
-        Classify a case.
-
-        :param case: The case to classify.
-        :return: The category that the case belongs to.
-        """
-        pass
-
-    @abstractmethod
-    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
-            -> Union[CaseAttribute, CallableExpression]:
-        """
-        Fit the RDR on a case, and ask the expert for refinements or alternatives if the classification is incorrect by
-        comparing the case with the target category.
-
-        :param case_query: The query containing the case to classify and the target category to compare the case with.
-        :param expert: The expert to ask for differentiating features as new rule conditions.
-        :return: The category that the case belongs to.
-        """
-        pass
-
     def fit(self, case_queries: List[CaseQuery],
             expert: Optional[Expert] = None,
             n_iter: int = None,
@@ -124,6 +98,63 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             plt.ioff()
             plt.show()
 
+    def __call__(self, case: Union[Case, SQLTable]) -> CaseAttribute:
+        return self.classify(case)
+
+    @abstractmethod
+    def classify(self, case: Union[Case, SQLTable]) -> Optional[CaseAttribute]:
+        """
+        Classify a case.
+
+        :param case: The case to classify.
+        :return: The category that the case belongs to.
+        """
+        pass
+
+    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
+            -> Union[CaseAttribute, CallableExpression]:
+        """
+        Fit the classifier to a case and ask the expert for refinements or alternatives if the classification is
+        incorrect by comparing the case with the target category.
+
+        :param case_query: The query containing the case to classify and the target category to compare the case with.
+        :param expert: The expert to ask for differentiating features as new rule conditions.
+        :return: The category that the case belongs to.
+        """
+        if case_query is None:
+            raise ValueError("The case query cannot be None.")
+        if case_query.target is None:
+            expert.ask_for_conclusion(case_query)
+            if case_query.target is None:
+                return self.classify(case_query.case)
+
+        self.update_start_rule(case_query, expert)
+
+        return self._fit_case(case_query, expert=expert, **kwargs)
+
+    @abstractmethod
+    def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
+            -> Union[CaseAttribute, CallableExpression]:
+        """
+        Fit the RDR on a case, and ask the expert for refinements or alternatives if the classification is incorrect by
+        comparing the case with the target category.
+
+        :param case_query: The query containing the case to classify and the target category to compare the case with.
+        :param expert: The expert to ask for differentiating features as new rule conditions.
+        :return: The category that the case belongs to.
+        """
+        pass
+
+    @abstractmethod
+    def update_start_rule(self, case_query: CaseQuery, expert: Expert):
+        """
+        Update the starting rule of the classifier.
+
+        :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.
+        """
+        pass
+
     def update_figures(self):
         """
         Update the figures of the classifier.
@@ -217,13 +248,16 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             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:
+            for scope in [rule.conditions.scope, rule.conclusion.scope]:
+                if scope is None:
                     continue
-                imports += new_imports
+                for k, v in scope.items():
+                    if not hasattr(v, "__module__") or not hasattr(v, "__name__"):
+                        continue
+                    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: str) -> Callable[[Any], Any]:
@@ -318,7 +352,7 @@ class SingleClassRDR(RDRWithCodeWriter):
         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) \
+    def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Union[CaseAttribute, CallableExpression, None]:
         """
         Classify a case, and ask the user for refinements or alternatives if the classification is incorrect by
@@ -328,38 +362,44 @@ 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()
         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, target, corner_case=case,
-                                              conclusion_name=case_query.attribute_name)
 
         pred = self.evaluate(case_query.case)
-        if pred.conclusion(case) != target(case):
-            conditions = expert.ask_for_conditions(case_query, pred)
-            pred.fit_rule(case_query.case, target, conditions=conditions)
+        if pred.conclusion(case_query.case) != case_query.target_value:
+            expert.ask_for_conditions(case_query, pred)
+            pred.fit_rule(case_query.case, case_query.target, conditions=case_query.conditions)
 
         return self.classify(case_query.case)
 
-    def classify(self, case: Case) -> Optional[Any]:
+    def update_start_rule(self, case_query: CaseQuery, expert: Expert):
+        """
+        Update the starting rule of the classifier.
+
+        :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:
+            expert.ask_for_conditions(case_query)
+            self.start_rule = SingleClassRule(case_query.conditions, case_query.target, corner_case=case_query.case,
+                                              conclusion_name=case_query.attribute_name)
+
+    def classify(self, case: Case, modify_original_case: bool = False) -> Optional[Any]:
         """
         Classify a case by recursively evaluating the rules until a rule fires or the last rule is reached.
+
+        :param case: The case to classify.
+        :param modify_original_case: Whether to modify the original case attributes with the conclusion or not.
         """
         pred = self.evaluate(case)
-        return pred.conclusion(case) if pred.fired else self.default_conclusion
+        return pred.conclusion(case) if pred is not None and pred.fired else self.default_conclusion
 
     def evaluate(self, case: Case) -> SingleClassRule:
         """
         Evaluate the starting rule on a case.
         """
-        matched_rule = self.start_rule(case)
-        return matched_rule if matched_rule else self.start_rule
+        matched_rule = self.start_rule(case) if self.start_rule is not None else None
+        return matched_rule if matched_rule is not None else self.start_rule
 
     def write_to_python_file(self, file_path: str, postfix: str = ""):
         super().write_to_python_file(file_path, postfix)
@@ -388,6 +428,12 @@ class SingleClassRDR(RDRWithCodeWriter):
     def conclusion_type_hint(self) -> str:
         return self.conclusion_type[0].__name__
 
+    @property
+    def conclusion_type(self) -> Tuple[Type]:
+        if self.default_conclusion is not None:
+            return (type(self.default_conclusion),)
+        return super().conclusion_type
+
     def _to_json(self) -> Dict[str, Any]:
         return {"start_rule": self.start_rule.to_json()}
 
@@ -419,13 +465,12 @@ class MultiClassRDR(RDRWithCodeWriter):
     The conditions of the stopping rule if needed.
     """
 
-    def __init__(self, start_rule: Optional[Rule] = None,
+    def __init__(self, start_rule: Optional[MultiClassTopRule] = 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.
         """
-        start_rule = MultiClassTopRule() if not start_rule else start_rule
         super(MultiClassRDR, self).__init__(start_rule)
         self.mode: MCRDRMode = mode
 
@@ -439,40 +484,28 @@ class MultiClassRDR(RDRWithCodeWriter):
             evaluated_rule = next_rule
         return make_set(self.conclusions)
 
-    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None,
-                 add_extra_conclusions: bool = False) -> Set[Union[CaseAttribute, CallableExpression, None]]:
+    def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None
+                 , **kwargs) -> 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.
 
         :param case_query: The query containing the case to classify and the target category to compare the case with.
         :param expert: The expert to ask for differentiating features as new rule conditions or for extra conclusions.
-        :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()
-        if case_query.target is None:
-            expert.ask_for_conclusion(case_query)
-        if case_query.target is None:
-            return self.classify(case_query.case)
-        self.update_start_rule(case_query, expert)
-        self.expert_accepted_conclusions = []
-        user_conclusions = []
         self.conclusions = []
         self.stop_rule_conditions = None
         evaluated_rule = self.start_rule
-        target = case_query.target(case_query.case)
+        target = make_set(case_query.target_value)
         while evaluated_rule:
             next_rule = evaluated_rule(case_query.case)
             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 target and not make_set(rule_conclusion).issubset(good_conclusions):
+                if not make_set(rule_conclusion).issubset(target):
                     # Rule fired and conclusion is different from target
-                    self.stop_wrong_conclusion_else_add_it(case_query, expert, evaluated_rule,
-                                                           len(user_conclusions) > 0)
+                    self.stop_wrong_conclusion_else_add_it(case_query, expert, evaluated_rule)
                 else:
                     # Rule fired and target is correct or there is no target to compare
                     self.add_conclusion(evaluated_rule, case_query.case)
@@ -483,14 +516,6 @@ class MultiClassRDR(RDRWithCodeWriter):
                     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:
-                    # No more conclusions can be made, ask the expert for extra conclusions if needed.
-                    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
 
@@ -529,12 +554,10 @@ class MultiClassRDR(RDRWithCodeWriter):
         :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:
+        if not self.start_rule:
             conditions = expert.ask_for_conditions(case_query)
-            self.start_rule.conditions = conditions
-            self.start_rule.conclusion = case_query.target
-            self.start_rule.corner_case = case_query.case
-            self.start_rule.conclusion_name = case_query.attribute_name
+            self.start_rule = MultiClassTopRule(conditions, case_query.target, corner_case=case_query.case,
+                                                conclusion_name=case_query.attribute_name)
 
     @property
     def last_top_rule(self) -> Optional[MultiClassTopRule]:
@@ -547,17 +570,13 @@ class MultiClassRDR(RDRWithCodeWriter):
             return self.start_rule.furthest_alternative[-1]
 
     def stop_wrong_conclusion_else_add_it(self, case_query: CaseQuery, expert: Expert,
-                                          evaluated_rule: MultiClassTopRule,
-                                          add_extra_conclusions: bool):
+                                          evaluated_rule: MultiClassTopRule):
         """
         Stop a wrong conclusion by adding a stopping 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)
+            self.stop_conclusion(case_query, expert, evaluated_rule)
 
     def stop_conclusion(self, case_query: CaseQuery,
                         expert: Expert, evaluated_rule: MultiClassTopRule):
@@ -576,27 +595,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)
 
-    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_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 = {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(case_query.case),
-                                                                          current_conclusions=conclusions)):
-            self.add_conclusion(evaluated_rule, case_query.case)
-            self.expert_accepted_conclusions.append(evaluated_rule.conclusion)
-            return True
-        return False
-
     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.
@@ -611,24 +609,6 @@ 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_rules(self, expert: Expert, case_query: CaseQuery) -> List[Any]:
-        """
-        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_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_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, case: Case) -> None:
         """
         Add the conclusion of the evaluated rule to the list of conclusions.
@@ -722,30 +702,32 @@ class GeneralRDR(RippleDownRules):
     def start_rules(self) -> List[Union[SingleClassRule, MultiClassTopRule]]:
         return [rdr.start_rule for rdr in self.start_rules_dict.values()]
 
-    def classify(self, case: Any) -> Optional[Dict[str, Any]]:
+    def classify(self, case: Any, modify_case: bool = False) -> Optional[Dict[str, Any]]:
         """
         Classify a case by going through all RDRs and adding the categories that are classified, and then restarting
         the classification until no more categories can be added.
 
         :param case: The case to classify.
+        :param modify_case: Whether to modify the original case or create a copy and modify it.
         :return: The categories that the case belongs to.
         """
-        return self._classify(self.start_rules_dict, case)
+        return self._classify(self.start_rules_dict, case, modify_original_case=modify_case)
 
     @staticmethod
     def _classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
-                  case: Any) -> Dict[str, Any]:
+                  case: Any, modify_original_case: bool = True) -> Dict[str, Any]:
         """
         Classify a case by going through all classifiers and adding the categories that are classified,
          and then restarting the classification until no more categories can be added.
 
         :param classifiers_dict: A dictionary mapping conclusion types to the classifiers that produce them.
         :param case: The case to classify.
+        :param modify_original_case: Whether to modify the original case or create a copy and modify it.
         :return: The categories that the case belongs to.
         """
         conclusions = {}
         case = case if isinstance(case, (Case, SQLTable)) else create_case(case)
-        case_cp = copy_case(case)
+        case_cp = copy_case(case) if not modify_original_case else case
         while True:
             new_conclusions = {}
             for attribute_name, rdr in classifiers_dict.items():
@@ -768,13 +750,13 @@ class GeneralRDR(RippleDownRules):
                         conclusions[attribute_name].update(pred_atts)
                 if attribute_name in 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)
+                    case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, mutually_exclusive)
+                    update_case(case_query, new_conclusions)
             if len(new_conclusions) == 0:
                 break
         return conclusions
 
-    def fit_case(self, case_queries: List[CaseQuery], expert: Optional[Expert] = None, **kwargs) \
+    def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Dict[str, Any]:
         """
         Fit the GRDR on a case, if the target is a new type of category, a new RDR is created for it,
@@ -784,115 +766,38 @@ class GeneralRDR(RippleDownRules):
         they are accepted by the expert, and the attribute of that category is represented in the case as a set of
         values.
 
-        :param case_queries: The queries containing the case to classify and the target categories to compare the case
+        :param case_query: The query containing the case to classify and the target category to compare the case
         with.
         :param expert: The expert to ask for differentiating features as new rule conditions.
         :return: The categories that the case belongs to.
         """
-        expert = expert if expert else Human()
-        case_queries = make_list(case_queries)
-        assert len(case_queries) > 0, "No case queries provided"
-        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")
-        original_case_query_cp = copy(case_queries[0])
-        for case_query in case_queries:
-            case_query_cp = copy(case_query)
-            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 []
-                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_query_cp, conclusions)
-
-                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_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_query_cp.case)
-                    else:
-                        conclusions = self.start_rules_dict[rdr_attribute_name].fit_case(case_query_cp, expert,
-                                                                                         **kwargs)
-                    if conclusions is not None:
-                        if (not is_iterable(conclusions)) or len(conclusions) > 0:
-                            conclusions = {rdr_attribute_name: 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)
+        case_query_cp = copy(case_query)
+        self.classify(case_query_cp.case, modify_case=True)
+        case_query_cp.update_target_value()
+
+        self.start_rules_dict[case_query_cp.attribute_name].fit_case(case_query_cp, expert, **kwargs)
+
+        return self.classify(case_query.case)
+
+    def update_start_rule(self, case_query: CaseQuery, expert: Expert):
+        """
+        Update the starting rule of the classifier.
+
+        :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 case_query.attribute_name not in self.start_rules_dict:
+            new_rdr = self.initialize_new_rdr_for_attribute(case_query)
+            self.add_rdr(new_rdr, case_query.attribute_name)
 
     @staticmethod
     def initialize_new_rdr_for_attribute(case_query: CaseQuery):
         """
         Initialize the appropriate RDR type for the 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(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(default_conclusion=case_query.default_value)
-
-    @staticmethod
-    def update_case(case_query: CaseQuery, conclusions: Dict[str, Any]):
-        """
-        Update the case with the conclusions.
-
-        :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_query.original_case, SQLTable) or is_dataclass(case_query.original_case):
-            for conclusion_name, conclusion in conclusions.items():
-                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):
-                    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 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"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_query.case.update(conclusions)
+        return SingleClassRDR(default_conclusion=case_query.default_value) if case_query.mutually_exclusive \
+            else MultiClassRDR()
 
     def _to_json(self) -> Dict[str, Any]:
         return {"start_rules": {t: rdr.to_json() for t, rdr in self.start_rules_dict.items()}}

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/src/ripple_down_rules/rules.py

@@ -130,6 +130,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                               "conclusion": conclusion_to_json(self.conclusion),
                               "parent": self.parent.json_serialization if self.parent else None,
                               "corner_case": self.corner_case.to_json() if self.corner_case else None,
+                              "conclusion_name": self.conclusion_name,
                               "weight": self.weight}
         return json_serialization
 
@@ -139,6 +140,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                           conclusion=CallableExpression.from_json(data["conclusion"]),
                           parent=cls.from_json(data["parent"]),
                           corner_case=Case.from_json(data["corner_case"]),
+                          conclusion_name=data["conclusion_name"],
                           weight=data["weight"])
         return loaded_rule
 
@@ -288,7 +290,7 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
 
     def __init__(self, *args, **kwargs):
         super(MultiClassStopRule, self).__init__(*args, **kwargs)
-        self.conclusion = Stop.stop
+        self.conclusion = CallableExpression(conclusion_type=(Stop,), conclusion=Stop.stop)
 
     def evaluate_next_rule(self, x: Case) -> Optional[Union[MultiClassStopRule, MultiClassTopRule]]:
         if self.fired:

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/src/ripple_down_rules/utils.py

@@ -26,6 +26,7 @@ from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get
 
 if TYPE_CHECKING:
     from .datastructures.case import Case
+    from .datastructures.dataclasses import CaseQuery
     from .rules import Rule
 
 import ast
@@ -33,6 +34,49 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def update_case(case_query: CaseQuery, conclusions: Dict[str, Any]):
+    """
+    Update the case with the conclusions.
+
+    :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_query.original_case, SQLTable) or is_dataclass(case_query.original_case):
+        for conclusion_name, conclusion in conclusions.items():
+            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):
+                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 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"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_query.case.update(conclusions)
+
+
 def is_conflicting(conclusion: Any, target: Any) -> bool:
     """
     :param conclusion: The conclusion to check.

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.63
+Version: 0.1.65
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/test/test_rdr.py

@@ -245,20 +245,12 @@ class TestRDR(TestCase):
         save_answers = False
         append = False
         filename = self.expert_answers_dir + "/mcrdr_stop_plus_rule_expert_answers_fit"
-        expert = Human(use_loaded_answers=use_loaded_answers)
+        expert = Human(use_loaded_answers=use_loaded_answers, append=append)
         if use_loaded_answers:
             expert.load_answers(filename)
         mcrdr = MultiClassRDR(mode=MCRDRMode.StopPlusRule)
         case_queries = self.case_queries
-        try:
-            mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
-        # catch pop from empty list error
-        except IndexError as e:
-            if append:
-                expert.use_loaded_answers = False
-                mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
-            else:
-                raise e
+        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
         render_tree(mcrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/mcrdr_stop_plus_rule")
         for case_query in case_queries:
@@ -267,7 +259,7 @@ class TestRDR(TestCase):
         if save_answers:
             cwd = os.getcwd()
             file = os.path.join(cwd, filename)
-            expert.save_answers(file, append=append)
+            expert.save_answers(file)
 
     def test_fit_mcrdr_stop_plus_rule_combined(self):
         use_loaded_answers = True
@@ -275,20 +267,12 @@ class TestRDR(TestCase):
         draw_tree = False
         append = False
         filename = self.expert_answers_dir + "/mcrdr_stop_plus_rule_combined_expert_answers_fit"
-        expert = Human(use_loaded_answers=use_loaded_answers)
+        expert = Human(use_loaded_answers=use_loaded_answers, append=append)
         if use_loaded_answers:
             expert.load_answers(filename)
         mcrdr = MultiClassRDR(mode=MCRDRMode.StopPlusRuleCombined)
         case_queries = self.case_queries
-        try:
-            mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
-        # catch pop from empty list error
-        except IndexError as e:
-            if append:
-                expert.use_loaded_answers = False
-                mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
-            else:
-                raise e
+        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
         render_tree(mcrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/mcrdr_stop_plus_rule_combined")
         for case_query in case_queries:
@@ -297,7 +281,7 @@ class TestRDR(TestCase):
         if save_answers:
             cwd = os.getcwd()
             file = os.path.join(cwd, filename)
-            expert.save_answers(file, append=append)
+            expert.save_answers(file)
 
     def test_classify_grdr(self):
         use_loaded_answers = True
@@ -314,7 +298,8 @@ class TestRDR(TestCase):
         targets = dict(zip(attribute_names, targets))
         case_queries = [CaseQuery(self.all_cases[0], a, (type(t),), True if a == 'species' else False,
                                   _target=t) for a, t in targets.items()]
-        cats = grdr.fit_case(case_queries, expert=expert)
+        grdr.fit(case_queries, expert=expert)
+        cats = grdr.classify(self.all_cases[0])
         for cat_name, value in cats.items():
             self.assertEqual(make_set(value), make_set(targets[cat_name]))
 

{ripple_down_rules-0.1.63 → ripple_down_rules-0.1.65}/test/test_rdr_world.py

@@ -13,66 +13,64 @@ from ripple_down_rules.rdr import GeneralRDR
 
 @dataclass
 class WorldEntity:
-    world: World = field(kw_only=True, repr=False)
+    world: Optional[World] = field(default=None, kw_only=True, repr=False, hash=False)
 
 
-@dataclass
+@dataclass(unsafe_hash=True)
 class Body(WorldEntity):
     name: str
 
-    def __hash__(self):
-        return hash(self.name)
-
 
-@dataclass
+@dataclass(unsafe_hash=True)
 class Handle(Body):
     ...
 
 
-@dataclass
+@dataclass(unsafe_hash=True)
 class Container(Body):
     ...
 
 
-@dataclass
+@dataclass(unsafe_hash=True)
 class Connection(WorldEntity):
     parent: Body
     child: Body
 
 
-@dataclass
+@dataclass(unsafe_hash=True)
 class FixedConnection(Connection):
     ...
 
 
-@dataclass
+@dataclass(unsafe_hash=True)
 class PrismaticConnection(Connection):
     ...
 
 
 @dataclass
 class World:
+    id: int = 0
     bodies: List[Body] = field(default_factory=list)
     connections: List[Connection] = field(default_factory=list)
     views: List[View] = field(default_factory=list, repr=False)
 
+    def __eq__(self, other):
+        if not isinstance(other, World):
+            return False
+        return self.id == other.id
 
-@dataclass
+
+@dataclass(unsafe_hash=True)
 class View(WorldEntity):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.world.views.append(self)
+    ...
 
 
-@dataclass
+@dataclass(unsafe_hash=True)
 class Drawer(View):
     handle: Handle
     container: Container
     correct: Optional[bool] = None
 
-    def __hash__(self):
-        return hash((self.handle.name, self.container.name))
-
 
 @dataclass
 class Cabinet(View):
@@ -80,7 +78,7 @@ class Cabinet(View):
     drawers: List[Drawer] = field(default_factory=list)
 
     def __hash__(self):
-        return hash(tuple([self.container.name] + [hash(drawer) for drawer in self.drawers]))
+        return hash((self.__class__.__name__, self.container))
 
 
 class TestRDRWorld(TestCase):
@@ -115,26 +113,34 @@ class TestRDRWorld(TestCase):
     def test_view_rdr(self):
         self.get_view_rdr(use_loaded_answers=True, save_answers=False, append=False)
 
-    def get_view_rdr(self, use_loaded_answers: bool = True, save_answers: bool = False,
+    def test_write_view_rdr_to_python_file(self):
+        rdrs_dir = "./test_generated_rdrs"
+        view_rdr = self.get_view_rdr()
+        view_rdr.write_to_python_file(rdrs_dir)
+        loaded_rdr_classifier = view_rdr.get_rdr_classifier_from_python_file(rdrs_dir)
+        found_views = loaded_rdr_classifier(self.world)
+        self.assertTrue(len([v for v in found_views["views"] if isinstance(v, Drawer)]) == 1)
+        self.assertTrue(len([v for v in found_views["views"] if isinstance(v, Cabinet)]) == 1)
+        self.assertTrue(len(found_views["views"]) == 2)
+
+    def get_view_rdr(self, views=(Drawer, Cabinet), use_loaded_answers: bool = True, save_answers: bool = False,
                      append: bool = False):
-        expert = Human(use_loaded_answers=use_loaded_answers)
+        expert = Human(use_loaded_answers=use_loaded_answers, append=append)
         filename = os.path.join(os.getcwd(), "test_expert_answers/view_rdr_expert_answers_fit")
         if use_loaded_answers:
             expert.load_answers(filename)
         rdr = GeneralRDR()
-        try:
-            rdr.fit_case([CaseQuery(self.world, "views", (View,), False)], expert=expert,
-                         add_extra_conclusions=True)
-        except Exception as e:
-            if append:
-                expert.use_loaded_answers = False
-                rdr.fit_case([CaseQuery(self.world, "views", (View,), False)], expert=expert,
-                             add_extra_conclusions=True)
-            else:
-                raise e
+        for view in views:
+            rdr.fit_case(CaseQuery(self.world, "views", (view,), False), expert=expert)
         if save_answers:
-            expert.save_answers(filename, append=append)
-        print(rdr.classify(self.world))
+            expert.save_answers(filename)
+
+        found_views = rdr.classify(self.world)
+        print(found_views)
+        for view in views:
+            self.assertTrue(len([v for v in found_views["views"] if isinstance(v, view)]) > 0)
+
+        return rdr
 
     def test_drawer_rdr(self):
         self.get_drawer_rdr(use_loaded_answers=True, save_answers=False)