ripple-down-rules 0.6.52__tar.gz → 0.6.60__tar.gz

{ripple_down_rules-0.6.52 → ripple_down_rules-0.6.60}/.github/workflows/ci.yml

@@ -24,6 +24,8 @@ jobs:
 
     - name: Install dependencies
       run: |
+        git submodule init
+        git submodule update
         sudo apt-get update
         sudo apt install graphviz graphviz-dev
         python -m pip install --upgrade pip

ripple_down_rules-0.6.60/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "src/ripple_down_rules_meta"]
+	path = src/ripple_down_rules_meta
+	url = https://github.com/AbdelrhmanBassiouny/ripple_down_rules_meta.git

{ripple_down_rules-0.6.52 → ripple_down_rules-0.6.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.52
+Version: 0.6.60
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -696,6 +696,8 @@ Requires-Dist: sqlalchemy
 Requires-Dist: pandas
 Requires-Dist: pyparsing>=3.2.3
 Requires-Dist: omegaconf
+Requires-Dist: rustworkx
+Requires-Dist: pydot
 Provides-Extra: viz
 Requires-Dist: networkx>=3.1; extra == "viz"
 Requires-Dist: matplotlib>=3.7.5; extra == "viz"

{ripple_down_rules-0.6.52 → ripple_down_rules-0.6.60}/doc/propositional_example_tutorial.md

@@ -85,7 +85,7 @@ grdr = GeneralRDR(save_dir="./", model_name="species_rdr")
 grdr.fit(case_queries, animate_tree=True)
 
 # Render the tree to a file
-render_tree(grdr.start_rules[0], use_dot_exporter=True, filename="species_rdr")
+render_tree(grdr.start_rules[0].node, use_dot_exporter=True, filename="species_rdr")
 
 # Classify a case
 cat = grdr.classify(all_cases[50])

{ripple_down_rules-0.6.52 → ripple_down_rules-0.6.60}/pyproject.toml

@@ -21,7 +21,7 @@ Homepage = "https://github.com/AbdelrhmanBassiouny/ripple_down_rules"
 
 [tool.setuptools.packages.find]
 where = ["src"]
-include = ["ripple_down_rules*"]
+include = ["ripple_down_rules"]
 
 [tool.setuptools.dynamic]
 version = {attr = "ripple_down_rules.__version__"}

{ripple_down_rules-0.6.52 → ripple_down_rules-0.6.60}/requirements.txt

@@ -11,4 +11,6 @@ pygments
 sqlalchemy
 pandas
 pyparsing>=3.2.3
-omegaconf
+omegaconf
+rustworkx
+pydot

ripple_down_rules-0.6.60/src/ripple_down_rules/__init__.py

@@ -0,0 +1,25 @@
+__version__ = "0.6.60"
+
+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-0.6.52 → ripple_down_rules-0.6.60}/src/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-0.6.52 → ripple_down_rules-0.6.60}/src/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-0.6.60/src/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} ")