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

ripple_down_rules/__init__.py

@@ -1,5 +1,25 @@
-__version__ = "0.6.0"
+__version__ = "0.6.6"
 
 import logging
+import sys
+
 logger = logging.Logger("rdr")
 logger.setLevel(logging.INFO)
+
+try:
+    from PyQt6.QtWidgets import QApplication
+    app = QApplication(sys.argv)
+except ImportError:
+    pass
+
+
+# Trigger patch
+try:
+    from .predicates import *
+    from .datastructures.tracked_object import TrackedObjectMixin
+    from .datastructures.dataclasses import CaseQuery
+    from .rdr_decorators import RDRDecorator
+    from .rdr import MultiClassRDR, SingleClassRDR, GeneralRDR
+    import ripple_down_rules_meta._apply_overrides
+except ImportError:
+    pass

ripple_down_rules/datastructures/callable_expression.py

@@ -95,7 +95,7 @@ class CallableExpression(SubclassJSONSerializer):
     encapsulating_function_name: str = "_get_value"
 
     def __init__(self, user_input: Optional[str] = None,
-                 conclusion_type: Optional[Tuple[Type]] = None,
+                 conclusion_type: Optional[Tuple[Type, ...]] = None,
                  expression_tree: Optional[AST] = None,
                  scope: Optional[Dict[str, Any]] = None,
                  conclusion: Optional[Any] = None,
@@ -116,13 +116,24 @@ class CallableExpression(SubclassJSONSerializer):
         if user_input is None:
             user_input = build_user_input_from_conclusion(conclusion)
         self.conclusion: Optional[Any] = conclusion
-        self._user_input: str = encapsulate_user_input(user_input, self.get_encapsulating_function())
+        if "def " in user_input:
+            self.user_defined_name = user_input.split('(')[0].replace('def ', '')
+        else:
+            self.user_defined_name = user_input
+        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)
             else:
                 conclusion_type = (conclusion_type,)
         self.conclusion_type = conclusion_type
+        self.expected_types: Set[Type] = set(conclusion_type) if conclusion_type is not None else set()
+        if list in self.expected_types:
+            self.expected_types.remove(list)
+        if set in self.expected_types:
+            self.expected_types.add(set)
         self.scope: Optional[Dict[str, Any]] = scope if scope is not None else {}
         self.scope = get_used_scope(self.user_input, self.scope)
         self.expression_tree: AST = expression_tree if expression_tree else parse_string_to_expression(self.user_input)
@@ -140,6 +151,8 @@ class CallableExpression(SubclassJSONSerializer):
 
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
+            # if not self.mutually_exclusive:
+            #     self.expected_types.update({list, set})
             if self.user_input is not None:
                 if not isinstance(case, Case):
                     case = create_case(case, max_recursion_idx=3)
@@ -151,8 +164,7 @@ class CallableExpression(SubclassJSONSerializer):
                     if self.mutually_exclusive and issubclass(type(output), (list, set)):
                         raise ValueError(f"Mutually exclusive types cannot be lists or sets, got {type(output)}")
                     output_types = {type(o) for o in make_list(output)}
-                    output_types.add(type(output))
-                    if not are_results_subclass_of_types(output_types, self.conclusion_type):
+                    if not are_results_subclass_of_types(output_types, self.expected_types):
                         raise ValueError(f"Not all result types {output_types} are subclasses of expected types"
                                          f" {self.conclusion_type}")
                 return output
@@ -161,7 +173,7 @@ class CallableExpression(SubclassJSONSerializer):
             else:
                 raise ValueError("Either user_input or conclusion must be provided.")
         except Exception as e:
-            raise ValueError(f"Error during evaluation: {e}")
+            raise ValueError(f"Error during evaluation: {e}, user_input: {self.user_input}")
 
     def combine_with(self, other: 'CallableExpression') -> 'CallableExpression':
         """
@@ -172,7 +184,8 @@ class CallableExpression(SubclassJSONSerializer):
         new_user_input = (f"{cond1_user_input}\n"
                           f"{cond2_user_input}\n"
                           f"return _cond1(case) and _cond2(case)")
-        return CallableExpression(new_user_input, conclusion_type=self.conclusion_type)
+        return CallableExpression(new_user_input, conclusion_type=self.conclusion_type,
+         mutually_exclusive=self.mutually_exclusive)
 
     def update_user_input_from_file(self, file_path: str, function_name: str):
         """
