ripple-down-rules 0.6.43__tar.gz → 0.6.45__tar.gz

{ripple_down_rules-0.6.43 → ripple_down_rules-0.6.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.43
+Version: 0.6.45
 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.45/src/ripple_down_rules/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.6.45"
+
+import logging
+logger = logging.Logger("rdr")
+logger.setLevel(logging.INFO)

{ripple_down_rules-0.6.43 → ripple_down_rules-0.6.45}/src/ripple_down_rules/rdr.py

@@ -45,7 +45,7 @@ from .utils import draw_tree, make_set, SubclassJSONSerializer, make_list, get_t
     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, \
     get_types_to_import_from_func_type_hints, get_function_return_type, get_file_that_ends_with, \
-    get_and_import_python_module, get_and_import_python_modules_in_a_package
+    get_and_import_python_module, get_and_import_python_modules_in_a_package, get_type_from_type_hint
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -217,10 +217,10 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         if os.path.exists(json_file + ".json"):
             rdr = cls.from_json_file(json_file)
         try:
+            acronym = cls.get_acronym().lower()
+            python_file_name = get_file_that_ends_with(model_dir, f"_{acronym}.py")
+            python_file_path = os.path.join(model_dir, python_file_name)
             if rdr is None:
-                acronym = cls.get_acronym().lower()
-                python_file_name = get_file_that_ends_with(model_dir, f"_{acronym}.py")
-                python_file_path = os.path.join(model_dir, python_file_name)
                 rdr = cls.from_python(model_dir, parent_package_name=package_name, python_file_path=python_file_path)
             else:
                 rdr.update_from_python(model_dir, package_name=package_name)
@@ -886,22 +886,52 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         self.update_rdr_metadata_from_python(main_module)
 
         functions_source = extract_function_source(defs_module.__file__,
-                                                   all_func_names, include_signature=False)
+                                                   all_func_names, include_signature=True)
         scope = extract_imports(defs_module.__file__, package_name=package_name)
 
+        cases_source, cases_scope = None, None
+        if cases_module:
+            with open(cases_module.__file__, "r") as f:
+                cases_source = f.read()
+            cases_scope = extract_imports(cases_module.__file__, package_name=package_name)
+
+        with open(main_module.__file__, "r") as f:
+            main_source = f.read()
+        main_scope = extract_imports(main_module.__file__, package_name=package_name)
+        attribute_name_line = [l for l in main_source.split('\n') if "attribute_name = " in l]
+        conclusion_name = None
+        if len(attribute_name_line) > 0:
+            conclusion_name = eval(attribute_name_line[0].split('=')[-1].strip(), main_scope)
+
         for rule in all_rules:
             if rule.conditions is not None:
                 conditions_wrapper_func_name = rule.generated_conditions_function_name
                 user_input = functions_source[conditions_wrapper_func_name]
+                user_input = '\n'.join(user_input.split("\n")[1:])  # Remove the function signature line
                 rule.conditions = CallableExpression(user_input, (bool,), scope=scope)
                 if cases_module:
-                    rule.corner_case_metadata = cases_module.__dict__.get(rule.generated_corner_case_object_name, None)
+                    try:
+                        rule.corner_case_metadata = cases_module.__dict__[rule.generated_corner_case_object_name]
+                    except KeyError:
+                        case_def_lines = [l for l in cases_source.split('\n') if rule.generated_corner_case_object_name in l]
+                        if len(case_def_lines) > 0:
+                            case_def_line = case_def_lines[0].split('=')[-1].strip()
+                            rule.corner_case_metadata = eval(case_def_line, cases_scope)
+
             if not isinstance(rule, MultiClassStopRule):
-                rule.conclusion_name = main_module.attribute_name
-                conclusion_wrapper_func_name = rule.generated_conclusion_function_name
-                user_input = functions_source[conclusion_wrapper_func_name]
+                if conclusion_name:
+                    rule.conclusion_name = conclusion_name
+                user_input = functions_source[rule.generated_conclusion_function_name]
+                split_user_input = user_input.split("\n")
+                user_input = '\n'.join(split_user_input[1:])
                 conclusion_func = defs_module.__dict__.get(rule.generated_conclusion_function_name)
-                conclusion_type = get_function_return_type(conclusion_func)
+                if conclusion_func is None:
+                    function_signature = split_user_input[0]
+                    return_type_hint_str = function_signature.split('->')[-1].strip(' :')
+                    return_type_hint = eval(return_type_hint_str, scope)
+                    conclusion_type = get_type_from_type_hint(return_type_hint)
+                else:
+                    conclusion_type = get_function_return_type(conclusion_func)
                 rule.conclusion = CallableExpression(user_input, conclusion_type, scope=scope,
                                                      mutually_exclusive=self.mutually_exclusive)
 

