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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.4.4
+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
@@ -677,12 +677,26 @@ License:                     GNU GENERAL PUBLIC LICENSE
         the library.  If this is what you want to do, use the GNU Lesser General
         Public License instead of this License.  But first, please read
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
-Project-URL: Homepage, https://github.com/AbdelrhmanBassiouny/ripple_down_rules
 Keywords: robotics,knowledge,reasoning,representation
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: anytree>=2.8.0
+Requires-Dist: pandas>=2.0.3
+Requires-Dist: networkx>=3.1
+Requires-Dist: ordered_set>=4
+Requires-Dist: pygraphviz>=1.7
+Requires-Dist: ucimlrepo>=0.0.7
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: matplotlib>=3.7.5
+Requires-Dist: sqlalchemy
+Requires-Dist: pyqt6
+Requires-Dist: qtconsole
+Requires-Dist: graphviz
+Requires-Dist: tabulate
+Requires-Dist: ipython
+Requires-Dist: requests
+Requires-Dist: colorama
 Dynamic: license-file
 
 # Ripple Down Rules (RDR)

{ripple_down_rules-0.4.4 → 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.4"
+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" }]
@@ -15,8 +15,21 @@ classifiers = [
     "Programming Language :: Python :: 3",
 ]
 keywords = ["robotics", "knowledge", "reasoning", "representation"]
-dependencies = []
-requires-python = ">=3.10"
-
-[project.urls]
-Homepage = "https://github.com/AbdelrhmanBassiouny/ripple_down_rules"
+dependencies = [
+    "anytree>=2.8.0",
+    "pandas>=2.0.3",
+    "networkx>=3.1",
+    "ordered_set>=4",
+    "pygraphviz>=1.7",
+    "ucimlrepo>=0.0.7",
+    "typing-extensions>=4.12.2",
+    "matplotlib>=3.7.5",
+    "sqlalchemy",
+    "pyqt6",
+    "qtconsole",
+    "graphviz",
+    "tabulate",
+    "ipython",
+    "requests",
+    "colorama",
+]

{ripple_down_rules-0.4.4 → 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.4 → 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.4 → 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.4 → ripple_down_rules-0.4.8}/src/ripple_down_rules/user_interface/prompt.py

@@ -134,14 +134,14 @@ class UserPrompt:
         """
         while True:
             if user_input is None:
-                if QApplication.instance() is None:
+                if self.viewer is None:
                     shell = IPythonShell() if shell is None else shell
                     shell.run()
                     user_input = shell.user_input
                 else:
                     app = QApplication.instance()
                     if app is None:
-                        app = QApplication([])
+                        raise RuntimeError("QApplication instance is None. Please run the application first.")
                     self.viewer.show()
                     app.exec()
                     user_input = self.viewer.user_input

{ripple_down_rules-0.4.4 → 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,15 +74,15 @@ 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
         self.case_query = case_query
         self.output_type = self.get_output_type()
         self.user_edit_line = 0
-        self.func_name: str = self.get_func_name()
+        self.func_name: str = self.get_func_name(self.prompt_for, self.case_query)
         self.func_doc: str = self.get_func_doc()
         self.function_signature: str = self.get_function_signature()
         self.editor: Optional[Editor] = detect_available_editor()
@@ -146,7 +149,7 @@ class TemplateFileCreator:
 
     def get_function_signature(self) -> str:
         if self.func_name is None:
-            self.func_name = self.get_func_name()
+            self.func_name = self.get_func_name(self.prompt_for, self.case_query)
         output_type_hint = self.get_output_type_hint()
         func_args = self.get_func_args()
         return f"def {self.func_name}({func_args}){output_type_hint}:"
@@ -228,25 +231,40 @@ 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}."
 
-    def get_func_name(self) -> Optional[str]:
+    @staticmethod
+    def get_func_name(prompt_for, case_query) -> Optional[str]:
         func_name = ""
-        if self.prompt_for == PromptFor.Conditions:
-            func_name = f"{self.prompt_for.value.lower()}_for_"
-        case_name = self.case_query.name.replace(".", "_")
-        if self.case_query.is_function:
+        if prompt_for == PromptFor.Conditions:
+            func_name = f"{prompt_for.value.lower()}_for_"
+        case_name = case_query.name.replace(".", "_")
+        if case_query.is_function:
             # convert any CamelCase word into snake_case by adding _ before each capital letter
-            case_name = case_name.replace(f"_{self.case_query.attribute_name}", "")
+            case_name = case_name.replace(f"_{case_query.attribute_name}", "")
         func_name += case_name
+        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
@@ -259,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.4 → ripple_down_rules-0.4.8}/src/ripple_down_rules/utils.py

@@ -14,6 +14,7 @@ from collections import UserDict
 from copy import deepcopy, copy
 from dataclasses import is_dataclass, fields
 from enum import Enum
+from textwrap import dedent
 from types import NoneType
 
 import matplotlib
@@ -22,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
@@ -106,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 = {}
 
@@ -130,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
 
@@ -168,7 +171,7 @@ def extract_function_source(file_path: str,
             if not include_signature:
                 func_lines = func_lines[1:]
             line_numbers.append((node.lineno, node.end_lineno))
-            functions_source[node.name] = "\n".join(func_lines) if join_lines else func_lines
+            functions_source[node.name] = dedent("\n".join(func_lines)) if join_lines else func_lines
             if len(functions_source) == len(function_names):
                 break
     if len(functions_source) != len(function_names):

{ripple_down_rules-0.4.4 → 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.4
+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
@@ -677,12 +677,26 @@ License:                     GNU GENERAL PUBLIC LICENSE
         the library.  If this is what you want to do, use the GNU Lesser General
         Public License instead of this License.  But first, please read
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
-Project-URL: Homepage, https://github.com/AbdelrhmanBassiouny/ripple_down_rules
 Keywords: robotics,knowledge,reasoning,representation
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: anytree>=2.8.0
+Requires-Dist: pandas>=2.0.3
+Requires-Dist: networkx>=3.1
+Requires-Dist: ordered_set>=4
+Requires-Dist: pygraphviz>=1.7
+Requires-Dist: ucimlrepo>=0.0.7
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: matplotlib>=3.7.5
+Requires-Dist: sqlalchemy
+Requires-Dist: pyqt6
+Requires-Dist: qtconsole
+Requires-Dist: graphviz
+Requires-Dist: tabulate
+Requires-Dist: ipython
+Requires-Dist: requests
+Requires-Dist: colorama
 Dynamic: license-file
 
 # Ripple Down Rules (RDR)

{ripple_down_rules-0.4.4 → ripple_down_rules-0.4.8}/src/ripple_down_rules.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/ripple_down_rules/utils.py
 src/ripple_down_rules.egg-info/PKG-INFO
 src/ripple_down_rules.egg-info/SOURCES.txt
 src/ripple_down_rules.egg-info/dependency_links.txt
+src/ripple_down_rules.egg-info/requires.txt
 src/ripple_down_rules.egg-info/top_level.txt
 src/ripple_down_rules/datastructures/__init__.py
 src/ripple_down_rules/datastructures/callable_expression.py
@@ -35,4 +36,5 @@ test/test_rdr_world.py
 test/test_relational_rdr.py
 test/test_relational_rdr_alchemy.py
 test/test_sql_model.py
+test/test_template_file_creator.py
 test/test_utils.py

ripple_down_rules-0.4.8/src/ripple_down_rules.egg-info/requires.txt

@@ -0,0 +1,16 @@
+anytree>=2.8.0
+pandas>=2.0.3
+networkx>=3.1
+ordered_set>=4
+pygraphviz>=1.7
+ucimlrepo>=0.0.7
+typing-extensions>=4.12.2
+matplotlib>=3.7.5
+sqlalchemy
+pyqt6
+qtconsole
+graphviz
+tabulate
+ipython
+requests
+colorama

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")