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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.61
+Version: 0.1.63
 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.61 → ripple_down_rules-0.1.63}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.61"
+version = "0.1.63"
 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.61 → ripple_down_rules-0.1.63}/src/ripple_down_rules/datastructures/case.py

@@ -24,7 +24,8 @@ class Case(UserDict, SubclassJSONSerializer):
     the names of the attributes and the values are the attributes. All are stored in lower case.
     """
 
-    def __init__(self, _obj_type: Type, _id: Optional[Hashable] = None, _name: Optional[str] = None, **kwargs):
+    def __init__(self, _obj_type: Type, _id: Optional[Hashable] = None,
+                 _name: Optional[str] = None, original_object: Optional[Any] = None, **kwargs):
         """
         Create a new row.
 
@@ -34,6 +35,7 @@ class Case(UserDict, SubclassJSONSerializer):
         :param kwargs: The attributes of the row.
         """
         super().__init__(kwargs)
+        self._original_object = original_object
         self._obj_type: Type = _obj_type
         self._id: Hashable = _id if _id is not None else id(self)
         self._name: str = _name if _name is not None else self._obj_type.__name__
@@ -221,9 +223,9 @@ def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
         return obj
     if ((recursion_idx > max_recursion_idx) or (obj.__class__.__module__ == "builtins")
             or (obj.__class__ in [MetaData, registry])):
-        return Case(type(obj), _id=id(obj), _name=obj_name,
+        return Case(type(obj), _id=id(obj), _name=obj_name, original_object=obj,
                     **{obj_name or obj.__class__.__name__: make_list(obj) if parent_is_iterable else obj})
-    case = Case(type(obj), _id=id(obj), _name=obj_name)
+    case = Case(type(obj), _id=id(obj), _name=obj_name, original_object=obj)
     for attr in dir(obj):
         if attr.startswith("_") or callable(getattr(obj, attr)):
             continue
@@ -251,7 +253,7 @@ def create_or_update_case_from_attribute(attr_value: Any, name: str, obj: Any, o
     :return: The updated/created case.
     """
     if case is None:
-        case = Case(type(obj), _id=id(obj), _name=obj_name)
+        case = Case(type(obj), _id=id(obj), _name=obj_name, original_object=obj)
     if isinstance(attr_value, (dict, UserDict)):
         case.update({f"{obj_name}.{k}": v for k, v in attr_value.items()})
     if hasattr(attr_value, "__iter__") and not isinstance(attr_value, str):
@@ -280,7 +282,7 @@ def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, ob
     """
     values = list(attr_value.values()) if isinstance(attr_value, (dict, UserDict)) else attr_value
     _type = type(list(values)[0]) if len(values) > 0 else get_value_type_from_type_hint(name, obj)
-    attr_case = Case(_type, _id=id(attr_value), _name=name)
+    attr_case = Case(_type, _id=id(attr_value), _name=name, original_object=attr_value)
     case_attr = CaseAttribute(values)
     for idx, val in enumerate(values):
         sub_attr_case = create_case(val, recursion_idx=recursion_idx,
@@ -305,7 +307,7 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
     """
     corner_case = None
     targets = {f"target_{name}": value for name, value in targets.items()} if targets else {}
-    current_conclusions = {name: value for name, value in current_conclusions.items} if current_conclusions else {}
+    current_conclusions = {name: value for name, value in current_conclusions.items()} if current_conclusions else {}
     if last_evaluated_rule:
         action = "Refinement" if last_evaluated_rule.fired else "Alternative"
         print(f"{action} needed for rule: {last_evaluated_rule}\n")
@@ -322,7 +324,7 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
             corner_row_dict = corner_case
 
     if corner_row_dict:
-        corner_conclusion = last_evaluated_rule.conclusion
+        corner_conclusion = last_evaluated_rule.conclusion(case)
         corner_row_dict.update({corner_conclusion.__class__.__name__: corner_conclusion})
         print(table_rows_as_str(corner_row_dict))
     print("=" * 50)

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

@@ -8,7 +8,7 @@ from typing_extensions import Any, Optional, Dict, Type, Tuple, Union
 
 from .callable_expression import CallableExpression
 from .case import create_case, Case
