ripple-down-rules 0.6.42__py3-none-any.whl → 0.6.43__py3-none-any.whl

ripple_down_rules/__init__.py

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

ripple_down_rules/rdr.py

@@ -4,10 +4,12 @@ import ast
 import importlib
 import json
 import os
+import sys
 from abc import ABC, abstractmethod
 from copy import copy
 from dataclasses import is_dataclass
 from io import TextIOWrapper
+from os.path import dirname
 from pathlib import Path
 from types import NoneType, ModuleType
 
@@ -42,7 +44,8 @@ except ImportError as e:
 from .utils import draw_tree, make_set, SubclassJSONSerializer, make_list, get_type_from_string, \
     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_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
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -524,7 +527,10 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param model_path: The path to the model directory.
         :return: The name of the model.
         """
-        return Path(model_path).name
+        file_name = get_file_that_ends_with(model_path, f"_{cls.get_acronym().lower()}.py")
+        if file_name is None:
+            raise FileNotFoundError(f"Could not find the python file for the model in the given path: {model_path}.")
+        return file_name.replace('.py', '')
 
     @property
     def generated_python_file_name(self) -> str:
@@ -871,54 +877,27 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
                                  if not isinstance(rule, MultiClassStopRule)]
         all_func_names = condition_func_names + conclusion_func_names
 
-        if python_file_path is None:
-            main_file_name = get_file_that_ends_with(model_dir, f"_{self.get_acronym().lower()}.py")
-            if not main_file_name:
-                raise FileNotFoundError(f"Could not find the main python file for the model {self.model_name} in {model_dir}.")
-            main_file_path = os.path.join(model_dir, main_file_name)
-        else:
-            main_file_path = python_file_path
-        if not os.path.exists(main_file_path):
-            raise ModuleNotFoundError(main_file_path)
-        self.generated_python_file_name = Path(main_file_path).name.replace(".py", "")
-
-        defs_file_path = main_file_path.replace(".py", "_defs.py")
-        defs_file_name = Path(defs_file_path).name.replace(".py", "")
+        main_module, defs_module, cases_module = self.get_and_import_model_python_modules(
+                                                        model_dir,
+                                                        python_file_path=python_file_path,
+                                                        parent_package_name=package_name)
+        self.generated_python_file_name = Path(main_module.__file__).name.replace(".py", "")
 
-        cases_path = main_file_path.replace(".py", "_cases.py")
-        cases_file_name = Path(cases_path).name.replace(".py", "")
-        model_import_path = get_import_path_from_path(model_dir)
-        cases_import_path = f"{model_import_path}.{cases_file_name}" if model_import_path \
-            else cases_file_name
-        if os.path.exists(cases_path):
-            cases_module = importlib.import_module(cases_import_path, package=package_name)
-            importlib.reload(cases_module)
-        else:
-            cases_module = None
-
-        defs_import_path = f"{model_import_path}.{defs_file_name}" if model_import_path \
-            else defs_file_name
-        defs_module = importlib.import_module(defs_import_path, package=package_name)
-        importlib.reload(defs_module)
+        self.update_rdr_metadata_from_python(main_module)
 
-        main_file_name = Path(main_file_path).name.replace(".py", "")
-        main_import_path = f"{model_import_path}.{main_file_name}" if model_import_path \
-            else main_file_name
-        main_module = importlib.import_module(main_import_path, package=package_name)
-        importlib.reload(main_module)
+        functions_source = extract_function_source(defs_module.__file__,
+                                                   all_func_names, include_signature=False)
+        scope = extract_imports(defs_module.__file__, package_name=package_name)
 
-        self.start_rule.conclusion_name = main_module.attribute_name
-        self.update_rdr_metadata_from_python(main_module)
-        functions_source = extract_function_source(defs_file_path, all_func_names, include_signature=False)
-        scope = extract_imports(defs_file_path, package_name=package_name)
         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]
                 rule.conditions = CallableExpression(user_input, (bool,), scope=scope)
-                if os.path.exists(cases_path):
+                if cases_module:
                     rule.corner_case_metadata = cases_module.__dict__.get(rule.generated_corner_case_object_name, None)
             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]
                 conclusion_func = defs_module.__dict__.get(rule.generated_conclusion_function_name)
@@ -926,6 +905,34 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
                 rule.conclusion = CallableExpression(user_input, conclusion_type, scope=scope,
                                                      mutually_exclusive=self.mutually_exclusive)
 
+    @classmethod
+    def get_and_import_model_python_modules(cls, model_dir: str,
+                                            python_file_path: Optional[str] = None,
+                                            parent_package_name: Optional[str] = None)\
+            -> Tuple[ModuleType, ModuleType, ModuleType]:
+        """
+        Get and import the python modules that contain the RDR classifier function, definitions, and corner cases.
+
+        :param model_dir: The path to the directory where the generated python files are located.
+        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
+        :return: A tuple containing the main module, defs module, and cases module.
+        """
+        if python_file_path is None:
+            main_file_path = cls.get_generated_python_file_path(model_dir)
+        else:
+            main_file_path = python_file_path
+        if not os.path.exists(main_file_path):
+            raise ModuleNotFoundError(main_file_path)
+
+        defs_file_path = main_file_path.replace(".py", "_defs.py")
+        cases_path = main_file_path.replace(".py", "_cases.py")
+
+        main_module, defs_module, cases_module = get_and_import_python_modules_in_a_package(
+            [main_file_path, defs_file_path, cases_path], parent_package_name=parent_package_name)
+        return main_module, defs_module, cases_module
+
     @abstractmethod
     def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = "",
                                            defs_file: Optional[str] = None, cases_file: Optional[str] = None,
@@ -1532,21 +1539,14 @@ class GeneralRDR(RippleDownRules):
         :return: An instance of the class.
         """
         if python_file_path is None:
-            file_name = get_file_that_ends_with(model_dir, f"_{cls.get_acronym().lower()}.py",)
-            main_python_file_path = os.path.join(model_dir, file_name)
+            main_python_file_path = cls.get_generated_python_file_path(model_dir)
         else:
             main_python_file_path = python_file_path
-        main_python_file_name = Path(main_python_file_path).name.replace('.py', '')
-        main_module_import_path = get_import_path_from_path(model_dir)
-        main_module_import_path = f"{main_module_import_path}.{main_python_file_name}" \
-            if main_module_import_path else main_python_file_name
-        main_module = importlib.import_module(main_module_import_path)
-        importlib.reload(main_module)
+        main_module = get_and_import_python_module(main_python_file_path, parent_package_name=parent_package_name)
         classifiers_dict = main_module.classifiers_dict
         start_rules_dict = {}
         for rdr_name, rdr_module in classifiers_dict.items():
-            rdr_module_name = rdr_module.__name__
-            rdr_acronym = rdr_module_name.split('_')[-1]
+            rdr_acronym = rdr_module.__name__.split('_')[-1]
             rdr_type = cls.get_rdr_type_from_acronym(rdr_acronym)
             rdr_model_path = main_python_file_path.replace('_rdr.py', f'_{rdr_name}_{rdr_acronym}.py')
             rdr = rdr_type.from_python(model_dir, python_file_path=rdr_model_path, parent_package_name=parent_package_name)

ripple_down_rules/rules.py

@@ -286,16 +286,10 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         pass
 
     def _to_json(self) -> Dict[str, Any]:
-        # try:
-        #     corner_case = SubclassJSONSerializer.to_json_static(self.corner_case) if self.corner_case else None
-        # except Exception as e:
-        #     logging.debug("Failed to serialize corner case to json, setting it to None. Error: %s", e)
-        #     corner_case = None
         json_serialization = {"_type": get_full_class_name(type(self)),
                               "conditions": self.conditions.to_json(),
                               "conclusion": conclusion_to_json(self.conclusion),
                               "parent": self.parent.json_serialization if self.parent else None,
-                              # "corner_case": corner_case,
                               "conclusion_name": self.conclusion_name,
                               "weight": self.weight,
                               "uid": self.uid}
@@ -303,15 +297,9 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Rule:
-        # try:
-        #     corner_case = Case.from_json(data["corner_case"])
-        # except Exception as e:
-        #     logging.debug("Failed to load corner case from json, setting it to None.")
-        #     corner_case = None
         loaded_rule = cls(conditions=CallableExpression.from_json(data["conditions"]),
                           conclusion=CallableExpression.from_json(data["conclusion"]),
                           parent=cls.from_json(data["parent"]),
-                          # corner_case=corner_case,
                           conclusion_name=data["conclusion_name"],
                           weight=data["weight"],
                           uid=data["uid"])

ripple_down_rules/utils.py

@@ -20,7 +20,7 @@ from pathlib import Path
 from subprocess import check_call
 from tempfile import NamedTemporaryFile
 from textwrap import dedent
-from types import NoneType
+from types import NoneType, ModuleType
 import inspect
 
 import six
@@ -60,6 +60,49 @@ if TYPE_CHECKING:
 import ast
 
 
