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

ripple_down_rules/prompt.py

@@ -1,91 +1,222 @@
 import ast
 import logging
 import os
+import shutil
+import socket
 import subprocess
 import tempfile
 from _ast import AST
 from functools import cached_property
 from textwrap import indent, dedent
 
-from IPython.core.magic import register_line_magic, line_magic, Magics, magics_class
+from IPython.core.magic import line_magic, Magics, magics_class
 from IPython.terminal.embed import InteractiveShellEmbed
+from colorama import Fore, Style
 from pygments import highlight
 from pygments.formatters.terminal import TerminalFormatter
 from pygments.lexers.python import PythonLexer
 from traitlets.config import Config
-from typing_extensions import List, Optional, Tuple, Dict, Type, Union, Any
+from typing_extensions import List, Optional, Tuple, Dict, Type
 
-from .datastructures.enums import PromptFor
-from .datastructures.case import Case
 from .datastructures.callable_expression import CallableExpression, parse_string_to_expression
+from .datastructures.case import Case
 from .datastructures.dataclasses import CaseQuery
-from .utils import extract_dependencies, contains_return_statement, make_set, get_imports_from_scope, make_list, \
-    get_import_from_type, get_imports_from_types, is_iterable, extract_function_source, encapsulate_user_input, \
-    are_results_subclass_of_types
-from colorama import Fore, Style, init
+from .datastructures.enums import PromptFor, Editor
+from .utils import extract_dependencies, contains_return_statement, get_imports_from_scope, make_list, \
+    get_imports_from_types, extract_function_source, encapsulate_user_input, str_to_snake_case, typing_hint_to_str
+
+
+def detect_available_editor() -> Optional[Editor]:
+    """
+    Detect the available editor on the system.
+
+    :return: The first found editor that is available on the system.
+    """
+    editor_env = os.environ.get("RDR_EDITOR")
+    if editor_env:
+        return Editor.from_str(editor_env)
+    for editor in [Editor.Pycharm, Editor.Code, Editor.CodeServer]:
+        if shutil.which(editor.value):
+            return editor
+    return None
+
+
+def is_port_in_use(port: int = 8080) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(("localhost", port)) == 0
+
+
+def start_code_server(workspace):
+    """
+    Start the code-server in the given workspace.
+    """
+    filename = os.path.join(os.path.dirname(__file__), "start-code-server.sh")
+    os.system(f"chmod +x {filename}")
+    print(f"Starting code-server at {filename}")
+    return subprocess.Popen(["/bin/bash", filename, workspace], stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE, text=True)
 
 
 @magics_class
 class MyMagics(Magics):
-    def __init__(self, shell, scope, output_type: Optional[Type] = None, func_name: str = "user_case",
-                 func_doc: str = "User defined function to be executed on the case.",
+    temp_file_path: Optional[str] = None
+    """
+    The path to the temporary file that is created for the user to edit.
+    """
+    port: int = int(os.environ.get("RDR_EDITOR_PORT", 8080))
+    """
+    The port to use for the code-server.
+    """
+    process: Optional[subprocess.Popen] = None
+    """
+    The process of the code-server.
+    """
+
+    def __init__(self, shell, scope,
                  code_to_modify: Optional[str] = None,
-                 attribute_type_hint: Optional[str] = None,
-                 prompt_for: Optional[PromptFor] = None):
+                 prompt_for: Optional[PromptFor] = None,
+                 case_query: Optional[CaseQuery] = None):
         super().__init__(shell)
         self.scope = scope
-        self.temp_file_path = None
-        self.func_name = func_name
-        self.func_doc = func_doc
         self.code_to_modify = code_to_modify
-        self.attribute_type_hint = attribute_type_hint
         self.prompt_for = prompt_for
-        self.output_type = make_list(output_type) if output_type is not None else None
+        self.case_query = case_query
+        self.output_type = self.get_output_type()
         self.user_edit_line = 0