-from ..utils import copy_case, make_list
+from ..utils import copy_case, make_list, make_set
 
 
 @dataclass
@@ -88,9 +88,10 @@ class CaseQuery:
         """
         :return: The type of the attribute.
         """
-        self._attribute_types = tuple(make_list(self._attribute_types))
-        if not self.mutually_exclusive and (set not in self._attribute_types):
-            self._attribute_types = tuple(list(self._attribute_types) + [set])
+        if not self.mutually_exclusive and (set not in make_list(self._attribute_types)):
+            self._attribute_types = tuple(set(make_list(self._attribute_types) + [set, list]))
+        elif not isinstance(self._attribute_types, tuple):
+            self._attribute_types = tuple(make_list(self._attribute_types))
         return self._attribute_types
 
     @attribute_type.setter

{ripple_down_rules-0.1.61 → ripple_down_rules-0.1.63}/src/ripple_down_rules/datastructures/enums.py

@@ -53,7 +53,7 @@ class ExpressionParser(Enum):
 
 class PromptFor(Enum):
     """
-    The reason of the prompt. (e.g. get conditions, or conclusions).
+    The reason of the prompt. (e.g. get conditions, conclusions, or affirmation).
     """
     Conditions: str = "conditions"
     """
@@ -63,6 +63,10 @@ class PromptFor(Enum):
     """
     Prompt for rule conclusion about a case.
     """
+    Affirmation: str = "affirmation"
+    """
+    Prompt for rule conclusion affirmation about a case.
+    """
 
     def __str__(self):
         return self.name

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

@@ -10,7 +10,7 @@ from .datastructures.callable_expression import CallableExpression
 from .datastructures.enums import PromptFor
 from .datastructures.dataclasses import CaseQuery
 from .datastructures.case import show_current_and_corner_cases
-from .prompt import prompt_user_for_expression
+from .prompt import prompt_user_for_expression, IPythonShell
 from .utils import get_all_subclasses, make_list
 
 if TYPE_CHECKING:
@@ -51,28 +51,24 @@ class Expert(ABC):
         pass
 
     @abstractmethod
-    def ask_for_extra_conclusions(self, x: Case, current_conclusions: List[CaseAttribute]) \
-            -> Dict[CaseAttribute, CallableExpression]:
+    def ask_for_extra_rules(self, case_query: CaseQuery) -> List[Dict[PromptFor, CallableExpression]]:
         """
-        Ask the expert to provide extra conclusions for a case by providing a pair of category and conditions for
-        that category.
+        Ask the expert to provide extra rules for a case by providing a pair of conclusion and conditions.
 
-        :param x: The case to classify.
-        :param current_conclusions: The current conclusions for the case.
-        :return: The extra conclusions for the case.
+        :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, x: Case, conclusion: CaseAttribute,
-                                     targets: Optional[List[CaseAttribute]] = None,
-                                     current_conclusions: Optional[List[CaseAttribute]] = None) -> bool:
+    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 x: The case to classify.
+        :param case_query: The case query about which the expert should answer.
         :param conclusion: The conclusion to check.
-        :param targets: The target categories to compare the case with.
         :param current_conclusions: The current conclusions for the case.
         """
         pass
@@ -126,10 +122,28 @@ class Human(Expert):
                            last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
         if not self.use_loaded_answers:
-            show_current_and_corner_cases(case_query.case, {case_query.attribute_name: case_query.target},
+            show_current_and_corner_cases(case_query.case, {case_query.attribute_name: case_query.target_value},
                                           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:
         """
@@ -151,24 +165,6 @@ class Human(Expert):
         case_query.conditions = condition
         return condition
 
