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

ripple_down_rules/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.4.9"
+
+import logging
+logger = logging.Logger("rdr")
+logger.setLevel(logging.INFO)

ripple_down_rules/datastructures/callable_expression.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import ast
 import logging
+import os
 from _ast import AST
 from enum import Enum
 
@@ -10,7 +11,7 @@ from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 from .case import create_case, Case
 from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable, \
     build_user_input_from_conclusion, encapsulate_user_input, extract_function_source, are_results_subclass_of_types, \
-    make_list
+    make_list, get_imports_from_scope
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -175,6 +176,24 @@ class CallableExpression(SubclassJSONSerializer):
             return
         self.user_input = self.encapsulating_function + '\n' + new_function_body
 
+    def write_to_python_file(self, file_path: str, append: bool = False):
+        """
+        Write the callable expression to a python file.
+
+        :param file_path: The path to the file where the callable expression will be written.
+        :param append: If True, the callable expression will be appended to the file. If False,
+         the file will be overwritten.
+        """
+        imports = '\n'.join(get_imports_from_scope(self.scope))
+        if append and os.path.exists(file_path):
+            with open(file_path, 'a') as f:
+                f.write('\n\n\n' + imports + '\n\n\n')
+                f.write(self.user_input)
+        else:
+            with open(file_path, 'w') as f:
+                f.write(imports + '\n\n\n')
+                f.write(self.user_input)
+
     @property
     def user_input(self):
         """

ripple_down_rules/datastructures/case.py

@@ -7,7 +7,7 @@ from enum import Enum
 
 from pandas import DataFrame
 from sqlalchemy import MetaData
-from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColumn, registry
+from sqlalchemy.orm import DeclarativeBase as SQLTable, registry
 from typing_extensions import Any, Optional, Dict, Type, Set, Hashable, Union, List, TYPE_CHECKING
 
 from ..utils import make_set, row_to_dict, table_rows_as_str, get_value_type_from_type_hint, SubclassJSONSerializer, \
@@ -354,11 +354,13 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
         if last_evaluated_rule and last_evaluated_rule.fired:
             corner_row_dict = copy_case(corner_case)
 
+    case_dict.update(targets)
+    case_dict.update(current_conclusions)
+    all_table_rows = [case_dict]
     if corner_row_dict:
         corner_conclusion = last_evaluated_rule.conclusion(case)
         corner_row_dict.update({corner_conclusion.__class__.__name__: corner_conclusion})
-        print(table_rows_as_str(corner_row_dict))
-    print("=" * 50)
-    case_dict.update(targets)
-    case_dict.update(current_conclusions)
-    print(table_rows_as_str(case_dict))
+        all_table_rows.append(corner_row_dict)
+        # print(table_rows_as_str(corner_row_dict))
+    print("\n" + "=" * 50)
+    print(table_rows_as_str(all_table_rows))

ripple_down_rules/datastructures/dataclasses.py

@@ -78,7 +78,15 @@ class CaseQuery:
         """
         :return: The type of the case that the attribute belongs to.
         """
-        return self.original_case._obj_type if isinstance(self.original_case, Case) else type(self.original_case)
+        if self.is_function:
+            if self.function_args_type_hints is not None:
+                func_args = [arg for name, arg in self.function_args_type_hints.items() if name != 'return']
+                case_type_args = Union[tuple(func_args)]
+            else:
+                case_type_args = Any
+            return Dict[str, case_type_args]
+        else:
+            return self.original_case._obj_type if isinstance(self.original_case, Case) else type(self.original_case)
 
     @property
     def case(self) -> Any:

ripple_down_rules/experts.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import ast
 import json
+import logging
+import os
 from abc import ABC, abstractmethod
 
 from typing_extensions import Optional, TYPE_CHECKING, List
@@ -9,7 +12,12 @@ 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 .user_interface.gui import RDRCaseViewer
+from .utils import extract_imports, extract_function_source, get_imports_from_scope, encapsulate_user_input
+
+try:
+    from .user_interface.gui import RDRCaseViewer
+except ImportError as e:
+    RDRCaseViewer = None
 from .user_interface.prompt import UserPrompt
 
 if TYPE_CHECKING:
@@ -32,10 +40,19 @@ class Expert(ABC):
     A flag to indicate if the expert should use loaded answers or not.
     """
 
-    def __init__(self, use_loaded_answers: bool = False, append: bool = False):
+    def __init__(self, use_loaded_answers: bool = True,
+                 append: bool = False,
+                 answers_save_path: Optional[str] = None):
         self.all_expert_answers = []
         self.use_loaded_answers = use_loaded_answers
         self.append = append