@@ -214,6 +227,10 @@ class CallableExpression(SubclassJSONSerializer):
         Set the user input.
         """
         if value is not None:
+            if "def " in value:
+                self.user_defined_name = value.split('(')[0].replace('def ', '')
+            else:
+                self.user_defined_name = value
             self._user_input = encapsulate_user_input(value, self.get_encapsulating_function())
             self.scope = get_used_scope(self.user_input, self.scope)
             self.expression_tree = parse_string_to_expression(self.user_input)
@@ -299,7 +316,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, get_method_object_from_pytest_request
+
+if TYPE_CHECKING:
+    from ..rdr import RippleDownRules
+    from ..rules import Rule
 
 
 @dataclass
@@ -31,7 +34,7 @@ class CaseQuery:
     """
     The name of the attribute.
     """
-    _attribute_types: Tuple[Type]
+    _attribute_types: Tuple[Type, ...]
     """
     The type(s) of the attribute.
     """
@@ -57,9 +60,14 @@ class CaseQuery:
     The executable scenario is the root callable that recreates the situation that the case is 
     created in, for example, when the case is created from a test function, this would be the test function itself.
     """
+    this_case_target_value: Optional[Any] = None
+    """
+    The non relational case query instance target value.
+    """
     _target: Optional[CallableExpression] = None
     """
-    The target expression of the attribute.
+    The relational target (the evaluatable conclusion of the rule) which is a callable expression that varies with
+     the case.
     """
     default_value: Optional[Any] = None
     """
@@ -92,6 +100,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:
@@ -139,13 +179,20 @@ class CaseQuery:
             attribute_types_str = f"Union[{', '.join([t.__name__ for t in self.core_attribute_type])}]"
         else:
             attribute_types_str = self.core_attribute_type[0].__name__
-        if all(t in self.attribute_type for t in [list, set]) and len(self.core_attribute_type) > 2:
+        if not self.mutually_exclusive:
             return f"List[{attribute_types_str}]"
         else:
             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 +294,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
@@ -264,6 +311,12 @@ class CaseFactoryMetaData:
     factory_idx: Optional[int] = None
     case_conf: Optional[CaseConf] = None
     scenario: Optional[Callable] = None
+    pytest_request: Optional[Callable] = field(hash=False, compare=False, default=None)
+    this_case_target_value: Optional[Any] = None
+
+    def __post_init__(self):
+        if self.pytest_request is not None and self.scenario is None:
+            self.scenario = get_method_object_from_pytest_request(self.pytest_request)
 
     @classmethod
     def from_case_query(cls, case_query: CaseQuery) -> CaseFactoryMetaData:
@@ -280,8 +333,76 @@ class CaseFactoryMetaData:
         return (f"CaseFactoryMetaData("
                 f"factory_method={factory_method_repr}, "
                 f"factory_idx={self.factory_idx}, "
-                f"case_conf={self.case_conf},"
-                f" scenario={scenario_repr})")
+                f"case_conf={self.case_conf}, "
+                f"scenario={scenario_repr}, "
+                f"this_case_target_value={self.this_case_target_value})")
 
     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.
+    """
+    _conclusion: 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 __getattribute__(self, name: str) -> Any:
+        if name.startswith('_'):
+            return object.__getattribute__(self, name)
+        else:
+            conclusion = object.__getattribute__(self, "_conclusion")
+
+            value = getattr(conclusion, name)
+
+            self._record_dependency(name)
+
+            return value
+
+    def __setattr__(self, name, value):
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._wrapped, name, value)
+
+    def _record_dependency(self, attr_name):
+        # Inspect stack to find instance of CallableExpression
+        for frame_info in inspect.stack():
+            func_name = frame_info.function
+            local_self = frame_info.frame.f_locals.get("self", None)
+            if (
+                    func_name == "__call__" and
+                    local_self is not None and
+                    type(local_self) is CallableExpression
+            ):
+                self._used_in_tracker = True
+                print("RDRConclusion used inside CallableExpression")
+                break
+
+    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/datastructures/enums.py

@@ -7,6 +7,19 @@ from typing_extensions import List, Dict, Any, Type
 from ripple_down_rules.utils import SubclassJSONSerializer
 
 
+class ExitStatus(Enum):
+    """
+    Describes the status at exit of the user interface.
+    """
+    CLOSE = auto()
+    """
+    The user wants to stop the program.
+    """
+    SUCCESS = auto()
+    """
+    The user completed the task successfully.
+    """
+
 class InteractionMode(Enum):
     """
     The interaction mode of the RDR.
@@ -80,20 +93,6 @@ class Stop(Category):
     stop = "stop"
 
 
-class ExpressionParser(Enum):
-    """
-    Parsers for expressions to evaluate and encapsulate the expression into a callable function.
-    """
-    ASTVisitor: int = auto()
-    """
-    Generic python Abstract Syntax Tree that detects variables, attributes, binary/boolean expressions , ...etc.
-    """
-    SQLAlchemy: int = auto()
-    """
-    Specific for SQLAlchemy expressions on ORM Tables.
-    """
-
-
 class PromptFor(Enum):
     """
     The reason of the prompt. (e.g. get conditions, conclusions, or affirmation).
@@ -118,51 +117,6 @@ class PromptFor(Enum):
         return self.__str__()
 
 
-class CategoricalValue(Enum):
-    """
-    A categorical value is a value that is a category.
-    """
-
-    def __eq__(self, other):
-        if isinstance(other, CategoricalValue):
-            return self.name == other.name
-        elif isinstance(other, str):
-            return self.name == other
-        return self.name == other
-
-    def __hash__(self):
-        return hash(self.name)
-
-    @classmethod
-    def to_list(cls):
-        return list(cls._value2member_map_.keys())
-
-    @classmethod
-    def from_str(cls, category: str):
-        return cls[category.lower()]
-
-    @classmethod
-    def from_strs(cls, categories: List[str]):
-        return [cls.from_str(c) for c in categories]
-
-    def __str__(self):
-        return self.name
-
-    def __repr__(self):
-        return self.__str__()
-
-
-class RDRMode(Enum):
-    Propositional = auto()
-    """
-    Propositional mode, the mode where the rules are propositional.
-    """
-    Relational = auto()
-    """
-    Relational mode, the mode where the rules are relational.
-    """
-
-
 class MCRDRMode(Enum):
     """
     The modes of the MultiClassRDR.
@@ -196,34 +150,23 @@ class RDREdge(Enum):
     """
     Next edge, the edge that represents the next rule to be evaluated.
     """
-
-
-class ValueType(Enum):
-    Unary = auto()
-    """
-    Unary value type (eg. null).
+    Filter = "filter if"
     """
-    Binary = auto()
+    Filter edge, the edge that represents the filter condition.
     """
-    Binary value type (eg. True, False).
+    Empty = ""
     """
-    Discrete = auto()
-    """
-    Discrete value type (eg. 1, 2, 3).
-    """
-    Continuous = auto()
-    """
-    Continuous value type (eg. 1.0, 2.5, 3.4).
-    """
-    Nominal = auto()
-    """
-    Nominal value type (eg. red, blue, green), categories where the values have no natural order.
-    """
-    Ordinal = auto()
-    """
-    Ordinal value type (eg. low, medium, high), categories where the values have a natural order.
-    """
-    Iterable = auto()
-    """
-    Iterable value type (eg. [1, 2, 3]).
+    Empty edge, used for example for the root/input node of the tree.
     """
+
+    @classmethod
+    def from_value(cls, value: str) -> RDREdge:
+        """
+        Convert a string value to an RDREdge enum.
+
+        :param value: The string that represents the edge type.
+        :return: The RDREdge enum.
+        """
+        if value not in cls._value2member_map_:
+            raise ValueError(f"RDREdge {value} is not supported.")
+        return cls._value2member_map_[value]