ripple-down-rules 0.1.2__tar.gz → 0.1.3__tar.gz

{ripple_down_rules-0.1.2 → ripple_down_rules-0.1.3}/PKG-INFO

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.2"
+version = "0.1.3"
 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.1.2 → ripple_down_rules-0.1.3}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -65,7 +65,8 @@ class VariableVisitor(ast.NodeVisitor):
 
 def get_used_scope(code_str, scope):
     # Parse the code into an AST
-    tree = ast.parse(code_str, mode='eval')
+    mode = 'exec' if code_str.startswith('def') else 'eval'
+    tree = ast.parse(code_str, mode=mode)
 
     # Walk the AST to collect used variable names
     class NameCollector(ast.NodeVisitor):
@@ -169,6 +170,8 @@ class CallableExpression(SubclassJSONSerializer):
                 case = create_case(case, max_recursion_idx=3)
             scope = {'case': case, **self.scope}
             output = eval(self.code, scope)
+            if output is None:
+                output = scope['_get_value'](case)
             if self.conclusion_type is not None:
                 assert isinstance(output, self.conclusion_type), (f"Expected output type {self.conclusion_type},"
                                                                   f" got {type(output)}")
@@ -219,7 +222,8 @@ def compile_expression_to_code(expression_tree: AST) -> Any:
     :param expression_tree: The parsed expression tree.
     :return: The code that was compiled from the expression tree.
     """
-    return compile(expression_tree, filename="<string>", mode="eval")
+    mode = 'exec' if isinstance(expression_tree, ast.Module) else 'eval'
+    return compile(expression_tree, filename="<string>", mode=mode)
 
 
 def assert_context_contains_needed_information(case: Any, context: Dict[str, Any],
@@ -273,6 +277,7 @@ def parse_string_to_expression(expression_str: str) -> AST:
     :param expression_str: The string which will be parsed.
     :return: The parsed expression.
     """
-    tree = ast.parse(expression_str, mode='eval')
+    mode = 'exec' if expression_str.startswith('def') else 'eval'
+    tree = ast.parse(expression_str, mode=mode)
     logging.debug(f"AST parsed successfully: {ast.dump(tree)}")
     return tree

{ripple_down_rules-0.1.2 → ripple_down_rules-0.1.3}/src/ripple_down_rules/prompt.py

@@ -11,58 +11,64 @@ from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
 from typing_extensions import Any, List, Optional, Tuple, Dict, Union, Type
 
 from .datastructures import Case, PromptFor, CallableExpression, create_case, parse_string_to_expression, CaseQuery
-from .utils import capture_variable_assignment
+from .utils import capture_variable_assignment, extract_dependencies, contains_return_statement
+
+
+class CustomInteractiveShell(InteractiveShellEmbed):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.all_lines = []
+
+    def run_cell(self, raw_cell: str, **kwargs):
+        """
+        Override the run_cell method to capture return statements.
+        """
+        if contains_return_statement(raw_cell):
+            self.all_lines.append(raw_cell)
+            print("Exiting shell on `return` statement.")
+            self.history_manager.store_inputs(line_num=self.execution_count, source=raw_cell)
+            self.ask_exit()
+            return None
+        result = super().run_cell(raw_cell, store_history=True, **kwargs)
+        if not result.error_in_exec:
+            self.all_lines.append(raw_cell)
+        return result
 
 
 class IpythonShell:
     """
     Create an embedded Ipython shell that can be used to prompt the user for input.
     """
-    def __init__(self, variable_to_capture: str, scope: Optional[Dict] = None, header: Optional[str] = None):
+    def __init__(self, prompt_for: PromptFor, scope: Optional[Dict] = None, header: Optional[str] = None):
         """
         Initialize the Ipython shell with the given scope and header.
 
-        :param variable_to_capture: The variable to capture from the user input.
         :param scope: The scope to use for the shell.
         :param header: The header to display when the shell is started.
         """
-        self.variable_to_capture: str = variable_to_capture
+        self.prompt_for: PromptFor = prompt_for
         self.scope: Dict = scope or {}
         self.header: str = header or ">>> Embedded Ipython Shell"
         self.user_input: Optional[str] = None
-        self.shell: InteractiveShellEmbed = self._init_shell()
-        self._register_hooks()
+        self.shell: CustomInteractiveShell = self._init_shell()
+        self.all_code_lines: List[str] = []
 
     def _init_shell(self):
         """
         Initialize the Ipython shell with a custom configuration.
         """
         cfg = Config()
-        shell = InteractiveShellEmbed(config=cfg, user_ns=self.scope, banner1=self.header)
+        shell = CustomInteractiveShell(config=cfg, user_ns=self.scope, banner1=self.header)
         return shell
 
-    def _register_hooks(self):
-        """
-        Register hooks to capture specific events in the Ipython shell.
-        """
-        def capture_variable(exec_info: ExecutionInfo):
-            code = exec_info.raw_cell
-            if self.variable_to_capture not in code:
-                return
-            # use ast to find if the user is assigning a value to the variable "condition"
-            assignment = capture_variable_assignment(code, self.variable_to_capture)
-            if assignment:
-                # if the user is assigning a value to the variable "condition", update the raw_condition
-                self.user_input = assignment
-                print(f"[Captured {self.variable_to_capture}]:\n{self.user_input}")
-
-        self.shell.events.register('pre_run_cell', capture_variable)
-
     def run(self):
         """
         Run the embedded shell.
         """
         self.shell()
