ripple-down-rules 0.6.23__tar.gz → 0.6.25__tar.gz

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.23
+Version: 0.6.25
 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.6.23 → ripple_down_rules-0.6.25}/scripts/live_dot_server_client.py

@@ -52,7 +52,7 @@ def generate_html(dot_output="graph.html"):
     }}
 
     fetchAndRender();
-    setInterval(fetchAndRender, 500);  // Refresh every 2 seconds
+    setInterval(fetchAndRender, 100);  // Refresh every 2 seconds
   </script>
 </body>
 </html>"""

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/src/ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.23"
+__version__ = "0.6.25"
 
 import logging
 logger = logging.Logger("rdr")

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -95,7 +95,7 @@ class CallableExpression(SubclassJSONSerializer):
     encapsulating_function_name: str = "_get_value"
 
     def __init__(self, user_input: Optional[str] = None,
-                 conclusion_type: Optional[Tuple[Type]] = None,
+                 conclusion_type: Optional[Tuple[Type, ...]] = None,
                  expression_tree: Optional[AST] = None,
                  scope: Optional[Dict[str, Any]] = None,
                  conclusion: Optional[Any] = None,
@@ -176,7 +176,8 @@ class CallableExpression(SubclassJSONSerializer):
         new_user_input = (f"{cond1_user_input}\n"
                           f"{cond2_user_input}\n"
                           f"return _cond1(case) and _cond2(case)")
-        return CallableExpression(new_user_input, conclusion_type=self.conclusion_type)
+        return CallableExpression(new_user_input, conclusion_type=self.conclusion_type,
+         mutually_exclusive=self.mutually_exclusive)
 
     def update_user_input_from_file(self, file_path: str, function_name: str):
         """

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -31,7 +31,7 @@ class CaseQuery:
     """
     The name of the attribute.
     """
-    _attribute_types: Tuple[Type]
+    _attribute_types: Tuple[Type, ...]
     """
     The type(s) of the attribute.
     """
@@ -139,7 +139,7 @@ class CaseQuery:
             attribute_types_str = f"Union[{', '.join([t.__name__ for t in self.core_attribute_type])}]"
         else:
             attribute_types_str = self.core_attribute_type[0].__name__
-        if all(t in self.attribute_type for t in [list, set]) and len(self.core_attribute_type) > 2:
+        if not self.mutually_exclusive:
             return f"List[{attribute_types_str}]"
         else:
             return attribute_types_str

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/src/ripple_down_rules/datastructures/enums.py

@@ -196,7 +196,10 @@ class RDREdge(Enum):
     """
     Next edge, the edge that represents the next rule to be evaluated.
     """
-
+    Filter = "filter if"
+    """
+    Filter edge, the edge that represents the filter condition.
+    """
 
 class ValueType(Enum):
     Unary = auto()

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/src/ripple_down_rules/experts.py

