ripple-down-rules 0.6.28__py3-none-any.whl → 0.6.30__py3-none-any.whl

ripple_down_rules/rdr.py

@@ -13,7 +13,6 @@ from . import logger
 
 try:
     from matplotlib import pyplot as plt
-
     Figure = plt.Figure
 except ImportError as e:
     logger.debug(f"{e}: matplotlib is not installed")
@@ -90,23 +89,13 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param save_dir: The directory to save the classifier to.
         """
         self.model_name: Optional[str] = model_name
-        self.save_dir = save_dir
-        self.start_rule = start_rule
+        self.save_dir: Optional[str] = save_dir
+        self.start_rule: Optional[Rule] = start_rule
         self.fig: Optional[Figure] = None
         self.viewer: Optional[RDRCaseViewer] = RDRCaseViewer.instances[0]\
             if RDRCaseViewer and any(RDRCaseViewer.instances) else None
         self.input_node: Optional[Rule] = None
 
-    @property
-    def viewer(self):
-        return self._viewer
-
-    @viewer.setter
-    def viewer(self, viewer):
-        self._viewer = viewer
-        if viewer:
-            viewer.set_save_function(self.save)
-
     def render_evaluated_rule_tree(self, filename: str, show_full_tree: bool = False) -> None:
         if show_full_tree:
             start_rule = self.start_rule if self.input_node is None else self.input_node
@@ -117,6 +106,26 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 render_tree(evaluated_rules[0], use_dot_exporter=True, filename=filename,
                             only_nodes=evaluated_rules)
 
+    def get_contributing_rules(self) -> Optional[List[Rule]]:
+        """
+        Get the contributing rules of the classifier.
+
+        :return: The contributing rules.
+        """
+        if self.start_rule is None:
+            return None
+        return [r for r in self.get_fired_rule_tree() if r.contributed]
+
+    def get_fired_rule_tree(self) -> Optional[List[Rule]]:
+        """
+        Get the fired rule tree of the classifier.
+
+        :return: The fired rule tree.
+        """
+        if self.start_rule is None:
+            return None
+        return [r for r in self.get_evaluated_rule_tree() if r.fired]
+
     def get_evaluated_rule_tree(self) -> Optional[List[Rule]]:
         """
         Get the evaluated rule tree of the classifier.
@@ -196,16 +205,6 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         pass
 
