ripple-down-rules 0.1.21__py3-none-any.whl → 0.1.62__py3-none-any.whl

ripple_down_rules/experts.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 import json
 from abc import ABC, abstractmethod
 
-from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColumn, Session
-from typing_extensions import Optional, Dict, TYPE_CHECKING, List, Tuple, Type, Union, Any, get_type_hints
+from typing_extensions import Optional, Dict, TYPE_CHECKING, List, Type, Any
 
-from .datastructures import (Case, PromptFor, CallableExpression, CaseAttribute, CaseQuery)
+from .datastructures.case import Case, CaseAttribute
+from .datastructures.callable_expression import CallableExpression
+from .datastructures.enums import PromptFor
+from .datastructures.dataclasses import CaseQuery
 from .datastructures.case import show_current_and_corner_cases
-from .prompt import prompt_user_for_expression, prompt_user_about_case
-from .utils import get_all_subclasses, is_iterable
+from .prompt import prompt_user_for_expression, IPythonShell
+from .utils import get_all_subclasses, make_list
 
 if TYPE_CHECKING:
     from .rdr import Rule
@@ -49,28 +51,24 @@ class Expert(ABC):
         pass
 
     @abstractmethod
-    def ask_for_extra_conclusions(self, x: Case, current_conclusions: List[CaseAttribute]) \
-            -> Dict[CaseAttribute, CallableExpression]:
+    def ask_for_extra_rules(self, case_query: CaseQuery) -> List[Dict[PromptFor, CallableExpression]]:
         """
-        Ask the expert to provide extra conclusions for a case by providing a pair of category and conditions for
-        that category.
+        Ask the expert to provide extra rules for a case by providing a pair of conclusion and conditions.
 
-        :param x: The case to classify.
-        :param current_conclusions: The current conclusions for the case.
-        :return: The extra conclusions for the case.
+        :param case_query: The case query containing the case to classify.
+        :return: The extra rules for the case as a list of dictionaries, where each dictionary contains the
+                    conclusion and conditions for the rule.
         """
         pass
 
     @abstractmethod
-    def ask_if_conclusion_is_correct(self, x: Case, conclusion: CaseAttribute,
-                                     targets: Optional[List[CaseAttribute]] = None,
-                                     current_conclusions: Optional[List[CaseAttribute]] = None) -> bool:
+    def ask_if_conclusion_is_correct(self, case_query: CaseQuery, conclusion: Any,
+                                     current_conclusions: Any) -> bool:
         """
         Ask the expert if the conclusion is correct.
 
-        :param x: The case to classify.
+        :param case_query: The case query about which the expert should answer.
         :param conclusion: The conclusion to check.
-        :param targets: The target categories to compare the case with.
         :param current_conclusions: The current conclusions for the case.
         """
         pass
@@ -89,10 +87,9 @@ class Human(Expert):
     The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
     """
 
-    def __init__(self, use_loaded_answers: bool = False, session: Optional[Session] = None):
+    def __init__(self, use_loaded_answers: bool = False):
         self.all_expert_answers = []
         self.use_loaded_answers = use_loaded_answers
-        self.session = session
 
     def save_answers(self, path: str, append: bool = False):
         """
@@ -129,6 +126,24 @@ class Human(Expert):
                                           last_evaluated_rule=last_evaluated_rule)
         return self._get_conditions(case_query)
 
+    def ask_for_extra_rules(self, case_query: CaseQuery) -> List[Dict[PromptFor, CallableExpression]]:
+        """
+        Ask the expert to provide extra rules for a case by providing a pair of conclusion and conditions.
+
+        :param case_query: The case query containing the case to classify.
+        :return: The extra rules for the case as a list of dictionaries, where each dictionary contains the
+                    conclusion and conditions for the rule.
+        """
+        rules = []
+        while True:
+            conclusion = self.ask_for_conclusion(case_query)
+            if conclusion is None:
+                break
+            conditions = self._get_conditions(case_query)
+            rules.append({PromptFor.Conclusion: conclusion,
+                         PromptFor.Conditions: conditions})
+        return rules
+
     def _get_conditions(self, case_query: CaseQuery) \
             -> CallableExpression:
         """
@@ -142,47 +157,30 @@ class Human(Expert):
         if self.use_loaded_answers:
             user_input = self.all_expert_answers.pop(0)
         if user_input:
-            condition = CallableExpression(user_input, bool, scope=case_query.scope, session=self.session)
+            condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
-            user_input, condition = prompt_user_for_expression(case_query, PromptFor.Conditions, session=self.session)
+            user_input, condition = prompt_user_for_expression(case_query, PromptFor.Conditions)
         if not self.use_loaded_answers:
             self.all_expert_answers.append(user_input)
         case_query.conditions = condition
         return condition
 
-    def ask_for_extra_conclusions(self, case: Case, current_conclusions: List[CaseAttribute]) \
-            -> Dict[CaseAttribute, CallableExpression]:
-        """
-        Ask the expert to provide extra conclusions for a case by providing a pair of category and conditions for
-        that category.
-
-        :param case: The case to classify.
-        :param current_conclusions: The current conclusions for the case.
-        :return: The extra conclusions for the case.
-        """
-        extra_conclusions = {}
-        while True:
-            category = self.ask_for_conclusion(CaseQuery(case), current_conclusions)
-            if not category:
-                break
-            extra_conclusions[category] = self._get_conditions(case, {category.__class__.__name__: category})
-        return extra_conclusions
-
-    def ask_for_conclusion(self, case_query: CaseQuery) -> CaseQuery:
+    def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
         """
         Ask the expert to provide a conclusion for the case.
 
         :param case_query: The case query containing the case to find a conclusion for.
