ripple-down-rules 0.6.0__py3-none-any.whl → 0.6.6__py3-none-any.whl

ripple_down_rules/experts.py

@@ -1,19 +1,23 @@
 from __future__ import annotations
 
 import ast
+import importlib
 import json
-import logging
 import os
-import uuid
+import sys
 from abc import ABC, abstractmethod
+from dataclasses import is_dataclass
+from textwrap import dedent, indent
+from typing import Tuple, Dict
 
 from typing_extensions import Optional, TYPE_CHECKING, List
 
 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 .utils import extract_imports, extract_function_source, get_imports_from_scope, encapsulate_user_input
+from .datastructures.dataclasses import CaseQuery
+from .datastructures.enums import PromptFor
+from .user_interface.template_file_creator import TemplateFileCreator
+from .utils import extract_imports, extract_function_source, get_imports_from_scope, get_class_file_path
 
 try:
     from .user_interface.gui import RDRCaseViewer
@@ -41,19 +45,18 @@ class Expert(ABC):
     A flag to indicate if the expert should use loaded answers or not.
     """
 
-    def __init__(self, use_loaded_answers: bool = True,
+    def __init__(self, use_loaded_answers: bool = False,
                  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 answers_save_path is not None and os.path.exists(answers_save_path + '.py'):
             if use_loaded_answers:
                 self.load_answers(answers_save_path)
-            else:
+            if not append:
                 os.remove(answers_save_path + '.py')
-            self.append = True
+        self.append = True
 
     @abstractmethod
     def ask_for_conditions(self, case_query: CaseQuery, last_evaluated_rule: Optional[Rule] = None) \
@@ -86,31 +89,29 @@ class Expert(ABC):
         """
         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.")
+                             "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 save_answers(self, path: Optional[str] = None):
+    def save_answers(self, path: Optional[str] = None, expert_answers: Optional[List[Tuple[Dict, str]]] = None):
         """
         Save the expert answers to a file.
 
         :param path: The path to save the answers to.
+        :param expert_answers: The expert answers to save.
         """
+        expert_answers = expert_answers if expert_answers else self.all_expert_answers
+        if not any(expert_answers):
+            return
         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.")
+                             "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)
+        self._save_to_python(path, expert_answers=expert_answers)
 
     def _save_to_json(self, path: str):
         """
@@ -127,12 +128,14 @@ class Expert(ABC):
         with open(path + '.json', "w") as f:
             json.dump(all_answers, f)
 
-    def _save_to_python(self, path: str):
+    def _save_to_python(self, path: str, expert_answers: Optional[List[Tuple[Dict, str]]] = None):
         """
         Save the expert answers to a Python file.
 
         :param path: The path to save the answers to.
+        :param expert_answers: The expert answers to save.
         """
+        expert_answers = expert_answers if expert_answers else self.all_expert_answers
         dir_name = os.path.dirname(path)
         if not os.path.exists(dir_name + '/__init__.py'):
             os.makedirs(dir_name, exist_ok=True)
@@ -145,18 +148,13 @@ class Expert(ABC):
                 current_file_data = f.read()
         action = 'a' if self.append and current_file_data is not None else 'w'
         with open(path + '.py', action) as f:
-            for scope, func_source in self.all_expert_answers:
+            for scope, func_source in 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:
-                    uid = uuid.uuid4().hex
-                    func_source = encapsulate_user_input(func_source, CallableExpression.get_encapsulating_function(f'_{uid}'))
-                else:
+                if func_source is None:
                     func_source = 'pass  # No user input provided for this case.\n'
-                if current_file_data is not None and func_source[1:] in current_file_data:
-                    continue
                 f.write(imports + func_source + '\n' + '\n\n\n\'===New Answer===\'\n\n\n')
 
     def load_answers(self, path: Optional[str] = None):
@@ -167,14 +165,13 @@ class Expert(ABC):
         """
         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.")
+                             "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'):
+        if os.path.exists(path + '.py'):
             self._load_answers_from_python(path)
