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

ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.28"
+__version__ = "0.6.30"
 
 import logging
 logger = logging.Logger("rdr")

ripple_down_rules/datastructures/callable_expression.py

@@ -120,7 +120,9 @@ class CallableExpression(SubclassJSONSerializer):
             self.user_defined_name = user_input.split('(')[0].replace('def ', '')
         else:
             self.user_defined_name = user_input
-        self._user_input: str = encapsulate_user_input(user_input, self.get_encapsulating_function())
+        if f"def {self.encapsulating_function_name}" not in user_input:
+            user_input = encapsulate_user_input(user_input, self.get_encapsulating_function())
+        self._user_input: str = user_input
         if conclusion_type is not None:
             if is_iterable(conclusion_type):
                 conclusion_type = tuple(conclusion_type)
@@ -308,7 +310,7 @@ def parse_string_to_expression(expression_str: str) -> AST:
     :param expression_str: The string which will be parsed.
     :return: The parsed expression.
     """
-    if not expression_str.startswith(CallableExpression.get_encapsulating_function()):
+    if not expression_str.startswith(f"def {CallableExpression.encapsulating_function_name}"):
         expression_str = encapsulate_user_input(expression_str, CallableExpression.get_encapsulating_function())
     mode = 'exec' if expression_str.startswith('def') else 'eval'
     tree = ast.parse(expression_str, mode=mode)

ripple_down_rules/datastructures/case.py

@@ -20,19 +20,20 @@ if TYPE_CHECKING:
 
 class Case(UserDict, SubclassJSONSerializer):
     """
-    A collection of attributes that represents a set of constraints on a case. This is a dictionary where the keys are
-    the names of the attributes and the values are the attributes. All are stored in lower case.
+    A collection of attributes that represents a set of attributes of a case. This is a dictionary where the keys are
+    the names of the attributes and the values are the attributes. All are stored in lower case, and can be accessed
+    using the dot notation as well as the dictionary access notation.
     """
 
     def __init__(self, _obj_type: Type, _id: Optional[Hashable] = None,
                  _name: Optional[str] = None, original_object: Optional[Any] = None, **kwargs):
         """
-        Create a new row.
+        Create a new case.
 
-        :param _obj_type: The type of the object that the row represents.
-        :param _id: The id of the row.
-        :param _name: The semantic name that describes the row.
-        :param kwargs: The attributes of the row.
+        :param _obj_type: The original type of the object that the case represents.
+        :param _id: The id of the case.
+        :param _name: The semantic name that describes the case.
+        :param kwargs: The attributes of the case.
         """
         super().__init__(kwargs)
         self._original_object = original_object
@@ -43,12 +44,12 @@ class Case(UserDict, SubclassJSONSerializer):
     @classmethod
     def from_obj(cls, obj: Any, obj_name: Optional[str] = None, max_recursion_idx: int = 3) -> Case:
         """
-        Create a row from an object.
+        Create a case from an object.
 
-        :param obj: The object to create a row from.
+        :param obj: The object to create a case from.
         :param max_recursion_idx: The maximum recursion index to prevent infinite recursion.
         :param obj_name: The name of the object.
-        :return: The row of the object.
+        :return: The case that represents the object.
         """
         return create_case(obj, max_recursion_idx=max_recursion_idx, obj_name=obj_name)
 
@@ -129,7 +130,7 @@ class Case(UserDict, SubclassJSONSerializer):
 @dataclass
 class CaseAttributeValue(SubclassJSONSerializer):
     """
-    A column value is a value in a column.
+    Encapsulates a single value of a case attribute, it adds an id to the value.
     """
     id: Hashable
     """

ripple_down_rules/datastructures/dataclasses.py

@@ -1,19 +1,22 @@
 from __future__ import annotations
 
 import inspect
-import typing
+import uuid
 from dataclasses import dataclass, field
 
-import typing_extensions
+from colorama import Fore, Style
 from omegaconf import MISSING
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, get_origin, Set, Callable
+from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, Set, Callable, TYPE_CHECKING
 
-from ..utils import get_method_name, get_function_import_data, get_function_representation
 from .callable_expression import CallableExpression
 from .case import create_case, Case