{ripple_down_rules-0.6.43 → ripple_down_rules-0.6.45}/src/ripple_down_rules/utils.py

@@ -168,20 +168,23 @@ def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = N
                 try:
                     scope[asname] = importlib.import_module(module_name, package=package_name)
                 except ImportError as e:
-                    print(f"Could not import {module_name}: {e}")
+                    logger.warning(f"Could not import {module_name}: {e}")
         elif isinstance(node, ast.ImportFrom):
             module_name = node.module
             for alias in node.names:
                 name = alias.name
                 asname = alias.asname or name
                 try:
-                    if package_name is not None and node.level > 0:  # Handle relative imports
-                        module_rel_path = Path(os.path.join(file_path, *['..'] * node.level, module_name)).resolve()
-                        idx = str(module_rel_path).rfind(package_name)
-                        if idx != -1:
-                            module_name = str(module_rel_path)[idx:].replace(os.path.sep, '.')
-                    module = importlib.import_module(module_name, package=package_name)
-                    scope[asname] = getattr(module, name)
+                    if node.level > 0:  # Handle relative imports
+                        package_name = get_import_path_from_path(Path(os.path.join(file_path, *['..'] * node.level)).resolve())
+                    try:
+                        module = importlib.import_module(module_name, package=package_name)
+                    except ModuleNotFoundError:
+                        module = importlib.import_module(f"{package_name}.{module_name}")
+                    if name == "*":
+                        scope.update(module.__dict__)
+                    else:
+                        scope[asname] = getattr(module, name)
                 except (ImportError, AttributeError) as e:
                     logger.warning(f"Could not import {module_name}: {e} while extracting imports from {file_path}")
 