+        elif os.path.exists(path + '.json'):
+            self._load_answers_from_json(path)
 
     def _load_answers_from_json(self, path: str):
         """
@@ -195,40 +192,114 @@ class Expert(ABC):
         file_path = path + '.py'
         with open(file_path, "r") as f:
             all_answers = f.read().split('\n\n\n\'===New Answer===\'\n\n\n')[:-1]
-        all_function_sources = list(extract_function_source(file_path, []).values())
-        all_function_sources_names = list(extract_function_source(file_path, []).keys())
+        all_function_sources = extract_function_source(file_path, [], as_list=True)
         for i, answer in enumerate(all_answers):
             answer = answer.strip('\n').strip()
             if 'def ' not in answer and 'pass' in answer:
                 self.all_expert_answers.append(({}, None))
                 continue
             scope = extract_imports(tree=ast.parse(answer))
-            function_source = all_function_sources[i].replace(all_function_sources_names[i],
+            func_name = all_function_sources[i].split('def ')[1].split('(')[0]
+            function_source = all_function_sources[i].replace(func_name,
                                                               CallableExpression.encapsulating_function_name)
             self.all_expert_answers.append((scope, function_source))
 
 
+class AI(Expert):
+    """
+    The AI Expert class, an expert that uses AI to provide differentiating features and conclusions.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the AI expert.
+        """
+        super().__init__(**kwargs)
+        self.user_prompt = UserPrompt()
+
+    def ask_for_conditions(self, case_query: CaseQuery,
+                           last_evaluated_rule: Optional[Rule] = None) \
+            -> CallableExpression:
+        prompt_str = self.get_prompt_for_ai(case_query, PromptFor.Conditions)
+        print(prompt_str)
+        sys.exit()
+
+    def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
+        prompt_str = self.get_prompt_for_ai(case_query, PromptFor.Conclusion)
+        output_type_source = self.get_output_type_class_source(case_query)
+        prompt_str = f"\n\n\nOutput type(s) class source:\n{output_type_source}\n\n" + prompt_str
+        print(prompt_str)
+        sys.exit()
+
+    def get_output_type_class_source(self, case_query: CaseQuery) -> str:
+        """
+        Get the output type class source for the AI expert.
+
+        :param case_query: The case query containing the case to classify.
+        :return: The output type class source.
+        """
+        output_types = case_query.core_attribute_type
+
+        def get_class_source(cls):
+            cls_source_file = get_class_file_path(cls)
+            found_class_source = extract_function_source(cls_source_file, function_names=[cls.__name__],
+                                        is_class=True,
+                                        as_list=True)[0]
+            class_signature = found_class_source.split('\n')[0]
+            if '(' in class_signature:
+                parent_class_names = list(map(lambda x: x.strip(),
+                                              class_signature.split('(')[1].split(')')[0].split(',')))
+                parent_classes = [importlib.import_module(cls.__module__).__dict__.get(cls_name.strip())
+                                  for cls_name in parent_class_names]
+            else:
+                parent_classes = []
+            if is_dataclass(cls):
+                found_class_source = f"@dataclass\n{found_class_source}"
+            return '\n'.join([get_class_source(pcls) for pcls in parent_classes] + [found_class_source])
+
+        found_class_sources = []
+        for output_type in output_types:
+            found_class_sources.append(get_class_source(output_type))
+        found_class_sources = '\n\n\n'.join(found_class_sources)
+        return found_class_sources
+
+    def get_prompt_for_ai(self, case_query: CaseQuery, prompt_for: PromptFor) -> str:
+        """
+        Get the prompt for the AI expert.
+
+        :param case_query: The case query containing the case to classify.
+        :param prompt_for: The type of prompt to get.
+        :return: The prompt for the AI expert.
+        """
+        # data_to_show = show_current_and_corner_cases(case_query.case)
+        data_to_show = f"\nCase ({case_query.case_name}):\n {case_query.case.__dict__}"
+        template_file_creator = TemplateFileCreator(case_query, prompt_for=prompt_for)
+        boilerplate_code = template_file_creator.build_boilerplate_code()
+        initial_prompt_str = data_to_show + "\n\n" + boilerplate_code + "\n\n"
+        return self.user_prompt.build_prompt_str_for_ai(case_query, prompt_for=prompt_for,
+                                                        initial_prompt_str=initial_prompt_str)
+
+
 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):
+    def __init__(self, **kwargs):
         """
         Initialize the Human expert.