-        self.function_signature: Optional[str] = None
-        self.build_function_signature()
+        self.func_name: str = self.get_func_name()
+        self.func_doc: str = self.get_func_doc()
+        self.function_signature: str = self.get_function_signature()
+        self.editor: Optional[Editor] = detect_available_editor()
+        self.workspace: str = os.environ.get("RDR_EDITOR_WORKSPACE", os.path.dirname(self.scope['__file__']))
+        self.temp_file_path: str = os.path.join(self.workspace, "edit_code_here.py")
+
+    def get_output_type(self) -> List[Type]:
+        """
+        :return: The output type of the function as a list of types.
+        """
+        if self.prompt_for == PromptFor.Conditions:
+            output_type = bool
+        else:
+            output_type = self.case_query.attribute_type
+        return make_list(output_type) if output_type is not None else None
 
     @line_magic
     def edit(self, line):
+        if self.editor is None:
+            print(f"{Fore.RED}ERROR:: No editor found. Please install PyCharm, VSCode or code-server.{Style.RESET_ALL}")
+            return
 
         boilerplate_code = self.build_boilerplate_code()
-
         self.write_to_file(boilerplate_code)
 
-        print(f"Opening {self.temp_file_path} in PyCharm...")
-        subprocess.Popen(["pycharm", "--line", str(self.user_edit_line), self.temp_file_path],
-                         stdout=subprocess.DEVNULL,
-                         stderr=subprocess.DEVNULL)
+        self.open_file_in_editor()
+
+    def open_file_in_editor(self):
+        """
+        Open the file in the available editor.
+        """
+        if self.editor == Editor.Pycharm:
+            subprocess.Popen(["pycharm", "--line", str(self.user_edit_line), self.temp_file_path],
+                             stdout=subprocess.DEVNULL,
+                             stderr=subprocess.DEVNULL)
+        elif self.editor == Editor.Code:
+            subprocess.Popen(["code", self.temp_file_path])
+        elif self.editor == Editor.CodeServer:
+            try:
+                subprocess.check_output(["pgrep", "-f", "code-server"])
+                # check if same port is in use
+                if is_port_in_use(self.port):
+                    print(f"Code-server is already running on port {self.port}.")
+                else:
+                    raise ValueError("Port is not in use.")
+            except (subprocess.CalledProcessError, ValueError) as e:
+                self.process = start_code_server(self.workspace)
+            print(f"Open code-server in your browser at http://localhost:{self.port}?folder={self.workspace}")
+        print(f"Edit the file: {Fore.BLUE}{self.temp_file_path}")
 
     def build_boilerplate_code(self):
         imports = self.get_imports()
-        self.build_function_signature()
+        if self.function_signature is None:
+            self.function_signature = self.get_function_signature()
+        if self.func_doc is None:
+            self.func_doc = self.get_func_doc()
         if self.code_to_modify is not None:
             body = indent(dedent(self.code_to_modify), '    ')
         else:
             body = "    # Write your code here\n    pass"
         boilerplate = f"""{imports}\n\n{self.function_signature}\n    \"\"\"{self.func_doc}\"\"\"\n{body}"""
-        self.user_edit_line = imports.count('\n')+6
+        self.user_edit_line = imports.count('\n') + 6
         return boilerplate
 
-    def build_function_signature(self):
+    def get_function_signature(self) -> str:
+        if self.func_name is None:
+            self.func_name = self.get_func_name()
+        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}:"
+
+    def get_output_type_hint(self) -> str:
+        """
+        :return: A string containing the output type hint for the function.
+        """
         output_type_hint = ""
         if self.prompt_for == PromptFor.Conditions:
             output_type_hint = " -> bool"
         elif self.prompt_for == PromptFor.Conclusion:
-            output_type_hint = f" -> {self.attribute_type_hint}"
-        self.function_signature = f"def {self.func_name}(case: {self.case_type.__name__}){output_type_hint}:"
+            output_type_hint = f" -> {self.case_query.attribute_type_hint}"
+        return output_type_hint
+
+    def get_func_args(self) -> str:
+        """
+        :return: A string containing the function arguments.
+        """
+        if self.case_query.is_function:
+            func_args = {}
+            for k, v in self.case_query.case.items():
+                if (self.case_query.function_args_type_hints is not None
+                        and k in self.case_query.function_args_type_hints):
+                    func_args[k] = typing_hint_to_str(self.case_query.function_args_type_hints[k])[0]
+                else:
+                    func_args[k] = type(v).__name__ if not isinstance(v, type) else f"Type[{v.__name__}]"
+            func_args = ', '.join([f"{k}: {v}" if str(v) not in ["NoneType", "None"] else str(k)
+                                   for k, v in func_args.items()])
+        else:
+            func_args = f"case: {self.case_type.__name__}"
+        return func_args
 
     def write_to_file(self, code: str):
-        tmp = tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix=".py",
-                                          dir=os.path.dirname(self.scope['__file__']))
-        tmp.write(code)
-        tmp.flush()
-        self.temp_file_path = tmp.name
-        tmp.close()
+        if self.temp_file_path is None:
+            tmp = tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix=".py",
+                                              dir=self.workspace)
+            tmp.write(code)
+            tmp.flush()
+            self.temp_file_path = tmp.name
+            tmp.close()
+        else:
+            with open(self.temp_file_path, 'w+') as f:
+                f.write(code)
 
     def get_imports(self):
-        case_type_import = f"from {self.case_type.__module__} import {self.case_type.__name__}"
+        """
+        :return: A string containing the imports for the function.
+        """
+        case_type_imports = []
+        if self.case_query.is_function:
+            for k, v in self.case_query.case.items():
+                if (self.case_query.function_args_type_hints is not None
+                        and k in self.case_query.function_args_type_hints):
+                    hint_list = typing_hint_to_str(self.case_query.function_args_type_hints[k])[1]
+                    for hint in hint_list:
+                        hint_split = hint.split('.')
+                        if len(hint_split) > 1:
+                            case_type_imports.append(f"from {'.'.join(hint_split[:-1])} import {hint_split[-1]}")
+                else:
+                    if isinstance(v, type):
+                        case_type_imports.append(f"from {v.__module__} import {v.__name__}")
+                    elif hasattr(v, "__module__") and not v.__module__.startswith("__"):
+                        case_type_imports.append(f"\nfrom {type(v).__module__} import {type(v).__name__}")
+        else:
+            case_type_imports.append(f"from {self.case_type.__module__} import {self.case_type.__name__}")
         if self.output_type is None:
             output_type_imports = [f"from typing_extensions import Any"]
         else:
@@ -96,12 +227,32 @@ class MyMagics(Magics):
                 output_type_imports.append("from typing_extensions import List")
         imports = get_imports_from_scope(self.scope)
         imports = [i for i in imports if ("get_ipython" not in i)]
-        if case_type_import not in imports:
-            imports.append(case_type_import)
+        imports.extend(case_type_imports)
         imports.extend([oti for oti in output_type_imports if oti not in imports])
         imports = set(imports)
         return '\n'.join(imports)
 
+    def get_func_doc(self) -> Optional[str]:
+        """
+        :return: A string containing the function docstring.
+        """
+        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}")
+        else:
+            return f"Get possible value(s) for {self.case_query.name}"
+
+    def get_func_name(self) -> 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:
+            # convert any CamelCase word into snake_case by adding _ before each capital letter
+            case_name = case_name.replace(f"_{self.case_query.attribute_name}", "")
+        func_name += case_name
+        return str_to_snake_case(func_name)
+
     @cached_property
     def case_type(self) -> Type:
         """
@@ -150,16 +301,20 @@ Loads the function defined in the temporary file into the user namespace, that c
         """
         print(help_text)
 
+    def __del__(self):
+        if hasattr(self, 'process') and self.process is not None and self.process.poll() is None:
+            self.process.terminate()  # Graceful shutdown
+            self.process.wait()  # Ensure cleanup
+
 
 class CustomInteractiveShell(InteractiveShellEmbed):
-    def __init__(self, output_type: Union[Type, Tuple[Type], None] = None, func_name: Optional[str] = None,
-                 func_doc: Optional[str] = None, code_to_modify: Optional[str] = None,
-                 attribute_type_hint: Optional[str] = None, prompt_for: Optional[PromptFor] = None, **kwargs):
+    def __init__(self, code_to_modify: Optional[str] = None,
+                 prompt_for: Optional[PromptFor] = None,
+                 case_query: Optional[CaseQuery] = None,
+                 **kwargs):
         super().__init__(**kwargs)
-        keys = ['output_type', 'func_name', 'func_doc', 'code_to_modify', 'attribute_type_hint', 'prompt_for']
-        values = [output_type, func_name, func_doc, code_to_modify, attribute_type_hint, prompt_for]
-        magics_kwargs = {key: value for key, value in zip(keys, values) if value is not None}
-        self.my_magics = MyMagics(self, self.user_ns, **magics_kwargs)
+        self.my_magics = MyMagics(self, self.user_ns, code_to_modify=code_to_modify,
+                                  prompt_for=prompt_for, case_query=case_query)
         self.register_magics(self.my_magics)
         self.all_lines = []
 
@@ -201,19 +356,10 @@ class IPythonShell:
         """
         self.scope: Dict = scope or {}
         self.header: str = header or ">>> Embedded Ipython Shell"
-        output_type = None
-        if prompt_for is not None:
-            if prompt_for == PromptFor.Conclusion and case_query is not None:
-                output_type = case_query.attribute_type
-            elif prompt_for == PromptFor.Conditions:
-                output_type = bool
         self.case_query: Optional[CaseQuery] = case_query
-        self.output_type: Optional[Type] = output_type
         self.prompt_for: Optional[PromptFor] = prompt_for
         self.code_to_modify: Optional[str] = code_to_modify
         self.user_input: Optional[str] = None
-        self.func_name: str = ""
-        self.func_doc: str = ""
         self.shell: CustomInteractiveShell = self._init_shell()
         self.all_code_lines: List[str] = []
 
@@ -222,58 +368,13 @@ class IPythonShell:
         Initialize the Ipython shell with a custom configuration.
         """
         cfg = Config()
-        self.build_func_name_and_doc()
         shell = CustomInteractiveShell(config=cfg, user_ns=self.scope, banner1=self.header,
-                                       output_type=self.output_type, func_name=self.func_name, func_doc=self.func_doc,
                                        code_to_modify=self.code_to_modify,
-                                       attribute_type_hint=self.case_query.attribute_type_hint,
-                                       prompt_for=self.prompt_for)
+                                       prompt_for=self.prompt_for,
+                                       case_query=self.case_query,
+                                       )
         return shell
 
