ripple-down-rules 0.4.7__tar.gz → 0.4.8__tar.gz

{ripple_down_rules-0.4.7 → ripple_down_rules-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.4.7
+Version: 0.4.8
 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.4.7 → ripple_down_rules-0.4.8}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.4.7"
+version = "0.4.8"
 description = "Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning."
 readme = "README.md"
 authors = [{ name = "Abdelrhman Bassiouny", email = "abassiou@uni-bremen.de" }]

{ripple_down_rules-0.4.7 → ripple_down_rules-0.4.8}/src/ripple_down_rules/rules.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
+import logging
 import re
 from abc import ABC, abstractmethod
 from uuid import uuid4
 
 from anytree import NodeMixin
-from rospy import logwarn, logdebug
 from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple
 
@@ -164,7 +164,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         try:
             corner_case = Case.from_json(data["corner_case"])
         except Exception as e:
-            logdebug("Failed to load corner case from json, setting it to None.")
+            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"]),

{ripple_down_rules-0.4.7 → ripple_down_rules-0.4.8}/src/ripple_down_rules/user_interface/gui.py

@@ -475,7 +475,10 @@ class RDRCaseViewer(QMainWindow):
     def _load(self):
         if not self.template_file_creator:
             return
-        self.code_lines = self.template_file_creator.load()
+        self.code_lines, updates = self.template_file_creator.load(self.template_file_creator.temp_file_path,
+                                                                    self.template_file_creator.func_name,
+                                                                    self.template_file_creator.print_func)
+        self.ipython_console.kernel.shell.user_ns.update(updates)
         if self.code_lines is not None:
             self.user_input = encapsulate_code_lines_into_a_function(
                 self.code_lines, self.template_file_creator.func_name,

{ripple_down_rules-0.4.7 → ripple_down_rules-0.4.8}/src/ripple_down_rules/user_interface/ipython_custom_shell.py

@@ -30,7 +30,10 @@ class MyMagics(Magics):
 
     @line_magic
     def load(self, line):
-        self.all_code_lines = self.rule_editor.load()
+        self.all_code_lines, updates = self.rule_editor.load(self.rule_editor.temp_file_path,
+                                                             self.rule_editor.func_name,
+                                                             self.rule_editor.print_func)
+        self.shell.user_ns.update(updates)
 
     @line_magic
     def help(self, line):

{ripple_down_rules-0.4.7 → ripple_down_rules-0.4.8}/src/ripple_down_rules/user_interface/template_file_creator.py

@@ -9,13 +9,13 @@ from textwrap import indent, dedent
 
 from colorama import Fore, Style
 from ipykernel.inprocess.ipkernel import InProcessInteractiveShell
-from typing_extensions import Optional, Type, List, Callable
+from typing_extensions import Optional, Type, List, Callable, Tuple, Dict
 
 from ..datastructures.case import Case
 from ..datastructures.dataclasses import CaseQuery
 from ..datastructures.enums import Editor, PromptFor
 from ..utils import str_to_snake_case, get_imports_from_scope, make_list, typing_hint_to_str, \
-    get_imports_from_types, extract_function_source
+    get_imports_from_types, extract_function_source, extract_imports
 
 
 def detect_available_editor() -> Optional[Editor]:
@@ -49,6 +49,9 @@ def start_code_server(workspace):
                             stderr=subprocess.PIPE, text=True)
 
 
+FunctionData = Tuple[Optional[List[str]], Optional[Dict[str, Callable]]]
+
+
 class TemplateFileCreator:
     """
     A class to create a rule template file for a given case and prompt for the user to edit it.
@@ -71,8 +74,8 @@ class TemplateFileCreator:
     """
 
     def __init__(self, shell: InProcessInteractiveShell, case_query: CaseQuery, prompt_for: PromptFor,
-                 code_to_modify: Optional[str] = None, print_func: Optional[Callable[[str], None]] = None):
-        self.print_func = print_func if print_func else print
+                 code_to_modify: Optional[str] = None, print_func: Callable[[str], None] = print):
+        self.print_func = print_func
         self.shell = shell
         self.code_to_modify = code_to_modify
         self.prompt_for = prompt_for
@@ -228,15 +231,27 @@ class TemplateFileCreator:
         imports = set(imports)
         return '\n'.join(imports)
 
+    @staticmethod
+    def get_core_attribute_types(case_query: CaseQuery) -> List[Type]:
+        """
+        Get the core attribute types of the case query.
+
+        :return: A list of core attribute types.
+        """
+        attr_types = [t for t in case_query.core_attribute_type if t.__module__ != "builtins" and t is not None
+                      and t is not type(None)]
+        return attr_types
+
     def get_func_doc(self) -> Optional[str]:
         """
         :return: A string containing the function docstring.
         """
+        type_data = f" of type {' or '.join(map(lambda c: c.__name__, self.get_core_attribute_types(self.case_query)))}"
         if self.prompt_for == PromptFor.Conditions:
             return (f"Get conditions on whether it's possible to conclude a value"
-                    f" for {self.case_query.name}")
+                    f" for {self.case_query.name} {type_data}.")
         else:
-            return f"Get possible value(s) for {self.case_query.name}"
+            return f"Get possible value(s) for {self.case_query.name} {type_data}."
 
     @staticmethod
     def get_func_name(prompt_for, case_query) -> Optional[str]:
@@ -248,9 +263,8 @@ class TemplateFileCreator:
             # convert any CamelCase word into snake_case by adding _ before each capital letter
             case_name = case_name.replace(f"_{case_query.attribute_name}", "")
         func_name += case_name
-        attr_types = [t for t in case_query.core_attribute_type if t.__module__ != "builtins" and t is not None
-                      and t is not type(None)]
-        func_name += f"_of_type_{'_or_'.join(map(lambda c: c.__name__, attr_types))}"
+        func_name += f"_of_type_{'_or_'.join(map(lambda c: c.__name__,
+                                                 TemplateFileCreator.get_core_attribute_types(case_query)))}"
         return str_to_snake_case(func_name)
 
     @cached_property
@@ -263,33 +277,43 @@ class TemplateFileCreator:
         case = self.case_query.scope['case']
         return case._obj_type if isinstance(case, Case) else type(case)
 
-    def load(self) -> Optional[List[str]]:
-        if not self.temp_file_path:
-            self.print_func(f"{Fore.RED}ERROR:: No file to load. Run %edit first.{Style.RESET_ALL}")
-            return None
+    @staticmethod
+    def load(file_path: str, func_name: str, print_func: Callable = print) -> FunctionData:
+        """
+        Load the function from the given file path.
+
+        :param file_path: The path to the file to load.
+        :param func_name: The name of the function to load.
+        :param print_func: The function to use for printing messages.
+        :return: A tuple containing the function source code and the function object as a dictionary
+        with the function name as the key and the function object as the value.
+        """
+        if not file_path:
+            print_func(f"{Fore.RED}ERROR:: No file to load. Run %edit first.{Style.RESET_ALL}")
+            return None, None
 
-        with open(self.temp_file_path, 'r') as f:
+        with open(file_path, 'r') as f:
             source = f.read()
 
         tree = ast.parse(source)
         updates = {}
         for node in tree.body:
-            if isinstance(node, ast.FunctionDef) and node.name == self.func_name:
+            if isinstance(node, ast.FunctionDef) and node.name == func_name:
                 exec_globals = {}
-                exec(source, self.case_query.scope, exec_globals)
-                user_function = exec_globals[self.func_name]
-                updates[self.func_name] = user_function
-                self.print_func(f"{Fore.BLUE}Loaded `{self.func_name}` function into user namespace.{Style.RESET_ALL}")
+                scope = extract_imports(tree=tree)
+                exec(source, scope, exec_globals)
+                user_function = exec_globals[func_name]
+                updates[func_name] = user_function
+                print_func(f"{Fore.BLUE}Loaded `{func_name}` function into user namespace.{Style.RESET_ALL}")
                 break
         if updates:
-            self.shell.user_ns.update(updates)
-            self.all_code_lines = extract_function_source(self.temp_file_path,
-                                                          [self.func_name],
-                                                          join_lines=False)[self.func_name]
-            return self.all_code_lines
+            all_code_lines = extract_function_source(file_path,
+                                                          [func_name],
+                                                          join_lines=False)[func_name]
+            return all_code_lines, updates
         else:
-            self.print_func(f"{Fore.RED}ERROR:: Function `{self.func_name}` not found.{Style.RESET_ALL}")
-            return None
+            print_func(f"{Fore.RED}ERROR:: Function `{func_name}` not found.{Style.RESET_ALL}")
+            return None, None
 
     def __del__(self):
         if hasattr(self, 'process') and self.process is not None and self.process.poll() is None:

{ripple_down_rules-0.4.7 → ripple_down_rules-0.4.8}/src/ripple_down_rules/utils.py

@@ -23,7 +23,6 @@ import requests
 from anytree import Node, RenderTree
 from anytree.exporter import DotExporter
 from matplotlib import pyplot as plt
-from rospy import logwarn
 from sqlalchemy import MetaData, inspect
 from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQLTable, Session
 from tabulate import tabulate
@@ -107,9 +106,12 @@ def get_imports_from_scope(scope: Dict[str, Any]) -> List[str]:
     return imports
 
 
-def extract_imports(file_path):
-    with open(file_path, "r") as f:
-        tree = ast.parse(f.read(), filename=file_path)
+def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = None) -> Dict[str, Any]:
+    if tree is None:
+        if file_path is None:
+            raise ValueError("Either file_path or tree must be provided")
+        with open(file_path, "r") as f:
+            tree = ast.parse(f.read(), filename=file_path)
 
     scope = {}
 
@@ -131,7 +133,7 @@ def extract_imports(file_path):
                     module = importlib.import_module(module_name)
                     scope[asname] = getattr(module, name)
                 except (ImportError, AttributeError) as e:
-                    logwarn(f"Could not import {module_name}: {e} while extracting imports from {file_path}")
+                    logging.warning(f"Could not import {module_name}: {e} while extracting imports from {file_path}")
 
     return scope
 

{ripple_down_rules-0.4.7 → ripple_down_rules-0.4.8}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.4.7
+Version: 0.4.8
 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.4.8/test/test_template_file_creator.py

@@ -0,0 +1,57 @@
+import os
+from textwrap import dedent
+
+from ripple_down_rules.datastructures.dataclasses import CaseQuery
+from ripple_down_rules.datastructures.enums import PromptFor
+from ripple_down_rules.user_interface.template_file_creator import TemplateFileCreator
+from test_rdr_world import World, Handle, Container
+
+
+
+def test_func_name_with_one_type():
+    # Test the function name
+    world = World()
+    case_query: CaseQuery = CaseQuery(world, "views", (Handle,), False)
+
+    func_name = TemplateFileCreator.get_func_name(PromptFor.Conclusion, case_query)
+    assert func_name == "world_views_of_type_handle"
+
+    func_name = TemplateFileCreator.get_func_name(PromptFor.Conditions, case_query)
+    assert func_name == "conditions_for_world_views_of_type_handle"
+
+def test_func_name_with_two_type():
+    # Test the function name
+    world = World()
+    case_query: CaseQuery = CaseQuery(world, "views", (Handle, Container), False)
+
+    func_name = TemplateFileCreator.get_func_name(PromptFor.Conclusion, case_query)
+    assert func_name == "world_views_of_type_handle_or_container"
+
+    func_name = TemplateFileCreator.get_func_name(PromptFor.Conditions, case_query)
+    assert func_name == "conditions_for_world_views_of_type_handle_or_container"
+
+def test_func_name_with_not_needed_types():
+    # Test the function name
+    world = World()
+    case_query: CaseQuery = CaseQuery(world, "views", (Handle, list, bool, type(None)), False)
+
+    func_name = TemplateFileCreator.get_func_name(PromptFor.Conclusion, case_query)
+    assert func_name == "world_views_of_type_handle"
+
+    func_name = TemplateFileCreator.get_func_name(PromptFor.Conditions, case_query)
+    assert func_name == "conditions_for_world_views_of_type_handle"
+
+def test_load():
+    # Test the load function
+    world = World()
+    imports = "from test_rdr_world import World\n\n\n"
+    func_code = "def test_func(case):\n    return case"
+    source_code = f"{imports}{func_code}\n"
+    source_code = dedent(source_code)
+    with open("test.py", "w") as f:
+        f.write(source_code)
+    code_lines, updates = TemplateFileCreator.load("test.py", "test_func")
+    assert code_lines == func_code.splitlines()
+    assert list(updates.keys()) == ["test_func"]
+    assert updates["test_func"](world) == world
+    os.remove("test.py")

ripple_down_rules-0.4.7/test/test_template_file_creator.py

@@ -1,42 +0,0 @@
-from unittest import TestCase
-
-from ripple_down_rules.datastructures.dataclasses import CaseQuery
-from ripple_down_rules.datastructures.enums import PromptFor
-from ripple_down_rules.user_interface.template_file_creator import TemplateFileCreator
-from test_rdr_world import World, Handle, Container
-
-
-class TestTemplateFileCreator(TestCase):
-
-    def test_func_name_with_one_type(self):
-        # Test the function name
-        world = World()
-        case_query: CaseQuery = CaseQuery(world, "views", (Handle,), False)
-
-        func_name = TemplateFileCreator.get_func_name(PromptFor.Conclusion, case_query)
-        self.assertEqual(func_name, "world_views_of_type_handle")
-
-        func_name = TemplateFileCreator.get_func_name(PromptFor.Conditions, case_query)
-        self.assertEqual(func_name, "conditions_for_world_views_of_type_handle")
-
-    def test_func_name_with_two_type(self):
-        # Test the function name
-        world = World()
-        case_query: CaseQuery = CaseQuery(world, "views", (Handle, Container), False)
-
-        func_name = TemplateFileCreator.get_func_name(PromptFor.Conclusion, case_query)
-        self.assertEqual(func_name, "world_views_of_type_handle_or_container")
-
-        func_name = TemplateFileCreator.get_func_name(PromptFor.Conditions, case_query)
-        self.assertEqual(func_name, "conditions_for_world_views_of_type_handle_or_container")
-
-    def test_func_name_with_not_needed_types(self):
-        # Test the function name
-        world = World()
-        case_query: CaseQuery = CaseQuery(world, "views", (Handle, list, bool, type(None)), False)
-
-        func_name = TemplateFileCreator.get_func_name(PromptFor.Conclusion, case_query)
-        self.assertEqual(func_name, "world_views_of_type_handle")
-
-        func_name = TemplateFileCreator.get_func_name(PromptFor.Conditions, case_query)
-        self.assertEqual(func_name, "conditions_for_world_views_of_type_handle")