-
-        :param viewer: The RDRCaseViewer instance to use for prompting the user.
         """
         super().__init__(**kwargs)
-        self.user_prompt = UserPrompt(viewer)
+        self.user_prompt = UserPrompt()
 
     def ask_for_conditions(self, case_query: CaseQuery,
                            last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
         data_to_show = None
         if (not self.use_loaded_answers or len(self.all_expert_answers) == 0) and self.user_prompt.viewer is None:
-            data_to_show = show_current_and_corner_cases(case_query.case, {case_query.attribute_name: case_query.target_value},
-                                          last_evaluated_rule=last_evaluated_rule)
+            data_to_show = show_current_and_corner_cases(case_query.case,
+                                                         {case_query.attribute_name: case_query.target_value},
+                                                         last_evaluated_rule=last_evaluated_rule)
         return self._get_conditions(case_query, data_to_show)
 
     def _get_conditions(self, case_query: CaseQuery, data_to_show: Optional[str] = None) \
@@ -251,10 +322,13 @@ class Human(Expert):
         if user_input is not None:
             case_query.scope.update(loaded_scope)
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
+            if self.answers_save_path is not None and not any(loaded_scope):
+                self.convert_json_answer_to_python_answer(case_query, user_input, condition, PromptFor.Conditions)
         else:
-            user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions, prompt_str=data_to_show)
-        if user_input == 'exit':
-            exit()
+            user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions,
+                                                                                prompt_str=data_to_show)
+        if user_input in ['exit', 'quit']:
+            sys.exit()
         if not self.use_loaded_answers:
             self.all_expert_answers.append((condition.scope, user_input))
             if self.answers_save_path is not None:
@@ -262,6 +336,19 @@ class Human(Expert):
         case_query.conditions = condition
         return condition
 
+    def convert_json_answer_to_python_answer(self, case_query: CaseQuery, user_input: str,
+                                             callable_expression: CallableExpression,
+                                             prompt_for: PromptFor):
+        tfc = TemplateFileCreator(case_query, prompt_for=prompt_for)
+        code = tfc.build_boilerplate_code()
+        if user_input.startswith('def'):
+            user_input = '\n'.join(user_input.split('\n')[1:])
+            user_input = indent(dedent(user_input), " " * 4).strip()
+            code = code.replace('pass', user_input)
+        else:
+            code = code.replace('pass', f"return {user_input}")
+        self.save_answers(expert_answers=[({}, code)])
+
     def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
         """
         Ask the expert to provide a conclusion for the case.
@@ -281,20 +368,24 @@ class Human(Expert):
                     expression = CallableExpression(expert_input, case_query.attribute_type,
                                                     scope=case_query.scope,
                                                     mutually_exclusive=case_query.mutually_exclusive)
+                    if self.answers_save_path is not None and not any(loaded_scope):
+                        self.convert_json_answer_to_python_answer(case_query, expert_input, expression,
+                                                                  PromptFor.Conclusion)
             except IndexError:
                 self.use_loaded_answers = False
         if not self.use_loaded_answers:
             data_to_show = None
             if self.user_prompt.viewer is None:
                 data_to_show = show_current_and_corner_cases(case_query.case)
-            expert_input, expression = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conclusion, prompt_str=data_to_show)
+            expert_input, expression = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conclusion,
+                                                                                   prompt_str=data_to_show)
             if expert_input is None:
                 self.all_expert_answers.append(({}, None))
