ripple-down-rules 0.1.62__tar.gz → 0.1.64__tar.gz

{ripple_down_rules-0.1.62 → ripple_down_rules-0.1.64}/PKG-INFO

@@ -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 → ripple_down_rules-0.1.64}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.62"
+version = "0.1.64"
 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.62 → ripple_down_rules-0.1.64}/src/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-0.1.62 → ripple_down_rules-0.1.64}/src/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-0.1.62 → ripple_down_rules-0.1.64}/src/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-0.1.62 → ripple_down_rules-0.1.64}/src/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 → ripple_down_rules-0.1.64}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -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 → ripple_down_rules-0.1.64}/test/test_rdr_world.py

@@ -7,8 +7,8 @@ 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.helpers import is_matching
+from ripple_down_rules.rdr import GeneralRDR
 
 
 @dataclass
@@ -94,7 +94,7 @@ class TestRDRWorld(TestCase):
 
         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)
@@ -109,7 +109,7 @@ class TestRDRWorld(TestCase):
                 all_possible_drawers.append(view)
 
         print(all_possible_drawers)
-        cls.drawer_case_queries = [CaseQuery(possible_drawer, "correct", bool, True, default_value=False)
+        cls.drawer_case_queries = [CaseQuery(possible_drawer, "correct", (bool,), True, default_value=False)
                                    for possible_drawer in all_possible_drawers]
 
     def test_view_rdr(self):
@@ -123,12 +123,12 @@ class TestRDRWorld(TestCase):
             expert.load_answers(filename)
         rdr = GeneralRDR()
         try:
-            rdr.fit_case(CaseQuery(self.world, "views", View, False), expert=expert,
-                    add_extra_conclusions=True)
+            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,
+                rdr.fit_case([CaseQuery(self.world, "views", (View,), False)], expert=expert,
                              add_extra_conclusions=True)
             else:
                 raise e