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

ripple_down_rules/__init__.py

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

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,22 +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 .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, encapsulate_user_input
+from .utils import extract_imports, extract_function_source, get_imports_from_scope, get_class_file_path
 
 try:
     from .user_interface.gui import RDRCaseViewer
@@ -49,12 +50,13 @@ class Expert(ABC):
                  answers_save_path: Optional[str] = None):
         self.all_expert_answers = []
         self.use_loaded_answers = use_loaded_answers
-        self.append = True
         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)
-            os.remove(answers_save_path + '.py')
+            if not append:
+                os.remove(answers_save_path + '.py')
+        self.append = True
 
     @abstractmethod
     def ask_for_conditions(self, case_query: CaseQuery, last_evaluated_rule: Optional[Rule] = None) \
@@ -87,7 +89,7 @@ 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 + '.py'):
@@ -106,7 +108,7 @@ class Expert(ABC):
             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
         self._save_to_python(path, expert_answers=expert_answers)
@@ -163,7 +165,7 @@ 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
         if os.path.exists(path + '.py'):
@@ -203,6 +205,81 @@ class Expert(ABC):
             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.
@@ -220,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) \
@@ -247,9 +325,10 @@ class Human(Expert):
             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,7 +339,6 @@ class Human(Expert):
     def convert_json_answer_to_python_answer(self, case_query: CaseQuery, user_input: str,
                                              callable_expression: CallableExpression,
                                              prompt_for: PromptFor):
-        case_query.scope['case'] = case_query.case
         tfc = TemplateFileCreator(case_query, prompt_for=prompt_for)
         code = tfc.build_boilerplate_code()
         if user_input.startswith('def'):
@@ -303,11 +381,11 @@ class Human(Expert):
                                                                                    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/rdr.py

@@ -13,7 +13,6 @@ from . import logger
 
 try:
     from matplotlib import pyplot as plt
-
     Figure = plt.Figure
 except ImportError as e:
     logger.debug(f"{e}: matplotlib is not installed")
@@ -90,23 +89,13 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param save_dir: The directory to save the classifier to.
         """
         self.model_name: Optional[str] = model_name
-        self.save_dir = save_dir
-        self.start_rule = start_rule
+        self.save_dir: Optional[str] = save_dir
+        self.start_rule: Optional[Rule] = start_rule
         self.fig: Optional[Figure] = None
         self.viewer: Optional[RDRCaseViewer] = RDRCaseViewer.instances[0]\
             if RDRCaseViewer and any(RDRCaseViewer.instances) else None
         self.input_node: Optional[Rule] = None
 
-    @property
-    def viewer(self):
-        return self._viewer
-
-    @viewer.setter
-    def viewer(self, viewer):
-        self._viewer = viewer
-        if viewer:
-            viewer.set_save_function(self.save)
-
     def render_evaluated_rule_tree(self, filename: str, show_full_tree: bool = False) -> None:
         if show_full_tree:
             start_rule = self.start_rule if self.input_node is None else self.input_node
@@ -117,6 +106,26 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 render_tree(evaluated_rules[0], use_dot_exporter=True, filename=filename,
                             only_nodes=evaluated_rules)
 
+    def get_contributing_rules(self) -> Optional[List[Rule]]:
+        """
+        Get the contributing rules of the classifier.
+
+        :return: The contributing rules.
+        """
+        if self.start_rule is None:
+            return None
+        return [r for r in self.get_fired_rule_tree() if r.contributed]
+
+    def get_fired_rule_tree(self) -> Optional[List[Rule]]:
+        """
+        Get the fired rule tree of the classifier.
+
+        :return: The fired rule tree.
+        """
+        if self.start_rule is None:
+            return None
+        return [r for r in self.get_evaluated_rule_tree() if r.fired]
+
     def get_evaluated_rule_tree(self) -> Optional[List[Rule]]:
         """
         Get the evaluated rule tree of the classifier.
@@ -196,16 +205,6 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         pass
 
