ripple-down-rules 0.4.8__py3-none-any.whl → 0.4.9__py3-none-any.whl

ripple_down_rules/rdr_decorators.py

@@ -5,15 +5,17 @@ of the RDRs.
 """
 import os.path
 from functools import wraps
+
+from pyparsing.tools.cvt_pyparsing_pep8_names import camel_to_snake
 from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union
 
-from ripple_down_rules.datastructures.case import create_case
+from ripple_down_rules.datastructures.case import create_case, Case
 from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.datastructures.enums import Category
 from ripple_down_rules.experts import Expert, Human
 from ripple_down_rules.rdr import GeneralRDR, RippleDownRules
 from ripple_down_rules.utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
-    get_method_class_if_exists
+    get_method_class_if_exists, get_method_name, str_to_snake_case
 
 
 class RDRDecorator:
@@ -41,99 +43,118 @@ class RDRDecorator:
         :return: A decorator to use a GeneralRDR as a classifier that monitors and modifies the function's output.
         """
         self.rdr_models_dir = models_dir
+        self.model_name: Optional[str] = None
         self.output_type = output_type
         self.parsed_output_type: List[Type] = []
         self.mutual_exclusive = mutual_exclusive
         self.rdr_python_path: Optional[str] = python_dir
         self.output_name = output_name
         self.fit: bool = fit
-        self.expert = expert if expert else Human()
-        self.rdr_model_path: Optional[str] = None
+        self.expert: Optional[Expert] = expert
         self.load()
 
     def decorator(self, func: Callable) -> Callable:
 
         @wraps(func)
         def wrapper(*args, **kwargs) -> Optional[Any]:
+
             if len(self.parsed_output_type) == 0:
-                self.parse_output_type(func, *args)
-            if self.rdr_model_path is None:
-                self.initialize_rdr_model_path_and_load(func)
-            case_dict = get_method_args_as_dict(func, *args, **kwargs)
-            func_output = func(*args, **kwargs)
-            case_dict.update({self.output_name: func_output})
-            case = create_case(case_dict, obj_name=get_func_rdr_model_name(func), max_recursion_idx=3)
+                self.parsed_output_type = self.parse_output_type(func, self.output_type, *args)
+            if self.model_name is None:
+                self.initialize_rdr_model_name_and_load(func)
+
             if self.fit:
-                scope = func.__globals__
-                scope.update(case_dict)
-                func_args_type_hints = get_type_hints(func)
-                func_args_type_hints.update({self.output_name: Union[tuple(self.parsed_output_type)]})
-                case_query = CaseQuery(case, self.output_name, Union[tuple(self.parsed_output_type)],
-                                       self.mutual_exclusive,
-                                       scope=scope, is_function=True, function_args_type_hints=func_args_type_hints)
+                expert_answers_path = os.path.join(self.rdr_models_dir, self.model_name, "expert_answers")
+                self.expert = self.expert or Human(answers_save_path=expert_answers_path)
+                case_query = self.create_case_query_from_method(func, self.parsed_output_type,
+                                                                self.mutual_exclusive, self.output_name,
+                                                                *args, **kwargs)
                 output = self.rdr.fit_case(case_query, expert=self.expert)
                 return output[self.output_name]
             else:
+                case, case_dict = self.create_case_from_method(func, self.output_name, *args, **kwargs)
                 return self.rdr.classify(case)[self.output_name]
 
         return wrapper
 
