ripple-down-rules 0.6.51__py3-none-any.whl → 0.6.60__py3-none-any.whl

ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.51"
+__version__ = "0.6.60"
 
 import logging
 import sys
@@ -12,6 +12,14 @@ try:
 except ImportError:
     pass
 
-from .datastructures.dataclasses import CaseQuery
-from .rdr_decorators import RDRDecorator
-from .rdr import MultiClassRDR, SingleClassRDR, GeneralRDR
+
+# 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/dataclasses.py

@@ -12,7 +12,7 @@ from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, Set
 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, render_tree, \
-    get_function_representation
+    get_function_representation, get_method_object_from_pytest_request
 
 if TYPE_CHECKING:
     from ..rdr import RippleDownRules
@@ -60,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
     """
@@ -306,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:
@@ -322,8 +333,9 @@ 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__()
@@ -335,26 +347,57 @@ 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
+    _conclusion: Any
     """
     The conclusion value.
     """
-    frozen_case: Any
+    _frozen_case: Any
     """
     The frozen case that the conclusion was made for.
     """
-    rule: Rule
+    _rule: Rule
     """
     The rule that gave this conclusion.
     """
-    rdr: RippleDownRules
+    _rdr: RippleDownRules
     """
     The Ripple Down Rules that classified the case and produced this conclusion.
     """
-    id: int = field(default_factory=lambda: uuid.uuid4().int)
+    _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)

ripple_down_rules/datastructures/enums.py

@@ -93,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).
@@ -131,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.
@@ -213,33 +154,19 @@ class RDREdge(Enum):
     """
     Filter edge, the edge that represents the filter condition.
     """
-
-class ValueType(Enum):
-    Unary = auto()
-    """
-    Unary value type (eg. null).
-    """
-    Binary = auto()
-    """
-    Binary value type (eg. True, False).
-    """
-    Discrete = auto()
-    """
-    Discrete value type (eg. 1, 2, 3).
+    Empty = ""
     """
-    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]

ripple_down_rules/datastructures/field_info.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import enum
+import importlib
+import inspect
+import logging
+import sys
+import typing
+from dataclasses import dataclass, Field
+from datetime import datetime
+from functools import lru_cache
+from types import NoneType
+
+from typing_extensions import Type, get_origin, Optional, get_type_hints, Tuple
+
+from ripple_down_rules.utils import make_tuple
+
+
+class ParseError(TypeError):
+    """
+    Error that will be raised when the parser encounters something that can/should not be parsed.
+
+    For instance, Union types
+    """
+    pass
+
+
+@dataclass
+class FieldInfo:
+    """
+    A class that wraps a field of dataclass and provides some utility functions.
+    """
+
+    clazz: Type
+    """
+    The class that the field is in.
+    """
+
+    name: str
+    """
+    The name of the field.
+    """
+
+    type: Tuple[Type, ...]
+    """
+    The type of the field or inner type of the container if it is a container.
+    """
+
+    optional: bool
+    """
+    True if the field is optional, False otherwise.
+    """
+
+    container: Optional[Type]
+    """
+    The type of the container if it is one (list, set, tuple, etc.). If there is no container this is None
+    """
+
+    is_type_field: bool = False
+    """
+    The field value is a type.
+    """
+
+    field: Field = None
+    """
+    The field instance.
+    """
+
+    def __init__(self, clazz: Type, f: Field):
+        self.field = f
+        self.name = f.name
+        self.clazz = clazz
+
+        try:
+            type_hints = get_type_hints(clazz)[self.name]
+        except NameError as e:
+            found_clazz = manually_search_for_class_name(e.name)
+            module = importlib.import_module(found_clazz.__module__)
+            locals()[e.name] = getattr(module, e.name)
+            type_hints = get_type_hints(clazz, localns=locals())[self.name]
+        type_args = typing.get_args(type_hints)
+
+        # try to unpack the type if it is a nested type
+        if len(type_args) > 0:
+            self.optional = NoneType in type_args
+
+            if self.optional:
+                self.container = None
+            else:
+                self.container = get_origin(type_hints)
+
+            if not self.optional and type_hints == Type[type_args]:
+                self.is_type_field = True
+
+            self.type = type_args
+        else:
+            self.optional = False
+            self.container = None
+            self.type = make_tuple(type_hints)
+
+    @property
+    def is_builtin_class(self) -> bool:
+        return not self.container and all(t.__module__ == 'builtins' for t in self.type)
+
+    @property
+    def is_container_of_builtin(self) -> bool:
+        return self.container and all(t.__module__ == 'builtins' for t in self.type)
+
+    @property
+    def is_type_type(self) -> bool:
+        return self.is_type_field
+
+    @property
+    def is_enum(self):
+        return len(self.type) == 1 and issubclass(self.type[0], enum.Enum)
+
+    @property
+    def is_datetime(self):
+        return len(self.type) == 1 and self.type[0] == datetime
+
+
+def is_container(clazz: Type) -> bool:
+    """
+    Check if a class is an iterable.
+
+    :param clazz: The class to check
+    :return: True if the class is an iterable, False otherwise
+    """
+    return get_origin(clazz) in [list, set, tuple]
+
+
+def manually_search_for_class_name(target_class_name: str) -> Type:
+    """
+    Searches for a class with the specified name in the current module's `globals()` dictionary
+    and all loaded modules present in `sys.modules`. This function attempts to find and resolve
+    the first class that matches the given name. If multiple classes are found with the same
+    name, a warning is logged, and the first one is returned. If no matching class is found,
+    an exception is raised.
+
+    :param target_class_name: Name of the class to search for.
+    :return: The resolved class with the matching name.
+
+    :raises ValueError: Raised when no class with the specified name can be found.
+    """
+    found_classes = []
+
+    # Search 1: In the current module's globals()
+    for name, obj in globals().items():
+        if inspect.isclass(obj) and obj.__name__ == target_class_name:
+            found_classes.append(obj)
+
+    # Search 2: In all loaded modules (via sys.modules)
+    for module_name, module in sys.modules.items():
+        if module is None or not hasattr(module, '__dict__'):
+            continue  # Skip built-in modules or modules without a __dict__
+
+        for name, obj in module.__dict__.items():
+            if inspect.isclass(obj) and obj.__name__ == target_class_name:
+                # Avoid duplicates if a class is imported into multiple namespaces
+                if (obj, f"from module '{module_name}'") not in found_classes:
+                    found_classes.append(obj)
+
+    # If you wanted to "resolve" the forward ref based on this
+    if len(found_classes) == 0:
+        raise ValueError(f"Could not find any class with name {target_class_name} in globals or sys.modules.")
+    elif len(found_classes) == 1:
+        resolved_class = found_classes[0]
+    else:
+        warn_multiple_classes(target_class_name, tuple(found_classes))
+        resolved_class = found_classes[0]
+
+    return resolved_class
+
+
+@lru_cache(maxsize=None)
+def warn_multiple_classes(target_class_name, found_classes):
+    logging.warning(f"Found multiple classes with name {target_class_name}. Found classes: {found_classes} ")

ripple_down_rules/datastructures/tracked_object.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import inspect
+import uuid
+from dataclasses import dataclass, field, Field, fields
+from enum import Enum
+from functools import lru_cache
+
+import pydot
+import rustworkx as rx
+from typing_extensions import Any, TYPE_CHECKING, Type, final, ClassVar, Dict, List, Optional, Tuple
+
+from .field_info import FieldInfo
+from .. import logger
+from ..rules import Rule
+from ..utils import recursive_subclasses
+
+
+class Direction(Enum):
+    OUTBOUND = False
+    INBOUND = True
+
+
+class Relation(str, Enum):
+    has = "has"
+    isA = "isA"
+    dependsOn = "dependsOn"
+
+
+@dataclass(unsafe_hash=True)
+class TrackedObjectMixin:
+    """
+    A class that is used as a base class to all classes that needs to be tracked for RDR inference, and reasoning.
+    """
+    _rdr_tracked_object_id: int = field(init=False, repr=False, hash=False,
+                                        compare=False, default_factory=lambda: uuid.uuid4().int)
+    """
+    The unique identifier of the conclusion.
+    """
+    _dependency_graph: ClassVar[rx.PyDAG[Type[TrackedObjectMixin]]] = rx.PyDAG()
+    """
+    A graph that represents the relationships between all tracked objects.
+    """
+    _class_graph_indices: ClassVar[Dict[Type[TrackedObjectMixin], int]] = {}
+    """
+    The index of the current class in the dependency graph.
+    """
+    _composition_edges: ClassVar[List[Tuple[int, int]]] = []
+    """
+    The edges that represent composition relations between objects (Relation.has).
+    """
+    _inheritance_edges: ClassVar[List[Tuple[int, int]]] = []
+    """
+    The edges that represent inheritance relations between objects (Relation.isA).
+    """
+    _overridden_by: Type[TrackedObjectMixin] = field(init=False, repr=False, hash=False,
+                              compare=False, default=None)
+    """
+    Whether the class has been overridden by a subclass.
+    This is used to only include the new class in the dependency graph, not the overridden class.
+    """
+
+    @classmethod
+    def _reset_dependency_graph(cls) -> None:
+        """
+        Reset the dependency graph and all class indices.
+        """
+        cls._dependency_graph = rx.PyDAG()
+        cls._class_graph_indices = {}
+        cls._composition_edges = []
+        cls._inheritance_edges = []
+
+    @classmethod
+    def _my_graph_idx(cls):
+        return cls._class_graph_indices[cls]
+
+    @classmethod
+    def make_class_dependency_graph(cls, composition: bool = True):
+        """
+        Create a direct acyclic graph containing the class hierarchy.
+
+        :param composition: If True, the class dependency graph will include composition relations.
+        """
+        classes_to_track = recursive_subclasses(cls) + [Rule] + recursive_subclasses(Rule)
+        for clazz in classes_to_track:
+            cls._add_class_to_dependency_graph(clazz)
+
+        for clazz in cls._class_graph_indices:
+            bases = [base for base in clazz.__bases__ if
+                     base.__module__ not in ["builtins"] and base in cls._class_graph_indices]
+
+            for base in bases:
+                cls._add_class_to_dependency_graph(base)
+                clazz_idx = cls._class_graph_indices[clazz]
+                base_idx = cls._class_graph_indices[base]
+                if (clazz_idx, base_idx) in cls._inheritance_edges or base._overridden_by == clazz:
+                    continue
+                cls._dependency_graph.add_edge(clazz_idx, base_idx, Relation.isA)
+                cls._inheritance_edges.append((clazz_idx, base_idx))
+
+        if not composition:
+            return
+        for clazz, idx in cls._class_graph_indices.items():
+            if clazz.__module__ == "builtins":
+                continue
+            TrackedObjectMixin.parse_fields(clazz)
+
+    @staticmethod
+    def parse_fields(clazz) -> None:
+        for f in TrackedObjectMixin.get_fields(clazz):
+
+            logger.debug("=" * 80)
+            logger.debug(f"Processing Field {clazz.__name__}.{f.name}: {f.type}.")
+
+            # skip private fields
+            if f.name.startswith("_"):
+                logger.debug(f"Skipping since the field starts with _.")
+                continue
+
+            field_info = FieldInfo(clazz, f)
+            TrackedObjectMixin.parse_field(field_info)
+
+    @staticmethod
+    def get_fields(clazz) -> List[Field]:
+        skip_fields = []
+        bases = [base for base in clazz.__bases__ if issubclass(base, TrackedObjectMixin)]
+        for base in bases:
+            skip_fields.extend(TrackedObjectMixin.get_fields(base))
+
+        result = [cls_field for cls_field in fields(clazz) if cls_field not in skip_fields]
+
+        return result
+
+    @staticmethod
+    def parse_field(field_info: FieldInfo):
+        parent_idx = TrackedObjectMixin._class_graph_indices[field_info.clazz]
+        field_cls: Optional[Type[TrackedObjectMixin]] = None
+        field_relation = Relation.has
+        if len(field_info.type) == 1 and issubclass(field_info.type[0], TrackedObjectMixin):
+            field_cls = field_info.type[0]
+        else:
+            # TODO: Create a new TrackedObjectMixin class for new type
+            logger.debug(f"Skipping unhandled field type: {field_info.type}")
+            # logger.debug(f"Creating new TrackedObject type for builtin type {field_info.type}.")
+            # field_cls = cls._create_tracked_object_class_for_field(field_info)
+
+        if field_cls is not None:
+            field_cls_idx = TrackedObjectMixin._class_graph_indices.get(field_cls, None)
+            if field_cls_idx is not None and (parent_idx, field_cls_idx) in TrackedObjectMixin._composition_edges:
+                return
+            elif field_cls_idx is None:
+                TrackedObjectMixin._add_class_to_dependency_graph(field_cls)
+                field_cls_idx = TrackedObjectMixin._class_graph_indices[field_cls]
+            TrackedObjectMixin._dependency_graph.add_edge(parent_idx, field_cls_idx, field_relation)
+            TrackedObjectMixin._composition_edges.append((parent_idx, field_cls_idx))
+
+    @classmethod
+    def _create_tracked_object_class_for_field(cls, field_info: FieldInfo):
+        raise NotImplementedError
+
+    @classmethod
+    def to_dot(cls, filepath: str, format='png') -> None:
+        if not filepath.endswith(f".{format}"):
+            filepath += f".{format}"
+        dot_str = cls._dependency_graph.to_dot(
+            lambda node: dict(
+                color='black', fillcolor='lightblue', style='filled', label=node.__name__),
+            lambda edge: dict(color='black', style='solid', label=edge))
+        dot = pydot.graph_from_dot_data(dot_str)[0]
+        dot.write(filepath, format=format)
+
+    @classmethod
+    def _add_class_to_dependency_graph(cls, class_to_add: Type[TrackedObjectMixin]) -> None:
+        """
+        Add a class to the dependency graph.
+        """
+        if class_to_add not in cls._class_graph_indices:
+            if not issubclass(class_to_add, TrackedObjectMixin):
+                class_to_add._overridden_by = None
+            cls_idx = cls._dependency_graph.add_node(class_to_add._overridden_by or class_to_add)
+            cls._class_graph_indices[class_to_add] = cls_idx
+            if class_to_add._overridden_by:
+                cls._class_graph_indices[class_to_add._overridden_by] = cls_idx
+
+    def __getattribute__(self, name: str) -> Any:
+        # if name not in [f.name for f in fields(TrackedObjectMixin)] + ['has', 'is_a', 'depends_on']\
+        #         and not name.startswith("_"):
+        #     self._record_dependency(name)
+        return object.__getattribute__(self, name)
+
+    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).__module__ == "callable_expression" and
+                    type(local_self).__name__ == "CallableExpression"
+            ):
+                logger.debug("TrackedObject used inside CallableExpression")
+                break
+
+
+annotations = TrackedObjectMixin.__annotations__
+for val in [f.name for f in fields(TrackedObjectMixin)]:
+    annotations.pop(val, None)

ripple_down_rules/helpers.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
+import importlib
 import os
 import sys
+from functools import wraps
 from types import ModuleType
-from typing import Tuple
+from typing import Tuple, Callable, Dict, Any, Optional
 
 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
+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
 
 if TYPE_CHECKING:
@@ -127,3 +129,36 @@ def enable_gui():
         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