-    def ask_for_extra_conclusions(self, case: Case, current_conclusions: List[CaseAttribute]) \
-            -> Dict[CaseAttribute, CallableExpression]:
-        """
-        Ask the expert to provide extra conclusions for a case by providing a pair of category and conditions for
-        that category.
-
-        :param case: The case to classify.
-        :param current_conclusions: The current conclusions for the case.
-        :return: The extra conclusions for the case.
-        """
-        extra_conclusions = {}
-        while True:
-            category = self.ask_for_conclusion(CaseQuery(case), current_conclusions)
-            if not category:
-                break
-            extra_conclusions[category] = self._get_conditions(case, {category.__class__.__name__: category})
-        return extra_conclusions
-
     def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
         """
         Ask the expert to provide a conclusion for the case.
@@ -212,44 +208,39 @@ class Human(Expert):
         :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_yes_no_question(question)
+        return not self.ask_for_affirmation(question)
 
-    def ask_if_conclusion_is_correct(self, x: Case, conclusion: Any,
-                                     targets: Optional[List[Any]] = None,
-                                     current_conclusions: Optional[List[Any]] = None) -> bool:
+    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 x: The case to classify.
+        :param case_query: The case query about which the expert should answer.
         :param conclusion: The conclusion to check.
-        :param targets: The target categories to compare the case with.
         :param current_conclusions: The current conclusions for the case.
         """
-        question = ""
         if not self.use_loaded_answers:
-            targets = targets or []
-            x.conclusions = make_list(current_conclusions)
-            x.targets = make_list(targets)
-            question = f"Is the conclusion {conclusion} correct for the case (y/n):" \
-                       f"\n{str(x)}"
-        return self.ask_yes_no_question(question)
+            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_yes_no_question(self, question: str) -> bool:
+    def ask_for_affirmation(self, case_query: CaseQuery, question: str) -> bool:
         """
         Ask the expert a yes or no question.
 
-        :param question: The question to ask.
+        :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.
         """
-        if not self.use_loaded_answers:
-            print(question)
         while True:
             if self.use_loaded_answers:
                 answer = self.all_expert_answers.pop(0)
             else:
-                answer = input()
-                self.all_expert_answers.append(answer)
-            if answer.lower() == "y":
+                _, 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
-            elif answer.lower() == "n":
+            else:
+                self.all_expert_answers.append(False)
                 return False

ripple_down_rules-0.1.63/src/ripple_down_rules/helpers.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import os
+
+from .datastructures.dataclasses import CaseQuery
+from sqlalchemy.orm import Session
+from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING
+
+from .utils import get_func_rdr_model_path
+from .utils import calculate_precision_and_recall
+
+if TYPE_CHECKING:
+    from .rdr import RippleDownRules
+
+
+def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+    """
+    :param classifier: The RDR classifier to check the prediction of.
+    :param case_query: The case query to check.
+    :param pred_cat: The predicted category.
+    :return: Whether the classifier prediction is matching case_query target or not.
+    """
+    if case_query.target is None:
+        return False
+    if pred_cat is None:
+        pred_cat = classifier(case_query.case)
+    if not isinstance(pred_cat, dict):
+        pred_cat = {case_query.attribute_name: pred_cat}
+    target = {case_query.attribute_name: case_query.target_value}
+    precision, recall = calculate_precision_and_recall(pred_cat, target)
+    return all(recall) and all(precision)
+
+
+def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDownRules],
+                                  session: Optional[Session] = None, **rdr_kwargs) -> RippleDownRules:
+    """
+    Load the RDR model of the function if it exists, otherwise create a new one.
+
+    :param func: The function to load the model for.
+    :param model_dir: The directory where the model is stored.
+    :param rdr_type: The type of the RDR model to load.
+    :param session: The SQLAlchemy session to use.
+    :param rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
+    """
+    model_path = get_func_rdr_model_path(func, model_dir)
+    if os.path.exists(model_path):
+        rdr = rdr_type.load(model_path)
+        rdr.session = session
+    else:
+        rdr = rdr_type(session=session, **rdr_kwargs)
+    return rdr

{ripple_down_rules-0.1.61 → ripple_down_rules-0.1.63}/src/ripple_down_rules/prompt.py

@@ -9,7 +9,7 @@ from typing_extensions import List, Optional, Tuple, Dict
 from .datastructures.enums import PromptFor
 from .datastructures.callable_expression import CallableExpression, parse_string_to_expression
 from .datastructures.dataclasses import CaseQuery
-from .utils import extract_dependencies, contains_return_statement
+from .utils import extract_dependencies, contains_return_statement, make_set
 
 
 class CustomInteractiveShell(InteractiveShellEmbed):