-    def initialize_rdr_model_path_and_load(self, func: Callable) -> None:
+    @staticmethod
+    def create_case_query_from_method(func: Callable, output_type, mutual_exclusive: bool,
+                                output_name: str = 'output_', *args, **kwargs) -> CaseQuery:
+        """
+        Create a CaseQuery from the function and its arguments.
+
+        :param func: The function to create a case from.
+        :param output_type: The type of the output.
+        :param mutual_exclusive: If True, the output types are mutually exclusive.
+        :param output_name: The name of the output in the case. Defaults to 'output_'.
+        :param args: The positional arguments of the function.
+        :param kwargs: The keyword arguments of the function.
+        :return: A CaseQuery object representing the case.
+        """
+        output_type = make_set(output_type)
+        case, case_dict = RDRDecorator.create_case_from_method(func, output_name, *args, **kwargs)
+        scope = func.__globals__
+        scope.update(case_dict)
+        func_args_type_hints = get_type_hints(func)
+        func_args_type_hints.update({output_name: Union[tuple(output_type)]})
+        return CaseQuery(case, output_name, Union[tuple(output_type)],
+                         mutual_exclusive, scope=scope,
+                         is_function=True, function_args_type_hints=func_args_type_hints)
+
+    @staticmethod
+    def create_case_from_method(func: Callable, output_name: str = "output_", *args, **kwargs) -> Tuple[Case, Dict[str, Any]]:
+        """
+        Create a Case from the function and its arguments.
+
+        :param func: The function to create a case from.
+        :param output_name: The name of the output in the case. Defaults to 'output_'.
+        :param args: The positional arguments of the function.
+        :param kwargs: The keyword arguments of the function.
+        :return: A Case object representing the case.
+        """
+        case_dict = get_method_args_as_dict(func, *args, **kwargs)
+        func_output = func(*args, **kwargs)
+        case_dict.update({output_name: func_output})
+        case_name = get_func_rdr_model_name(func)
+        return create_case(case_dict, obj_name=case_name, max_recursion_idx=3), case_dict
+
+    def initialize_rdr_model_name_and_load(self, func: Callable) -> None:
         model_file_name = get_func_rdr_model_name(func, include_file_name=True)
-        model_file_name = (''.join(['_' + c.lower() if c.isupper() else c for c in model_file_name]).lstrip('_')
-                           .replace('__', '_') + ".json")
-        self.rdr_model_path = os.path.join(self.rdr_models_dir, model_file_name)
+        self.model_name = str_to_snake_case(model_file_name)
         self.load()
 
-    def parse_output_type(self, func: Callable, *args) -> None:
-        for ot in make_set(self.output_type):
+    @staticmethod
+    def parse_output_type(func: Callable, output_type: Any, *args) -> List[Type]:
+        parsed_output_type = []
+        for ot in make_set(output_type):
             if ot is Self:
                 func_class = get_method_class_if_exists(func, *args)
                 if func_class is not None:
-                    self.parsed_output_type.append(func_class)
+                    parsed_output_type.append(func_class)
                 else:
                     raise ValueError(f"The function {func} is not a method of a class,"
                                      f" and the output type is {Self}.")
             else:
-                self.parsed_output_type.append(ot)
+                parsed_output_type.append(ot)
+        return parsed_output_type
 
     def save(self):
         """
         Save the RDR model to the specified directory.
         """
-        self.rdr.save(self.rdr_model_path)
-
-        if self.rdr_python_path is not None:
-            if not os.path.exists(self.rdr_python_path):
-                os.makedirs(self.rdr_python_path)
-            if not os.path.exists(os.path.join(self.rdr_python_path, "__init__.py")):
-                # add __init__.py file to the directory
-                with open(os.path.join(self.rdr_python_path, "__init__.py"), "w") as f:
-                    f.write("# This is an empty __init__.py file to make the directory a package.")
-            # write the RDR model to a python file
-            self.rdr.write_to_python_file(self.rdr_python_path)
+        self.rdr.save(self.rdr_models_dir)
 
     def load(self):
         """
         Load the RDR model from the specified directory.
         """
-        if self.rdr_model_path is not None and os.path.exists(self.rdr_model_path):
-            self.rdr = GeneralRDR.load(self.rdr_model_path)
+        if self.model_name is not None and os.path.exists(os.path.join(self.rdr_models_dir, self.model_name)):
+            self.rdr = GeneralRDR.load(self.rdr_models_dir, self.model_name)
         else:
-            self.rdr = GeneralRDR()
-
-    def write_to_python_file(self, package_dir: str, file_name_postfix: str = ""):
-        """
-        Write the RDR model to a python file.
-
-        :param package_dir: The path to the directory to write the python file.
-        """
-        self.rdr.write_to_python_file(package_dir, postfix=file_name_postfix)
+            self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name)
 
