ripple-down-rules 0.6.1__tar.gz → 0.6.12__tar.gz

{ripple_down_rules-0.6.1 → ripple_down_rules-0.6.12}/PKG-INFO

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

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

{ripple_down_rules-0.6.1 → ripple_down_rules-0.6.12}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -161,7 +161,7 @@ class CallableExpression(SubclassJSONSerializer):
             else:
                 raise ValueError("Either user_input or conclusion must be provided.")
         except Exception as e:
-            raise ValueError(f"Error during evaluation: {e}")
+            raise ValueError(f"Error during evaluation: {e}, user_input: {self.user_input}")
 
     def combine_with(self, other: 'CallableExpression') -> 'CallableExpression':
         """

{ripple_down_rules-0.6.1 → ripple_down_rules-0.6.12}/src/ripple_down_rules/helpers.py

@@ -55,7 +55,7 @@ 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 all(rdr.mutually_exclusive for rdr in classifiers_dict.values())):
+        if len(new_conclusions) == 0: #or (len(classifiers_dict) == 1 and all(rdr.mutually_exclusive for rdr in classifiers_dict.values())):
             break
     return conclusions
 

{ripple_down_rules-0.6.1 → ripple_down_rules-0.6.12}/src/ripple_down_rules/rdr.py

@@ -244,6 +244,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                  expert: Optional[Expert] = None,
                  update_existing_rules: bool = True,
                  scenario: Optional[Callable] = None,
+                 ask_now: Callable = lambda _: True,
                  **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
@@ -255,6 +256,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param update_existing_rules: Whether to update the existing same conclusion type rules that already gave
         some conclusions with the type required by the case query.
         :param scenario: The scenario at which the case was created, this is used to recreate the case if needed.
+        :ask_now: Whether to ask the expert for refinements or alternatives.
         :return: The category that the case belongs to.
         """
         if case_query is None:
@@ -271,7 +273,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         if case_query.target is None:
             case_query_cp = copy(case_query)
             conclusions = self.classify(case_query_cp.case, modify_case=True, case_query=case_query_cp)
-            if self.should_i_ask_the_expert_for_a_target(conclusions, case_query_cp, update_existing_rules):
+            if (self.should_i_ask_the_expert_for_a_target(conclusions, case_query_cp, update_existing_rules)
+                    and ask_now(case_query_cp.case)):
                 expert.ask_for_conclusion(case_query_cp)
                 case_query.target = case_query_cp.target
             if case_query.target is None:

{ripple_down_rules-0.6.1 → ripple_down_rules-0.6.12}/src/ripple_down_rules/rdr_decorators.py

@@ -33,7 +33,8 @@ class RDRDecorator:
                  viewer: Optional[RDRCaseViewer] = None,
                  package_name: Optional[str] = None,
                  use_generated_classifier: bool = False,
-                 ask_now: Callable[[Any], bool] = lambda _: True):
+                 ask_now: Callable[[Any, Any], bool] = lambda _,n: True,
+                 fitting_decorator: Optional[Callable] = None):
         """
         :param models_dir: The directory to save/load the RDR models.
         :param output_type: The type of the output. This is used to create the RDR model.
@@ -66,6 +67,7 @@ class RDRDecorator:
         self.use_generated_classifier = use_generated_classifier
         self.generated_classifier: Optional[Callable] = None
         self.ask_now = ask_now
+        self.fitting_decorator = fitting_decorator
         self.load()
 
     def decorator(self, func: Callable) -> Callable:
@@ -79,8 +81,9 @@ class RDRDecorator:
             func_output = {self.output_name: func(*args, **kwargs)}
 
             case, case_dict = self.create_case_from_method(func, func_output, *args, **kwargs)
-            
-            if self.fit and not self.use_generated_classifier and self.ask_now(case_dict):
+
+            @self.fitting_decorator
+            def fit():
                 if len(self.parsed_output_type) == 0:
                     self.parsed_output_type = self.parse_output_type(func, self.output_type, *args)
                 if self.expert is None:
@@ -89,10 +92,15 @@ class RDRDecorator:
                 case_query = self.create_case_query_from_method(func, func_output,
                                                                 self.parsed_output_type,
                                                                 self.mutual_exclusive,
+                                                                case, case_dict,
                                                                 *args, **kwargs)
                 output = self.rdr.fit_case(case_query, expert=self.expert,
                                            update_existing_rules=self.update_existing_rules,
                                            viewer=self.viewer)
+                return output
+            
+            if self.fit and not self.use_generated_classifier and self.ask_now(case_dict, self.rdr.classify(case)):
+                output = fit()
             else:
                 if self.use_generated_classifier:
                     if self.generated_classifier is None:
@@ -114,6 +122,8 @@ class RDRDecorator:
                                       func_output: Dict[str, Any],
                                       output_type: Sequence[Type],
                                       mutual_exclusive: bool,
+                                      case: Optional[Case] = None,
+                                      case_dict: Optional[Dict[str, Any]] = None,
                                       *args, **kwargs) -> CaseQuery:
         """
         Create a CaseQuery from the function and its arguments.
@@ -127,7 +137,8 @@ class RDRDecorator:
         :return: A CaseQuery object representing the case.
         """
         output_type = make_set(output_type)
-        case, case_dict = RDRDecorator.create_case_from_method(func, func_output, *args, **kwargs)
+        if case is None or case_dict is None:
+            case, case_dict = RDRDecorator.create_case_from_method(func, func_output, *args, **kwargs)
         scope = func.__globals__
         scope.update(case_dict)
         func_args_type_hints = get_type_hints(func)

{ripple_down_rules-0.6.1 → ripple_down_rules-0.6.12}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.1
+Version: 0.6.12
 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