-        :return: The case query updated with the conclusion for the case.
+        :return: The conclusion for the case as a callable expression.
         """
+        expression: Optional[CallableExpression] = None
         if self.use_loaded_answers:
             expert_input = self.all_expert_answers.pop(0)
-            expression = CallableExpression(expert_input, case_query.attribute_type, session=self.session,
-                                            scope=case_query.scope)
+            if expert_input is not None:
+                expression = CallableExpression(expert_input, case_query.attribute_type,
+                                                scope=case_query.scope)
         else:
             show_current_and_corner_cases(case_query.case)
-            expert_input, expression = prompt_user_for_expression(case_query, PromptFor.Conclusion,
-                                                                  session=self.session)
+            expert_input, expression = prompt_user_for_expression(case_query, PromptFor.Conclusion)
             self.all_expert_answers.append(expert_input)
         case_query.target = expression
         return expression
@@ -195,7 +193,8 @@ class Human(Expert):
         :return: The category type.
         """
         cat_name = cat_name.lower()
-        self.known_categories = get_all_subclasses(CaseAttribute) if not self.known_categories else self.known_categories
+        self.known_categories = get_all_subclasses(
+            CaseAttribute) if not self.known_categories else self.known_categories
         self.known_categories.update(CaseAttribute.registry)
         category_type = None
         if cat_name in self.known_categories:
@@ -209,45 +208,39 @@ class Human(Expert):
         :param category_name: The name of the category to ask about.
         """
         question = f"Can a case have multiple values of the new category {category_name}? (y/n):"
-        return not self.ask_yes_no_question(question)
+        return not self.ask_for_affirmation(question)
 
-    def ask_if_conclusion_is_correct(self, x: Case, conclusion: CaseAttribute,
-                                     targets: Optional[List[CaseAttribute]] = None,
-                                     current_conclusions: Optional[List[CaseAttribute]] = None) -> bool:
+    def ask_if_conclusion_is_correct(self, case_query: CaseQuery, conclusion: Any,
+                                     current_conclusions: Any) -> bool:
         """
         Ask the expert if the conclusion is correct.
 
-        :param x: The case to classify.
+        :param case_query: The case query about which the expert should answer.
         :param conclusion: The conclusion to check.
-        :param targets: The target categories to compare the case with.
         :param current_conclusions: The current conclusions for the case.
         """
-        question = ""
         if not self.use_loaded_answers:
-            targets = targets or []
-            targets = targets if isinstance(targets, list) else [targets]
-            x.conclusions = current_conclusions
-            x.targets = targets
-            question = f"Is the conclusion {conclusion} correct for the case (y/n):" \
-                       f"\n{str(x)}"
-        return self.ask_yes_no_question(question)
+            print(f"Current conclusions: {current_conclusions}")
+        return self.ask_for_affirmation(case_query,
+                                        f"Is the conclusion {conclusion} correct for the case (True/False):")
 
-    def ask_yes_no_question(self, question: str) -> bool:
+    def ask_for_affirmation(self, case_query: CaseQuery, question: str) -> bool:
         """
         Ask the expert a yes or no question.
 
