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

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)