ripple-down-rules 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

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/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/rdr.py

@@ -163,9 +163,9 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         Update the figures of the classifier.
         """
         if isinstance(self, GeneralRDR):
-            for i, (_type, rdr) in enumerate(self.start_rules_dict.items()):
+            for i, (rdr_name, rdr) in enumerate(self.start_rules_dict.items()):
                 if not rdr.fig:
-                    rdr.fig = plt.figure(f"Rule {i}: {_type.__name__}")
+                    rdr.fig = plt.figure(f"Rule {i}: {rdr_name}")
                 draw_tree(rdr.start_rule, rdr.fig)
         else:
             if not self.fig:

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

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

@@ -3,18 +3,18 @@ ripple_down_rules/datasets.py,sha256=AzPtqUXuR1qLQNtRsWLsJ3gX2oIf8nIkFvmsmz7fHlw
 ripple_down_rules/experts.py,sha256=Xz1U1Tdq7jrFlcVuSusaMB241AG9TEs7q101i59Xijs,10683
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/helpers.py,sha256=AhqerAQoCdSovJ7SdQrNtAI_hYagKpLsy2nJQGA0bl0,1062
-ripple_down_rules/prompt.py,sha256=z6KddZOsNiStptgCRNh2OVHHuH6Ooa2f-nsrgJH1qJ8,6311
-ripple_down_rules/rdr.py,sha256=vuRGyqB2wasAzSUhj9HenBp0nC-C1zCGUj3e_th2X7A,43511
+ripple_down_rules/prompt.py,sha256=kXQAiNDCayB6Ijecxx487eOqqWLcfvmp0q7FbyfuQM0,6433
+ripple_down_rules/rdr.py,sha256=NXVYIflUxcDzC5DDrK-l_ZT-sBmUV1ZgkznshSsJZYc,43508
 ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
 ripple_down_rules/rules.py,sha256=aM3Im4ePuFDlkuD2EKRtiVmYgoQ_sxlwcbzrDKqXAfs,14578
-ripple_down_rules/utils.py,sha256=9gPnRWlLye7FettI2QRWJx8oU9z3ckwdO5jopXK8b-8,24290
+ripple_down_rules/utils.py,sha256=HWu5rvAaV2SXIORHR0c2RBdWNc9q4B7DjWIskuyDTA8,26877
 ripple_down_rules/datastructures/__init__.py,sha256=zpmiYm4WkwNHaGdTIfacS7llN5d2xyU6U-saH_TpydI,103
-ripple_down_rules/datastructures/callable_expression.py,sha256=ac2TaMr0hiRX928GMcr3oTQic8KXXO4syLw4KV-Iehs,10515
+ripple_down_rules/datastructures/callable_expression.py,sha256=noukQQh1Loto9s8EJWnaS-7kaPaKuUccyEz5xHp7KtI,10790
 ripple_down_rules/datastructures/case.py,sha256=3Pl07jmYn94wdCVTaRZDmBPgyAsN1TjebvrE6-68MVU,13606
 ripple_down_rules/datastructures/dataclasses.py,sha256=AI-wqNy8y9QPg6lov0P-c5b8JXemuM4X62tIRhW-Gqs,4231
 ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
-ripple_down_rules-0.1.1.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.1.1.dist-info/METADATA,sha256=rzAQLYJ7yFFBy9Nthw1qwhhwbOZtv1aTNnNSVyf9BQE,42518
-ripple_down_rules-0.1.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-ripple_down_rules-0.1.1.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.1.1.dist-info/RECORD,,
+ripple_down_rules-0.1.3.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.1.3.dist-info/METADATA,sha256=k5i5LEQ0cEKeuTQvwRIBNYy3YAVG160mvh8DYsJKxJ0,42518
+ripple_down_rules-0.1.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+ripple_down_rules-0.1.3.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.1.3.dist-info/RECORD,,

{ripple_down_rules-0.1.1.dist-info → ripple_down_rules-0.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any