ripple-down-rules 0.1.62__py3-none-any.whl → 0.1.64__py3-none-any.whl

ripple_down_rules/datastructures/case.py

@@ -307,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")
@@ -324,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/experts.py

@@ -122,7 +122,7 @@ 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)
 

ripple_down_rules/rdr.py

@@ -217,13 +217,16 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             if not rule.conditions:
                 continue
-            if rule.conditions.scope is None or len(rule.conditions.scope) == 0:
-                continue
-            for k, v in rule.conditions.scope.items():
-                new_imports = f"from {v.__module__} import {v.__name__}\n"
-                if new_imports in imports:
+            for scope in [rule.conditions.scope, rule.conclusion.scope]:
+                if scope is None:
                     continue
-                imports += new_imports
+                for k, v in scope.items():
+                    if not hasattr(v, "__module__") or not hasattr(v, "__name__"):
+                        continue
+                    new_imports = f"from {v.__module__} import {v.__name__}\n"
+                    if new_imports in imports:
+                        continue
+                    imports += new_imports
         return imports
 
     def get_rdr_classifier_from_python_file(self, package_name: str) -> Callable[[Any], Any]:
@@ -722,7 +725,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.
@@ -734,7 +737,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.
@@ -775,7 +778,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
@@ -790,7 +793,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,"
@@ -823,10 +826,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)

ripple_down_rules/rules.py

@@ -288,7 +288,7 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
 
     def __init__(self, *args, **kwargs):
         super(MultiClassStopRule, self).__init__(*args, **kwargs)
-        self.conclusion = Stop.stop
+        self.conclusion = CallableExpression(conclusion_type=(Stop,), conclusion=Stop.stop)
 
     def evaluate_next_rule(self, x: Case) -> Optional[Union[MultiClassStopRule, MultiClassTopRule]]:
         if self.fired:

{ripple_down_rules-0.1.62.dist-info → ripple_down_rules-0.1.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.62
+Version: 0.1.64
 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.62.dist-info → ripple_down_rules-0.1.64.dist-info}/RECORD

@@ -1,20 +1,20 @@
 ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/datasets.py,sha256=rCSpeFeu1gTuKESwjHUdQkPPvomI5OMRNGpbdKmHwMg,4639
-ripple_down_rules/experts.py,sha256=TXU-VKhWlSE3aYrCEcXf9t9N4TBDW_T5tE4T6MdCibE,10342
+ripple_down_rules/experts.py,sha256=TretkdR1IY2RjcSh4WJUFJtYEbItsand7SYFmzouE_Y,10348
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
 ripple_down_rules/prompt.py,sha256=cHqhMJqubGhfGpOOY_uXv5L7PBNb64O0IBWSfiY0ui0,6682
-ripple_down_rules/rdr.py,sha256=K-b1I1pBEN6rn3AZdTAxgOs6AFXXvqkGI4x8dV9nrWw,47793
+ripple_down_rules/rdr.py,sha256=tJDbPF3D2qJ5cw2WPmZrs_C2Jj6b7cCxEJDp2SK9GCI,47863
 ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
-ripple_down_rules/rules.py,sha256=KTB7kPnyyU9GuZhVe9ba25-3ICdzl46r9MFduckk-_Y,16147
+ripple_down_rules/rules.py,sha256=4oQSb4p36A-YzW0hJ8HH2FhmIvokjXKK1rIXEn-8WcE,16203
 ripple_down_rules/utils.py,sha256=JIF99Knqzqjgny7unvEnib3sCmExqU-w9xYOSGIT86Q,32276
 ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
 ripple_down_rules/datastructures/callable_expression.py,sha256=TW_u6CJfelW2CiJj9pWFpdOBNIxeEuhhsQEz_pLpFVE,9092
-ripple_down_rules/datastructures/case.py,sha256=XJC6Sb67gzpEYYYYjvECJlJBRVphMScWhWMTc2kTtbc,13792
+ripple_down_rules/datastructures/case.py,sha256=uM5YkJOfYfARrZZ3oAxKMWE5QBSnvHLLZa9Atoxb7eY,13800
 ripple_down_rules/datastructures/dataclasses.py,sha256=_aabVXsgdVUeAmgGA9K_LZpO2U5a6-htrg2Tka7qc30,5960
 ripple_down_rules/datastructures/enums.py,sha256=RdyPUp9Ls1QuLmkcMMkBbCWrmXIZI4xWuM-cLPYZhR0,4666
-ripple_down_rules-0.1.62.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.1.62.dist-info/METADATA,sha256=jPKNb7YM2Wcsy9p1otEVqyxv5apcfADU-sPin5Wu0qs,42576
-ripple_down_rules-0.1.62.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-ripple_down_rules-0.1.62.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.1.62.dist-info/RECORD,,
+ripple_down_rules-0.1.64.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.1.64.dist-info/METADATA,sha256=PChgWG-I8g-_yaKMDwrxJPuIHOe0fIrThGu_vOqrQkE,42576
+ripple_down_rules-0.1.64.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
+ripple_down_rules-0.1.64.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.1.64.dist-info/RECORD,,

{ripple_down_rules-0.1.62.dist-info → ripple_down_rules-0.1.64.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any