-        :param question: The question to ask.
+        :param case_query: The case query about which the expert should answer.
+        :param question: The question to ask the expert.
         :return: The answer to the question.
         """
-        if not self.use_loaded_answers:
-            print(question)
         while True:
             if self.use_loaded_answers:
                 answer = self.all_expert_answers.pop(0)
             else:
-                answer = input()
-                self.all_expert_answers.append(answer)
-            if answer.lower() == "y":
+                _, expression = prompt_user_for_expression(case_query, PromptFor.Affirmation, question)
+                answer = expression(case_query.case)
+            if answer:
+                self.all_expert_answers.append(True)
                 return True
-            elif answer.lower() == "n":
+            else:
+                self.all_expert_answers.append(False)
                 return False

ripple_down_rules/helpers.py

@@ -1,10 +1,34 @@
+from __future__ import annotations
+
 import os
 
+from .datastructures.dataclasses import CaseQuery
 from sqlalchemy.orm import Session
-from typing_extensions import Type, Optional
+from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING
+
+from .utils import get_func_rdr_model_path
+from .utils import calculate_precision_and_recall
+
+if TYPE_CHECKING:
+    from .rdr import RippleDownRules
 
-from ripple_down_rules.rdr import RippleDownRules
-from ripple_down_rules.utils import get_func_rdr_model_path
+
+def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+    """
+    :param classifier: The RDR classifier to check the prediction of.
+    :param case_query: The case query to check.
+    :param pred_cat: The predicted category.
+    :return: Whether the classifier prediction is matching case_query target or not.
+    """
+    if case_query.target is None:
+        return False
+    if pred_cat is None:
+        pred_cat = classifier(case_query.case)
+    if not isinstance(pred_cat, dict):
+        pred_cat = {case_query.attribute_name: pred_cat}
+    target = {case_query.attribute_name: case_query.target_value}
+    precision, recall = calculate_precision_and_recall(pred_cat, target)
+    return all(recall) and all(precision)
 
 
 def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDownRules],

ripple_down_rules/prompt.py

@@ -2,84 +2,118 @@ import ast
 import logging
 from _ast import AST
 
-from IPython.core.interactiveshell import ExecutionInfo
 from IPython.terminal.embed import InteractiveShellEmbed
 from traitlets.config import Config
-from prompt_toolkit import PromptSession
-from prompt_toolkit.completion import WordCompleter
-from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
-from typing_extensions import Any, List, Optional, Tuple, Dict, Union, Type
+from typing_extensions import List, Optional, Tuple, Dict
 
-from .datastructures import Case, PromptFor, CallableExpression, create_case, parse_string_to_expression, CaseQuery
-from .utils import capture_variable_assignment
+from .datastructures.enums import PromptFor
+from .datastructures.callable_expression import CallableExpression, parse_string_to_expression
+from .datastructures.dataclasses import CaseQuery
+from .utils import extract_dependencies, contains_return_statement, make_set
 
 
-class IpythonShell:
+class CustomInteractiveShell(InteractiveShellEmbed):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.all_lines = []
+
+    def run_cell(self, raw_cell: str, **kwargs):
+        """
+        Override the run_cell method to capture return statements.
+        """
+        if contains_return_statement(raw_cell):
+            self.all_lines.append(raw_cell)
+            print("Exiting shell on `return` statement.")
+            self.history_manager.store_inputs(line_num=self.execution_count, source=raw_cell)
+            self.ask_exit()
+            return None
+        result = super().run_cell(raw_cell, **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, variable_to_capture: str, scope: Optional[Dict] = None, header: Optional[str] = None):
+
+    def __init__(self, scope: Optional[Dict] = None, header: Optional[str] = None):
         """
         Initialize the Ipython shell with the given scope and header.
 
-        :param variable_to_capture: The variable to capture from the user input.
         :param scope: The scope to use for the shell.
         :param header: The header to display when the shell is started.
         """
-        self.variable_to_capture: str = variable_to_capture
         self.scope: Dict = scope or {}
         self.header: str = header or ">>> Embedded Ipython Shell"
         self.user_input: Optional[str] = None
-        self.shell: InteractiveShellEmbed = self._init_shell()
-        self._register_hooks()
+        self.shell: CustomInteractiveShell = self._init_shell()
+        self.all_code_lines: List[str] = []
 
     def _init_shell(self):
         """
         Initialize the Ipython shell with a custom configuration.
         """
         cfg = Config()
-        shell = InteractiveShellEmbed(config=cfg, user_ns=self.scope, banner1=self.header)
+        shell = CustomInteractiveShell(config=cfg, user_ns=self.scope, banner1=self.header)
         return shell
 
-    def _register_hooks(self):
-        """
-        Register hooks to capture specific events in the Ipython shell.
-        """
-        def capture_variable(exec_info: ExecutionInfo):
-            code = exec_info.raw_cell
-            if self.variable_to_capture not in code:
-                return
-            # use ast to find if the user is assigning a value to the variable "condition"
-            assignment = capture_variable_assignment(code, self.variable_to_capture)
-            if assignment:
-                # if the user is assigning a value to the variable "condition", update the raw_condition
-                self.user_input = assignment
-                print(f"[Captured {self.variable_to_capture}]:\n{self.user_input}")
-
-        self.shell.events.register('pre_run_cell', capture_variable)
-
     def run(self):
         """
         Run the embedded shell.
         """
-        self.shell()
-
-
-def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor,
-                               session: Optional[Session] = None) -> Tuple[str, CallableExpression]:
+        while True:
+            try:
+                self.shell()
+                self.update_user_input_from_code_lines()
+                break
+            except Exception as e:
+                logging.error(e)
+                print(e)
+
+    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:
+                if self.all_code_lines[0].strip() == '':
+                    self.user_input = None
+                else:
+                    self.user_input = self.all_code_lines[0].replace('return', '').strip()
+            else:
+                self.user_input = f"def _get_value(case):\n    "
+                for cl in self.all_code_lines:
+                    sub_code_lines = cl.split('\n')
+                    self.user_input += '\n    '.join(sub_code_lines) + '\n    '
+
+
+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.
 
     :param case_query: The case query to prompt the user for.
     :param prompt_for: The type of information ask user about.
-    :param session: The sqlalchemy orm session.
+    :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.
     """
     while True:
-        user_input, expression_tree = prompt_user_about_case(case_query, prompt_for)
+        user_input, expression_tree = prompt_user_about_case(case_query, prompt_for, prompt_str)
+        if user_input is None:
+            if prompt_for == PromptFor.Conclusion:
+                print("No conclusion provided. Exiting.")
+                return None, None
+            else:
+                print("Conditions must be provided. Please try again.")
+                continue
         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, session=session)
+                                                 scope=case_query.scope)
         try:
             callable_expression(case_query.case)
             break
@@ -89,37 +123,26 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor,
     return user_input, callable_expression
 
 
-def prompt_user_about_case(case_query: CaseQuery, prompt_for: PromptFor) -> Tuple[str, AST]:
+def prompt_user_about_case(case_query: CaseQuery, prompt_for: PromptFor,
+                           prompt_str: 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.
     :return: The user input, and the executable expression that was parsed from the user input.
     """
-    prompt_str = f"Give {prompt_for} for {case_query.name}"
+    if prompt_str is None:
+        prompt_str = f"Give {prompt_for} for {case_query.name}"
     scope = {'case': case_query.case, **case_query.scope}
-    shell = IpythonShell(prompt_for.value, scope=scope, header=prompt_str)
-    user_input, expression_tree = prompt_user_input_and_parse_to_expression(shell=shell)
-    return user_input, expression_tree
-
-
-def get_completions(obj: Any) -> List[str]:
-    """
-    Get all completions for the object. This is used in the python prompt shell to provide completions for the user.
-
-    :param obj: The object to get completions for.
-    :return: A list of completions.
-    """
-    # Define completer with all object attributes and comparison operators
-    completions = ['==', '!=', '>', '<', '>=', '<=', 'in', 'not', 'and', 'or', 'is']
-    completions += ["isinstance(", "issubclass(", "type(", "len(", "hasattr(", "getattr(", "setattr(", "delattr("]
-    completions += list(create_case(obj).keys())
-    return completions
+    shell = IPythonShell(scope=scope, header=prompt_str)
+    return prompt_user_input_and_parse_to_expression(shell=shell)
 
 
-def prompt_user_input_and_parse_to_expression(shell: Optional[IpythonShell] = None,
-                                              user_input: Optional[str] = None) -> Tuple[str, ast.AST]:
+def prompt_user_input_and_parse_to_expression(shell: Optional[IPythonShell] = None,
+                                              user_input: Optional[str] = None)\
+        -> Tuple[Optional[str], Optional[ast.AST]]:
     """
     Prompt the user for input.
 
@@ -129,9 +152,12 @@ def prompt_user_input_and_parse_to_expression(shell: Optional[IpythonShell] = No
     """
     while True:
         if user_input is None:
-            shell = IpythonShell() if shell is None else shell
+            shell = IPythonShell() if shell is None else shell
             shell.run()
             user_input = shell.user_input
+            if user_input is None:
+                return None, None
+            print(user_input)
         try:
             return user_input, parse_string_to_expression(user_input)
         except Exception as e:
@@ -139,16 +165,3 @@ def prompt_user_input_and_parse_to_expression(shell: Optional[IpythonShell] = No
             logging.error(msg)
             print(msg)
             user_input = None
-
-
-def get_prompt_session_for_obj(obj: Any) -> PromptSession:
-    """
-    Get a prompt session for an object.
-
-    :param obj: The object to get the prompt session for.
-    :return: The prompt session.
-    """
-    completions = get_completions(obj)
-    completer = WordCompleter(completions)
-    session = PromptSession(completer=completer)
-    return session