@@ -28,12 +28,12 @@ class CustomInteractiveShell(InteractiveShellEmbed):
             self.ask_exit()
             return None
         result = super().run_cell(raw_cell, **kwargs)
-        if not result.error_in_exec:
+        if result.error_in_exec is None and result.error_before_exec is None:
             self.all_lines.append(raw_cell)
         return result
 
 
-class IpythonShell:
+class IPythonShell:
     """
     Create an embedded Ipython shell that can be used to prompt the user for input.
     """
@@ -63,8 +63,14 @@ class IpythonShell:
         """
         Run the embedded shell.
         """
-        self.shell()
-        self.update_user_input_from_code_lines()
+        while True:
+            try:
+                self.shell()
+                self.update_user_input_from_code_lines()
+                break
+            except Exception as e:
+                logging.error(e)
+                print(e)
 
     def update_user_input_from_code_lines(self):
         """
@@ -81,20 +87,23 @@ class IpythonShell:
                     self.user_input = self.all_code_lines[0].replace('return', '').strip()
             else:
                 self.user_input = f"def _get_value(case):\n    "
-                self.user_input += '\n    '.join(self.all_code_lines)
+                for cl in self.all_code_lines:
+                    sub_code_lines = cl.split('\n')
+                    self.user_input += '\n    '.join(sub_code_lines) + '\n    '
 
 
-def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor)\
+def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, prompt_str: Optional[str] = None)\
         -> Tuple[Optional[str], Optional[CallableExpression]]:
     """
     Prompt the user for an executable python expression to the given case query.
 
     :param case_query: The case query to prompt the user for.
     :param prompt_for: The type of information ask user about.
+    :param prompt_str: The prompt string to display to the user.
     :return: A callable expression that takes a case and executes user expression on it.
     """
     while True:
-        user_input, expression_tree = prompt_user_about_case(case_query, prompt_for)
+        user_input, expression_tree = prompt_user_about_case(case_query, prompt_for, prompt_str)
         if user_input is None:
             if prompt_for == PromptFor.Conclusion:
                 print("No conclusion provided. Exiting.")
@@ -114,21 +123,24 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor)\
     return user_input, callable_expression
 
 
-def prompt_user_about_case(case_query: CaseQuery, prompt_for: PromptFor) -> Tuple[Optional[str], Optional[AST]]:
+def prompt_user_about_case(case_query: CaseQuery, prompt_for: PromptFor,
+                           prompt_str: Optional[str] = None) -> Tuple[Optional[str], Optional[AST]]:
     """
     Prompt the user for input.
 
     :param case_query: The case query to prompt the user for.
     :param prompt_for: The type of information the user should provide for the given case.
+    :param prompt_str: The prompt string to display to the user.
     :return: The user input, and the executable expression that was parsed from the user input.
     """
-    prompt_str = f"Give {prompt_for} for {case_query.name}"
+    if prompt_str is None:
+        prompt_str = f"Give {prompt_for} for {case_query.name}"
     scope = {'case': case_query.case, **case_query.scope}
-    shell = IpythonShell(scope=scope, header=prompt_str)
+    shell = IPythonShell(scope=scope, header=prompt_str)
     return prompt_user_input_and_parse_to_expression(shell=shell)
 
 
-def prompt_user_input_and_parse_to_expression(shell: Optional[IpythonShell] = None,
+def prompt_user_input_and_parse_to_expression(shell: Optional[IPythonShell] = None,
                                               user_input: Optional[str] = None)\
         -> Tuple[Optional[str], Optional[ast.AST]]:
     """
