ripple-down-rules 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

ripple_down_rules/user_interface/ipython_custom_shell.py

@@ -0,0 +1,146 @@
+import logging
+from typing import Optional, List
+
+from IPython.core.magic import magics_class, Magics, line_magic
+from IPython.terminal.embed import InteractiveShellEmbed
+from colorama import Fore, Style
+from traitlets.config import Config
+
+from ..datastructures.dataclasses import CaseQuery
+from ..datastructures.enums import PromptFor
+from .gui import encapsulate_code_lines_into_a_function
+from .template_file_creator import TemplateFileCreator
+from ..utils import contains_return_statement, extract_dependencies
+
+
+@magics_class
+class MyMagics(Magics):
+
+    def __init__(self, shell,
+                 code_to_modify: Optional[str] = None,
+                 prompt_for: Optional[PromptFor] = None,
+                 case_query: Optional[CaseQuery] = None):
+        super().__init__(shell)
+        self.rule_editor = TemplateFileCreator(shell, case_query, prompt_for=prompt_for, code_to_modify=code_to_modify)
+        self.all_code_lines: Optional[List[str]] = None
+
+    @line_magic
+    def edit(self, line):
+        self.rule_editor.edit()
+
+    @line_magic
+    def load(self, line):
+        self.all_code_lines = self.rule_editor.load()
+
+    @line_magic
+    def help(self, line):
+        """
+        Display help information for the Ipython shell.
+        """
+        help_text = f"""
+Directly write python code in the shell, and then `{Fore.GREEN}return {Fore.RESET}output`. Or use 
+the magic commands to write the code in a temporary file and edit it in PyCharm:
+{Fore.MAGENTA}Usage: %edit{Style.RESET_ALL}
+Opens a temporary file in PyCharm for editing a function (conclusion or conditions for case)
+ that will be executed on the case object.
+{Fore.MAGENTA}Usage: %load{Style.RESET_ALL}
+Loads the function defined in the temporary file into the user namespace, that can then be used inside the
+ Ipython shell. You can then do `{Fore.GREEN}return {Fore.RESET}function_name(case)`.
+        """
+        print(help_text)
+
+
+class CustomInteractiveShell(InteractiveShellEmbed):
+    def __init__(self, code_to_modify: Optional[str] = None,
+                 prompt_for: Optional[PromptFor] = None,
+                 case_query: Optional[CaseQuery] = None,
+                 **kwargs):
+        kwargs.update({'user_ns': case_query.scope})
+        super().__init__(**kwargs)
+        self.my_magics = MyMagics(self, code_to_modify=code_to_modify,
+                                  prompt_for=prompt_for, case_query=case_query)
+        self.register_magics(self.my_magics)
+        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) and 'def ' not in raw_cell:
+            if self.my_magics.rule_editor.func_name in raw_cell:
+                self.all_lines = self.my_magics.all_code_lines
+            self.all_lines.append(raw_cell)
+            self.history_manager.store_inputs(line_num=self.execution_count, source=raw_cell)
+            self.ask_exit()
+            return None
+        result = super().run_cell(raw_cell, **kwargs)
+        if result.error_in_exec is None and result.error_before_exec is None:
+            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, header: Optional[str] = None,
+                 prompt_for: Optional[PromptFor] = None, case_query: Optional[CaseQuery] = None,
+                 code_to_modify: Optional[str] = None):
+        """
+        Initialize the Ipython shell with the given scope and header.
+
+        :param header: The header to display when the shell is started.
+        :param prompt_for: The type of information to ask the user about.
+        :param case_query: The case query which contains the case and the attribute to ask about.
+        :param code_to_modify: The code to modify. If given, will be used as a start for user to modify.
+        """
+        self.header: str = header or ">>> Embedded Ipython Shell"
+        self.case_query: Optional[CaseQuery] = case_query
+        self.prompt_for: Optional[PromptFor] = prompt_for
+        self.code_to_modify: Optional[str] = code_to_modify
+        self.user_input: Optional[str] = None
+        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 = CustomInteractiveShell(config=cfg, banner1=self.header,
+                                       code_to_modify=self.code_to_modify,
+                                       prompt_for=self.prompt_for,
+                                       case_query=self.case_query,
+                                       )
+        return shell
+
+    def run(self):
+        """
+        Run the embedded shell.
+        """
+        while True:
+            try:
+                self.shell()
+                self.update_user_input_from_code_lines()
+                break
+            except Exception as e:
+                logging.error(e)
+                print(f"{Fore.RED}ERROR::{e}{Style.RESET_ALL}")
+
+    def update_user_input_from_code_lines(self):
+        """
+        Update the user input from the code lines captured in the shell.
+        """
+        if len(self.shell.all_lines) == 1 and self.shell.all_lines[0].replace('return', '').strip() == '':
+            self.user_input = None
+        else:
+            self.all_code_lines = extract_dependencies(self.shell.all_lines)
+            if len(self.all_code_lines) == 1 and self.all_code_lines[0].strip() == '':
+                self.user_input = None
+            else:
+                self.user_input = encapsulate_code_lines_into_a_function(self.all_code_lines,
+                                                       function_name=self.shell.my_magics.rule_editor.func_name,
+                                                       function_signature=self.shell.my_magics.rule_editor.function_signature,
+                                                       func_doc=self.shell.my_magics.rule_editor.func_doc,
+                                                       case_query=self.case_query)