-    def set_viewer(self, viewer: RDRCaseViewer):
-        """
-        Set the viewer for the classifier.
-
-        :param viewer: The viewer to set.
-        """
-        self.viewer = viewer
-        if self.viewer is not None:
-            self.viewer.set_save_function(self.save)
-
     def fit(self, case_queries: List[CaseQuery],
             expert: Optional[Expert] = None,
             n_iter: int = None,
@@ -230,7 +229,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         num_rules: int = 0
         while not stop_iterating:
             for case_query in case_queries:
-                pred_cat = self.fit_case(case_query, expert=expert, **kwargs_for_fit_case)
+                pred_cat = self.fit_case(case_query, expert=expert, clear_expert_answers=False,
+                                         **kwargs_for_fit_case)
                 if case_query.target is None:
                     continue
                 target = {case_query.attribute_name: case_query.target(case_query.case)}
@@ -272,8 +272,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         if self.start_rule is not None:
             for rule in [self.start_rule] + list(self.start_rule.descendants):
-                rule.evaluated = False
-                rule.fired = False
+                rule.reset()
         if self.start_rule is not None and self.start_rule.parent is None:
             if self.input_node is None:
                 self.input_node = type(self.start_rule)(parent=None, uid='0')
@@ -308,6 +307,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                  update_existing_rules: bool = True,
                  scenario: Optional[Callable] = None,
                  ask_now: Callable = lambda _: True,
+                 clear_expert_answers: bool = True,
                  **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
@@ -319,7 +319,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param update_existing_rules: Whether to update the existing same conclusion type rules that already gave
         some conclusions with the type required by the case query.
         :param scenario: The scenario at which the case was created, this is used to recreate the case if needed.
-        :ask_now: Whether to ask the expert for refinements or alternatives.
+        :param ask_now: Whether to ask the expert for refinements or alternatives.
+        :param clear_expert_answers: Whether to clear expert answers after saving the new rule.
         :return: The category that the case belongs to.
         """
         if case_query is None:
@@ -329,6 +330,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         self.case_type = case_query.case_type if self.case_type is None else self.case_type
         self.case_name = case_query.case_name if self.case_name is None else self.case_name
         case_query.scenario = scenario if case_query.scenario is None else case_query.scenario
+        case_query.rdr = self
 
         expert = expert or Human(answers_save_path=self.save_dir + '/expert_answers'
                                  if self.save_dir else None)
@@ -348,7 +350,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
         if self.save_dir is not None:
             self.save()
-            expert.clear_answers()
+            if clear_expert_answers:
+                expert.clear_answers()
 
         return fit_case_result
 
@@ -767,6 +770,11 @@ class SingleClassRDR(RDRWithCodeWriter):
         """
         pred = self.evaluate(case)
         conclusion = pred.conclusion(case) if pred is not None and pred.fired else self.default_conclusion
+        if pred is not None and pred.fired:
+            pred.contributed = True
+            pred.last_conclusion = conclusion
+            if case_query is not None:
+                pred.contributed_to_case_query = True
         if pred is not None and pred.fired and case_query is not None:
             if pred.corner_case_metadata is None and conclusion is not None \
                     and type(conclusion) in case_query.core_attribute_type:
@@ -884,6 +892,13 @@ class MultiClassRDR(RDRWithCodeWriter):
                             and any(
                         ct in case_query.core_attribute_type for ct in map(type, make_list(rule_conclusion))):
                         evaluated_rule.corner_case_metadata = CaseFactoryMetaData.from_case_query(case_query)
+                if rule_conclusion is not None and any(make_list(rule_conclusion)):
+                    evaluated_rule.contributed = True
+                    evaluated_rule.last_conclusion = rule_conclusion
+                    if case_query is not None:
+                        rule_conclusion_types = set(map(type, make_list(rule_conclusion)))
+                        if any(rule_conclusion_types.intersection(set(case_query.core_attribute_type))):
+                            evaluated_rule.contributed_to_case_query = True
                 self.add_conclusion(rule_conclusion)
             evaluated_rule = next_rule
         return make_set(self.conclusions)
@@ -978,7 +993,7 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         if not self.start_rule:
             conditions = expert.ask_for_conditions(case_query)
-            self.start_rule = MultiClassTopRule.from_case_query(case_query)
+            self.start_rule: MultiClassTopRule = MultiClassTopRule.from_case_query(case_query)
 
     @property
     def last_top_rule(self) -> Optional[MultiClassTopRule]:

ripple_down_rules/rules.py

@@ -63,6 +63,9 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         self.uid: str = uid if uid else str(uuid4().int)
         self.evaluated: bool = False
         self._user_defined_name: Optional[str] = None
+        self.last_conclusion: Optional[Any] = None
+        self.contributed: bool = False
+        self.contributed_to_case_query: bool = False
 
     def get_an_updated_case_copy(self, case: Case) -> Case:
         """
@@ -72,11 +75,22 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         return get_an_updated_case_copy(case, self.conclusion, self.conclusion_name, self.conclusion.conclusion_type,
                                         self.mutually_exclusive)
 
+    def reset(self):
+        self.evaluated = False
+        self.fired = False
+        self.contributed = False
+        self.contributed_to_case_query = False
+        self.last_conclusion = None
+
     @property
     def color(self) -> str:
         if self.evaluated:
-            if self.fired:
+            if self.contributed_to_case_query:
                 return "green"
+            elif self.contributed:
+                return "yellow"
+            elif self.fired:
+                return "orange"
             else:
                 return "red"
         else:

ripple_down_rules/user_interface/gui.py

@@ -1,15 +1,19 @@
-from  __future__ import annotations
+from __future__ import annotations
 
 import inspect
 import logging
+import os.path
 from types import MethodType
 
+from graphviz import Digraph, Source
+
 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
+        QSizePolicy, QToolButton, QHBoxLayout, QPushButton, QMainWindow, QGraphicsView, QGraphicsScene,
+        QGraphicsPixmapItem
     )
     from qtconsole.inprocess import QtInProcessKernelManager
     from qtconsole.rich_jupyter_widget import RichJupyterWidget
@@ -120,7 +124,7 @@ class BackgroundWidget(QWidget):
 
 
 class CollapsibleBox(QWidget):
-    def __init__(self, title="", parent=None, viewer: Optional[RDRCaseViewer]=None, chain_name: Optional[str] = None,
+    def __init__(self, title="", parent=None, viewer: Optional[RDRCaseViewer] = None, chain_name: Optional[str] = None,
                  main_obj: Optional[Dict[str, Any]] = None):
         super().__init__(parent)
 
@@ -259,12 +263,14 @@ def color_name_to_html(color_name):
         'g': 'green',
         'b': 'blue',
         'o': 'orange',
+        'm': 'magenta',
     }
     color_map = {
         'red': '#d6336c',
         'green': '#2eb872',
         'blue': '#007acc',
         'orange': '#FFA07A',
+        'magenta': '#a22bcf',
     }
     if len(color_name) == 1:
         color_name = single_char_to_name.get(color_name, color_name)
@@ -285,16 +291,10 @@ class RDRCaseViewer(QMainWindow):
     instances: List[RDRCaseViewer] = []
     exit_status: ExitStatus = ExitStatus.CLOSE
 
-    def __init__(self, parent=None,
-                 save_dir: Optional[str] = None,
-                 save_model_name: Optional[str] = None):
+    def __init__(self, parent=None):
         super().__init__(parent)
-        self.exit_status = ExitStatus.CLOSE
         self.instances.clear()
         self.instances.append(self)
-        self.save_dir = save_dir
-        self.save_model_name = save_model_name
-
         self.setWindowTitle("RDR Case Viewer")
 
         self.setBaseSize(1600, 600)  # or your preferred initial size
@@ -333,35 +333,28 @@ class RDRCaseViewer(QMainWindow):
         main_layout.addWidget(middle_widget, stretch=2)
         main_layout.addWidget(self.obj_diagram_viewer, stretch=2)
 
-    def set_save_function(self, save_function: Callable[[str, str], None]) -> None:
-        """
-        Set the function to save the file.
-
-        :param save_function: The function to save the file.
-        """
-        self.save_function = save_function
-        self.save_btn.clicked.connect(lambda: self.save_function(self.save_dir, self.save_model_name))
-
     def print(self, msg):
         """
         Print a message to the console.
         """
         self.ipython_console._append_plain_text(msg + '\n', True)
 
-    def update_for_case_query(self, case_query: CaseQuery, title_txt: Optional[str] = None,
-                              prompt_for: Optional[PromptFor] = None, code_to_modify: Optional[str] = None):
+    def update_for_case_query(self, case_query: CaseQuery, prompt_str: Optional[str] = None,
+                              prompt_for: Optional[PromptFor] = None, code_to_modify: Optional[str] = None,
+                              title: Optional[str] = None):
         self.case_query = case_query
         self.prompt_for = prompt_for
         self.code_to_modify = code_to_modify
-        title_text = title_txt or ""
+        title_text = title or ""
         case_attr_type = ', '.join([t.__name__ for t in case_query.core_attribute_type])
         case_attr_type = style(f"{case_attr_type}", 'g', 28, 'bold')
         case_name = style(f"{case_query.name}", 'b', 28, 'bold')
         title_text = style(f"{title_text} {case_name} of type {case_attr_type}", 'o', 28, 'bold')
-        self.update_for_object(case_query.case, case_query.case_name, case_query.scope, title_text)
+        self.update_for_object(case_query.case, case_query.case_name, scope=case_query.scope, title_text=title_text,
+                               header=prompt_str)
 
     def update_for_object(self, obj: Any, name: str, scope: Optional[dict] = None,
-                          title_text: Optional[str] = None):
+                          title_text: Optional[str] = None, header: Optional[str] = None):
         self.update_main_obj(obj, name)
         title_text = title_text or style(f"{name}", 'o', 28, 'bold')
         scope = scope or {}
@@ -370,6 +363,9 @@ class RDRCaseViewer(QMainWindow):
         self.update_attribute_layout(obj, name)
         self.title_label.setText(title_text)
         self.ipython_console.update_namespace(scope)
+        if header is not None and len(header) > 0:
+            self.ipython_console.print(header)
+        self.exit_status = ExitStatus.CLOSE
 
     def update_main_obj(self, obj, name):
         self.main_obj = {name: obj}
@@ -441,8 +437,6 @@ class RDRCaseViewer(QMainWindow):
                 if isinstance(item.widget(), CollapsibleBox):
                     self.expand_collapse_all(item.widget(), expand=True, curr_depth=curr_depth + 1, max_depth=max_depth)
 
-
-
     def create_buttons_widget(self):
         button_widget = QWidget()
         button_widget_layout = QVBoxLayout(button_widget)
@@ -466,13 +460,19 @@ class RDRCaseViewer(QMainWindow):
         load_btn.clicked.connect(self._load)
         load_btn.setStyleSheet(f"background-color: {color_name_to_html('b')}; color: white;")  # Blue button
 
-        self.save_btn = QPushButton("Save")
-        self.save_btn.setStyleSheet(f"background-color: {color_name_to_html('b')}; color: white;")  # Blue button
+        current_value_btn = QPushButton("Current Value")
+        current_value_btn.clicked.connect(self._show_current_value)
+        current_value_btn.setStyleSheet(f"background-color: {color_name_to_html('m')}; color: white;")
+
+        rule_tree_btn = QPushButton("Rule Tree")
+        rule_tree_btn.clicked.connect(self._show_rule_tree)  # Placeholder for rule tree functionality
+        rule_tree_btn.setStyleSheet(f"background-color: {color_name_to_html('r')}; color: white;")
 
         row_1_button_widget_layout.addWidget(edit_btn)
         row_1_button_widget_layout.addWidget(load_btn)
-        row_1_button_widget_layout.addWidget(accept_btn)
-        row_2_button_widget_layout.addWidget(self.save_btn)
+        row_1_button_widget_layout.addWidget(current_value_btn)
+        row_2_button_widget_layout.addWidget(rule_tree_btn)
+        row_2_button_widget_layout.addWidget(accept_btn)
         return button_widget
 
     def _accept(self):
@@ -481,16 +481,15 @@ class RDRCaseViewer(QMainWindow):
         self.close()
 
     def _edit(self):
-        self.template_file_creator = TemplateFileCreator(self.case_query, self.prompt_for, self.code_to_modify,
-                                                         self.print)
+        self.template_file_creator = self.create_template_file_creator()
         self.template_file_creator.edit()
 
     def _load(self):
         if not self.template_file_creator:
             return
         self.code_lines, updates = self.template_file_creator.load(self.template_file_creator.temp_file_path,
-                                                                    self.template_file_creator.func_name,
-                                                                    self.template_file_creator.print_func)
+                                                                   self.template_file_creator.func_name,
+                                                                   self.template_file_creator.print_func)
         self.ipython_console.kernel.shell.user_ns.update(updates)
         if self.code_lines is not None:
             self.user_input = encapsulate_code_lines_into_a_function(
@@ -498,7 +497,22 @@ class RDRCaseViewer(QMainWindow):
                 self.template_file_creator.function_signature,
                 self.template_file_creator.func_doc, self.case_query)
             self.case_query.scope.update(updates)
-        self.template_file_creator = None
+
+    def _show_current_value(self):
+        self.ipython_console.print(self.case_query.current_value_str)
+
+    def _show_rule_tree(self):
+        if self.case_query is None:
+            self.ipython_console.print("No case query provided.")
+            return
+        if not self.case_query.rdr:
+            self.ipython_console.print("No rule tree available for this case query.")
+            return
+        self.case_query.render_rule_tree(view=True)
+
+    def create_template_file_creator(self) -> TemplateFileCreator:
+        return TemplateFileCreator(self.case_query, self.prompt_for, self.code_to_modify,
+                                   self.print)
 
     def update_attribute_layout(self, obj, name: str):
         # Clear the existing layout
@@ -547,7 +561,8 @@ class RDRCaseViewer(QMainWindow):
             attr = f"{attr}"
             try:
                 if is_iterable(value) or hasattr(value, "__dict__") and not inspect.isfunction(value):
-                    self.add_collapsible(attr, value, layout, current_depth + 1, max_depth, chain_name=f"{chain_name}.{attr}")
+                    self.add_collapsible(attr, value, layout, current_depth + 1, max_depth,
+                                         chain_name=f"{chain_name}.{attr}")
                 else:
                     self.add_non_collapsible(attr, value, layout)
             except Exception as e:
@@ -559,7 +574,7 @@ class RDRCaseViewer(QMainWindow):
         type_name = type(value) if not isinstance(value, type) else value
         collapsible = CollapsibleBox(
             f'<b><span style="color:#FFA07A;">{attr}</span></b> {python_colored_repr(type_name)}', viewer=self,
-        chain_name=chain_name, main_obj=self.main_obj)
+            chain_name=chain_name, main_obj=self.main_obj)
         self.add_attributes(value, attr, collapsible.content_layout, current_depth, max_depth, chain_name=chain_name)
         layout.addWidget(collapsible)
 
@@ -587,7 +602,6 @@ class IPythonConsole(RichJupyterWidget):
 
         # Monkey patch its run_cell method
         def custom_run_cell(this, raw_cell, **kwargs):
-            print(raw_cell)
             if contains_return_statement(raw_cell) and 'def ' not in raw_cell:
                 if self.parent.template_file_creator and self.parent.template_file_creator.func_name in raw_cell:
                     self.command_log = self.parent.code_lines
@@ -601,7 +615,6 @@ class IPythonConsole(RichJupyterWidget):
 
         original_run_cell = self.kernel.shell.run_cell
         self.kernel.shell.run_cell = MethodType(custom_run_cell, self.kernel.shell)
-
         self.kernel_client = self.kernel_manager.client()
         self.kernel_client.start_channels()
 
@@ -630,7 +643,7 @@ class IPythonConsole(RichJupyterWidget):
     .in-prompt { font-weight: bold; color: %(in_prompt_color)s }
     .out-prompt-number { font-weight: bold; color: %(out_prompt_number_color)s }
     .out-prompt { font-weight: bold; color: %(out_prompt_color)s }
-'''%dict(
+''' % dict(
             bgcolor='#0b0d0b', fgcolor='#47d9cc', select="#555",
             in_prompt_number_color='lime', in_prompt_color='lime',
             out_prompt_number_color='red', out_prompt_color='red'
@@ -648,6 +661,12 @@ class IPythonConsole(RichJupyterWidget):
         """
         self.kernel.shell.user_ns.update(namespace)
 
+    def print(self, msg):
+        """
+        Custom print function to append messages to the command log.
+        """
+        self.execute(f"print(\"\\n\\n{msg}\")", hidden=True)
+
     def execute(self, source=None, hidden=False, interactive=False):
         # Log the command before execution
         source = source if source is not None else self.input_buffer

ripple_down_rules/user_interface/ipython_custom_shell.py

@@ -1,4 +1,5 @@
 import logging
+import os
 from typing import Optional, List
 
 from IPython.core.magic import magics_class, Magics, line_magic
@@ -6,9 +7,9 @@ from IPython.terminal.embed import InteractiveShellEmbed
 from colorama import Fore, Style
 from traitlets.config import Config
 
+from .template_file_creator import TemplateFileCreator
 from ..datastructures.dataclasses import CaseQuery
 from ..datastructures.enums import PromptFor
-from .template_file_creator import TemplateFileCreator
 from ..utils import contains_return_statement, extract_dependencies, encapsulate_code_lines_into_a_function
 
 
@@ -20,6 +21,7 @@ class MyMagics(Magics):
                  prompt_for: Optional[PromptFor] = None,
                  case_query: Optional[CaseQuery] = None):
         super().__init__(shell)