@@ -140,7 +152,7 @@ def prompt_user_input_and_parse_to_expression(shell: Optional[IpythonShell] = No
     """
     while True:
         if user_input is None:
-            shell = IpythonShell() if shell is None else shell
+            shell = IPythonShell() if shell is None else shell
             shell.run()
             user_input = shell.user_input
             if user_input is None:
@@ -151,4 +163,5 @@ def prompt_user_input_and_parse_to_expression(shell: Optional[IpythonShell] = No
         except Exception as e:
             msg = f"Error parsing expression: {e}"
             logging.error(msg)
+            print(msg)
             user_input = None

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

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import importlib
-import re
 import sys
 from abc import ABC, abstractmethod
 from copy import copy
@@ -14,15 +13,16 @@ from ordered_set import OrderedSet
 from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple, Callable, Set
 
-from .datastructures.case import Case, CaseAttribute
 from .datastructures.callable_expression import CallableExpression
+from .datastructures.case import Case, CaseAttribute, create_case
 from .datastructures.dataclasses import CaseQuery
-from .datastructures.enums import MCRDRMode
+from .datastructures.enums import MCRDRMode, PromptFor
 from .experts import Expert, Human
+from .helpers import is_matching
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 from .utils import draw_tree, make_set, copy_case, \
-    get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list, get_type_from_string, \
-    get_case_attribute_type, ask_llm, is_matching
+    SubclassJSONSerializer, is_iterable, make_list, get_type_from_string, \
+    get_case_attribute_type, is_conflicting
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -277,7 +277,6 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         else:
             return "SCRDR"
 
-
     @property
     def case_type(self) -> Type:
         """
@@ -366,7 +365,7 @@ class SingleClassRDR(RDRWithCodeWriter):
         super().write_to_python_file(file_path, postfix)
         if self.default_conclusion is not None:
             with open(file_path + f"/{self.generated_python_file_name}.py", "a") as f:
-                f.write(f"{' '*4}else:\n{' '*8}return {self.default_conclusion}\n")
+                f.write(f"{' ' * 4}else:\n{' ' * 8}return {self.default_conclusion}\n")
 
     def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file: TextIOWrapper, parent_indent: str = "",
                                            defs_file: Optional[str] = None):
@@ -377,7 +376,6 @@ class SingleClassRDR(RDRWithCodeWriter):
             if_clause = rule.write_condition_as_source_code(parent_indent, defs_file)
             file.write(if_clause)
             if rule.refinement:
-
                 self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
                                                         defs_file=defs_file)
 
@@ -474,7 +472,7 @@ class MultiClassRDR(RDRWithCodeWriter):
                 if target and not make_set(rule_conclusion).issubset(good_conclusions):
                     # Rule fired and conclusion is different from target
                     self.stop_wrong_conclusion_else_add_it(case_query, expert, evaluated_rule,
-                                                           add_extra_conclusions)
+                                                           len(user_conclusions) > 0)
                 else:
                     # Rule fired and target is correct or there is no target to compare
                     self.add_conclusion(evaluated_rule, case_query.case)
@@ -485,11 +483,14 @@ 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 and not user_conclusions:
+                elif add_extra_conclusions:
                     # No more conclusions can be made, ask the expert for extra conclusions if needed.
-                    user_conclusions.extend(self.ask_expert_for_extra_conclusions(expert, case_query.case))
-                    if user_conclusions:
+                    new_user_conclusions = self.ask_expert_for_extra_rules(expert, case_query)
+                    user_conclusions.extend(new_user_conclusions)
+                    if len(new_user_conclusions) > 0:
                         next_rule = self.last_top_rule
+                    else:
+                        add_extra_conclusions = False
             evaluated_rule = next_rule
         return self.conclusions
 