ripple_down_rules/user_interface/object_diagram.py

@@ -0,0 +1,109 @@
+import graphviz
+
+
+def is_simple(obj):
+    return isinstance(obj, (int, float, str, bool, type(None)))
+
+
+def get_colored_value(value):
+    if isinstance(value, str):
+        color = '#A31515'  # red for strings
+        val = repr(value)
+    elif isinstance(value, (int, float)):
+        color = '#098658'  # green for numbers
+        val = str(value)
+    elif isinstance(value, bool):
+        color = '#0000FF'  # blue for booleans
+        val = str(value)
+    elif value is None:
+        color = '#808080'  # gray for None
+        val = 'None'
+    else:
+        color = '#000000'  # fallback
+        val = str(value)
+    val = (val.replace("class ", "").replace("'", "").replace('<', "")
+           .replace('>', "").replace('?', '').replace('\n', ' '))
+    val = val[:50] + '...' if len(val) > 50 else val
+    return f'<FONT COLOR="{color}">{val}</FONT>'
+
+
+def generate_object_graph(obj, name='root', seen=None, graph=None, current_depth=0, max_depth=3, chain_name=None,
+                          included_attrs=None):
+    if seen is None:
+        seen = set()
+    if graph is None:
+        graph = graphviz.Digraph(format='svg', graph_attr={'dpi': '300'})
+        graph.attr('node', shape='plaintext')
+
+    obj_id = id(obj)
+    if obj_id in seen or current_depth > max_depth:
+        return graph
+    seen.add(obj_id)
+
+    # Build HTML table label for this object node
+    type_name = type(obj).__name__ if not isinstance(obj, type) else obj.__name__
+    rows = [f'<TR><TD><B>{name}</B></TD><TD><I>{type_name}</I></TD></TR>']
+
+    # We'll keep track of non-simple attrs to add edges later
+    non_simple_attrs = []
+
+    if isinstance(obj, (list, tuple, set, dict)):
+        items = obj.items() if isinstance(obj, dict) else enumerate(obj)
+        for idx, item in items:
+            if idx == "scope":
+                continue
+            # Represent items as attr = index + type (for the label)
+            if is_simple(item):
+                val_colored = get_colored_value(item)
+                rows.append(f'<TR><TD ALIGN="LEFT" PORT="{idx}">[{idx}]</TD><TD ALIGN="LEFT">{val_colored}</TD></TR>')
+            else:
+                type_name = type(item).__name__ if not isinstance(item, type) else item.__name__
+                rows.append(
+                    f'<TR><TD ALIGN="LEFT" PORT="{idx}">[{idx}]</TD><TD ALIGN="LEFT"><I>{type_name}</I></TD></TR>')
+                non_simple_attrs.append((str(idx), item))
+
+    else:
+        for attr in dir(obj):
+            if attr.startswith('_'):
+                continue
+            if attr == 'scope':
+                continue
+            value = getattr(obj, attr)
+            if callable(value):
+                continue
+            if is_simple(value):
+                val_colored = get_colored_value(value)
+                rows.append(f'<TR><TD ALIGN="LEFT" PORT="{attr}">{attr}</TD><TD ALIGN="LEFT">{val_colored}</TD></TR>')
+            else:
+                type_name = type(value).__name__ if not isinstance(value, type) else value.__name__
+                # Show just name and type inside the node
+                rows.append(
+                    f'<TR><TD ALIGN="LEFT" PORT="{attr}">{attr}</TD><TD ALIGN="LEFT"><I>{type_name}</I></TD></TR>')
+                non_simple_attrs.append((attr, value))
+
+    label = f"""<
+        <TABLE BORDER="1" CELLBORDER="1" CELLSPACING="0" CELLPADDING="4">
+        {''.join(rows)}
+        </TABLE>
+    >"""
+
+    graph.node(str(obj_id), label)
+    chain_name = chain_name if chain_name is not None else name
+
+    # Add edges from this node to non-simple attribute nodes
+    for attr, value in non_simple_attrs:
+        if attr.startswith('_'):
+            continue
+        if attr == 'scope':
+            continue
+        if callable(value):
+            continue
+        attr_chain_name = f"{chain_name}.{attr}"
+        if included_attrs is not None and attr_chain_name not in included_attrs:
+            continue
+        generate_object_graph(value, attr, seen, graph, current_depth + 1, max_depth, chain_name=f"{chain_name}.{attr}",
+                              included_attrs=included_attrs)
+        # Edge from this object's attribute port to nested object's node
+        graph.edge(f"{obj_id}:{attr}", str(id(value)), label=attr)
+
+    return graph

ripple_down_rules/user_interface/prompt.py

@@ -0,0 +1,159 @@
+import ast
+import logging
+from _ast import AST
+
+from PyQt6.QtWidgets import QApplication
+from colorama import Fore, Style
+from pygments import highlight
+from pygments.formatters.terminal import TerminalFormatter
+from pygments.lexers.python import PythonLexer
+from typing_extensions import Optional, Tuple
+
+from ..datastructures.callable_expression import CallableExpression, parse_string_to_expression
+from ..datastructures.dataclasses import CaseQuery
+from ..datastructures.enums import PromptFor, InteractionMode
+from .gui import RDRCaseViewer
+from .ipython_custom_shell import IPythonShell
+from ..utils import make_list
+
+
+class UserPrompt:
+    """
+    A class to handle user prompts for the RDR.
+    """
+    def __init__(self, viewer: Optional[RDRCaseViewer] = None):
+        """
+        Initialize the UserPrompt class.
+
+        :param viewer: The RDRCaseViewer instance to use for prompting the user.
+        """
+        self.viewer = viewer
+        self.print_func = print if viewer is None else viewer.print
+
+
+    def prompt_user_for_expression(self, case_query: CaseQuery, prompt_for: PromptFor, prompt_str: Optional[str] = None) \
+            -> Tuple[Optional[str], Optional[CallableExpression]]:
+        """
+        Prompt the user for an executable python expression to the given case query.
+
+        :param case_query: The case query to prompt the user for.
+        :param prompt_for: The type of information ask user about.
+        :param prompt_str: The prompt string to display to the user.
+        :return: A callable expression that takes a case and executes user expression on it.
+        """
+        prev_user_input: Optional[str] = None
+        callable_expression: Optional[CallableExpression] = None
+        while True:
+            user_input, expression_tree = self.prompt_user_about_case(case_query, prompt_for, prompt_str,
+                                                                 code_to_modify=prev_user_input)
+            if user_input is None:
+                if prompt_for == PromptFor.Conclusion:
+                    self.print_func(f"{Fore.YELLOW}No conclusion provided. Exiting.{Style.RESET_ALL}")
+                    return None, None
+                else:
+                    self.print_func(f"{Fore.RED}Conditions must be provided. Please try again.{Style.RESET_ALL}")
+                    continue
+            prev_user_input = '\n'.join(user_input.split('\n')[2:-1])
+            conclusion_type = bool if prompt_for == PromptFor.Conditions else case_query.attribute_type
+            callable_expression = CallableExpression(user_input, conclusion_type, expression_tree=expression_tree,
+                                                     scope=case_query.scope,
+                                                      mutually_exclusive=case_query.mutually_exclusive)
+            try:
+                result = callable_expression(case_query.case)
+                if len(make_list(result)) == 0:
+                    self.print_func(f"{Fore.YELLOW}The given expression gave an empty result for case {case_query.name}."
+                          f" Please modify!{Style.RESET_ALL}")
+                    continue
+                break
+            except Exception as e:
+                logging.error(e)
+                self.print_func(f"{Fore.RED}{e}{Style.RESET_ALL}")
+        return user_input, callable_expression
+
+
+    def prompt_user_about_case(self, case_query: CaseQuery, prompt_for: PromptFor,
+                               prompt_str: Optional[str] = None,
+                               code_to_modify: Optional[str] = None) -> Tuple[Optional[str], Optional[AST]]:
+        """
+        Prompt the user for input.
+
+        :param case_query: The case query to prompt the user for.
+        :param prompt_for: The type of information the user should provide for the given case.
+        :param prompt_str: The prompt string to display to the user.
+        :param code_to_modify: The code to modify. If given will be used as a start for user to modify.
+        :return: The user input, and the executable expression that was parsed from the user input.
+        """
+        if prompt_str is None:
+            if prompt_for == PromptFor.Conclusion:
+                prompt_str = f"Give possible value(s) for:"
+            else:
+                prompt_str = f"Give conditions on when can the rule be evaluated for:"
+        case_query.scope.update({'case': case_query.case})
+        shell = None
+        if QApplication.instance() is None:
+            prompt_str = self.construct_prompt_str_for_shell(case_query, prompt_for, prompt_str)
+            shell = IPythonShell(header=prompt_str, prompt_for=prompt_for, case_query=case_query,
+                                 code_to_modify=code_to_modify)
+        else:
+
+            self.viewer.update_for_case_query(case_query, prompt_str,
+                                              prompt_for=prompt_for, code_to_modify=code_to_modify)
+        return self.prompt_user_input_and_parse_to_expression(shell=shell)
+
+
+    def construct_prompt_str_for_shell(self, case_query: CaseQuery, prompt_for: PromptFor,
+                                       prompt_str: Optional[str] = None) -> str:
+        """
+        Construct the prompt string for the shell.
+
+        :param case_query: The case query to prompt the user for.
+        :param prompt_for: The type of information the user should provide for the given case.
+        :param prompt_str: The prompt string to display to the user.
+        """
+        prompt_str += (f"\n{Fore.CYAN}{case_query.name}{Fore.MAGENTA} of type(s) "
+                       f"{Fore.CYAN}({', '.join(map(lambda x: x.__name__, case_query.core_attribute_type))}){Fore.MAGENTA}")
+        if prompt_for == PromptFor.Conditions:
+            prompt_str += (f"\ne.g. `{Fore.GREEN}return {Fore.BLUE}len{Fore.RESET}(case.attribute) > {Fore.BLUE}0` "
+                           f"{Fore.MAGENTA}\nOR `{Fore.GREEN}return {Fore.YELLOW}True`{Fore.MAGENTA} (If you want the"
+                           f" rule to be always evaluated) \n"
+                           f"You can also do {Fore.YELLOW}%edit{Fore.MAGENTA} for more complex conditions.")
+
+        prompt_str = f"{Fore.MAGENTA}{prompt_str}{Fore.YELLOW}\n(Write %help for guide){Fore.RESET}"
+        return prompt_str
+
+
+    def prompt_user_input_and_parse_to_expression(self, shell: Optional[IPythonShell] = None,
+                                                  user_input: Optional[str] = None) \
+            -> Tuple[Optional[str], Optional[ast.AST]]:
+        """
+        Prompt the user for input.
+
+        :param shell: The Ipython shell to use for prompting the user.
+        :param user_input: The user input to use. If given, the user input will be used instead of prompting the user.
+        :return: The user input and the AST tree.
+        """
+        while True:
+            if user_input is None:
+                if QApplication.instance() 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([])
+                    self.viewer.show()
+                    app.exec()
+                    user_input = self.viewer.user_input
+                if user_input is None:
+                    return None, None
+                self.print_func(f"{Fore.GREEN}Captured User input: {Style.RESET_ALL}")
+                highlighted_code = highlight(user_input, PythonLexer(), TerminalFormatter())
+                self.print_func(highlighted_code)
+            try:
+                return user_input, parse_string_to_expression(user_input)
+            except Exception as e:
+                msg = f"Error parsing expression: {e}"
+                logging.error(msg)
+                self.print_func(f"{Fore.RED}{msg}{Style.RESET_ALL}")
+                user_input = None