@@ -41,14 +41,14 @@ class Expert(ABC):
     A flag to indicate if the expert should use loaded answers or not.
     """
 
-    def __init__(self, use_loaded_answers: bool = True,
+    def __init__(self, use_loaded_answers: bool = False,
                  append: bool = False,
                  answers_save_path: Optional[str] = None):
         self.all_expert_answers = []
         self.use_loaded_answers = use_loaded_answers
         self.append = append
         self.answers_save_path = answers_save_path
-        if answers_save_path is not None:
+        if answers_save_path is not None and os.path.exists(answers_save_path + '.py'):
             if use_loaded_answers:
                 self.load_answers(answers_save_path)
             else:

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/src/ripple_down_rules/helpers.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 
 import os
 from types import ModuleType
+from typing import Tuple
 
-from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
-
-from .datastructures.case import create_case
-from .datastructures.dataclasses import CaseQuery
 from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING, Union
 
-from .utils import get_func_rdr_model_name, copy_case, make_set, update_case
+from .datastructures.case import create_case, Case
+from .datastructures.dataclasses import CaseQuery
 from .utils import calculate_precision_and_recall
+from .utils import get_func_rdr_model_name, copy_case, make_set, update_case
 
 if TYPE_CHECKING:
     from .rdr import RippleDownRules
@@ -55,12 +54,14 @@ def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDow
             if attribute_name in new_conclusions:
                 temp_case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, rdr.mutually_exclusive)
                 update_case(temp_case_query, new_conclusions)
-        if len(new_conclusions) == 0 or len(classifiers_dict) == 1 and list(classifiers_dict.values())[0].mutually_exclusive:
+        if len(new_conclusions) == 0 or len(classifiers_dict) == 1 and list(classifiers_dict.values())[
+            0].mutually_exclusive:
             break
     return conclusions
 
 
-def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+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.
@@ -95,3 +96,23 @@ def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDow
     else:
         rdr = rdr_type(**rdr_kwargs)
     return rdr
+
+
+def get_an_updated_case_copy(case: Case, conclusion: Callable, attribute_name: str, conclusion_type: Tuple[Type, ...],
+                             mutually_exclusive: bool) -> Case:
+    """
+    :param case: The case to copy and update.
+    :param conclusion: The conclusion to add to the case.
+    :param attribute_name: The name of the attribute to update.
+    :param conclusion_type: The type of the conclusion to update.
+    :param mutually_exclusive: Whether the rule belongs to a mutually exclusive RDR.
+    :return: A copy of the case updated with the given conclusion.
+    """
+    case_cp = copy_case(case)
+    temp_case_query = CaseQuery(case_cp, attribute_name, conclusion_type,
+                                mutually_exclusive=mutually_exclusive)
+    output = conclusion(case_cp)
+    if not isinstance(output, Dict):
+        output = {attribute_name: output}
+    update_case(temp_case_query, output)
+    return case_cp

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/src/ripple_down_rules/rdr.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import importlib
+import json
 import os
 from abc import ABC, abstractmethod
 from copy import copy
+from dataclasses import is_dataclass
 from types import NoneType
 
 from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
@@ -27,15 +29,16 @@ from .datastructures.case import Case, CaseAttribute, create_case
 from .datastructures.dataclasses import CaseQuery
 from .datastructures.enums import MCRDRMode
 from .experts import Expert, Human
-from .helpers import is_matching, general_rdr_classify
-from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
+from .helpers import is_matching, general_rdr_classify, get_an_updated_case_copy
+from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule, MultiClassRefinementRule, \
+    MultiClassFilterRule
 
 try:
     from .user_interface.gui import RDRCaseViewer
 except ImportError as e:
     RDRCaseViewer = None
 from .utils import draw_tree, make_set, SubclassJSONSerializer, make_list, get_type_from_string, \
-    is_conflicting, extract_function_source, extract_imports, get_full_class_name, \
+    is_value_conflicting, extract_function_source, extract_imports, get_full_class_name, \
     is_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types, render_tree
 
 
@@ -97,11 +100,12 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 self.viewer = RDRCaseViewer.instances[0]
                 logger.error("No viewer was provided, but there is already an existing viewer. "
                              "Using the existing viewer.")
+        self.input_node: Optional[Rule] = None
 
     @property
     def viewer(self):
         return self._viewer
-    
+
     @viewer.setter
     def viewer(self, value):
         self._viewer = value
@@ -110,23 +114,24 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
     def render_evaluated_rule_tree(self, filename: str, show_full_tree: bool = False) -> None:
         if show_full_tree:
-            render_tree(self.start_rule, use_dot_exporter=True, filename=filename)
+            start_rule = self.start_rule if self.input_node is None else self.input_node
+            render_tree(start_rule, use_dot_exporter=True, filename=filename)
         else:
             evaluated_rules = self.get_evaluated_rule_tree()
             if evaluated_rules is not None and len(evaluated_rules) > 0:
                 render_tree(evaluated_rules[0], use_dot_exporter=True, filename=filename,
                             only_nodes=evaluated_rules)
 
-    def get_evaluated_rule_tree(self) -> List[Rule]:
+    def get_evaluated_rule_tree(self) -> Optional[List[Rule]]:
         """
         Get the evaluated rule tree of the classifier.
 
         :return: The evaluated rule tree.
         """
         if self.start_rule is None:
-            return
-            # raise ValueError("The start rule is not set. Please set the start rule before getting the evaluated rule tree.")
-        evaluated_rule_tree = [r for r in [self.start_rule] + list(self.start_rule.descendants) if r.evaluated]
+            return None
+        start_rule = self.start_rule
+        evaluated_rule_tree = [r for r in [start_rule] + list(start_rule.descendants) if r.evaluated]
         return evaluated_rule_tree
 
     def save(self, save_dir: Optional[str] = None, model_name: Optional[str] = None,
@@ -260,9 +265,38 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     def __call__(self, case: Union[Case, SQLTable]) -> Union[CallableExpression, Dict[str, CallableExpression]]:
         return self.classify(case)
 
+    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False, case_query: Optional[CaseQuery] = None) \
+            -> Optional[Union[CallableExpression, Dict[str, CallableExpression]]]:
+        """
+        Classify a case using the RDR classifier.
+
+        :param case: The case to classify.
+        :param modify_case: Whether to modify the original case attributes with the conclusion or not.
+        :param case_query: The case query containing the case to classify and the target category to compare the case with.
+        :return: The category that the case belongs to.
+        """
+        if self.start_rule is not None:
+            for rule in [self.start_rule] + list(self.start_rule.descendants):
+                rule.evaluated = False
+                rule.fired = False
+        if self.start_rule is not None and self.start_rule.parent is None:
+            if self.input_node is None:
+                self.input_node = type(self.start_rule)(parent=None, uid='0')
+                self.input_node.evaluated = False
+                self.input_node.fired = False
+            self.start_rule.parent = self.input_node
+            self.start_rule.weight = ""
+        if self.input_node is not None:
+            data = case.__dict__ if is_dataclass(case) else case
+            if hasattr(case, "items"):
+                self.input_node.name = json.dumps({k: str(v) for k, v in data.items()}, indent=4)
+            else:
+                self.input_node.name = str(data)
+        return self._classify(case, modify_case=modify_case, case_query=case_query)
+
     @abstractmethod
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) \
+    def _classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) \
             -> Optional[Union[CallableExpression, Dict[str, CallableExpression]]]:
         """
         Classify a case.
@@ -467,25 +501,51 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         conclusion_func_names = [f'conclusion_{rid}' for rid in rules_dict.keys()
                                  if not isinstance(rules_dict[rid], MultiClassStopRule)]
         all_func_names = condition_func_names + conclusion_func_names
+        rule_tree_file_path = f"{model_dir}/{self.generated_python_file_name}.py"
         filepath = f"{model_dir}/{self.generated_python_defs_file_name}.py"
         cases_path = f"{model_dir}/{self.generated_python_cases_file_name}.py"
         cases_import_path = get_import_path_from_path(model_dir)
         cases_import_path = f"{cases_import_path}.{self.generated_python_cases_file_name}" if cases_import_path \
             else self.generated_python_cases_file_name
         functions_source = extract_function_source(filepath, all_func_names, include_signature=False)
+        python_rule_tree_source = ""
+        with open(rule_tree_file_path, "r") as rule_tree_source:
+            python_rule_tree_source = rule_tree_source.read()
         # get the scope from the imports in the file
         scope = extract_imports(filepath, package_name=package_name)
+        rules_not_found = set()
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             if rule.conditions is not None:
-                rule.conditions.user_input = functions_source[f"conditions_{rule.uid}"]
+                conditions_name = rule.generated_conditions_function_name
+                if conditions_name not in functions_source or conditions_name not in python_rule_tree_source:
+                    rules_not_found.add(rule)
+                    continue
+                rule.conditions.user_input = functions_source[conditions_name]
                 rule.conditions.scope = scope
                 if os.path.exists(cases_path):
                     module = importlib.import_module(cases_import_path, package=package_name)
                     importlib.reload(module)
                     rule.corner_case_metadata = module.__dict__.get(f"corner_case_{rule.uid}", None)
-            if rule.conclusion is not None and not isinstance(rule, MultiClassStopRule):
-                rule.conclusion.user_input = functions_source[f"conclusion_{rule.uid}"]
+            if not isinstance(rule, MultiClassStopRule):
+                conclusion_name = rule.generated_conclusion_function_name
+                if conclusion_name not in functions_source or conclusion_name not in python_rule_tree_source:
+                    rules_not_found.add(rule)
+                rule.conclusion.user_input = functions_source[conclusion_name]
                 rule.conclusion.scope = scope
+        for rule in rules_not_found:
+            if isinstance(rule, MultiClassTopRule):
+                import pdb; pdb.set_trace()
+                rule.parent.set_immediate_alternative(rule.alternative)
+                if rule.refinement is not None:
+                    ref_rules = [ref_rule for ref_rule in [rule.refinement] + list(rule.refinement.descendants)]
+                    for ref_rule in ref_rules:
+                        del ref_rule
+            else:
+                rule.parent.refinement = rule.alternative
+            if rule.alternative is not None:
+                rule.alternative = None
+            rule.parent = None
+            del rule
 
     @abstractmethod
     def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = "",
@@ -564,7 +624,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         pass
 
-    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+    def _get_types_to_import(self) -> Tuple[Set[Union[Type, Callable]], Set[Type], Set[Type]]:
         """
         :return: The types of the main, defs, and corner cases files of the RDR classifier that will be imported.
         """
@@ -703,8 +763,8 @@ class SingleClassRDR(RDRWithCodeWriter):
             expert.ask_for_conditions(case_query)
             self.start_rule = SingleClassRule.from_case_query(case_query)
 