+        self.answers_save_path = answers_save_path
+        if answers_save_path is not None:
+            if use_loaded_answers:
+                self.load_answers(answers_save_path)
+            else:
+                os.remove(answers_save_path + '.py')
+            self.append = True
 
     @abstractmethod
     def ask_for_conditions(self, case_query: CaseQuery, last_evaluated_rule: Optional[Rule] = None) \
@@ -59,46 +76,138 @@ class Expert(ABC):
         :return: A callable expression that can be called with a new case as an argument.
         """
 
+    def clear_answers(self, path: Optional[str] = None):
+        """
+        Clear the expert answers.
 
-class Human(Expert):
-    """
-    The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
-    """
+        :param path: The path to clear the answers from. If None, the answers will be cleared from the
+                     answers_save_path attribute.
+        """
+        if path is None and self.answers_save_path is None:
+            raise ValueError("No path provided to clear expert answers, either provide a path or set the "
+                                "answers_save_path attribute.")
+        if path is None:
+            path = self.answers_save_path
+        if os.path.exists(path + '.json'):
+            os.remove(path + '.json')
+        if os.path.exists(path + '.py'):
+            os.remove(path + '.py')
+        self.all_expert_answers = []
 
-    def __init__(self, use_loaded_answers: bool = False, append: bool = False, viewer: Optional[RDRCaseViewer] = None):
+    def save_answers(self, path: Optional[str] = None):
         """
-        Initialize the Human expert.
+        Save the expert answers to a file.
 
-        :param viewer: The RDRCaseViewer instance to use for prompting the user.
+        :param path: The path to save the answers to.
         """
-        super().__init__(use_loaded_answers=use_loaded_answers, append=append)
-        self.user_prompt = UserPrompt(viewer)
+        if path is None and self.answers_save_path is None:
+            raise ValueError("No path provided to save expert answers, either provide a path or set the "
+                                "answers_save_path attribute.")
+        if path is None:
+            path = self.answers_save_path
+        is_json = os.path.exists(path + '.json')
+        if is_json:
+            self._save_to_json(path)
+        else:
+            self._save_to_python(path)
 
-    def save_answers(self, path: str):
+    def _save_to_json(self, path: str):
         """
-        Save the expert answers to a file.
+        Save the expert answers to a JSON file.
 
         :param path: The path to save the answers to.
         """
-        if self.append:
+        all_answers = self.all_expert_answers
+        if self.append and os.path.exists(path + '.json'):
             # read the file and append the new answers
             with open(path + '.json', "r") as f:
-                all_answers = json.load(f)
-                all_answers.extend(self.all_expert_answers)
-            with open(path + '.json', "w") as f:
-                json.dump(all_answers, f)
-        else:
-            with open(path + '.json', "w") as f:
-                json.dump(self.all_expert_answers, f)
+                old_answers = json.load(f)
+                all_answers = old_answers + all_answers
+        with open(path + '.json', "w") as f:
+            json.dump(all_answers, f)
 
-    def load_answers(self, path: str):
+    def _save_to_python(self, path: str):
+        """
+        Save the expert answers to a Python file.
+
+        :param path: The path to save the answers to.
+        """
+        dir_name = os.path.dirname(path)
+        if not os.path.exists(dir_name + '/__init__.py'):
+            os.makedirs(dir_name, exist_ok=True)
+            with open(dir_name + '/__init__.py', 'w') as f:
+                f.write('# This is an empty init file to make the directory a package.\n')
+        action = 'w' if not self.append else 'a'
+        with open(path + '.py', action) as f:
+            for scope, func_source in self.all_expert_answers:
+                if len(scope) > 0:
+                    imports = '\n'.join(get_imports_from_scope(scope)) + '\n\n\n'
+                else:
+                    imports = ''
+                if func_source is not None:
+                    func_source = encapsulate_user_input(func_source, CallableExpression.encapsulating_function)
+                else:
+                    func_source = 'pass  # No user input provided for this case.\n'
+                f.write(imports + func_source + '\n' + '\n\n\n\'===New Answer===\'\n\n\n')
+
+    def load_answers(self, path: Optional[str] = None):
         """
         Load the expert answers from a file.
 