-    def build_func_name_and_doc(self) -> Tuple[str, str]:
-        """
-        Build the function name and docstring for the user-defined function.
-
-        :return: A tuple containing the function name and docstring.
-        """
-        case = self.scope['case']
-        case_type = case._obj_type if isinstance(case, Case) else type(case)
-        self.func_name = self.build_func_name(case_type)
-        self.func_doc = self.build_func_doc(case_type)
-
-    def build_func_doc(self, case_type: Type) -> Optional[str]:
-        if self.case_query is None or self.prompt_for is None:
-            return
-
-        if self.prompt_for == PromptFor.Conditions:
-            func_doc = (f"Get conditions on whether it's possible to conclude a value"
-                        f" for {case_type.__name__}.{self.case_query.attribute_name}")
-        elif self.prompt_for == PromptFor.Conclusion:
-            func_doc = f"Get possible value(s) for {case_type.__name__}.{self.case_query.attribute_name}"
-        else:
-            return
-
-        possible_types = [t.__name__ for t in self.case_query.attribute_type if t not in [list, set]]
-        if list in self.case_query.attribute_type:
-            func_doc += f" of type list of {' and/or '.join(possible_types)}"
-        else:
-            func_doc += f" of type(s) {', '.join(possible_types)}"
-
-        return func_doc
-
-    def build_func_name(self, case_type: Type) -> Optional[str]:
-        func_name = None
-        if self.prompt_for is not None:
-            func_name = f"get_{self.prompt_for.value.lower()}_for"
-            func_name += f"_{case_type.__name__}"
-
-        if self.case_query is not None:
-            func_name += f"_{self.case_query.attribute_name}"
-            output_names = [f"{t.__name__}" for t in self.case_query.attribute_type if t not in [list, set]]
-            func_name += '_of_type_' + '_'.join(output_names)
-
-        return func_name.lower() if func_name is not None else None
-
     def run(self):
         """
         Run the embedded shell.
@@ -300,12 +401,16 @@ class IPythonShell:
             else:
                 self.user_input = '\n'.join(self.all_code_lines)
                 self.user_input = encapsulate_user_input(self.user_input, self.shell.my_magics.function_signature,
-                                                         self.func_doc)
-                if f"return {self.func_name}(case)" not in self.user_input:
-                    self.user_input = self.user_input.strip() + f"\nreturn {self.func_name}(case)"
+                                                         self.shell.my_magics.func_doc)
+                if self.case_query.is_function:
+                    args = "**case"
+                else:
+                    args = "case"
+                if f"return {self.shell.my_magics.func_name}({args})" not in self.user_input:
+                    self.user_input = self.user_input.strip() + f"\nreturn {self.shell.my_magics.func_name}({args})"
 
 
-def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, prompt_str: Optional[str] = None)\
+def prompt_user_for_expression(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.
@@ -320,7 +425,6 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, pro
     while True:
         user_input, expression_tree = prompt_user_about_case(case_query, prompt_for, prompt_str,
                                                              code_to_modify=prev_user_input)
-        prev_user_input = '\n'.join(user_input.split('\n')[2:-1])
         if user_input is None:
             if prompt_for == PromptFor.Conclusion:
                 print(f"{Fore.YELLOW}No conclusion provided. Exiting.{Style.RESET_ALL}")
@@ -328,9 +432,11 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, pro
             else:
                 print(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)
+                                                 scope=case_query.scope,
+                                                  mutually_exclusive=case_query.mutually_exclusive)
         try:
             result = callable_expression(case_query.case)
             if len(make_list(result)) == 0:
@@ -376,7 +482,7 @@ def prompt_user_about_case(case_query: CaseQuery, prompt_for: PromptFor,
 
 
 def prompt_user_input_and_parse_to_expression(shell: Optional[IPythonShell] = None,
-                                              user_input: Optional[str] = None)\
+                                              user_input: Optional[str] = None) \
         -> Tuple[Optional[str], Optional[ast.AST]]:
     """
     Prompt the user for input.

ripple_down_rules/rdr.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copyreg
 import importlib
 import sys
 from abc import ABC, abstractmethod
@@ -96,11 +97,12 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             plt.ioff()
             plt.show()
 
-    def __call__(self, case: Union[Case, SQLTable]) -> CaseAttribute:
+    def __call__(self, case: Union[Case, SQLTable]) -> Union[CallableExpression, Dict[str, CallableExpression]]:
         return self.classify(case)
 
     @abstractmethod
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False) -> Optional[CaseAttribute]:
+    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False) \
+            -> Optional[Union[CallableExpression, Dict[str, CallableExpression]]]:
         """
         Classify a case.
 
@@ -111,7 +113,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         pass
 
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
-            -> Union[CaseAttribute, CallableExpression]:
+            -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
         Fit the classifier to a case and ask the expert for refinements or alternatives if the classification is
         incorrect by comparing the case with the target category.
@@ -136,7 +138,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
     @abstractmethod
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
-            -> Union[CaseAttribute, CallableExpression]:
+            -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
         Fit the RDR on a case, and ask the expert for refinements or alternatives if the classification is incorrect by
         comparing the case with the target category.
@@ -929,7 +931,7 @@ class GeneralRDR(RippleDownRules):
         imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
         # add rdr python generated functions.
         for rdr_key, rdr in self.start_rules_dict.items():
-            imports += (f"from {file_path.strip('./')}"
+            imports += (f"from ."
                         f" import {rdr.generated_python_file_name} as {self.rdr_key_to_function_name(rdr_key)}\n")
         return imports