-    def set_viewer(self, viewer: RDRCaseViewer):
-        """
-        Set the viewer for the classifier.
-
-        :param viewer: The viewer to set.
-        """
-        self.viewer = viewer
-        if self.viewer is not None:
-            self.viewer.set_save_function(self.save)
-
     def fit(self, case_queries: List[CaseQuery],
             expert: Optional[Expert] = None,
             n_iter: int = None,
@@ -273,8 +272,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         if self.start_rule is not None:
             for rule in [self.start_rule] + list(self.start_rule.descendants):
-                rule.evaluated = False
-                rule.fired = False
+                rule.reset()
         if self.start_rule is not None and self.start_rule.parent is None:
             if self.input_node is None:
                 self.input_node = type(self.start_rule)(parent=None, uid='0')
@@ -332,6 +330,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         self.case_type = case_query.case_type if self.case_type is None else self.case_type
         self.case_name = case_query.case_name if self.case_name is None else self.case_name
         case_query.scenario = scenario if case_query.scenario is None else case_query.scenario
+        case_query.rdr = self
 
         expert = expert or Human(answers_save_path=self.save_dir + '/expert_answers'
                                  if self.save_dir else None)
@@ -771,6 +770,11 @@ class SingleClassRDR(RDRWithCodeWriter):
         """
         pred = self.evaluate(case)
         conclusion = pred.conclusion(case) if pred is not None and pred.fired else self.default_conclusion
+        if pred is not None and pred.fired:
+            pred.contributed = True
+            pred.last_conclusion = conclusion
+            if case_query is not None:
+                pred.contributed_to_case_query = True
         if pred is not None and pred.fired and case_query is not None:
             if pred.corner_case_metadata is None and conclusion is not None \
                     and type(conclusion) in case_query.core_attribute_type:
@@ -888,6 +892,13 @@ class MultiClassRDR(RDRWithCodeWriter):
                             and any(
                         ct in case_query.core_attribute_type for ct in map(type, make_list(rule_conclusion))):
                         evaluated_rule.corner_case_metadata = CaseFactoryMetaData.from_case_query(case_query)
+                if rule_conclusion is not None and any(make_list(rule_conclusion)):
+                    evaluated_rule.contributed = True
+                    evaluated_rule.last_conclusion = rule_conclusion
+                    if case_query is not None:
+                        rule_conclusion_types = set(map(type, make_list(rule_conclusion)))
+                        if any(rule_conclusion_types.intersection(set(case_query.core_attribute_type))):
+                            evaluated_rule.contributed_to_case_query = True
                 self.add_conclusion(rule_conclusion)
             evaluated_rule = next_rule
         return make_set(self.conclusions)
@@ -982,7 +993,7 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         if not self.start_rule:
             conditions = expert.ask_for_conditions(case_query)
-            self.start_rule = MultiClassTopRule.from_case_query(case_query)
+            self.start_rule: MultiClassTopRule = MultiClassTopRule.from_case_query(case_query)
 
     @property
     def last_top_rule(self) -> Optional[MultiClassTopRule]:

ripple_down_rules/rules.py

@@ -63,6 +63,9 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         self.uid: str = uid if uid else str(uuid4().int)
         self.evaluated: bool = False
         self._user_defined_name: Optional[str] = None
+        self.last_conclusion: Optional[Any] = None
+        self.contributed: bool = False
+        self.contributed_to_case_query: bool = False
 
     def get_an_updated_case_copy(self, case: Case) -> Case:
         """
@@ -72,11 +75,22 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         return get_an_updated_case_copy(case, self.conclusion, self.conclusion_name, self.conclusion.conclusion_type,
                                         self.mutually_exclusive)
 
+    def reset(self):
+        self.evaluated = False
+        self.fired = False
+        self.contributed = False
+        self.contributed_to_case_query = False
+        self.last_conclusion = None
+
     @property
     def color(self) -> str:
         if self.evaluated:
-            if self.fired:
+            if self.contributed_to_case_query:
                 return "green"
+            elif self.contributed:
+                return "yellow"
+            elif self.fired:
+                return "orange"
             else:
                 return "red"
         else: