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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.24
+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.24 → ripple_down_rules-0.6.25}/src/ripple_down_rules/__init__.py

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

{ripple_down_rules-0.6.24 → 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.24 → 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.24 → 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.24 → 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.24 → 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.24 → ripple_down_rules-0.6.25}/src/ripple_down_rules/rdr.py

@@ -1,12 +1,12 @@
 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
-import json
 
 from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
 from . import logger
@@ -29,16 +29,17 @@ 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_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types, render_tree, table_rows_as_str
+    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
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -500,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 = "",
@@ -597,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.
         """
@@ -930,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:
@@ -939,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
@@ -972,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):
         """