-    def update_from_python_file(self, package_dir: str):
+    def update_from_python(self):
         """
         Update the RDR model from a python file.
-
-        :param package_dir: The directory of the package that contains the generated python file.
         """
-        self.rdr.update_from_python_file(package_dir)
+        self.rdr.update_from_python(self.rdr_models_dir, self.model_name)

ripple_down_rules/rules.py

@@ -118,7 +118,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             func_call = f"{parent_indent}    return {new_function_name.replace('def ', '')}(case)\n"
             return "\n".join(conclusion_lines).strip(' '), func_call
         else:
-            raise ValueError(f"Conclusion is format is not valid, it should be contain a function definition."
+            raise ValueError(f"Conclusion format is not valid, it should contain a function definition."
                              f" Instead got:\n{conclusion}\n")
 
     def write_condition_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
@@ -129,9 +129,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         :param defs_file: The file to write the conditions to if they are a definition.
         """
         if_clause = self._if_statement_source_code_clause()
-        if '\n' not in self.conditions.user_input:
-            return f"{parent_indent}{if_clause} {self.conditions.user_input}:\n"
-        elif "def " in self.conditions.user_input:
+        if "def " in self.conditions.user_input:
             if defs_file is None:
                 raise ValueError("Cannot write conditions to source code as definitions python file was not given.")
             # This means the conditions are a definition that should be written and then called
@@ -143,6 +141,9 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             with open(defs_file, 'a') as f:
                 f.write(def_code.strip() + "\n\n\n")
             return f"\n{parent_indent}{if_clause} {new_function_name.replace('def ', '')}(case):\n"
+        else:
+            raise ValueError(f"Conditions format is not valid, it should contain a function definition"
+                             f" Instead got:\n{self.conditions.user_input}\n")
 
     @abstractmethod
     def _if_statement_source_code_clause(self) -> str:

ripple_down_rules/start-code-server.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+set -e
+if [ -z "$RDR_EDITOR_PORT" ]; then
+    echo "RDR_EDITOR_PORT is not set. Using default port 8080."
+    RDR_EDITOR_PORT=8080
+fi
+ADDR="0.0.0.0:$RDR_EDITOR_PORT"
+# DATA_DIR="/root/.local/share/code-server"
+echo "🚀 Starting code-server on $ADDR"
+# Activate your Python virtual environment if exists else ignore
+if [ -z "$RDR_VENV_PATH" ]; then
+    echo "No virtual environment found. Skipping activation."
+else
+  source "$RDR_VENV_PATH/bin/activate"
+  # Set the default Python interpreter for VS Code
+  export DEFAULT_PYTHON_PATH=$(which python)
+fi
+
+# Start code-server.
+echo "🚀 Starting code-server on $ADDR"
+if [ -z "$CODE_SERVER_USER_DATA_DIR" ]; then
+    echo "No user data directory found. Using default"
+    code-server --bind-addr $ADDR --auth none "$@"
+else
+    echo "Using user data directory: $CODE_SERVER_USER_DATA_DIR"
+    code-server --bind-addr $ADDR --user-data-dir $CODE_SERVER_USER_DATA_DIR --auth none "$@"
+fi

ripple_down_rules/user_interface/gui.py

@@ -1,23 +1,29 @@
 from  __future__ import annotations
 
 import inspect
-from copy import copy
+import logging
 from types import MethodType
 
-from PyQt6.QtCore import Qt
-from PyQt6.QtGui import QPixmap, QPainter, QPalette
-from PyQt6.QtWidgets import (
-    QWidget, QVBoxLayout, QLabel, QScrollArea,
-    QSizePolicy, QToolButton, QHBoxLayout, QPushButton, QMainWindow, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
-)
-from qtconsole.inprocess import QtInProcessKernelManager
-from qtconsole.rich_jupyter_widget import RichJupyterWidget
+try:
+    from PyQt6.QtCore import Qt
+    from PyQt6.QtGui import QPixmap, QPainter, QPalette
+    from PyQt6.QtWidgets import (
+        QWidget, QVBoxLayout, QLabel, QScrollArea,
+        QSizePolicy, QToolButton, QHBoxLayout, QPushButton, QMainWindow, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
+    )
+    from qtconsole.inprocess import QtInProcessKernelManager
+    from qtconsole.rich_jupyter_widget import RichJupyterWidget
+except ImportError as e:
+    logging.debug("RDRCaseViewer is not available. GUI features will not work. "
+                  "Make sure you have PyQt6 installed if you want to use the GUI features.")
+    raise ImportError("PyQt6 is required for the GUI features. Please install it using 'pip install PyQt6'") from e
+
 from typing_extensions import Optional, Any, List, Dict, Callable
 
 from ..datastructures.dataclasses import CaseQuery
 from ..datastructures.enums import PromptFor
 from .template_file_creator import TemplateFileCreator
-from ..utils import is_iterable, contains_return_statement, encapsulate_user_input
+from ..utils import is_iterable, contains_return_statement, encapsulate_code_lines_into_a_function
 from .object_diagram import generate_object_graph
 
 
@@ -467,8 +473,7 @@ class RDRCaseViewer(QMainWindow):
         self.close()
 
     def _edit(self):
-        self.template_file_creator = TemplateFileCreator(self.ipython_console.kernel.shell,
-                                                         self.case_query, self.prompt_for, self.code_to_modify,
+        self.template_file_creator = TemplateFileCreator(self.case_query, self.prompt_for, self.code_to_modify,
                                                          self.print)
         self.template_file_creator.edit()
 
@@ -561,28 +566,6 @@ class RDRCaseViewer(QMainWindow):
         layout.addWidget(item_label)
 
 
-def encapsulate_code_lines_into_a_function(code_lines: List[str], function_name: str, function_signature: str,
-                                           func_doc: str, case_query: CaseQuery) -> str:
-    """
-    Encapsulate the given code lines into a function with the specified name, signature, and docstring.
-
-    :param code_lines: The lines of code to include in the user input.
-    :param function_name: The name of the function to include in the user input.
-    :param function_signature: The function signature to include in the user input.
-    :param func_doc: The function docstring to include in the user input.
-    :param case_query: The case query object.
-    """
-    code = '\n'.join(code_lines)
-    code = encapsulate_user_input(code, function_signature, func_doc)
-    if case_query.is_function:
-        args = "**case"
-    else:
-        args = "case"
-    if f"return {function_name}({args})" not in code:
-        code = code.strip() + f"\nreturn {function_name}({args})"
-    return code
-
-
 class IPythonConsole(RichJupyterWidget):
     def __init__(self, namespace=None, parent=None):
         super(IPythonConsole, self).__init__(parent)

ripple_down_rules/user_interface/ipython_custom_shell.py

@@ -8,9 +8,8 @@ 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
+from ..utils import contains_return_statement, extract_dependencies, encapsulate_code_lines_into_a_function
 
 
 @magics_class
@@ -21,7 +20,7 @@ class MyMagics(Magics):
                  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.rule_editor = TemplateFileCreator(case_query, prompt_for=prompt_for, code_to_modify=code_to_modify)
         self.all_code_lines: Optional[List[str]] = None
 
     @line_magic

ripple_down_rules/user_interface/object_diagram.py

@@ -1,4 +1,10 @@
-import graphviz
+import logging
+
+try:
+    import graphviz
+except ImportError:
+    graphviz = None
+    logging.debug("Graphviz is not installed")
 
 
 def is_simple(obj):

ripple_down_rules/user_interface/prompt.py

@@ -2,7 +2,13 @@ import ast
 import logging
 from _ast import AST
 
-from PyQt6.QtWidgets import QApplication
+try:
+    from PyQt6.QtWidgets import QApplication
+    from .gui import RDRCaseViewer
+except ImportError:
+    QApplication = None
+    RDRCaseViewer = None
+
 from colorama import Fore, Style
 from pygments import highlight
 from pygments.formatters.terminal import TerminalFormatter
@@ -11,8 +17,7 @@ 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 ..datastructures.enums import PromptFor
 from .ipython_custom_shell import IPythonShell
 from ..utils import make_list
 
@@ -90,7 +95,7 @@ class UserPrompt:
                 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:
+        if self.viewer 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)

ripple_down_rules/user_interface/template_file_creator.py

@@ -8,7 +8,6 @@ from functools import cached_property
 from textwrap import indent, dedent
 
 from colorama import Fore, Style
-from ipykernel.inprocess.ipkernel import InProcessInteractiveShell
 from typing_extensions import Optional, Type, List, Callable, Tuple, Dict
 
 from ..datastructures.case import Case
@@ -73,10 +72,9 @@ class TemplateFileCreator:
     The list of all code lines in the function in the temporary file.
     """
 
-    def __init__(self, shell: InProcessInteractiveShell, case_query: CaseQuery, prompt_for: PromptFor,
+    def __init__(self, case_query: CaseQuery, prompt_for: PromptFor,
                  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
@@ -260,11 +258,12 @@ class TemplateFileCreator:
             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"_{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)))}"
+            func_name += case_name.replace(f"_{case_query.attribute_name}", "")
+        else:
+            func_name += case_name
+            attribute_types = TemplateFileCreator.get_core_attribute_types(case_query)
+            attribute_type_names = [t.__name__ for t in attribute_types]
+            func_name += f"_of_type_{'_or_'.join(attribute_type_names)}"
         return str_to_snake_case(func_name)
 
     @cached_property

ripple_down_rules/utils.py

@@ -16,13 +16,27 @@ from dataclasses import is_dataclass, fields
 from enum import Enum
 from textwrap import dedent
 from types import NoneType
+from typing import List
+
+try:
+    import matplotlib
+    from matplotlib import pyplot as plt
+    Figure = plt.Figure
+except ImportError as e:
+    matplotlib = None
+    plt = None
+    Figure = None
+    logging.debug(f"{e}: matplotlib is not installed")
+
+try:
+    import networkx as nx
+except ImportError as e:
+    nx = None
+    logging.debug(f"{e}: networkx is not installed")
 
-import matplotlib
-import networkx as nx
 import requests
 from anytree import Node, RenderTree
 from anytree.exporter import DotExporter
-from matplotlib import pyplot as plt
 from sqlalchemy import MetaData, inspect
 from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQLTable, Session
 from tabulate import tabulate
@@ -164,7 +178,7 @@ def extract_function_source(file_path: str,
     functions_source: Dict[str, Union[str, List[str]]] = {}
     line_numbers = []
     for node in tree.body:
-        if isinstance(node, ast.FunctionDef) and node.name in function_names:
+        if isinstance(node, ast.FunctionDef) and (node.name in function_names or len(function_names) == 0):
             # Get the line numbers of the function
             lines = source.splitlines()
             func_lines = lines[node.lineno - 1:node.end_lineno]
@@ -172,9 +186,9 @@ def extract_function_source(file_path: str,
                 func_lines = func_lines[1:]
             line_numbers.append((node.lineno, node.end_lineno))
             functions_source[node.name] = dedent("\n".join(func_lines)) if join_lines else func_lines
-            if len(functions_source) == len(function_names):
+            if len(functions_source) >= len(function_names):
                 break
-    if len(functions_source) != len(function_names):
+    if len(functions_source) < len(function_names):
         raise ValueError(f"Could not find all functions in {file_path}: {function_names} not found,"
                          f"functions not found: {set(function_names) - set(functions_source.keys())}")
     if return_line_numbers:
@@ -891,8 +905,8 @@ class SubclassJSONSerializer:
         if not filename.endswith(".json"):
             filename += ".json"
         with open(filename, "r") as f:
-            scrdr_json = json.load(f)
-        deserialized_obj = cls.from_json(scrdr_json)
+            rdr_json = json.load(f)
+        deserialized_obj = cls.from_json(rdr_json)
         cls.data_class_refs.clear()
         return deserialized_obj
 
@@ -939,9 +953,6 @@ class SubclassJSONSerializer:
 
         raise ValueError("Unknown type {}".format(data["_type"]))
 
-    save = to_json_file
-    load = from_json_file
-
 
 def _pickle_thread(thread_obj) -> Any:
     """Return a plain object with user-defined attributes but no thread behavior."""
@@ -1084,24 +1095,29 @@ def get_origin_and_args_from_type_hint(type_hint: Type) -> Tuple[Optional[Type],
         return origin, args
 
 
-def table_rows_as_str(row_dict: Dict[str, Any], columns_per_row: int = 9):
+def table_rows_as_str(row_dicts: List[Dict[str, Any]], columns_per_row: int = 20):
     """
     Print a table row.
 
-    :param row_dict: The row to print.
+    :param row_dicts: The rows to print.
     :param columns_per_row: The maximum number of columns per row.
     """
-    all_items = list(row_dict.items())
+    all_row_dicts_items = [list(row_dict.items()) for row_dict in row_dicts]
     # make items a list of n rows such that each row has a max size of 4
-    all_items = [all_items[i:i + columns_per_row] for i in range(0, len(all_items), columns_per_row)]
+    all_items = [all_items[i:i + columns_per_row] for all_items in all_row_dicts_items
+                 for i in range(0, len(all_items), columns_per_row)]
     keys = [list(map(lambda i: i[0], row)) for row in all_items]
     values = [list(map(lambda i: i[1], row)) for row in all_items]
+    zipped_keys = list(zip(*keys))
+    zipped_values = list(zip(*values))
+    keys_values = [list(zip(zipped_keys[i], zipped_values[i])) for i in range(len(zipped_keys))]
+    keys_values = [list(r[0]) + list(r[1]) if len(r) > 1 else r[0] for r in keys_values]
     all_table_rows = []
-    for row_keys, row_values in zip(keys, values):
-        row_values = [str(v) if v is not None else "" for v in row_values]
-        row_values = [v.lower() if v in ["True", "False"] else v for v in row_values]
-        table = tabulate([row_values], headers=row_keys, tablefmt='plain', maxcolwidths=[20] * len(row_keys))
-        all_table_rows.append(table)
+    row_values = [list(map(lambda v: str(v) if v is not None else "", row)) for row in keys_values]
+    row_values = [list(map(lambda v: v[:150] + '...' if len(v) > 150 else v, row)) for row in row_values]
+    row_values = [list(map(lambda v: v.lower() if v in ["True", "False"] else v, row)) for row in row_values]
+    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=[150] * 2)
+    all_table_rows.append(table)
     return "\n".join(all_table_rows)
 
 
@@ -1350,7 +1366,7 @@ def render_tree(root: Node, use_dot_exporter: bool = False,
         de.to_picture(f"{filename}{'.png'}")
 
 
-def draw_tree(root: Node, fig: plt.Figure):
+def draw_tree(root: Node, fig: Figure):
     """
     Draw the tree using matplotlib and networkx.
     """
@@ -1374,3 +1390,25 @@ def draw_tree(root: Node, fig: plt.Figure):
     nx.draw_networkx_edge_labels(graph, pos, edge_labels=nx.get_edge_attributes(graph, 'weight'),
                                  ax=fig.gca(), rotate=False, clip_on=False)
     plt.pause(0.1)
+
+
+def encapsulate_code_lines_into_a_function(code_lines: List[str], function_name: str, function_signature: str,
+                                           func_doc: str, case_query: CaseQuery) -> str:
+    """
+    Encapsulate the given code lines into a function with the specified name, signature, and docstring.
+
+    :param code_lines: The lines of code to include in the user input.
+    :param function_name: The name of the function to include in the user input.
+    :param function_signature: The function signature to include in the user input.
+    :param func_doc: The function docstring to include in the user input.
+    :param case_query: The case query object.
+    """
+    code = '\n'.join(code_lines)
+    code = encapsulate_user_input(code, function_signature, func_doc)
+    if case_query.is_function:
+        args = "**case"
+    else:
+        args = "case"
+    if f"return {function_name}({args})" not in code:
+        code = code.strip() + f"\nreturn {function_name}({args})"
+    return code

{ripple_down_rules-0.4.8.dist-info → ripple_down_rules-0.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.4.8
+Version: 0.4.9
 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
@@ -682,21 +682,23 @@ Classifier: Programming Language :: Python :: 3
 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
+Requires-Dist: pygments
+Requires-Dist: sqlalchemy
+Requires-Dist: pandas
+Provides-Extra: viz
+Requires-Dist: networkx>=3.1; extra == "viz"
+Requires-Dist: matplotlib>=3.7.5; extra == "viz"
+Provides-Extra: gui
+Requires-Dist: pyqt6; extra == "gui"
+Requires-Dist: qtconsole; extra == "gui"
 Dynamic: license-file
 
 # Ripple Down Rules (RDR)

ripple_down_rules-0.4.9.dist-info/RECORD

@@ -0,0 +1,26 @@
+ripple_down_rules/__init__.py,sha256=PUnq-y-UONNX6u9U669iIwMK6S5qMXYECFClTLPBrbI,99
+ripple_down_rules/datasets.py,sha256=fJbZ7V-UUYTu5XVVpFinTbuzN3YePCnUB01L3AyZVM8,6837
+ripple_down_rules/experts.py,sha256=9Vc3vx0uhDPy3YlNjwKuWJLl_A-kubRPUU6bMvQhaAg,13237
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
+ripple_down_rules/rdr.py,sha256=E1OiiZClQyAfGjL64ID-MWYFO4-h8iUAX-Vm9qrOoeQ,48727
+ripple_down_rules/rdr_decorators.py,sha256=pYCKLgMKgQ6x_252WQtF2t4ZNjWPBxnaWtJ6TpGdcc0,7820
+ripple_down_rules/rules.py,sha256=TPNVMqW9T-_46BS4WemrspLg5uG8kP6tsPvWWBAzJxg,17515
+ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
+ripple_down_rules/utils.py,sha256=uS38KcFceRMzT_470DCL1M0LzETdP5RLwE7cCmfo7eI,51086
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=3EucsD3jWzekhjyzL2y0dyUsucd-aqC9glmgPL0Ubb4,12425
+ripple_down_rules/datastructures/case.py,sha256=r8kjL9xP_wk84ThXusspgPMrAoed2bGQmKi54fzhmH8,15258
+ripple_down_rules/datastructures/dataclasses.py,sha256=PuD-7zWqWT2p4FnGvnihHvZlZKg9A1ctnFgVYf2cs-8,8554
+ripple_down_rules/datastructures/enums.py,sha256=ce7tqS0otfSTNAOwsnXlhsvIn4iW_Y_N3TNebF3YoZs,5700
+ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/user_interface/gui.py,sha256=SB0gUhgReJ3yx-NEHRPMGVuNRLPRUwW8-qup-Kd4Cfo,27182
+ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=24MIFwqnAhC6ofObEO6x5xRWRnyQmPpPmTvxbCKBrzM,6514
+ripple_down_rules/user_interface/object_diagram.py,sha256=tsB6iuLNEbHxp5lR2WjyejjWbnAX_nHF9xS8jNPOQVk,4548
+ripple_down_rules/user_interface/prompt.py,sha256=AkkltdDIaioN43lkRKDPKSjJcmdSSGZDMYz7AL7X9lE,8082
+ripple_down_rules/user_interface/template_file_creator.py,sha256=ycCbddy_BJP8d0Q2Sj21UzamhGtqGZuK_e73VTJqznY,13766
+ripple_down_rules-0.4.9.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.4.9.dist-info/METADATA,sha256=T-Q5WS_rd2wJsVcip0d6-so4qlvygGnUdsYBWLVBKEE,43306
+ripple_down_rules-0.4.9.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+ripple_down_rules-0.4.9.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.4.9.dist-info/RECORD,,