+def get_and_import_python_modules_in_a_package(file_paths: List[str],
+                                               parent_package_name: Optional[str] = None) -> List[Optional[ModuleType]]:
+    """
+    :param file_paths: The paths to the python files to import.
+    :param parent_package_name: The name of the parent package to use for relative imports.
+    :return: The imported modules.
+    """
+    package_path = dirname(file_paths[0])
+    package_import_path = get_import_path_from_path(package_path)
+    file_names = [Path(file_path).name.replace(".py", "") for file_path in file_paths]
+    module_import_paths = [
+        f"{package_import_path}.{file_name}" if package_import_path else file_name
+        for file_name in file_names
+    ]
+    modules = [
+        importlib.import_module(module_import_path, package=parent_package_name)
+        if os.path.exists(file_paths[i]) else None
+        for i, module_import_path in enumerate(module_import_paths)
+    ]
+    for module in modules:
+        if module is not None:
+            importlib.reload(module)
+    return modules
+
+
+def get_and_import_python_module(python_file_path: str, package_import_path: Optional[str] = None,
+                                 parent_package_name: Optional[str] = None) -> ModuleType:
+    """
+    :param python_file_path: The path to the python file to import.
+    :param package_import_path: The import path of the package that contains the python file.
+    :param parent_package_name: The name of the parent package to use for relative imports.
+    :return: The imported module.
+    """
+    if package_import_path is None:
+        package_path = dirname(python_file_path)
+        package_import_path = get_import_path_from_path(package_path)
+    file_name = Path(python_file_path).name.replace(".py", "")
+    module_import_path = f"{package_import_path}.{file_name}" if package_import_path else file_name
+    module = importlib.import_module(module_import_path, package=parent_package_name)
+    importlib.reload(module)
+    return module
+
+
 def str_to_snake_case(snake_str: str) -> str:
     """
     Convert a string to snake case.

{ripple_down_rules-0.6.42.dist-info → ripple_down_rules-0.6.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.42
+Version: 0.6.43
 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.42.dist-info → ripple_down_rules-0.6.43.dist-info}/RECORD

@@ -1,11 +1,11 @@
-ripple_down_rules/__init__.py,sha256=Cz1RyE7DY-e05V8keWdWjsykmUF-cCRomJdyuWL81l0,99
+ripple_down_rules/__init__.py,sha256=NAOJdOIPnZXrnWLryxT1ZsFVSXmALEqXeTLcaySBVa8,99
 ripple_down_rules/experts.py,sha256=KXwWCmDrCffu9HW3yNewqWc1e5rnPI5Rnc981w_5M7U,17896
 ripple_down_rules/helpers.py,sha256=X1psHOqrb4_xYN4ssQNB8S9aRKKsqgihAyWJurN0dqk,5499
-ripple_down_rules/rdr.py,sha256=8qiuaoJ56j-F0b3Ob0sTMlizyYS1YCkWu0bPr5_0TZo,81490
+ripple_down_rules/rdr.py,sha256=wK6Altc7YNP9JR_mUrKignTkojq2kUy9L9g0g9_c7nM,81626
 ripple_down_rules/rdr_decorators.py,sha256=xoBGsIJMkJYUdsrsEaPZqoAsGuXkuVZAKCoP-xD2Iv8,11668
-ripple_down_rules/rules.py,sha256=32apFTxtWXKRQ2MJDnqc1URjRJDnNBe_t5A_gGfKNd0,29349
+ripple_down_rules/rules.py,sha256=L4Ws-x3g5ljE0GrDt4LAib2qtR1C1_Ra4cRcIB-IQDI,28702
 ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=SuZKBnGZvfDqlry7PY_N8AzLBOhEeuev57AVS-fJy78,77992
+ripple_down_rules/utils.py,sha256=lMRJoCtrbP6YSMqmgnqB6hY9UyQtn-Db-syUMoLzpUU,80035
 ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
 ripple_down_rules/datastructures/callable_expression.py,sha256=rzMrpD5oztaCRlt3hQ2B_xZ09cSuJNkYOCePndfQJRA,13684
 ripple_down_rules/datastructures/case.py,sha256=dfLnrjsHIVF2bgbz-4ID7OdQvw68V71btCeTK372P-g,15667
@@ -17,8 +17,8 @@ ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=RLdPqPxx-a0Sh74U
 ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
 ripple_down_rules/user_interface/prompt.py,sha256=WPbw_8_-8SpF2ISyRZRuFwPKBEuGC4HaX3lbCPFHhh8,10314
 ripple_down_rules/user_interface/template_file_creator.py,sha256=uSbosZS15MOR3Nv7M3MrFuoiKXyP4cBId-EK3I6stHM,13660
-ripple_down_rules-0.6.42.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.6.42.dist-info/METADATA,sha256=0Cl2r-t_u-UDFbanHIbLnUnJ5vwTghzmZraqDlwxTAA,48294
-ripple_down_rules-0.6.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.6.42.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.6.42.dist-info/RECORD,,
+ripple_down_rules-0.6.43.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.6.43.dist-info/METADATA,sha256=H9Y0gibG6FcFb2LLUiZVwiGWFdKDlXJVY4GYkvZoBeA,48294
+ripple_down_rules-0.6.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.6.43.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.6.43.dist-info/RECORD,,