+        :param path: The path to load the answers from.
+        """
+        if path is None and self.answers_save_path is None:
+            raise ValueError("No path provided to load expert answers from, either provide a path or set the "
+                                "answers_save_path attribute.")
+        if path is None:
+            path = self.answers_save_path
+        is_json = os.path.exists(path + '.json')
+        if is_json:
+            self._load_answers_from_json(path)
+        elif os.path.exists(path + '.py'):
+            self._load_answers_from_python(path)
+
+    def _load_answers_from_json(self, path: str):
+        """
+        Load the expert answers from a JSON file.
+
         :param path: The path to load the answers from.
         """
         with open(path + '.json', "r") as f:
-            self.all_expert_answers = json.load(f)
+            all_answers = json.load(f)
+        self.all_expert_answers = [({}, answer) for answer in all_answers]
+
+    def _load_answers_from_python(self, path: str):
+        """
+        Load the expert answers from a Python file.
+
+        :param path: The path to load the answers from.
+        """
+        file_path = path + '.py'
+        with open(file_path, "r") as f:
+            all_answers = f.read().split('\n\n\n\'===New Answer===\'\n\n\n')
+        for answer in all_answers:
+            answer = answer.strip('\n').strip()
+            if 'def ' not in answer and 'pass' in answer:
+                self.all_expert_answers.append(({}, None))
+            scope = extract_imports(tree=ast.parse(answer))
+            func_source = list(extract_function_source(file_path, []).values())[0]
+            self.all_expert_answers.append((scope, func_source))
+
+
+class Human(Expert):
+    """
+    The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
+    """
+
+    def __init__(self, viewer: Optional[RDRCaseViewer] = None, **kwargs):
+        """
+        Initialize the Human expert.
+
+        :param viewer: The RDRCaseViewer instance to use for prompting the user.
+        """
+        super().__init__(**kwargs)
+        self.user_prompt = UserPrompt(viewer)
 
     def ask_for_conditions(self, case_query: CaseQuery,
                            last_evaluated_rule: Optional[Rule] = None) \
@@ -121,13 +230,18 @@ class Human(Expert):
         if self.use_loaded_answers and len(self.all_expert_answers) == 0 and self.append:
             self.use_loaded_answers = False
         if self.use_loaded_answers:
-            user_input = self.all_expert_answers.pop(0)
-        if user_input:
+            try:
+                loaded_scope, user_input = self.all_expert_answers.pop(0)
+            except IndexError:
+                self.use_loaded_answers = False
+        if user_input is not None:
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
             user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions)
         if not self.use_loaded_answers:
-            self.all_expert_answers.append(user_input)
+            self.all_expert_answers.append((condition.scope, user_input))
+            if self.answers_save_path is not None:
+                self.save_answers()
         case_query.conditions = condition
         return condition
 
@@ -139,18 +253,65 @@ class Human(Expert):
         :return: The conclusion for the case as a callable expression.
         """
         expression: Optional[CallableExpression] = None
+        expert_input: Optional[str] = None
         if self.use_loaded_answers and len(self.all_expert_answers) == 0 and self.append:
             self.use_loaded_answers = False
         if self.use_loaded_answers:
-            expert_input = self.all_expert_answers.pop(0)
-            if expert_input is not None:
-                expression = CallableExpression(expert_input, case_query.attribute_type,
-                                                scope=case_query.scope,
-                                                 mutually_exclusive=case_query.mutually_exclusive)
-        else:
+            try:
+                loaded_scope, expert_input = self.all_expert_answers.pop(0)
+                if expert_input is not None:
+                    expression = CallableExpression(expert_input, case_query.attribute_type,
+                                                    scope=case_query.scope,
+                                                    mutually_exclusive=case_query.mutually_exclusive)
+            except IndexError:
+                self.use_loaded_answers = False
+        if not self.use_loaded_answers:
             if self.user_prompt.viewer is None:
                 show_current_and_corner_cases(case_query.case)
             expert_input, expression = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conclusion)
-            self.all_expert_answers.append(expert_input)
+            if expression is None:
+                self.all_expert_answers.append(({}, None))
+            else:
+                self.all_expert_answers.append((expression.scope, expert_input))
+            if self.answers_save_path is not None:
+                self.save_answers()
         case_query.target = expression
         return expression
+
+
+class File(Expert):
+    """
+    The File Expert class, an expert that reads the answers from a file.
+    This is used for testing purposes.
+    """
+
+    def __init__(self, filename: str, **kwargs):
+        """
+        Initialize the File expert.
+
+        :param filename: The path to the file containing the expert answers.
+        """
+        super().__init__(**kwargs)
+        self.filename = filename
+        self.load_answers(filename)
+
+    def ask_for_conditions(self, case_query: CaseQuery,
+                           last_evaluated_rule: Optional[Rule] = None) -> CallableExpression:
+        loaded_scope, user_input = self.all_expert_answers.pop(0)
+        if user_input:
+            condition = CallableExpression(user_input, bool, scope=case_query.scope)
+        else:
+            raise ValueError("No user input found in the expert answers file.")
+        case_query.conditions = condition
+        return condition
+
+    def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
+        loaded_scope, expert_input = self.all_expert_answers.pop(0)
+        if expert_input is not None:
+            expression = CallableExpression(expert_input, case_query.attribute_type,
+                                            scope=case_query.scope,
+                                            mutually_exclusive=case_query.mutually_exclusive)
+        else:
+            raise ValueError("No expert input found in the expert answers file.")
+        case_query.target = expression
+        return expression