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

ripple_down_rules/__init__.py

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

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

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

@@ -1,11 +1,11 @@
-ripple_down_rules/__init__.py,sha256=NAOJdOIPnZXrnWLryxT1ZsFVSXmALEqXeTLcaySBVa8,99
+ripple_down_rules/__init__.py,sha256=Z5fiv4M_TwRxBMIvhX3FBYkZZinOcnuaS0BLy7iHusI,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=wK6Altc7YNP9JR_mUrKignTkojq2kUy9L9g0g9_c7nM,81626
+ripple_down_rules/rdr.py,sha256=FgM2Fww2NEn0AyRLR8Nw6OBSj9R5ke13l4veqtm0Hww,83293
 ripple_down_rules/rdr_decorators.py,sha256=xoBGsIJMkJYUdsrsEaPZqoAsGuXkuVZAKCoP-xD2Iv8,11668
 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=lMRJoCtrbP6YSMqmgnqB6hY9UyQtn-Db-syUMoLzpUU,80035
+ripple_down_rules/utils.py,sha256=ODmLlSqqSppzsAwsM0udKJVh__ERv4T8fl3WVmrKaVY,80336
 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.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,,
+ripple_down_rules-0.6.45.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.6.45.dist-info/METADATA,sha256=Mn4UYgmCtgMHMUl4tLOV9mJnSrawWHnbaKm_EbUylNM,48294
+ripple_down_rules-0.6.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.6.45.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.6.45.dist-info/RECORD,,