ripple-down-rules 0.5.71__tar.gz → 0.5.75__tar.gz

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/PKG-INFO

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

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

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -9,7 +9,7 @@ from omegaconf import MISSING
 from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, get_origin, Set, Callable
 
-from ..utils import get_method_name, get_function_import_path_and_representation
+from ..utils import get_method_name, get_function_import_data, get_function_representation
 from .callable_expression import CallableExpression
 from .case import create_case, Case
 from ..utils import copy_case, make_list, make_set, get_origin_and_args_from_type_hint, get_value_type_from_type_hint, \
@@ -274,9 +274,9 @@ class CaseFactoryMetaData:
         factory_method_repr = None
         scenario_repr = None
         if self.factory_method is not None:
-            _, factory_method_repr = get_function_import_path_and_representation(self.factory_method)
+            factory_method_repr = get_function_representation(self.factory_method)
         if self.scenario is not None:
-            _, scenario_repr = get_function_import_path_and_representation(self.scenario)
+            scenario_repr = get_function_representation(self.scenario)
         return (f"CaseFactoryMetaData("
                 f"factory_method={factory_method_repr}, "
                 f"factory_idx={self.factory_idx}, "

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/src/ripple_down_rules/rdr.py

@@ -39,7 +39,7 @@ except ImportError as e:
 from .utils import draw_tree, make_set, copy_case, \
     SubclassJSONSerializer, make_list, get_type_from_string, \
     is_conflicting, get_imports_from_scope, extract_function_source, extract_imports, get_full_class_name, \
-    is_iterable, str_to_snake_case, get_import_path_from_path
+    is_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -401,12 +401,9 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         # remove from imports if exists first
         package_name = get_import_path_from_path(package_name)
         name = f"{package_name}.{self.generated_python_file_name}" if package_name else self.generated_python_file_name
-        try:
-            module = importlib.import_module(name)
-            del sys.modules[name]
-        except ModuleNotFoundError:
-            pass
-        return importlib.import_module(name).classify
+        module = importlib.import_module(name)
+        importlib.reload(module)
+        return module.classify
 
 
 class RDRWithCodeWriter(RippleDownRules, ABC):
@@ -434,7 +431,9 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
                 rule.conditions.user_input = functions_source[f"conditions_{rule.uid}"]
                 rule.conditions.scope = scope
                 if os.path.exists(cases_path):
-                    rule.corner_case_metadata = importlib.import_module(cases_import_path).__dict__.get(f"corner_case_{rule.uid}", None)
+                    module = importlib.import_module(cases_import_path)
+                    importlib.reload(module)
+                    rule.corner_case_metadata = module.__dict__.get(f"corner_case_{rule.uid}", None)
             if rule.conclusion is not None and not isinstance(rule, MultiClassStopRule):
                 rule.conclusion.user_input = functions_source[f"conclusion_{rule.uid}"]
                 rule.conclusion.scope = scope
@@ -471,8 +470,10 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         # clear the files first
         with open(defs_file_name, "w") as f:
             f.write(defs_imports + "\n\n")
+        case_factory_import = get_imports_from_types([CaseFactoryMetaData])
         with open(cases_file_name, "w") as cases_f:
             cases_f.write("# This file contains the corner cases for the rules.\n")
+            cases_f.write('\n'.join(case_factory_import) + "\n\n\n")
         with open(file_name, "w") as f:
             imports += f"from .{self.generated_python_defs_file_name} import *\n"
             f.write(imports + "\n\n")
@@ -482,8 +483,8 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             f.write(f"\n\n{func_def}")
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
-            self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4, defs_file=defs_file_name,
-                                                    cases_file=cases_file_name)
+        self.write_rules_as_source_code_to_file(self.start_rule, file_name, " " * 4, defs_file=defs_file_name,
+                                                cases_file=cases_file_name)
 
     @property
     @abstractmethod
@@ -663,7 +664,7 @@ class SingleClassRDR(RDRWithCodeWriter):
             with open(model_dir + f"/{self.generated_python_file_name}.py", "a") as f:
                 f.write(f"{' ' * 4}else:\n{' ' * 8}return {self.default_conclusion}\n")
 
