ripple-down-rules 0.5.71__py3-none-any.whl → 0.5.75__py3-none-any.whl

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/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/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/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/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.dist-info → ripple_down_rules-0.5.75.dist-info}/METADATA

@@ -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.dist-info → ripple_down_rules-0.5.75.dist-info}/RECORD

@@ -1,15 +1,15 @@
-ripple_down_rules/__init__.py,sha256=PBN_Kv8LIfx9OpzrltJZONTiFxTieXefSOjX0uYtV0E,100
+ripple_down_rules/__init__.py,sha256=6Ze00N3Py1dmFEMGBz3jz63qsUVLz8WzFn7qx3lJnfM,100
 ripple_down_rules/experts.py,sha256=bwozulI1rv0uyaMZQqEgapDO-s8wvW0D6Jqxmvu5fik,12610
 ripple_down_rules/helpers.py,sha256=v4oE7C5PfQUVJfSUs1FfLHEwrJXEHJLn4vJhJMvyCR8,4453
-ripple_down_rules/rdr.py,sha256=5VeA6YT16SL-sZK3VYiZ6vqazqZzCj_Uhk7xKYyqwVA,51354
+ripple_down_rules/rdr.py,sha256=Mqh7lDjQu6wZUcJiJ57CZ3P0-hM4WfhFuV4s1jZnRv8,51833
 ripple_down_rules/rdr_decorators.py,sha256=0sk7izDB53lTKSB9fm33vQahmY_05FyCOWljyQOMB0U,9072
-ripple_down_rules/rules.py,sha256=rIFE5OIJpuXrquTPAXXOTuatWBD7CkWqRMnDmItLwUc,20176
+ripple_down_rules/rules.py,sha256=ctf9yREG5l99HPFcYosjppKXTOwplZmzQbm4R1DMVaA,20107
 ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=yeSW2KvnxHTL2FMi-95-K6RmcMdzubJBc-jHeMPLL0g,56961
+ripple_down_rules/utils.py,sha256=iwfpTlsxUqLHWpYqSKwrDnEEa_FYFHYb2LugEVDH_kk,57132
 ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
 ripple_down_rules/datastructures/callable_expression.py,sha256=f3wUPTrLa1INO-1qfgVz87ryrCABronfyq0_JKWoZCs,12800
 ripple_down_rules/datastructures/case.py,sha256=1zSaXUljaH6z3SgMGzYPoDyjotNam791KpYgvxuMh90,15463
-ripple_down_rules/datastructures/dataclasses.py,sha256=vlMmlsFJs3s71fwE8d79x_f8z6ZNcLGC5gjSAqabWxY,11021
+ripple_down_rules/datastructures/dataclasses.py,sha256=qoTFHV8Hi-X8VtfC9VdvH4tif73YjF3dUe8dyHXTYts,10993
 ripple_down_rules/datastructures/enums.py,sha256=ce7tqS0otfSTNAOwsnXlhsvIn4iW_Y_N3TNebF3YoZs,5700
 ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/user_interface/gui.py,sha256=_lgZAUXxxaBUFQJAHjA5TBPp6XEvJ62t-kSN8sPsocE,27379
@@ -17,8 +17,8 @@ ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=Jrf7NxOdlrwGXH0X
 ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
 ripple_down_rules/user_interface/prompt.py,sha256=AkkltdDIaioN43lkRKDPKSjJcmdSSGZDMYz7AL7X9lE,8082
 ripple_down_rules/user_interface/template_file_creator.py,sha256=VLS9Nxg6gPNa-YYliJ_VNsTvLPlZ003EVkJ2t8zuDgE,13563
-ripple_down_rules-0.5.71.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.5.71.dist-info/METADATA,sha256=yfIhc979M1q7zytxPiuINjHj4DHe7g7QSVTnaCgx2sA,48214
-ripple_down_rules-0.5.71.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.5.71.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.5.71.dist-info/RECORD,,
+ripple_down_rules-0.5.75.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.75.dist-info/METADATA,sha256=M1N-k7Zp8qzOsGlF8K4n889agx_bLu_rWO9_c-cEViQ,48214
+ripple_down_rules-0.5.75.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.5.75.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.75.dist-info/RECORD,,