@@ -551,13 +552,12 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         Stop a wrong conclusion by adding a stopping rule.
         """
-        target = case_query.target(case_query.case)
         rule_conclusion = evaluated_rule.conclusion(case_query.case)
-        if self.is_same_category_type(rule_conclusion, target) \
-                and self.is_conflicting_with_target(rule_conclusion, 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)
+        if is_conflicting(rule_conclusion, case_query.target_value):
+            if self.conclusion_is_correct(case_query, expert, evaluated_rule, add_extra_conclusions):
+                return
+            else:
+                self.stop_conclusion(case_query, expert, evaluated_rule)
 
     def stop_conclusion(self, case_query: CaseQuery,
                         expert: Expert, evaluated_rule: MultiClassTopRule):
@@ -576,31 +576,6 @@ class MultiClassRDR(RDRWithCodeWriter):
             new_top_rule_conditions = conditions.combine_with(evaluated_rule.conditions)
             self.add_top_rule(new_top_rule_conditions, case_query.target, case_query.case)
 
-    @staticmethod
-    def is_conflicting_with_target(conclusion: Any, target: Any) -> bool:
-        """
-        Check if the conclusion is conflicting with the target category.
-
-        :param conclusion: The conclusion to check.
-        :param target: The target category to compare the conclusion with.
-        :return: Whether the conclusion is conflicting with the target category.
-        """
-        if hasattr(conclusion, "mutually_exclusive") and conclusion.mutually_exclusive:
-            return True
-        else:
-            return not make_set(conclusion).issubset(make_set(target))
-
-    @staticmethod
-    def is_same_category_type(conclusion: Any, target: Any) -> bool:
-        """
-        Check if the conclusion is of the same class as the target category.
-
-        :param conclusion: The conclusion to check.
-        :param target: The target category to compare the conclusion with.
-        :return: Whether the conclusion is of the same class as the target category but has a different value.
-        """
-        return conclusion.__class__ == target.__class__ and target.__class__ != CaseAttribute
-
     def conclusion_is_correct(self, case_query: CaseQuery,
                               expert: Expert, evaluated_rule: Rule,
                               add_extra_conclusions: bool) -> bool:
@@ -616,7 +591,6 @@ class MultiClassRDR(RDRWithCodeWriter):
         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),
-                                                                          targets=case_query.target(case_query.case),
                                                                           current_conclusions=conclusions)):
             self.add_conclusion(evaluated_rule, case_query.case)
             self.expert_accepted_conclusions.append(evaluated_rule.conclusion)
@@ -637,23 +611,22 @@ class MultiClassRDR(RDRWithCodeWriter):
             conditions = expert.ask_for_conditions(case_query)
         self.add_top_rule(conditions, case_query.target, case_query.case)
 
-    def ask_expert_for_extra_conclusions(self, expert: Expert, case: Union[Case, SQLTable]) -> List[Any]:
+    def ask_expert_for_extra_rules(self, expert: Expert, case_query: CaseQuery) -> List[Any]:
         """
-        Ask the expert for extra conclusions when no more conclusions can be made.
+        Ask the expert for extra rules when no more conclusions can be made for a case.
 
         :param expert: The expert to ask for extra conclusions.
-        :param case: The case to ask extra conclusions for.
-        :return: The extra conclusions that the expert has provided.
+        :param case_query: The case query to ask the expert about.
+        :return: The extra conclusions for the rules that the expert has provided.
         """
         extra_conclusions = []
         conclusions = list(OrderedSet(self.conclusions))
         if not expert.use_loaded_answers:
             print("current conclusions:", conclusions)
-        extra_conclusions_dict = expert.ask_for_extra_conclusions(case, conclusions)
-        if extra_conclusions_dict:
-            for conclusion, conditions in extra_conclusions_dict.items():
-                self.add_top_rule(conditions, conclusion, case)
-                extra_conclusions.append(conclusion)
+        extra_rules = expert.ask_for_extra_rules(case_query)
+        for rule in extra_rules:
+            self.add_top_rule(rule[PromptFor.Conditions], rule[PromptFor.Conclusion], case_query.case)
+            extra_conclusions.extend(rule[PromptFor.Conclusion](case_query.case))
         return extra_conclusions
 
     def add_conclusion(self, evaluated_rule: Rule, case: Case) -> None:
@@ -749,7 +722,7 @@ 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: Union[Case, SQLTable]) -> Optional[List[Any]]:
+    def classify(self, case: Any) -> 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.
@@ -761,7 +734,7 @@ class GeneralRDR(RippleDownRules):
 
     @staticmethod
     def _classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
-                  case: Union[Case, SQLTable]) -> Optional[Dict[str, Any]]:
+                  case: Any) -> 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.
@@ -771,6 +744,7 @@ class GeneralRDR(RippleDownRules):
         :return: The categories that the case belongs to.
         """
         conclusions = {}
+        case = case if isinstance(case, (Case, SQLTable)) else create_case(case)
         case_cp = copy_case(case)
         while True:
             new_conclusions = {}
@@ -801,7 +775,7 @@ class GeneralRDR(RippleDownRules):
         return conclusions
 
     def fit_case(self, case_queries: List[CaseQuery], expert: Optional[Expert] = None, **kwargs) \