-            elif expert_input != 'exit':
+            elif expert_input not in ['exit', 'quit']:
                 self.all_expert_answers.append((expression.scope, expert_input))
-            if self.answers_save_path is not None and expert_input != 'exit':
+            if self.answers_save_path is not None and expert_input not in ['exit', 'quit']:
                 self.save_answers()
-        if expert_input == 'exit':
-            exit()
+        if expert_input in ['exit', 'quit']:
+            sys.exit()
         case_query.target = expression
         return expression

ripple_down_rules/failures.py

@@ -0,0 +1,4 @@
+
+
+class RDRLoadError(Exception):
+    pass

ripple_down_rules/helpers.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
 
+import importlib
 import os
+import sys
+from functools import wraps
 from types import ModuleType
+from typing import Tuple, Callable, Dict, Any, Optional
 
-from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
-
-from .datastructures.case import create_case
-from .datastructures.dataclasses import CaseQuery
 from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING, Union
 
+from .datastructures.case import create_case, Case
+from .datastructures.dataclasses import CaseQuery
+from .utils import calculate_precision_and_recall, get_method_args_as_dict, get_func_rdr_model_name
 from .utils import get_func_rdr_model_name, copy_case, make_set, update_case
-from .utils import calculate_precision_and_recall
 
 if TYPE_CHECKING:
     from .rdr import RippleDownRules
@@ -55,12 +57,14 @@ def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDow
             if attribute_name in new_conclusions:
                 temp_case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, rdr.mutually_exclusive)
                 update_case(temp_case_query, new_conclusions)
-        if len(new_conclusions) == 0:
+        if len(new_conclusions) == 0 or len(classifiers_dict) == 1 and list(classifiers_dict.values())[
+            0].mutually_exclusive:
             break
     return conclusions
 
 