-    def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file: TextIOWrapper, parent_indent: str = "",
+    def write_rules_as_source_code_to_file(self, rule: SingleClassRule, filename: str, parent_indent: str = "",
                                            defs_file: Optional[str] = None, cases_file: Optional[str] = None):
         """
         Write the rules as source code to a file.
@@ -671,16 +672,18 @@ class SingleClassRDR(RDRWithCodeWriter):
         if rule.conditions:
             rule.write_corner_case_as_source_code(cases_file)
             if_clause = rule.write_condition_as_source_code(parent_indent, defs_file)
-            file.write(if_clause)
+            with open(filename, "a") as file:
+                file.write(if_clause)
             if rule.refinement:
-                self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
+                self.write_rules_as_source_code_to_file(rule.refinement, filename, parent_indent + "    ",
                                                         defs_file=defs_file, cases_file=cases_file)
 
             conclusion_call = rule.write_conclusion_as_source_code(parent_indent, defs_file)
-            file.write(conclusion_call)
+            with open(filename, "a") as file:
+                file.write(conclusion_call)
 
             if rule.alternative:
-                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file,
+                self.write_rules_as_source_code_to_file(rule.alternative, filename, parent_indent, defs_file=defs_file,
                                                         cases_file=cases_file)
 
     @property
@@ -785,26 +788,30 @@ class MultiClassRDR(RDRWithCodeWriter):
         return self.conclusions
 
     def write_rules_as_source_code_to_file(self, rule: Union[MultiClassTopRule, MultiClassStopRule],
-                                           file, parent_indent: str = "", defs_file: Optional[str] = None,
+                                           filename: str, parent_indent: str = "", defs_file: Optional[str] = None,
                                            cases_file: Optional[str] = None):
         if rule == self.start_rule:
-            file.write(f"{parent_indent}conclusions = set()\n")
+            with open(filename, "a") as file:
+                file.write(f"{parent_indent}conclusions = set()\n")
         if rule.conditions:
             rule.write_corner_case_as_source_code(cases_file)
             if_clause = rule.write_condition_as_source_code(parent_indent, defs_file)
-            file.write(if_clause)
+            with open(filename, "a") as file:
+                file.write(if_clause)
             conclusion_indent = parent_indent
             if hasattr(rule, "refinement") and rule.refinement:
-                self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
+                self.write_rules_as_source_code_to_file(rule.refinement, filename, parent_indent + "    ",
                                                         defs_file=defs_file, cases_file=cases_file)
                 conclusion_indent = parent_indent + " " * 4
-                file.write(f"{conclusion_indent}else:\n")
+                with open(filename, "a") as file:
+                    file.write(f"{conclusion_indent}else:\n")
 
             conclusion_call = rule.write_conclusion_as_source_code(conclusion_indent, defs_file)
-            file.write(conclusion_call)
+            with open(filename, "a") as file:
+                file.write(conclusion_call)
 
             if rule.alternative:
-                self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file,
+                self.write_rules_as_source_code_to_file(rule.alternative, filename, parent_indent, defs_file=defs_file,
                                                         cases_file=cases_file)
 
     @property

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/src/ripple_down_rules/rules.py

@@ -8,11 +8,11 @@ from uuid import uuid4
 
 from anytree import NodeMixin
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple, Callable
+from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple
 
 from .datastructures.callable_expression import CallableExpression
 from .datastructures.case import Case
-from .datastructures.dataclasses import CaseFactoryMetaData, CaseConf, CaseQuery
+from .datastructures.dataclasses import CaseFactoryMetaData, CaseQuery
 from .datastructures.enums import RDREdge, Stop
 from .utils import SubclassJSONSerializer, conclusion_to_json, get_full_class_name, get_imports_from_types
 
@@ -117,7 +117,6 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             types_to_import.add(self.corner_case_metadata.scenario)
         if self.corner_case_metadata.case_conf is not None:
             types_to_import.add(self.corner_case_metadata.case_conf)
-        types_to_import.add(CaseFactoryMetaData)
         imports = get_imports_from_types(list(types_to_import))
         with open(cases_file, 'a') as f:
             f.write("\n".join(imports) + "\n\n\n")

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/src/ripple_down_rules/utils.py

@@ -799,7 +799,7 @@ def get_import_path_from_path(path: str) -> Optional[str]:
     return package_name
 
 
-def get_function_import_path_and_representation(func: Callable) -> Tuple[str, str]:
+def get_function_import_data(func: Callable) -> Tuple[str, str]:
     """
     Get the import path of a function.
 