+        self.case_query: Optional[CaseQuery] = case_query
         self.rule_editor = TemplateFileCreator(case_query, prompt_for=prompt_for, code_to_modify=code_to_modify)
         self.all_code_lines: Optional[List[str]] = None
 
@@ -34,6 +36,29 @@ class MyMagics(Magics):
                                                              self.rule_editor.print_func)
         self.shell.user_ns.update(updates)
 
+    @line_magic
+    def current_value(self, line):
+        """
+        Display the current value of the attribute of the case.
+        """
+        if self.case_query is None:
+            print(f"{Fore.RED}No case query provided.{Style.RESET_ALL}")
+            return
+        print(self.case_query.current_value_str)
+
+    @line_magic
+    def show_rule_tree(self, line):
+        """
+        Display the rule tree for the current case query.
+        """
+        if self.case_query is None:
+            print(f"{Fore.RED}No case query provided.{Style.RESET_ALL}")
+            return
+        if self.case_query.rdr is None:
+            print(f"{Fore.RED}No RDR available for the current case query.{Style.RESET_ALL}")
+            return
+        self.case_query.render_rule_tree(view=True)
+
     @line_magic
     def help(self, line):
         """
@@ -42,12 +67,16 @@ class MyMagics(Magics):
         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}
+{Fore.MAGENTA}%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}
+{Fore.MAGENTA}%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)`.
+{Fore.MAGENTA}%current_value{Style.RESET_ALL}
+Shows the current value of the case attribute on which the rule are being fit.
+{Fore.MAGENTA}%show_rule_tree{Style.RESET_ALL}
+Displays the rule tree for the current case query.
         """
         print(help_text)
 
@@ -144,7 +173,7 @@ class IPythonShell:
                 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)
+                                                                         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)