+        self.all_code_lines = extract_dependencies(self.shell.all_lines)
+        self.user_input = f"def _get_value(case):\n    "
+        self.user_input += '\n    '.join(self.all_code_lines)
 
 
 def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor,
@@ -99,7 +105,7 @@ def prompt_user_about_case(case_query: CaseQuery, prompt_for: PromptFor) -> Tupl
     """
     prompt_str = f"Give {prompt_for} for {case_query.name}"
     scope = {'case': case_query.case, **case_query.scope}
-    shell = IpythonShell(prompt_for.value, scope=scope, header=prompt_str)
+    shell = IpythonShell(prompt_for, scope=scope, header=prompt_str)
     user_input, expression_tree = prompt_user_input_and_parse_to_expression(shell=shell)
     return user_input, expression_tree
 
@@ -132,12 +138,12 @@ def prompt_user_input_and_parse_to_expression(shell: Optional[IpythonShell] = No
             shell = IpythonShell() if shell is None else shell
             shell.run()
             user_input = shell.user_input
+            print(user_input)
         try:
             return user_input, parse_string_to_expression(user_input)
         except Exception as e:
             msg = f"Error parsing expression: {e}"
             logging.error(msg)
-            print(msg)
             user_input = None
 
 

{ripple_down_rules-0.1.2 → ripple_down_rules-0.1.3}/src/ripple_down_rules/utils.py

@@ -5,10 +5,9 @@ import importlib
 import json
 import logging
 import os
-from abc import abstractmethod
 from collections import UserDict
 from copy import deepcopy
-from dataclasses import dataclass, is_dataclass, fields
+from dataclasses import is_dataclass, fields
 
 import matplotlib
 import networkx as nx
@@ -24,9 +23,82 @@ from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get
 if TYPE_CHECKING:
     from .datastructures import Case
 
+import ast
+
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def contains_return_statement(source: str) -> bool:
+    """
+    :param source: The source code to check.
+    :return: True if the source code contains a return statement, False otherwise.
+    """
+    try:
+        tree = ast.parse(source)
+        for node in tree.body:
+            if isinstance(node, ast.Return):
+                return True
+        return False
+    except SyntaxError:
+        return False
+
+
+def get_names_used(node):
+    return {n.id for n in ast.walk(node) if isinstance(n, ast.Name)}
+
+
+def extract_dependencies(code_lines):
+    full_code = '\n'.join(code_lines)
+    tree = ast.parse(full_code)
+    final_stmt = tree.body[-1]
+
+    if not isinstance(final_stmt, ast.Return):
+        raise ValueError("Last line is not a return statement")
+
+    needed = get_names_used(final_stmt.value)
+    required_lines = []
+    line_map = {id(node): i for i, node in enumerate(tree.body)}
+
+    def handle_stmt(stmt, needed):
+        keep = False
+        if isinstance(stmt, ast.Assign):
+            targets = [t.id for t in stmt.targets if isinstance(t, ast.Name)]
+            if any(t in needed for t in targets):
+                needed.update(get_names_used(stmt.value))
+                keep = True
+        elif isinstance(stmt, ast.AugAssign):
+            if isinstance(stmt.target, ast.Name) and stmt.target.id in needed:
+                needed.update(get_names_used(stmt.value))
+                keep = True
+        elif isinstance(stmt, ast.FunctionDef):
+            if stmt.name in needed:
+                for n in ast.walk(stmt):
+                    if isinstance(n, ast.Name):
+                        needed.add(n.id)
+                keep = True
+        elif isinstance(stmt, (ast.For, ast.While, ast.If)):
+            # Check if any of the body statements interact with needed variables
+            for substmt in stmt.body + getattr(stmt, 'orelse', []):
+                if handle_stmt(substmt, needed):
+                    keep = True
+            # Also check the condition (test or iter)
+            if isinstance(stmt, ast.For):
+                if isinstance(stmt.target, ast.Name) and stmt.target.id in needed:
+                    keep = True
+                needed.update(get_names_used(stmt.iter))
+            elif isinstance(stmt, ast.If) or isinstance(stmt, ast.While):
+                needed.update(get_names_used(stmt.test))
+
+        return keep
+
+    for stmt in reversed(tree.body[:-1]):
+        if handle_stmt(stmt, needed):
+            required_lines.insert(0, code_lines[line_map[id(stmt)]])
+
+    required_lines.append(code_lines[-1])  # Always include return
+    return required_lines
+
+
 def serialize_dataclass(obj: Any) -> Union[Dict, Any]:
     """
     Recursively serialize a dataclass to a dictionary. If the dataclass contains any nested dataclasses, they will be
@@ -61,6 +133,7 @@ def deserialize_dataclass(data: dict) -> Any:
     :param data: The dictionary to deserialize.
     :return: The deserialized dataclass.
     """
+
     def recursive_load(obj):
         if isinstance(obj, dict) and "__dataclass__" in obj:
             module_name, class_name = obj["__dataclass__"].rsplit(".", 1)

{ripple_down_rules-0.1.2 → ripple_down_rules-0.1.3}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.2
+Version: 0.1.3
 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