-            -> List[Union[CaseAttribute, CallableExpression]]:
+            -> 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,
         else the existing RDR of that type will be fitted on the case, and then classification is done and all
@@ -816,7 +790,7 @@ class GeneralRDR(RippleDownRules):
         :return: The categories that the case belongs to.
         """
         expert = expert if expert else Human()
-        case_queries = [case_queries] if not isinstance(case_queries, list) else case_queries
+        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,"
@@ -849,10 +823,11 @@ class GeneralRDR(RippleDownRules):
                     else:
                         conclusions = self.start_rules_dict[rdr_attribute_name].fit_case(case_query_cp, expert,
                                                                                          **kwargs)
-                    if conclusions is not None or (is_iterable(conclusions) and len(conclusions) > 0):
-                        conclusions = {rdr_attribute_name: conclusions}
-                        case_query_cp.mutually_exclusive = True if isinstance(rdr, SingleClassRDR) else False
-                        self.update_case(case_query_cp, conclusions)
+                    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)
@@ -863,17 +838,17 @@ class GeneralRDR(RippleDownRules):
         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\
+            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)\
+        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)\
+            return MultiClassRDR() if is_iterable(attribute) or (attribute is None) \
                 else SingleClassRDR(default_conclusion=case_query.default_value)
 
     @staticmethod
@@ -895,13 +870,18 @@ class GeneralRDR(RippleDownRules):
                     attribute_type = case_query.attribute_type
                 else:
                     attribute_type = (get_case_attribute_type(case_query.original_case, conclusion_name, attribute),)
-                if isinstance(attribute, set) or any(at in {Set, set} for at in attribute_type):
-                    attribute = set() if attribute is None else attribute
+                if isinstance(attribute, set):
                     for c in conclusion:
                         attribute.update(make_set(c))
-                elif isinstance(attribute, list) or any(at in {List, list} for at in attribute_type):
+                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])

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

@@ -33,22 +33,25 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
-def is_matching(rdr_classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+def is_conflicting(conclusion: Any, target: Any) -> bool:
     """
-    :param rdr_classifier: The RDR classifier to check the prediction of.
-    :param case_query: The case query to check.
-    :param pred_cat: The predicted category.
-    :return: Whether the classifier prediction is matching case_query target or not.
+    :param conclusion: The conclusion to check.
+    :param target: The target to compare the conclusion with.
+    :return: Whether the conclusion is conflicting with the target by have different values for same type categories.
     """
-    if case_query.target is None:
-        return False
-    if pred_cat is None:
-        pred_cat = rdr_classifier(case_query.case)
-    if not isinstance(pred_cat, dict):
-        pred_cat = {case_query.attribute_name: pred_cat}
-    target = {case_query.attribute_name: case_query.target_value}
-    precision, recall = calculate_precision_and_recall(pred_cat, target)
-    return all(recall) and all(precision)
+    return have_common_types(conclusion, target) and not make_set(conclusion).issubset(make_set(target))
+
+
+def have_common_types(conclusion: Any, target: Any) -> bool:
+    """
+    :param conclusion: The conclusion to check.
+    :param target: The target to compare the conclusion with.
+    :return: Whether the conclusion shares some types with the target.
+    """
+    target_types = {type(t) for t in make_set(target)}
+    conclusion_types = {type(c) for c in make_set(conclusion)}
+    common_types = conclusion_types.intersection(target_types)
+    return len(common_types) > 0
 
 
 def calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, Any]) -> Tuple[
@@ -177,7 +180,8 @@ def extract_dependencies(code_lines):
 
     if not isinstance(final_stmt, ast.Return):
         raise ValueError("Last line is not a return statement")
-
+    if final_stmt.value is None:
+        raise ValueError("Return statement has no value")
     needed = get_names_used(final_stmt.value)
     required_lines = []
     line_map = {id(node): i for i, node in enumerate(tree.body)}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.61
+Version: 0.1.63
 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.61 → ripple_down_rules-0.1.63}/test/test_rdr_world.py

@@ -7,19 +7,22 @@ from unittest import TestCase
 
 from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.experts import Human
-from ripple_down_rules.rdr import SingleClassRDR, GeneralRDR
-from ripple_down_rules.utils import is_matching
+from ripple_down_rules.helpers import is_matching
+from ripple_down_rules.rdr import GeneralRDR
 
 
 @dataclass
 class WorldEntity:
-    world: Optional[World] = field(kw_only=True, default=None, repr=False)
+    world: World = field(kw_only=True, repr=False)
 
 
 @dataclass
 class Body(WorldEntity):
     name: str
 
+    def __hash__(self):
+        return hash(self.name)
+
 
 @dataclass
 class Handle(Body):
@@ -51,11 +54,14 @@ class PrismaticConnection(Connection):
 class World:
     bodies: List[Body] = field(default_factory=list)
     connections: List[Connection] = field(default_factory=list)
+    views: List[View] = field(default_factory=list, repr=False)
 
 
 @dataclass
 class View(WorldEntity):
-    ...
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.world.views.append(self)
 
 
 @dataclass
@@ -64,17 +70,31 @@ class Drawer(View):
     container: Container
     correct: Optional[bool] = None
 
+    def __hash__(self):
+        return hash((self.handle.name, self.container.name))
+
+
+@dataclass
+class Cabinet(View):
+    container: Container
+    drawers: List[Drawer] = field(default_factory=list)
+
+    def __hash__(self):
+        return hash(tuple([self.container.name] + [hash(drawer) for drawer in self.drawers]))
+
 
 class TestRDRWorld(TestCase):
     drawer_case_queries: List[CaseQuery]
+    world: World
 
     @classmethod
     def setUpClass(cls):
         world = World()
+        cls.world = world
 
         handle = Handle('h1', world=world)
         handle_2 = Handle('h2', world=world)
-        container_1 = Container('c1',world=world)
+        container_1 = Container('c1', world=world)
         container_2 = Container('c2', world=world)
         connection_1 = FixedConnection(container_1, handle, world=world)
         connection_2 = PrismaticConnection(container_2, container_1, world=world)
@@ -82,17 +102,39 @@ class TestRDRWorld(TestCase):
         world.bodies = [handle, container_1, container_2, handle_2]
         world.connections = [connection_1, connection_2]
 
-        all_views = []
-
-        i = 1
+        all_possible_drawers = []
         for handle in [body for body in world.bodies if isinstance(body, Handle)]:
             for container in [body for body in world.bodies if isinstance(body, Container)]:
                 view = Drawer(handle, container, world=world)
-                all_views.append(view)
-                i += 1
+                all_possible_drawers.append(view)
+
+        print(all_possible_drawers)
+        cls.drawer_case_queries = [CaseQuery(possible_drawer, "correct", (bool,), True, default_value=False)
+                                   for possible_drawer in all_possible_drawers]
 
-        print(all_views)
-        cls.drawer_case_queries = [CaseQuery(view, "correct", bool, True, default_value=False) for view in all_views]
+    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,
+                     append: bool = False):
+        expert = Human(use_loaded_answers=use_loaded_answers)
+        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
+        if save_answers:
+            expert.save_answers(filename, append=append)
+        print(rdr.classify(self.world))
 
     def test_drawer_rdr(self):
         self.get_drawer_rdr(use_loaded_answers=True, save_answers=False)

ripple_down_rules-0.1.61/src/ripple_down_rules/helpers.py

@@ -1,27 +0,0 @@
-import os
-
-from sqlalchemy.orm import Session
-from typing_extensions import Type, Optional
-
-from ripple_down_rules.rdr import RippleDownRules
-from ripple_down_rules.utils import get_func_rdr_model_path
-
-
-def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDownRules],
-                                  session: Optional[Session] = None, **rdr_kwargs) -> RippleDownRules:
-    """
-    Load the RDR model of the function if it exists, otherwise create a new one.
-
-    :param func: The function to load the model for.
-    :param model_dir: The directory where the model is stored.
-    :param rdr_type: The type of the RDR model to load.
-    :param session: The SQLAlchemy session to use.
-    :param rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
-    """
-    model_path = get_func_rdr_model_path(func, model_dir)
-    if os.path.exists(model_path):
-        rdr = rdr_type.load(model_path)
-        rdr.session = session
-    else:
-        rdr = rdr_type(session=session, **rdr_kwargs)
-    return rdr