@@ -813,12 +813,24 @@ def get_function_import_path_and_representation(func: Callable) -> Tuple[str, st
     func_import_path = get_import_path_from_path(dirname(func_file_path))
     func_import_path = f"{func_import_path}.{func_file_name}" if func_import_path else func_file_name
     if func_class_name and func_class_name != func_name:
-        import_path = f"from {func_import_path} import {func_class_name}"
-        func_representation = f"{func_class_name}.{func_name}"
+        func_import_name = func_class_name
     else:
-        import_path = f"from {func_import_path} import {func_name}"
-        func_representation = func_name
-    return import_path, func_representation
+        func_import_name = func_name
+    return func_import_path, func_import_name
+
+
+def get_function_representation(func: Callable) -> str:
+    """
+    Get a string representation of a function, including its module and class if applicable.
+
+    :param func: The function to represent.
+    :return: A string representation of the function.
+    """
+    func_name = get_method_name(func)
+    func_class_name = get_method_class_name_if_exists(func)
+    if func_class_name and func_class_name != func_name:
+        return f"{func_class_name}.{func_name}"
+    return func_name
 
 
 def get_imports_from_types(type_objs: List[Type]) -> List[str]:
@@ -836,10 +848,7 @@ def get_imports_from_types(type_objs: List[Type]) -> List[str]:
                 module = tp.__module__
                 name = tp.__qualname__
             elif callable(tp):
-                import_, _ = get_function_import_path_and_representation(tp)
-                if import_ is not None:
-                    other_imports.append(import_)
-                module = None
+                module, name = get_function_import_data(tp)
             elif hasattr(type(tp), "__module__"):
                 module = type(tp).__module__
                 name = type(tp).__qualname__

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.71
+Version: 0.5.75
 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.71 → ripple_down_rules-0.5.75}/test/test_results/datasets_physical_object_is_a_robot/rdr_metadata/datasets_physical_object_is_a_robot.json

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

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/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

@@ -5,7 +5,7 @@ from .physical_object_select_objects_that_are_parts_of_robot_output__mcrdr_defs
 
 
 attribute_name = 'output_'
-conclusion_type = (PhysicalObject, set, list,)
+conclusion_type = (set, PhysicalObject, list,)
 mutually_exclusive = False
 
 

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/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": {
-                        "PhysicalObject": "datasets.PhysicalObject",
+                        "Robot": "datasets.Robot",
                         "Union": "typing.Union",
+                        "List": "typing.List",
                         "Dict": "typing.Dict",
-                        "Robot": "datasets.Robot",
-                        "List": "typing.List"
+                        "PhysicalObject": "datasets.PhysicalObject"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",
@@ -33,11 +33,11 @@
                         "builtins.list"
                     ],
                     "scope": {
-                        "PhysicalObject": "datasets.PhysicalObject",
+                        "Robot": "datasets.Robot",
                         "Union": "typing.Union",
+                        "List": "typing.List",
                         "Dict": "typing.Dict",
-                        "Robot": "datasets.Robot",
-                        "List": "typing.List"
+                        "PhysicalObject": "datasets.PhysicalObject"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/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 Robot
 from datasets import PhysicalObject
 from typing import Dict
+from datasets import Robot
 
 
 def conditions_226969243620390858682731042391766665817(case):

{ripple_down_rules-0.5.71 → ripple_down_rules-0.5.75}/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 datasets import PhysicalObject
-from typing import Dict
+from datasets import Robot
 from typing import List
+from typing import Dict
+from datasets import PhysicalObject
 from typing import Union
-from datasets import Robot
 from typing_extensions import Union