ripple-down-rules 0.0.15__py3-none-any.whl → 0.1.1__py3-none-any.whl

ripple_down_rules/experts.py

@@ -4,7 +4,7 @@ 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
+from typing_extensions import Optional, Dict, TYPE_CHECKING, List, Tuple, Type, Union, Any, get_type_hints
 
 from .datastructures import (Case, PromptFor, CallableExpression, CaseAttribute, CaseQuery)
 from .datastructures.case import show_current_and_corner_cases
@@ -36,14 +36,13 @@ class Expert(ABC):
     """
 
     @abstractmethod
-    def ask_for_conditions(self, x: Case, targets: List[CaseAttribute], last_evaluated_rule: Optional[Rule] = None) \
+    def ask_for_conditions(self, case_query: CaseQuery, last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
         """
         Ask the expert to provide the differentiating features between two cases or unique features for a case
         that doesn't have a corner case to compare to.
 
-        :param x: The case to classify.
-        :param targets: The target categories to compare the case with.
+        :param case_query: The case query containing the case to classify and the required target.
         :param last_evaluated_rule: The last evaluated rule.
         :return: The differentiating features as new rule conditions.
         """
@@ -76,13 +75,11 @@ class Expert(ABC):
         """
         pass
 
-    def ask_for_conclusion(self, case_query: CaseQuery,
-                           session: Optional[Session] = None) -> Optional[CallableExpression]:
+    def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
         """
         Ask the expert to provide a relational conclusion for the case.
 
         :param case_query: The case query containing the case to find a conclusion for.
-        :param session: The sqlalchemy orm session to use if the case is a Table.
         :return: A callable expression that can be called with a new case as an argument.
         """
 
@@ -124,37 +121,33 @@ class Human(Expert):
         with open(path + '.json', "r") as f:
             self.all_expert_answers = json.load(f)
 
-    def ask_for_conditions(self, case: Case,
-                           targets: Union[List[CaseAttribute], List[SQLColumn]],
+    def ask_for_conditions(self, case_query: CaseQuery,
                            last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
         if not self.use_loaded_answers:
-            show_current_and_corner_cases(case, targets, last_evaluated_rule=last_evaluated_rule)
-        return self._get_conditions(case, targets)
+            show_current_and_corner_cases(case_query.case, {case_query.attribute_name: case_query.target},
+                                          last_evaluated_rule=last_evaluated_rule)
+        return self._get_conditions(case_query)
 
-    def _get_conditions(self, case: Case, targets: List[CaseAttribute]) \
+    def _get_conditions(self, case_query: CaseQuery) \
             -> CallableExpression:
         """
         Ask the expert to provide the differentiating features between two cases or unique features for a case
         that doesn't have a corner case to compare to.
 
-        :param case: The case to classify.
-        :param targets: The target categories to compare the case with.
+        :param case_query: The case query containing the case to classify.
         :return: The differentiating features as new rule conditions.
         """
-        targets = targets if isinstance(targets, list) else [targets]
-        condition = None
-        for target in targets:
-            target_name = target.__class__.__name__
-            user_input = None
-            if self.use_loaded_answers:
-                user_input = self.all_expert_answers.pop(0)
-            if user_input:
-                condition = CallableExpression(user_input, bool, session=self.session)
-            else:
-                user_input, condition = prompt_user_for_expression(case, PromptFor.Conditions, target_name, bool)
-            if not self.use_loaded_answers:
-                self.all_expert_answers.append(user_input)
+        user_input = None
+        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)
+        else:
+            user_input, condition = prompt_user_for_expression(case_query, PromptFor.Conditions, session=self.session)
+        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]) \
@@ -172,30 +165,26 @@ class Human(Expert):
             category = self.ask_for_conclusion(CaseQuery(case), current_conclusions)
             if not category:
                 break
-            extra_conclusions[category] = self._get_conditions(case, category)
+            extra_conclusions[category] = self._get_conditions(case, {category.__class__.__name__: category})
         return extra_conclusions
 
-    def ask_for_conclusion(self, case_query: CaseQuery,
-                           current_conclusions: Optional[List[Any]] = None)\
-            -> Optional[CallableExpression]:
+    def ask_for_conclusion(self, case_query: CaseQuery) -> CaseQuery:
         """
         Ask the expert to provide a conclusion for the case.
 
         :param case_query: The case query containing the case to find a conclusion for.
-        :param current_conclusions: The current conclusions for the case if any.
-        :return: The conclusion for the case.
+        :return: The case query updated with the conclusion for the case.
         """
-        case = case_query.case
-        attribute_name = case_query.attribute_name
-        attribute_type = case_query.attribute_type
         if self.use_loaded_answers:
             expert_input = self.all_expert_answers.pop(0)
-            expression = CallableExpression(expert_input, conclusion_type=attribute_type, session=self.session)
+            expression = CallableExpression(expert_input, case_query.attribute_type, session=self.session,
+                                            scope=case_query.scope)
         else:
-            show_current_and_corner_cases(case, current_conclusions=current_conclusions)
-            expert_input, expression = prompt_user_for_expression(case, PromptFor.Conclusion, attribute_name,
-                                                                  attribute_type)
+            show_current_and_corner_cases(case_query.case)
+            expert_input, expression = prompt_user_for_expression(case_query, PromptFor.Conclusion,
+                                                                  session=self.session)
             self.all_expert_answers.append(expert_input)
+        case_query.target = expression
         return expression
 
     def get_category_type(self, cat_name: str) -> Optional[Type[CaseAttribute]]:

ripple_down_rules/helpers.py

@@ -0,0 +1,27 @@
+import os
+
+from sqlalchemy.orm import Session
+from typing_extensions import Type, Optional
+
+from ripple_down_rules.rdr import RippleDownRules
+from ripple_down_rules.utils import get_func_rdr_model_path
+
+
+def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDownRules],
+                                  session: Optional[Session] = None, **rdr_kwargs) -> RippleDownRules:
+    """
+    Load the RDR model of the function if it exists, otherwise create a new one.
+
+    :param func: The function to load the model for.
+    :param model_dir: The directory where the model is stored.
+    :param rdr_type: The type of the RDR model to load.
+    :param session: The SQLAlchemy session to use.
+    :param rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
+    """
+    model_path = get_func_rdr_model_path(func, model_dir)
+    if os.path.exists(model_path):
+        rdr = rdr_type.load(model_path)
+        rdr.session = session
+    else:
+        rdr = rdr_type(session=session, **rdr_kwargs)
+    return rdr

ripple_down_rules/prompt.py

@@ -2,31 +2,86 @@ 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 .datastructures import Case, PromptFor, CallableExpression, create_case, parse_string_to_expression
+from .datastructures import Case, PromptFor, CallableExpression, create_case, parse_string_to_expression, CaseQuery
+from .utils import capture_variable_assignment
 
 
-def prompt_user_for_expression(case: Union[Case, SQLTable], prompt_for: PromptFor, target_name: str,
-                               output_type: Type, session: Optional[Session] = None) -> Tuple[str, CallableExpression]:
+class IpythonShell:
     """
-    Prompt the user for an executable python expression.
+    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):
+        """
+        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()
+
+    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)
+        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]:
+    """
+    Prompt the user for an executable python expression to the given case query.
 
-    :param case: The case to classify.
+    :param case_query: The case query to prompt the user for.
     :param prompt_for: The type of information ask user about.
-    :param target_name: The name of the target attribute to compare the case with.
-    :param output_type: The type of the output of the given statement from the user.
     :param session: The sqlalchemy orm session.
     :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, prompt_for, target_name)
-        callable_expression = CallableExpression(user_input, output_type, expression_tree=expression_tree, session=session)
+        user_input, expression_tree = prompt_user_about_case(case_query, prompt_for)
+        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)
         try:
-            callable_expression(case)
+            callable_expression(case_query.case)
             break
         except Exception as e:
             logging.error(e)
@@ -34,19 +89,18 @@ def prompt_user_for_expression(case: Union[Case, SQLTable], prompt_for: PromptFo
     return user_input, callable_expression
 
 
-def prompt_user_about_case(case: Union[Case, SQLTable], prompt_for: PromptFor, target_name: str) \
-        -> Tuple[str, AST]:
+def prompt_user_about_case(case_query: CaseQuery, prompt_for: PromptFor) -> Tuple[str, AST]:
     """
     Prompt the user for input.
 
-    :param case: The case to prompt the user on.
+    :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 target_name: The name of the target property of the case that is queried.
     :return: The user input, and the executable expression that was parsed from the user input.
     """
-    prompt_str = f"Give {prompt_for} for {case.__class__.__name__}.{target_name}"
-    session = get_prompt_session_for_obj(case)
-    user_input, expression_tree = prompt_user_input_and_parse_to_expression(prompt_str, session)
+    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
 
 
@@ -64,21 +118,20 @@ def get_completions(obj: Any) -> List[str]:
     return completions
 
 
-def prompt_user_input_and_parse_to_expression(prompt: Optional[str] = None, session: Optional[PromptSession] = None,
+def prompt_user_input_and_parse_to_expression(shell: Optional[IpythonShell] = None,
                                               user_input: Optional[str] = None) -> Tuple[str, ast.AST]:
     """
     Prompt the user for input.
 
-    :param prompt: The prompt to display to the user.
-    :param session: The prompt session to use.
+    :param shell: The Ipython shell to use for prompting the user.
     :param user_input: The user input to use. If given, the user input will be used instead of prompting the user.
     :return: The user input and the AST tree.
     """
     while True:
-        if not user_input:
-            user_input = session.prompt(f"\n{prompt} >>> ")
-        if user_input.lower() in ['exit', 'quit', '']:
-            break
+        if user_input is None:
+            shell = IpythonShell() if shell is None else shell
+            shell.run()
+            user_input = shell.user_input
         try:
             return user_input, parse_string_to_expression(user_input)
         except Exception as e: