ripple-down-rules 0.5.58__tar.gz → 0.5.60__tar.gz

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/PKG-INFO

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

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

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -259,7 +259,8 @@ class CallableExpression(SubclassJSONSerializer):
                 "conclusion_type": [get_full_class_name(t) for t in self.conclusion_type]
                 if self.conclusion_type is not None else None,
                 "scope": {k: get_full_class_name(v) for k, v in self.scope.items()
-                          if hasattr(v, '__module__') and hasattr(v, '__name__')},
+                          if hasattr(v, '__module__') and hasattr(v, '__name__')
+                          and v.__module__ is not None and v.__name__ is not None},
                 "conclusion": conclusion_to_json(self.conclusion),
                 "mutually_exclusive": self.mutually_exclusive,
                 }

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/src/ripple_down_rules/rdr.py

@@ -78,7 +78,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     """
 
     def __init__(self, start_rule: Optional[Rule] = None, viewer: Optional[RDRCaseViewer] = None,
-                 save_dir: Optional[str] = None, ask_always: bool = True, model_name: Optional[str] = None):
+                 save_dir: Optional[str] = None, ask_always: bool = False, model_name: Optional[str] = None):
         """
         :param start_rule: The starting rule for the classifier.
         :param viewer: The viewer gui to use for the classifier. If None, no viewer is used.
@@ -241,12 +241,18 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         self.case_type = case_query.case_type if self.case_type is None else self.case_type
         self.case_name = case_query.case_name if self.case_name is None else self.case_name
 
-        expert = expert or Human(answers_save_path=self.save_dir + '/expert_answers' if self.save_dir else None)
+        expert = expert or Human(viewer=self.viewer,
+                                 answers_save_path=self.save_dir + '/expert_answers'
+                                 if self.save_dir else None)
 
         if case_query.target is None:
             case_query_cp = copy(case_query)
             conclusions = self.classify(case_query_cp.case, modify_case=True)
-            if self.ask_always or conclusions is None or is_iterable(conclusions) and len(conclusions) == 0:
+            if (self.ask_always or conclusions is None
+                or is_iterable(conclusions) and len(conclusions) == 0
+                or (isinstance(conclusions, dict) and (case_query_cp.attribute_name not in conclusions
+                    or not any(type(c) in case_query_cp.core_attribute_type
+                               for c in make_list(conclusions[case_query_cp.attribute_name]))))):
                 expert.ask_for_conclusion(case_query_cp)
                 case_query.target = case_query_cp.target
             if case_query.target is None:
@@ -493,7 +499,8 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         return self.start_rule.conclusion_name
 
     def _to_json(self) -> Dict[str, Any]:
-        return {"start_rule": self.start_rule.to_json(),  "generated_python_file_name": self.generated_python_file_name,
+        return {"start_rule": self.start_rule.to_json(),
+                "generated_python_file_name": self.generated_python_file_name,
                 "name": self.name,
                 "case_type": get_full_class_name(self.case_type) if self.case_type is not None else None,
                 "case_name": self.case_name}
@@ -645,12 +652,12 @@ class MultiClassRDR(RDRWithCodeWriter):
     """
 
     def __init__(self, start_rule: Optional[MultiClassTopRule] = None,
-                 mode: MCRDRMode = MCRDRMode.StopOnly):
+                 mode: MCRDRMode = MCRDRMode.StopOnly, **kwargs):
         """
         :param start_rule: The starting rules for the classifier.
         :param mode: The mode of the classifier, either StopOnly or StopPlusRule, or StopPlusRuleCombined.
         """
-        super(MultiClassRDR, self).__init__(start_rule)
+        super(MultiClassRDR, self).__init__(start_rule, **kwargs)
         self.mode: MCRDRMode = mode
 
     def classify(self, case: Union[Case, SQLTable], modify_case: bool = False) -> Set[Any]:

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/src/ripple_down_rules/rdr_decorators.py

@@ -24,7 +24,6 @@ class RDRDecorator:
     def __init__(self, models_dir: str,
                  output_type: Tuple[Type],
                  mutual_exclusive: bool,
-                 python_dir: Optional[str] = None,
                  output_name: str = "output_",
                  fit: bool = True,
                  expert: Optional[Expert] = None):
@@ -32,7 +31,6 @@ class RDRDecorator:
         :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.
         :param mutual_exclusive: If True, the output types are mutually exclusive.
-        :param python_dir: The directory to save the RDR model as a python file.
          If None, the RDR model will not be saved as a python file.
         :param output_name: The name of the output. This is used to create the RDR model.
         :param fit: If True, the function will be in fit mode. This means that the RDR will prompt the user for the
@@ -47,7 +45,6 @@ class RDRDecorator:
         self.output_type = output_type
         self.parsed_output_type: List[Type] = []
         self.mutual_exclusive = mutual_exclusive
-        self.rdr_python_path: Optional[str] = python_dir
         self.output_name = output_name
         self.fit: bool = fit
         self.expert: Optional[Expert] = expert
@@ -64,8 +61,6 @@ class RDRDecorator:
                 self.initialize_rdr_model_name_and_load(func)
 
             if self.fit:
-                expert_answers_path = os.path.join(self.rdr_models_dir, self.model_name, "expert_answers")
-                self.expert = self.expert or Human(answers_save_path=expert_answers_path)
                 case_query = self.create_case_query_from_method(func, self.parsed_output_type,
                                                                 self.mutual_exclusive, self.output_name,
                                                                 *args, **kwargs)
@@ -148,9 +143,12 @@ class RDRDecorator:
         """
         Load the RDR model from the specified directory.
         """
-        if self.model_name is not None and os.path.exists(os.path.join(self.rdr_models_dir, self.model_name)):
-            self.rdr = GeneralRDR.load(self.rdr_models_dir, self.model_name)
-        else:
+        self.rdr = None
+        if self.model_name is not None:
+            model_path = os.path.join(self.rdr_models_dir, self.model_name + f"/rdr_metadata/{self.model_name}.json")
+            if os.path.exists(os.path.join(self.rdr_models_dir, model_path)):
+                self.rdr = GeneralRDR.load(self.rdr_models_dir, self.model_name)
+        if self.rdr is None:
             self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name)
 
     def update_from_python(self):

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/src/ripple_down_rules/utils.py

@@ -497,21 +497,8 @@ def serialize_dataclass(obj: Any, seen=None) -> Any:
             value = getattr(obj, f.name)
             result['fields'][f.name] = serialize_dataclass(value, seen)
         return result
-    elif isinstance(obj, list):
-        return [serialize_dataclass(v, seen) for v in obj]
-    elif isinstance(obj, dict):
-        serialized_dict = {}
-        for k, v in obj.items():
-            if not isinstance(k, (str, int, bool, float, type(None))):
-                continue
-            serialized_dict[k] = serialize_dataclass(v, seen)
-        return serialized_dict
     else:
-        try:
-            json.dumps(obj)  # Check if the object is JSON serializable
-            return obj
-        except TypeError:
-            return None
+        return SubclassJSONSerializer.to_json_static(obj, seen)
 
 
 def deserialize_dataclass(data: Any, refs: Optional[Dict[str, Any]] = None) -> Any:
@@ -875,10 +862,26 @@ class SubclassJSONSerializer:
         return data
 
     @staticmethod
-    def to_json_static(obj) -> Dict[str, Any]:
-        if is_dataclass(obj):
-            return serialize_dataclass(obj)
-        return {"_type": get_full_class_name(obj.__class__), **obj._to_json()}
+    def to_json_static(obj, seen=None) -> Any:
+        if isinstance(obj, SubclassJSONSerializer):
+            return {"_type": get_full_class_name(obj.__class__), **obj._to_json()}
+        elif is_dataclass(obj):
+            return serialize_dataclass(obj, seen)
+        elif isinstance(obj, list):
+            return [SubclassJSONSerializer.to_json_static(v, seen) for v in obj]
+        elif isinstance(obj, dict):
+            serialized_dict = {}
+            for k, v in obj.items():
+                if not isinstance(k, (str, int, bool, float, type(None))):
+                    continue
+                serialized_dict[k] = SubclassJSONSerializer.to_json_static(v, seen)
+            return serialized_dict
+        else:
+            try:
+                json.dumps(obj)  # Check if the object is JSON serializable
+                return obj
+            except TypeError:
+                return None
 
     def to_json(self) -> Dict[str, Any]:
         return self.to_json_static(self)

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.58
+Version: 0.5.60
 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.5.58 → ripple_down_rules-0.5.60}/test/test_helpers/helpers.py

@@ -17,14 +17,15 @@ def get_fit_scrdr(cases: List[Any], targets: List[Any], attribute_name: str = "s
                   expert_answers_file: str = "scrdr_expert_answers_fit",
                   draw_tree: bool = False,
                   load_answers: bool = True,
-                  save_answers: bool = False) -> Tuple[SingleClassRDR, List[CaseQuery]]:
+                  save_answers: bool = False,
+                  ask_always: bool = False) -> Tuple[SingleClassRDR, List[CaseQuery]]:
     filename = os.path.join(os.getcwd(), expert_answers_dir, expert_answers_file)
     expert = Human(use_loaded_answers=load_answers)
     if load_answers:
         expert.load_answers(filename)
 
     targets = [None for _ in cases] if targets is None or len(targets) == 0 else targets
-    scrdr = SingleClassRDR()
+    scrdr = SingleClassRDR(ask_always=ask_always)
     case_queries = [CaseQuery(case, attribute_name, (attribute_type,), True, _target=target)
                     for case, target in zip(cases, targets)]
     scrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
@@ -43,13 +44,14 @@ def get_fit_mcrdr(cases: List[Any], targets: List[Any], attribute_name: str = "s
                   expert_answers_file: str = "mcrdr_expert_answers_stop_only_fit",
                   draw_tree: bool = False,
                   load_answers: bool = True,
-                  save_answers: bool = False) -> MultiClassRDR:
+                  save_answers: bool = False,
+                  ask_always: bool = False) -> MultiClassRDR:
     filename = os.path.join(os.getcwd(), expert_answers_dir, expert_answers_file)
     expert = Human(use_loaded_answers=load_answers)
     if load_answers:
         expert.load_answers(filename)
     targets = [None for _ in cases] if targets is None or len(targets) == 0 else targets
-    mcrdr = MultiClassRDR()
+    mcrdr = MultiClassRDR(ask_always=ask_always)
     case_queries = [CaseQuery(case, attribute_name, (attribute_type,), mutually_exclusive, _target=target)
                     for case, target in zip(cases, targets)]
     mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
@@ -66,7 +68,8 @@ def get_fit_grdr(cases: List[Any], targets: List[Any], expert_answers_dir: str =
                  load_answers: bool = True,
                  save_answers: bool = False,
                  append: bool = False,
-                 no_targets: bool = False) -> Tuple[GeneralRDR, List[dict]]:
+                 no_targets: bool = False,
+                 ask_always: bool = False) -> Tuple[GeneralRDR, List[dict]]:
     filename = os.path.join(os.path.dirname(__file__), '..', expert_answers_dir, expert_answers_file)
     expert = Human(use_loaded_answers=load_answers, append=append)
     if load_answers:
@@ -74,7 +77,7 @@ def get_fit_grdr(cases: List[Any], targets: List[Any], expert_answers_dir: str =
 
     fit_scrdr, _ = get_fit_scrdr(cases, targets, draw_tree=False)
 
-    grdr = GeneralRDR()
+    grdr = GeneralRDR(ask_always=ask_always)
     grdr.add_rdr(fit_scrdr)
 
     n = 20

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/test/test_rdr.py

@@ -125,7 +125,8 @@ class TestRDR(TestCase):
                                             expert_answers_dir=self.expert_answers_dir,
                                             expert_answers_file="scrdr_expert_answers_fit_no_targets",
                                             load_answers=True,
-                                            save_answers=False)
+                                            save_answers=False,
+                                            ask_always=True)
         if draw:
             render_tree(scrdr.start_rule, use_dot_exporter=True,
                         filename=self.test_results_dir + f"/scrdr_no_targets")
@@ -135,7 +136,8 @@ class TestRDR(TestCase):
         scrdr, case_queries = get_fit_scrdr(self.all_cases[:20], [], draw_tree=False,
                                             expert_answers_dir=self.expert_answers_dir,
                                             expert_answers_file="scrdr_expert_answers_fit_no_targets",
-                                            load_answers=True, save_answers=False)
+                                            load_answers=True, save_answers=False,
+                                            ask_always=True)
         model_dir = self.generated_rdrs_dir + '/scrdr_no_targets'
         os.makedirs(model_dir, exist_ok=True)
         scrdr._write_to_python(model_dir)
@@ -150,7 +152,8 @@ class TestRDR(TestCase):
                               expert_answers_dir=self.expert_answers_dir,
                               expert_answers_file="mcrdr_expert_answers_fit_no_targets",
                               load_answers=True,
-                              save_answers=False)
+                              save_answers=False,
+                              ask_always=True)
         # render_tree(mcrdr.start_rule, use_dot_exporter=True,
         #             filename=self.test_results_dir + f"/mcrdr_no_targets")
         for case, target in zip(self.all_cases[:20], self.targets[:20]):
@@ -162,7 +165,8 @@ class TestRDR(TestCase):
         mcrdr = get_fit_mcrdr(self.all_cases[:20], [], draw_tree=False,
                               expert_answers_dir=self.expert_answers_dir,
                               expert_answers_file="mcrdr_expert_answers_fit_no_targets",
-                              load_answers=True, save_answers=False)
+                              load_answers=True, save_answers=False,
+                              ask_always=True)
         model_dir = self.generated_rdrs_dir + '/mcrdr_no_targets'
         os.makedirs(model_dir, exist_ok=True)
         mcrdr._write_to_python(model_dir)
@@ -178,7 +182,8 @@ class TestRDR(TestCase):
         grdr, all_targets = get_fit_grdr(self.all_cases, self.targets, draw_tree=draw_tree,
                                          expert_answers_dir=self.expert_answers_dir,
                                          expert_answers_file="grdr_expert_answers_fit_no_targets",
-                                         load_answers=True, save_answers=False, append=False, no_targets=True)
+                                         load_answers=True, save_answers=False, append=False, no_targets=True,
+                                         ask_always=True)
         if draw_tree:
             for conclusion_name, rdr in grdr.start_rules_dict.items():
                 render_tree(rdr.start_rule, use_dot_exporter=True,
@@ -194,7 +199,8 @@ class TestRDR(TestCase):
         grdr, all_targets = get_fit_grdr(self.all_cases, self.targets, draw_tree=False,
                                          expert_answers_dir=self.expert_answers_dir,
                                          expert_answers_file="grdr_expert_answers_fit_no_targets",
-                                         load_answers=True, save_answers=False, append=False, no_targets=True)
+                                         load_answers=True, save_answers=False, append=False, no_targets=True,
+                                         ask_always=True)
         model_dir = self.generated_rdrs_dir + '/grdr_no_targets'
         grdr._write_to_python(model_dir)
         classify_species_grdr = grdr.get_rdr_classifier_from_python_file(model_dir)

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/test/test_rdr_world.py

@@ -182,7 +182,7 @@ class TestRDRWorld(TestCase):
         filename = os.path.join(os.getcwd(), "test_expert_answers/correct_drawer_rdr_expert_answers_fit")
         if use_loaded_answers:
             expert.load_answers(filename)
-        rdr = GeneralRDR()
+        rdr = GeneralRDR(ask_always=True)
         rdr.fit(self.drawer_case_queries, expert=expert, animate_tree=False)
         if save_answers:
             expert.save_answers(filename)

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/test/test_results/datasets_physical_object_is_a_robot/rdr_metadata/datasets_physical_object_is_a_robot.json

@@ -12,9 +12,9 @@
                         "builtins.bool"
                     ],
                     "scope": {
-                        "PhysicalObject": "datasets.PhysicalObject",
+                        "Dict": "typing.Dict",
                         "Robot": "datasets.Robot",
-                        "Dict": "typing.Dict"
+                        "PhysicalObject": "datasets.PhysicalObject"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",
@@ -29,9 +29,9 @@
                         "builtins.bool"
                     ],
                     "scope": {
-                        "PhysicalObject": "datasets.PhysicalObject",
+                        "Dict": "typing.Dict",
                         "Robot": "datasets.Robot",
-                        "Dict": "typing.Dict"
+                        "PhysicalObject": "datasets.PhysicalObject"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_output__mcrdr.py

@@ -6,7 +6,7 @@ from ripple_down_rules.rdr import MultiClassRDR
 
 
 attribute_name = 'output_'
-conclusion_type = (set, list, PhysicalObject,)
+conclusion_type = (PhysicalObject, list, set,)
 type_ = MultiClassRDR
 
 

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/rdr_metadata/datasets_physical_object_select_objects_that_are_parts_of_robot.json

@@ -12,11 +12,11 @@
                         "builtins.bool"
                     ],
                     "scope": {
-                        "Robot": "datasets.Robot",
                         "Dict": "typing.Dict",
-                        "PhysicalObject": "datasets.PhysicalObject",
+                        "Union": "typing.Union",
+                        "Robot": "datasets.Robot",
                         "List": "typing.List",
-                        "Union": "typing.Union"
+                        "PhysicalObject": "datasets.PhysicalObject"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",
@@ -33,11 +33,11 @@
                         "builtins.list"
                     ],
                     "scope": {
-                        "Robot": "datasets.Robot",
                         "Dict": "typing.Dict",
-                        "PhysicalObject": "datasets.PhysicalObject",
+                        "Union": "typing.Union",
+                        "Robot": "datasets.Robot",
                         "List": "typing.List",
-                        "Union": "typing.Union"
+                        "PhysicalObject": "datasets.PhysicalObject"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_output__scrdr_defs.py

@@ -1,6 +1,6 @@
-from datasets import PhysicalObject
 from datasets import Robot
 from typing import Dict
+from datasets import PhysicalObject
 
 
 def conditions_226969243620390858682731042391766665817(case):

{ripple_down_rules-0.5.58 → ripple_down_rules-0.5.60}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_output__mcrdr_defs.py

@@ -1,8 +1,8 @@
-from typing import List
 from datasets import Robot
-from datasets import PhysicalObject
+from typing import List
 from typing import Union
 from typing import Dict
+from datasets import PhysicalObject
 from typing_extensions import Union