-def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+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.
@@ -89,9 +93,72 @@ def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDow
     :param rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
     """
     model_name = get_func_rdr_model_name(func)
-    model_path = os.path.join(model_dir, model_name, "rdr_metadata", f"{model_name}.json")
+    model_path = os.path.join(model_dir, model_name, f"{model_name}.py")
     if os.path.exists(model_path):
         rdr = rdr_type.load(load_dir=model_dir, model_name=model_name)
     else:
         rdr = rdr_type(**rdr_kwargs)
     return rdr
+
+
+def get_an_updated_case_copy(case: Case, conclusion: Callable, attribute_name: str, conclusion_type: Tuple[Type, ...],
+                             mutually_exclusive: bool) -> Case:
+    """
+    :param case: The case to copy and update.
+    :param conclusion: The conclusion to add to the case.
+    :param attribute_name: The name of the attribute to update.
+    :param conclusion_type: The type of the conclusion to update.
+    :param mutually_exclusive: Whether the rule belongs to a mutually exclusive RDR.
+    :return: A copy of the case updated with the given conclusion.
+    """
+    case_cp = copy_case(case)
+    temp_case_query = CaseQuery(case_cp, attribute_name, conclusion_type,
+                                mutually_exclusive=mutually_exclusive)
+    output = conclusion(case_cp)
+    if not isinstance(output, Dict):
+        output = {attribute_name: output}
+    update_case(temp_case_query, output)
+    return case_cp
+
+def enable_gui():
+    """
+    Enable the GUI for Ripple Down Rules if available.
+    """
+    try:
+        from .user_interface.gui import RDRCaseViewer
+        viewer = RDRCaseViewer()
+    except ImportError:
+        pass
+
+
+def create_case_from_method(func: Callable,
+                            func_output: Dict[str, Any],
+                            *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 func_output: A dictionary containing the output of the function, where the key is the output name.
+    :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)
+    case_dict.update(func_output)
+    case_name = get_func_rdr_model_name(func)
+    return Case(dict, id(case_dict), case_name, case_dict, **case_dict), case_dict
+
+
+class MockRDRDecorator:
+    def __init__(self, models_dir: str):
+        self.models_dir = models_dir
+    def decorator(self, func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Optional[Any]:
+            model_dir = get_func_rdr_model_name(func, include_file_name=True)
+            model_name = get_func_rdr_model_name(func, include_file_name=False)
+            rdr = importlib.import_module(os.path.join(self.models_dir, model_dir, f"{model_name}_rdr.py"))
+            func_output = {"output_": func(*args, **kwargs)}
+            case, case_dict = create_case_from_method(func, func_output, *args, **kwargs)
+            return rdr.classify(case)
+        return wrapper

ripple_down_rules/predicates.py

@@ -0,0 +1,97 @@
+import os.path
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from os.path import dirname
+
+from typing_extensions import Type, ClassVar, TYPE_CHECKING, Tuple, Optional, Callable
+
+from .datastructures.tracked_object import TrackedObjectMixin, Direction, Relation
+
+if TYPE_CHECKING:
+    from .rdr_decorators import RDRDecorator
+
+
+@dataclass(eq=False)
+class Predicate(TrackedObjectMixin, ABC):
+
+    def __call__(self, *args, **kwargs):
+        return self.evaluate(*args, **kwargs)
+
+    @classmethod
+    @abstractmethod
+    def evaluate(cls, *args, **kwargs):
+        """
+        Evaluate the predicate with the given arguments.
+        This method should be implemented by subclasses.
+        """
+        pass
+
+    @classmethod
+    def rdr_decorator(cls, output_types: Tuple[Type, ...], mutually_exclusive: bool,
+                      package_name: Optional[str] = None) -> Callable[[Callable], Callable]:
+        """
+        Returns the RDRDecorator to decorate the predicate evaluate method with.
+        """
+        rdr_decorator: RDRDecorator = RDRDecorator(cls.models_dir, output_types, mutually_exclusive,
+                                                   package_name=package_name)
+        return rdr_decorator.decorator
+
+    def __hash__(self):
+        return hash(self.__class__.__name__)
+
+    def __eq__(self, other):
+        if not isinstance(other, Predicate):
+            return False
+        return self.__class__ == other.__class__
+
+
+@dataclass
+class IsA(Predicate):
+    """
+    A predicate that checks if an object type is a subclass of another object type.
+    """
+
+    @classmethod
+    def evaluate(cls, child_type: Type[TrackedObjectMixin], parent_type: Type[TrackedObjectMixin]) -> bool:
+        return issubclass(child_type, parent_type)
+
+isA = IsA()
+
+
+@dataclass
+class Has(Predicate):
+    """
+    A predicate that checks if an object type has a certain member object type.
+    """
+
+    @classmethod
+    def evaluate(cls, owner_type: Type[TrackedObjectMixin],
+                 member_type: Type[TrackedObjectMixin], recursive: bool = False) -> bool:
+        neighbors = cls._dependency_graph.adj_direction(owner_type._my_graph_idx(), Direction.OUTBOUND.value)
+        curr_val = any(e == Relation.has and isA(cls._dependency_graph.get_node_data(n), member_type)
+                       or e == Relation.isA and cls.evaluate(cls._dependency_graph.get_node_data(n), member_type)
+                       for n, e in neighbors.items())
+        if recursive:
+            return curr_val or any((e == Relation.has
+                                    and cls.evaluate(cls._dependency_graph.get_node_data(n), member_type, recursive=True))
+                                   for n, e in neighbors.items())
+        else:
+            return curr_val
+
+has = Has()
+
+
+@dataclass
+class DependsOn(Predicate):
+    """
+    A predicate that checks if an object type depends on another object type.
+    """
+
+    @classmethod
+    def evaluate(cls, dependent: Type[TrackedObjectMixin],
+                 dependency: Type[TrackedObjectMixin], recursive: bool = False) -> bool:
+        raise NotImplementedError("Should be overridden in rdr meta")
+
+
+dependsOn = DependsOn()