-    def classify(self, case: Case, modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Optional[Any]:
+    def _classify(self, case: Case, modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> Optional[Any]:
         """
         Classify a case by recursively evaluating the rules until a rule fires or the last rule is reached.
 
@@ -818,8 +878,8 @@ class MultiClassRDR(RDRWithCodeWriter):
         super(MultiClassRDR, self).__init__(start_rule, **kwargs)
         self.mode: MCRDRMode = mode
 
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Set[Any]:
+    def _classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> Set[Any]:
         evaluated_rule = self.start_rule
         self.conclusions = []
         while evaluated_rule:
@@ -897,6 +957,9 @@ class MultiClassRDR(RDRWithCodeWriter):
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, filename, parent_indent, defs_file=defs_file,
                                                         cases_file=cases_file, package_name=package_name)
+            elif isinstance(rule, MultiClassTopRule):
+                with open(filename, "a") as file:
+                    file.write(f"{parent_indent}return conclusions\n")
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -906,8 +969,9 @@ class MultiClassRDR(RDRWithCodeWriter):
         else:
             return f"Set[Union[{', '.join(conclusion_types)}]]"
 
-    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+    def _get_types_to_import(self) -> Tuple[Set[Union[Type, Callable]], Set[Type], Set[Type]]:
         main_types, defs_types, cases_types = super()._get_types_to_import()
+        main_types.add(get_an_updated_case_copy)
         main_types.update({Set, make_set})
         defs_types.update({List, Set})
         return main_types, defs_types, cases_types
@@ -939,28 +1003,43 @@ class MultiClassRDR(RDRWithCodeWriter):
         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):
-            self.stop_conclusion(case_query, expert, evaluated_rule)
-        else:
+        stop: bool = False
+        add_filter_rule: bool = False
+        if is_value_conflicting(rule_conclusion, case_query.target_value):
+            if make_set(case_query.target_value).issubset(rule_conclusion):
+                add_filter_rule = True
+            else:
+                stop = True
+        elif make_set(case_query.core_attribute_type).issubset(make_set(evaluated_rule.conclusion.conclusion_type)):
+            if make_set(case_query.target_value).issubset(rule_conclusion):
+                add_filter_rule = True
+
+        if not stop:
             self.add_conclusion(rule_conclusion)
+        if stop or add_filter_rule:
+            refinement_type = MultiClassStopRule if stop else MultiClassFilterRule
+            self.stop_or_filter_conclusion(case_query, expert, evaluated_rule, refinement_type=refinement_type)
 
-    def stop_conclusion(self, case_query: CaseQuery,
-                        expert: Expert, evaluated_rule: MultiClassTopRule):
+    def stop_or_filter_conclusion(self, case_query: CaseQuery,
+                                  expert: Expert, evaluated_rule: MultiClassTopRule,
+                                  refinement_type: Type[MultiClassRefinementRule] = MultiClassStopRule):
         """
         Stop a conclusion by adding a stopping rule.
 
         :param case_query: The case query to stop the conclusion for.
         :param expert: The expert to ask for differentiating features as new rule conditions.
         :param evaluated_rule: The evaluated rule to ask the expert about.
+        :param refinement_type: The refinement type to use.
         """
         conditions = expert.ask_for_conditions(case_query, evaluated_rule)
-        evaluated_rule.fit_rule(case_query)
-        if self.mode == MCRDRMode.StopPlusRule:
-            self.stop_rule_conditions = conditions
-        if self.mode == MCRDRMode.StopPlusRuleCombined:
-            new_top_rule_conditions = conditions.combine_with(evaluated_rule.conditions)
-            case_query.conditions = new_top_rule_conditions
-            self.add_top_rule(case_query)
+        evaluated_rule.fit_rule(case_query, refinement_type=refinement_type)
+        if refinement_type is MultiClassStopRule:
+            if self.mode == MCRDRMode.StopPlusRule:
+                self.stop_rule_conditions = conditions
+            if self.mode == MCRDRMode.StopPlusRuleCombined:
+                new_top_rule_conditions = conditions.combine_with(evaluated_rule.conditions)
+                case_query.conditions = new_top_rule_conditions
+                self.add_top_rule(case_query)
 
     def add_rule_for_case(self, case_query: CaseQuery, expert: Expert):
         """
@@ -1064,8 +1143,8 @@ 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, modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Optional[Dict[str, Any]]:
+    def _classify(self, case: Any, modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> 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.

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.25}/src/ripple_down_rules/rdr_decorators.py

@@ -8,15 +8,16 @@ from functools import wraps
 
 from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union, Sequence
 
-from ripple_down_rules.datastructures.case import Case
-from ripple_down_rules.datastructures.dataclasses import CaseQuery
-from ripple_down_rules.experts import Expert, Human
-from ripple_down_rules.rdr import GeneralRDR
+from .datastructures.case import Case
+from .datastructures.dataclasses import CaseQuery
+from .experts import Expert, Human
+from .rdr import GeneralRDR
+from . import logger
 try:
-    from ripple_down_rules.user_interface.gui import RDRCaseViewer
+    from .user_interface.gui import RDRCaseViewer
 except ImportError:
     RDRCaseViewer = None
-from ripple_down_rules.utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
+from .utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
     get_method_class_if_exists, str_to_snake_case