-from ..utils import copy_case, make_list, make_set, get_origin_and_args_from_type_hint, get_value_type_from_type_hint, \
-    typing_to_python_type
+from ..utils import copy_case, make_list, make_set, get_origin_and_args_from_type_hint, render_tree, \
+    get_function_representation
+
+if TYPE_CHECKING:
+    from ..rdr import RippleDownRules
+    from ..rules import Rule
 
 
 @dataclass
@@ -92,6 +95,38 @@ class CaseQuery:
     """
     The type hints of the function arguments. This is used to recreate the function signature.
     """
+    rdr: Optional[RippleDownRules] = None
+    """
+    The Ripple Down Rules that was used to answer the case query.
+    """
+
+    def render_rule_tree(self, filepath: Optional[str] = None, view: bool = False):
+        if self.rdr is None:
+            return
+        render_tree(self.rdr.start_rule, use_dot_exporter=True, filename=filepath, view=view)
+
+    @property
+    def current_value_str(self):
+        return (f"{Fore.MAGENTA}Current value of {Fore.CYAN}{self.name}{Fore.MAGENTA} of type(s) "
+                f"{Fore.CYAN}({self.core_attribute_type_str}){Fore.MAGENTA}: "
+                f"{Fore.WHITE}{self.current_value}{Style.RESET_ALL}")
+
+    @property
+    def current_value(self) -> Any:
+        """
+        :return: The current value of the attribute.
+        """
+        if not hasattr(self.case, self.attribute_name):
+            return None
+
+        attr_value = getattr(self.case, self.attribute_name)
+
+        if attr_value is None:
+            return attr_value
+        elif self.mutually_exclusive:
+            return attr_value
+        else:
+            return list({v for v in make_list(attr_value) if isinstance(v, self.core_attribute_type)})
 
     @property
     def case_type(self) -> Type:
@@ -145,7 +180,14 @@ class CaseQuery:
             return attribute_types_str
 
     @property
-    def core_attribute_type(self) -> Tuple[Type]:
+    def core_attribute_type_str(self) -> str:
+        """
+        :return: The names of the core types of the attribute.
+        """
+        return ','.join([t.__name__ for t in self.core_attribute_type])
+
+    @property
+    def core_attribute_type(self) -> Tuple[Type, ...]:
         """
         :return: The core type of the attribute.
         """
@@ -247,7 +289,7 @@ class CaseQuery:
                          conditions=self.conditions, is_function=self.is_function,
                          function_args_type_hints=self.function_args_type_hints,
                          case_factory=self.case_factory, case_factory_idx=self.case_factory_idx,
-                         case_conf=self.case_conf, scenario=self.scenario)
+                         case_conf=self.case_conf, scenario=self.scenario, rdr=self.rdr)
 
 
 @dataclass
@@ -284,4 +326,40 @@ class CaseFactoryMetaData:
                 f" scenario={scenario_repr})")
 
     def __str__(self):
-        return self.__repr__()
+        return self.__repr__()
+
+
+@dataclass
+class RDRConclusion:
+    """
+    This dataclass represents a conclusion of a Ripple Down Rule.
+    It contains the conclusion expression, the type of the conclusion, and the scope in which it is evaluated.
+    """
+    value: Any
+    """
+    The conclusion value.
+    """
+    frozen_case: Any
+    """
+    The frozen case that the conclusion was made for.
+    """
+    rule: Rule
+    """
+    The rule that gave this conclusion.
+    """
+    rdr: RippleDownRules
+    """
+    The Ripple Down Rules that classified the case and produced this conclusion.
+    """
+    id: int = field(default_factory=lambda: uuid.uuid4().int)
+    """
+    The unique identifier of the conclusion.
+    """
+
+    def __hash__(self):
+        return hash(self.id)
+
+    def __eq__(self, other):
+        if not isinstance(other, RDRConclusion):
+            return False
+        return self.id == other.id

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
@@ -46,14 +50,13 @@ class Expert(ABC):
                  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 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,19 +192,94 @@ 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.
@@ -225,8 +297,9 @@ class Human(Expert):
             -> 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) \
@@ -249,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:
@@ -260,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.
@@ -279,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