ripple-down-rules 0.6.44__tar.gz → 0.6.46__tar.gz

{ripple_down_rules-0.6.44 → ripple_down_rules-0.6.46}/PKG-INFO

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

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

ripple_down_rules-0.6.46/src/ripple_down_rules/failures.py

@@ -0,0 +1,4 @@
+
+
+class RDRLoadError(Exception):
+    pass

{ripple_down_rules-0.6.44 → ripple_down_rules-0.6.46}/src/ripple_down_rules/rdr.py

@@ -15,6 +15,7 @@ from types import NoneType, ModuleType
 
 from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
 from . import logger
+from .failures import RDRLoadError
 
 try:
     from matplotlib import pyplot as plt
@@ -45,7 +46,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 +218,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)
@@ -228,6 +229,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         except (FileNotFoundError, ValueError, SyntaxError, ModuleNotFoundError) as e:
             logger.warning(f"Could not load the python file for the model {model_name} from {model_dir}. "
                            f"Make sure the file exists and is valid.")
+            if rdr is None:
+                raise RDRLoadError(f"Could not load the rdr model {model_name} from {model_dir}, error is {e}")
             rdr.save(save_dir=load_dir, model_name=model_name, package_name=package_name)
         rdr.save_dir = load_dir
         rdr.model_name = model_name
@@ -886,22 +889,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.44 → ripple_down_rules-0.6.46}/src/ripple_down_rules/rdr_decorators.py

@@ -213,9 +213,7 @@ class RDRDecorator:
         """
         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, package_name=self.package_name)
+            self.rdr = GeneralRDR.load(self.rdr_models_dir, self.model_name, package_name=self.package_name)
         if self.rdr is None:
             self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name)
 

{ripple_down_rules-0.6.44 → ripple_down_rules-0.6.46}/src/ripple_down_rules/utils.py

@@ -168,20 +168,28 @@ 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 node.level > 0:  # Handle relative imports
+                        package_name = get_import_path_from_path(Path(os.path.join(file_path, *['..'] * node.level)).resolve())
                     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)
+                    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 +790,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:

{ripple_down_rules-0.6.44 → ripple_down_rules-0.6.46}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.44
+Version: 0.6.46
 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.44 → ripple_down_rules-0.6.46}/src/ripple_down_rules.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ results/relational_scrdr_classify.png
 scripts/live_dot_server_client.py
 src/ripple_down_rules/__init__.py
 src/ripple_down_rules/experts.py
+src/ripple_down_rules/failures.py
 src/ripple_down_rules/helpers.py
 src/ripple_down_rules/rdr.py
 src/ripple_down_rules/rdr_decorators.py
@@ -152,7 +153,6 @@ test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robo
 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
 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
 test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_rdr.py
-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
 test/test_user_interface/__init__.py
 test/test_user_interface/test_ipython.py
 test/test_user_interface/test_ipython_copilot.py

{ripple_down_rules-0.6.44 → ripple_down_rules-0.6.46}/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.46/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_output__scrdr_defs.py

@@ -0,0 +1,19 @@
+from ...datasets import PhysicalObject, Robot
+from types import NoneType
+from typing_extensions import Dict, Optional, Union
+
+
+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.44 → ripple_down_rules-0.6.46}/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,7 +22,7 @@
                 },
                 "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"
                     ],

ripple_down_rules-0.6.46/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 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.44/src/ripple_down_rules/__init__.py

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

ripple_down_rules-0.6.44/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.44/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.44/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

@@ -1,59 +0,0 @@
-{
-    "_type": "ripple_down_rules.rdr.GeneralRDR",
-    "start_rules": {
-        "output_": {
-            "_type": "ripple_down_rules.rdr.MultiClassRDR",
-            "start_rule": {
-                "_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    ",
-                    "conclusion_type": [
-                        "builtins.bool"
-                    ],
-                    "scope": {
-                        "Robot": "test.datasets.Robot",
-                        "List": "typing.List",
-                        "PhysicalObject": "test.datasets.PhysicalObject"
-                    },
-                    "conclusion": {
-                        "_type": "builtins.NoneType",
-                        "value": null
-                    },
-                    "mutually_exclusive": true
-                },
-                "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    ",
-                    "conclusion_type": [
-                        "test.datasets.PhysicalObject"
-                    ],
-                    "scope": {
-                        "Robot": "test.datasets.Robot",
-                        "List": "typing.List",
-                        "PhysicalObject": "test.datasets.PhysicalObject"
-                    },
-                    "conclusion": {
-                        "_type": "builtins.NoneType",
-                        "value": null
-                    },
-                    "mutually_exclusive": false
-                },
-                "parent": null,
-                "conclusion_name": "output_",
-                "weight": "",
-                "uid": "164855806603893754507167918997373216146",
-                "refinement": null,
-                "alternative": null
-            },
-            "generated_python_file_name": "physical_object_select_objects_that_are_parts_of_robot_output__mcrdr",
-            "name": "output_",
-            "case_type": "typing.Dict",
-            "case_name": "PhysicalObject_select_objects_that_are_parts_of_robot"
-        }
-    },
-    "generated_python_file_name": "physical_object_select_objects_that_are_parts_of_robot_rdr",
-    "name": "output_",
-    "case_type": "typing.Dict",
-    "case_name": "PhysicalObject_select_objects_that_are_parts_of_robot"
-}

{ripple_down_rules-0.6.44 → ripple_down_rules-0.6.46}/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_rdr.py

@@ -1,6 +1,6 @@
 from typing_extensions import Any, Dict
-from ripple_down_rules.datastructures.case import Case, create_case
 from ripple_down_rules.helpers import general_rdr_classify
+from ripple_down_rules.datastructures.case import Case, create_case
 from . import physical_object_is_a_robot_output__scrdr as output__classifier
 
 name = 'output_'

{ripple_down_rules-0.6.44 → ripple_down_rules-0.6.46}/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,7 +1,7 @@
 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 ripple_down_rules.helpers import get_an_updated_case_copy
 from .physical_object_select_objects_that_are_parts_of_robot_output__mcrdr_defs import *
 
 

{ripple_down_rules-0.6.44 → ripple_down_rules-0.6.46}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_rdr.py

@@ -1,6 +1,6 @@
 from typing_extensions import Any, Dict
-from ripple_down_rules.datastructures.case import Case, create_case
 from ripple_down_rules.helpers import general_rdr_classify
+from ripple_down_rules.datastructures.case import Case, create_case
 from . import physical_object_select_objects_that_are_parts_of_robot_output__mcrdr as output__classifier
 
 name = 'output_'