@@ -782,10 +785,14 @@ def get_function_return_type(func: Callable) -> Union[Type, None, Tuple[Type, ..
     if sig.return_annotation == inspect.Signature.empty:
         return None
     type_hint = sig.return_annotation
+    return get_type_from_type_hint(type_hint)
+
+
+def get_type_from_type_hint(type_hint: Type) -> Union[Type, Tuple[Type, ...]]:
     origin = get_origin(type_hint)
     args = get_args(type_hint)
     if origin not in [list, set, None, Union]:
-        raise TypeError(f"{origin} is not a handled return type for function {func.__name__}")
+        raise TypeError(f"{origin} is not a handled return type for type hint {type_hint}")
     if origin is None:
         return typing_to_python_type(type_hint)
     if args is None or len(args) == 0:
@@ -2091,7 +2098,10 @@ def render_tree(root: Node, use_dot_exporter: bool = False,
         else:
             filename = filename or "rule_tree"
             de.to_dotfile(f"{filename}{'.dot'}")
-            de.to_picture(f"{filename}{'.svg'}")
+            try:
+                de.to_picture(f"{filename}{'.svg'}")
+            except FileNotFoundError as e:
+                logger.warning(f"{e}")
 
 
 def draw_tree(root: Node, fig: Figure):

{ripple_down_rules-0.6.43 → ripple_down_rules-0.6.45}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.43
+Version: 0.6.45
 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.43 → ripple_down_rules-0.6.45}/test/test_rdr.py

@@ -106,8 +106,8 @@ class TestRDR(TestCase):
     def test_read_mcrdr_tree(self):
         original_mcrdr = get_fit_mcrdr(self.all_cases, self.targets)
         save_dir = self.generated_rdrs_dir
-        model_name = original_mcrdr.save(save_dir)
-        scrdr_loaded = MultiClassRDR.load(save_dir, original_mcrdr.generated_python_file_name)
+        model_name = original_mcrdr.save(save_dir, 'test_read_mcrdr_tree')
+        scrdr_loaded = MultiClassRDR.load(save_dir, model_name, package_name=f"test.test_generated_rdrs.{model_name}")
         model_path = os.path.join(save_dir, model_name)
         rules_root = MultiClassRDR.read_rule_tree_from_python(model_path)
         for rule, og_rule in zip([rules_root] + list(rules_root.descendants),
@@ -130,7 +130,7 @@ class TestRDR(TestCase):
     def test_load_mcrdr_from_python(self):
         original_mcrdr = get_fit_mcrdr(self.all_cases, self.targets)
         save_dir = self.generated_rdrs_dir
-        model_name = original_mcrdr.save(save_dir)
+        model_name = original_mcrdr.save(save_dir, 'test_load_mcrdr_from_python')
         model_path = os.path.join(save_dir, model_name)
         mcrdr_loaded = MultiClassRDR.from_python(model_path)
         for case, target in zip(self.all_cases, self.targets):
@@ -139,7 +139,7 @@ class TestRDR(TestCase):
     def test_load_grdr_from_python(self):
         original_grdr, targets = get_fit_grdr(self.all_cases, self.targets)
         save_dir = self.generated_rdrs_dir
-        model_name = original_grdr.save(save_dir)
+        model_name = original_grdr.save(save_dir, 'test_load_grdr_from_python')
         model_path = os.path.join(save_dir, model_name)
         grdr_loaded = GeneralRDR.from_python(model_path)
         for case, target in zip(self.all_cases[:len(targets)], targets):

ripple_down_rules-0.6.45/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_output__scrdr_defs.py

@@ -0,0 +1,19 @@
+from types import NoneType
+from typing_extensions import Dict, Optional, Union
+from ...datasets import PhysicalObject, Robot
+
+
+def conditions_226969243620390858682731042391766665817(case) -> bool:
+        def conditions_for_physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:
+            """Get conditions on whether it's possible to conclude a value for PhysicalObject_is_a_robot.output_  of type ."""
+            return True
+        return conditions_for_physical_object_is_a_robot(**case)
+
+
+def conclusion_226969243620390858682731042391766665817(case) -> bool:
+        def physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:
+            """Get possible value(s) for PhysicalObject_is_a_robot.output_  of type ."""
+            return isinstance(self_, Robot)
+        return physical_object_is_a_robot(**case)
+
+

{ripple_down_rules-0.6.43 → ripple_down_rules-0.6.45}/test/test_results/datasets_physical_object_is_a_robot/rdr_metadata/datasets_physical_object_is_a_robot.json

@@ -7,7 +7,7 @@
                 "_type": "ripple_down_rules.rules.SingleClassRule",
                 "conditions": {
                     "_type": "ripple_down_rules.datastructures.callable_expression.CallableExpression",
-                    "user_input": "def _get_value(case):\n    def conditions_for_physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:\n        \"\"\"Get conditions on whether it's possible to conclude a value for PhysicalObject_is_a_robot.output_  of type .\"\"\"\n        return True\n    return conditions_for_physical_object_is_a_robot(**case)\n    ",
+                    "user_input": "def _get_value(case):\n        def conditions_for_physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:\n            \"\"\"Get conditions on whether it's possible to conclude a value for PhysicalObject_is_a_robot.output_  of type .\"\"\"\n            return True\n        return conditions_for_physical_object_is_a_robot(**case)\n    ",
                     "conclusion_type": [
                         "builtins.bool"
                     ],
@@ -22,13 +22,13 @@
                 },
                 "conclusion": {
                     "_type": "ripple_down_rules.datastructures.callable_expression.CallableExpression",
-                    "user_input": "def _get_value(case):\n    def physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:\n        \"\"\"Get possible value(s) for PhysicalObject_is_a_robot.output_  of type .\"\"\"\n        return isinstance(self_, Robot)\n    return physical_object_is_a_robot(**case)\n    ",
+                    "user_input": "def _get_value(case):\n        def physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:\n            \"\"\"Get possible value(s) for PhysicalObject_is_a_robot.output_  of type .\"\"\"\n            return isinstance(self_, Robot)\n        return physical_object_is_a_robot(**case)\n    ",
                     "conclusion_type": [
                         "builtins.bool"
                     ],
                     "scope": {
-                        "Robot": "test.datasets.Robot",
-                        "PhysicalObject": "test.datasets.PhysicalObject"
+                        "PhysicalObject": "test.datasets.PhysicalObject",
+                        "Robot": "test.datasets.Robot"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",

ripple_down_rules-0.6.45/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

@@ -0,0 +1,19 @@
+from ...datasets import PhysicalObject, Robot
+from typing_extensions import Dict, List, Set, Union
+
+
+def conditions_164855806603893754507167918997373216146(case) -> bool:
+        def conditions_for_physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> bool:
+            """Get conditions on whether it's possible to conclude a value for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject."""
+            return robot is not None
+        return conditions_for_physical_object_select_objects_that_are_parts_of_robot(**case)
+
+
+def conclusion_164855806603893754507167918997373216146(case) -> List[PhysicalObject]:
+        def physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> List[PhysicalObject]:
+            """Get possible value(s) for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject."""
+            robot_parts = [obj for obj in objects if obj in robot.parts]
+            return robot_parts
+        return physical_object_select_objects_that_are_parts_of_robot(**case)
+
+

{ripple_down_rules-0.6.43 → ripple_down_rules-0.6.45}/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

@@ -7,14 +7,14 @@
                 "_type": "ripple_down_rules.rules.MultiClassTopRule",
                 "conditions": {
                     "_type": "ripple_down_rules.datastructures.callable_expression.CallableExpression",
-                    "user_input": "def _get_value(case):\n    def conditions_for_physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> bool:\n        \"\"\"Get conditions on whether it's possible to conclude a value for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject.\"\"\"\n        return robot is not None\n    return conditions_for_physical_object_select_objects_that_are_parts_of_robot(**case)\n    ",
+                    "user_input": "def _get_value(case):\n        def conditions_for_physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> bool:\n            \"\"\"Get conditions on whether it's possible to conclude a value for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject.\"\"\"\n            return robot is not None\n        return conditions_for_physical_object_select_objects_that_are_parts_of_robot(**case)\n    ",
                     "conclusion_type": [
                         "builtins.bool"
                     ],
                     "scope": {
+                        "PhysicalObject": "test.datasets.PhysicalObject",
                         "Robot": "test.datasets.Robot",
-                        "List": "typing.List",
-                        "PhysicalObject": "test.datasets.PhysicalObject"
+                        "List": "typing.List"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",
@@ -24,14 +24,14 @@
                 },
                 "conclusion": {
                     "_type": "ripple_down_rules.datastructures.callable_expression.CallableExpression",
-                    "user_input": "def _get_value(case):\n    def physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> List[PhysicalObject]:\n        \"\"\"Get possible value(s) for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject.\"\"\"\n        robot_parts = [obj for obj in objects if obj in robot.parts]\n        return robot_parts\n    return physical_object_select_objects_that_are_parts_of_robot(**case)\n    ",
+                    "user_input": "def _get_value(case):\n        def physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> List[PhysicalObject]:\n            \"\"\"Get possible value(s) for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject.\"\"\"\n            robot_parts = [obj for obj in objects if obj in robot.parts]\n            return robot_parts\n        return physical_object_select_objects_that_are_parts_of_robot(**case)\n    ",
                     "conclusion_type": [
                         "test.datasets.PhysicalObject"
                     ],
                     "scope": {
+                        "PhysicalObject": "test.datasets.PhysicalObject",
                         "Robot": "test.datasets.Robot",
-                        "List": "typing.List",
-                        "PhysicalObject": "test.datasets.PhysicalObject"
+                        "List": "typing.List"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",

ripple_down_rules-0.6.43/src/ripple_down_rules/__init__.py

@@ -1,5 +0,0 @@
-__version__ = "0.6.43"
-
-import logging
-logger = logging.Logger("rdr")
-logger.setLevel(logging.INFO)

ripple_down_rules-0.6.43/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_output__scrdr_defs.py

@@ -1,19 +0,0 @@
-from typing_extensions import Dict, Optional, Union
-from types import NoneType
-from ...datasets import PhysicalObject, Robot
-
-
-def conditions_226969243620390858682731042391766665817(case) -> bool:
-    def conditions_for_physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:
-        """Get conditions on whether it's possible to conclude a value for PhysicalObject_is_a_robot.output_  of type ."""
-        return True
-    return conditions_for_physical_object_is_a_robot(**case)
-
-
-def conclusion_226969243620390858682731042391766665817(case) -> bool:
-    def physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:
-        """Get possible value(s) for PhysicalObject_is_a_robot.output_  of type ."""
-        return isinstance(self_, Robot)
-    return physical_object_is_a_robot(**case)
-
-

ripple_down_rules-0.6.43/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,19 +0,0 @@
-from typing_extensions import Dict, List, Set, Union
-from ...datasets import PhysicalObject, Robot
-
-
-def conditions_164855806603893754507167918997373216146(case) -> bool:
-    def conditions_for_physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> bool:
-        """Get conditions on whether it's possible to conclude a value for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject."""
-        return robot is not None
-    return conditions_for_physical_object_select_objects_that_are_parts_of_robot(**case)
-
-
-def conclusion_164855806603893754507167918997373216146(case) -> List[PhysicalObject]:
-    def physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> List[PhysicalObject]:
-        """Get possible value(s) for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject."""
-        robot_parts = [obj for obj in objects if obj in robot.parts]
-        return robot_parts
-    return physical_object_select_objects_that_are_parts_of_robot(**case)
-
-

{ripple_down_rules-0.6.43 → ripple_down_rules-0.6.45}/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

@@ -1,6 +1,6 @@
+from ripple_down_rules.helpers import get_an_updated_case_copy
 from ripple_down_rules.datastructures.case import Case, create_case
 from typing_extensions import Optional, Set
-from ripple_down_rules.helpers import get_an_updated_case_copy
 from ripple_down_rules.utils import make_set
 from .physical_object_select_objects_that_are_parts_of_robot_output__mcrdr_defs import *