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

{ripple_down_rules-0.6.51 → 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.51 → ripple_down_rules-0.6.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.51
+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.51 → 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.60/examples/decorator_model_robot_get_contained_objects/rdr_metadata/decorator_model_robot_get_contained_objects.json

@@ -0,0 +1,60 @@
+{
+    "_type": "ripple_down_rules.rdr.GeneralRDR",
+    "start_rules": {
+        "output_": {
+            "_type": "ripple_down_rules.rdr.MultiClassRDR",
+            "start_rule": {
+                "_type": "ripple_down_rules.rules.MultiClassTopRule",
+                "conditions": {
+                    "_type": "ripple_down_rules.datastructures.callable_expression.CallableExpression",
+                    "user_input": "def _get_value(case):\n    def conditions_for_robot_get_contained_objects(self_: Robot, output_: PhysicalObject) -> bool:\n        \"\"\"Get conditions on whether it's possible to conclude a value for Robot_get_contained_objects.output_  of type PhysicalObject.\"\"\"\n        return len(self_.parts) > 0\n    return conditions_for_robot_get_contained_objects(**case)\n    ",
+                    "conclusion_type": [
+                        "builtins.bool"
+                    ],
+                    "scope": {
+                        "PhysicalObject": "relational_model.PhysicalObject",
+                        "Robot": "decorator_model.Robot"
+                    },
+                    "conclusion": {
+                        "_type": "builtins.NoneType",
+                        "value": null
+                    },
+                    "mutually_exclusive": false
+                },
+                "conclusion": {
+                    "_type": "ripple_down_rules.datastructures.callable_expression.CallableExpression",
+                    "user_input": "def _get_value(case):\n    def robot_get_contained_objects(self_: Robot, output_: PhysicalObject) -> List[PhysicalObject]:\n        \"\"\"Get possible value(s) for Robot_get_contained_objects.output_  of type PhysicalObject.\"\"\"\n        contained_objects = []\n        for part in self_.parts:\n            contained_objects.extend(part.contained_objects)\n        return contained_objects\n    return robot_get_contained_objects(**case)\n    ",
+                    "conclusion_type": [
+                        "relational_model.PhysicalObject",
+                        "builtins.set",
+                        "builtins.list"
+                    ],
+                    "scope": {
+                        "PhysicalObject": "relational_model.PhysicalObject",
+                        "List": "typing.List",
+                        "Robot": "decorator_model.Robot"
+                    },
+                    "conclusion": {
+                        "_type": "builtins.NoneType",
+                        "value": null
+                    },
+                    "mutually_exclusive": false
+                },
+                "parent": null,
+                "conclusion_name": "output_",
+                "weight": "",
+                "uid": "167615852950279355863004646114673699744",
+                "refinement": null,
+                "alternative": null
+            },
+            "generated_python_file_name": "robot_get_contained_objects_output__mcrdr",
+            "name": "output_",
+            "case_type": "typing.Dict",
+            "case_name": "Robot_get_contained_objects"
+        }
+    },
+    "generated_python_file_name": "robot_get_contained_objects_rdr",
+    "name": "output_",
+    "case_type": "typing.Dict",
+    "case_name": "Robot_get_contained_objects"
+}

ripple_down_rules-0.6.60/examples/decorator_model_robot_get_contained_objects/robot_get_contained_objects_output__mcrdr.py

@@ -0,0 +1,23 @@
+from ripple_down_rules.datastructures.case import Case, create_case
+from typing_extensions import Optional, Set
+from ripple_down_rules.utils import make_set
+from ripple_down_rules.helpers import get_an_updated_case_copy
+from .robot_get_contained_objects_output__mcrdr_defs import *
+
+
+attribute_name = 'output_'
+conclusion_type = (set, list, PhysicalObject,)
+mutually_exclusive = False
+name = 'output_'
+case_type = Dict
+case_name = 'Robot_get_contained_objects'
+
+
+def classify(case: Dict, **kwargs) -> Set[PhysicalObject]:
+    if not isinstance(case, Case):
+        case = create_case(case, max_recursion_idx=3)
+    conclusions = set()
+
+    if conditions_167615852950279355863004646114673699744(case):
+        conclusions.update(make_set(conclusion_167615852950279355863004646114673699744(case)))
+    return conclusions

ripple_down_rules-0.6.60/examples/decorator_model_robot_get_contained_objects/robot_get_contained_objects_output__mcrdr_cases.py

@@ -0,0 +1,7 @@
+# This file contains the corner cases for the rules.
+from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
+
+
+corner_case_167615852950279355863004646114673699744 = CaseFactoryMetaData(factory_method=None, factory_idx=None, case_conf=None, scenario=None)
+
+

ripple_down_rules-0.6.60/examples/decorator_model_robot_get_contained_objects/robot_get_contained_objects_output__mcrdr_defs.py

@@ -0,0 +1,23 @@
+from ripple_down_rules.datastructures.case import Case
+from typing_extensions import Dict, List, Set, Union
+from decorator_model import Robot
+from relational_model import PhysicalObject
+
+
+def conditions_167615852950279355863004646114673699744(case) -> bool:
+    def conditions_for_robot_get_contained_objects(self_: Robot, output_: PhysicalObject) -> bool:
+        """Get conditions on whether it's possible to conclude a value for Robot_get_contained_objects.output_  of type PhysicalObject."""
+        return len(self_.parts) > 0
+    return conditions_for_robot_get_contained_objects(**case)
+
+
+def conclusion_167615852950279355863004646114673699744(case) -> List[PhysicalObject]:
+    def robot_get_contained_objects(self_: Robot, output_: PhysicalObject) -> List[PhysicalObject]:
+        """Get possible value(s) for Robot_get_contained_objects.output_  of type PhysicalObject."""
+        contained_objects = []
+        for part in self_.parts:
+            contained_objects.extend(part.contained_objects)
+        return contained_objects
+    return robot_get_contained_objects(**case)
+
+

ripple_down_rules-0.6.60/examples/decorator_model_robot_get_contained_objects/robot_get_contained_objects_rdr.py

@@ -0,0 +1,16 @@
+from typing_extensions import Any, Dict
+from ripple_down_rules.helpers import general_rdr_classify
+from ripple_down_rules.datastructures.case import Case, create_case
+from . import robot_get_contained_objects_output__mcrdr as output__classifier
+
+name = 'output_'
+case_type = Dict
+case_name = 'Robot_get_contained_objects'
+classifiers_dict = dict()
+classifiers_dict['output_'] = output__classifier
+
+
+def classify(case: Dict, **kwargs) -> Dict[str, Any]:
+    if not isinstance(case, Case):
+        case = create_case(case, max_recursion_idx=3)
+    return general_rdr_classify(classifiers_dict, case, **kwargs)

ripple_down_rules-0.6.60/examples/part_containment_rdr/rdr_metadata/part_containment_rdr.json

@@ -0,0 +1,59 @@
+{
+    "_type": "ripple_down_rules.rdr.GeneralRDR",
+    "start_rules": {
+        "contained_objects": {
+            "_type": "ripple_down_rules.rdr.MultiClassRDR",
+            "start_rule": {
+                "_type": "ripple_down_rules.rules.MultiClassTopRule",
+                "conditions": {
+                    "_type": "ripple_down_rules.datastructures.callable_expression.CallableExpression",
+                    "user_input": "def _get_value(case):\n    def conditions_for_robot_contained_objects_of_type_physical_object(case: Robot) -> bool:\n        \"\"\"Get conditions on whether it's possible to conclude a value for Robot.contained_objects  of type PhysicalObject.\"\"\"\n        return len(case.parts) > 0\n    return conditions_for_robot_contained_objects_of_type_physical_object(case)\n    ",
+                    "conclusion_type": [
+                        "builtins.bool"
+                    ],
+                    "scope": {
+                        "Robot": "relational_model.Robot"
+                    },
+                    "conclusion": {
+                        "_type": "builtins.NoneType",
+                        "value": null
+                    },
+                    "mutually_exclusive": false
+                },
+                "conclusion": {
+                    "_type": "ripple_down_rules.datastructures.callable_expression.CallableExpression",
+                    "user_input": "def _get_value(case):\n    def robot_contained_objects_of_type_physical_object(case: Robot) -> List[PhysicalObject]:\n        \"\"\"Get possible value(s) for Robot.contained_objects  of type PhysicalObject.\"\"\"\n        contained_objects: List[PhysicalObject] = []\n        for part in case.parts:\n            contained_objects.extend(part.contained_objects)\n        return contained_objects\n    return robot_contained_objects_of_type_physical_object(case)\n    ",
+                    "conclusion_type": [
+                        "relational_model.PhysicalObject",
+                        "builtins.set",
+                        "builtins.list"
+                    ],
+                    "scope": {
+                        "Robot": "relational_model.Robot",
+                        "PhysicalObject": "relational_model.PhysicalObject",
+                        "List": "typing.List"
+                    },
+                    "conclusion": {
+                        "_type": "builtins.NoneType",
+                        "value": null
+                    },
+                    "mutually_exclusive": false
+                },
+                "parent": null,
+                "conclusion_name": "contained_objects",
+                "weight": "",
+                "uid": "298609776593271728826836208156881692889",
+                "refinement": null,
+                "alternative": null
+            },
+            "generated_python_file_name": "robot_contained_objects_mcrdr",
+            "name": "contained_objects",
+            "case_type": "relational_model.Robot",
+            "case_name": "Robot"
+        }
+    },
+    "generated_python_file_name": "robot_rdr",
+    "name": "contained_objects",
+    "case_type": "relational_model.Robot",
+    "case_name": "Robot"
+}

ripple_down_rules-0.6.60/examples/part_containment_rdr/robot_contained_objects_mcrdr.py

@@ -0,0 +1,23 @@
+from ripple_down_rules.utils import make_set
+from ripple_down_rules.helpers import get_an_updated_case_copy
+from typing_extensions import Optional, Set
+from ripple_down_rules.datastructures.case import Case, create_case
+from .robot_contained_objects_mcrdr_defs import *
+
+
+attribute_name = 'contained_objects'
+conclusion_type = (set, PhysicalObject, list,)
+mutually_exclusive = False
+name = 'contained_objects'
+case_type = Robot
+case_name = 'Robot'
+
+
+def classify(case: Robot, **kwargs) -> Set[PhysicalObject]:
+    if not isinstance(case, Case):
+        case = create_case(case, max_recursion_idx=3)
+    conclusions = set()
+
+    if conditions_298609776593271728826836208156881692889(case):
+        conclusions.update(make_set(conclusion_298609776593271728826836208156881692889(case)))
+    return conclusions

ripple_down_rules-0.6.60/examples/part_containment_rdr/robot_contained_objects_mcrdr_cases.py

@@ -0,0 +1,7 @@
+# This file contains the corner cases for the rules.
+from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
+
+
+corner_case_298609776593271728826836208156881692889 = CaseFactoryMetaData(factory_method=None, factory_idx=None, case_conf=None, scenario=None)
+
+

ripple_down_rules-0.6.60/examples/part_containment_rdr/robot_contained_objects_mcrdr_defs.py

@@ -0,0 +1,21 @@
+from typing_extensions import List, Set, Union
+from relational_model import PhysicalObject, Robot
+
+
+def conditions_298609776593271728826836208156881692889(case) -> bool:
+    def conditions_for_robot_contained_objects_of_type_physical_object(case: Robot) -> bool:
+        """Get conditions on whether it's possible to conclude a value for Robot.contained_objects  of type PhysicalObject."""
+        return len(case.parts) > 0
+    return conditions_for_robot_contained_objects_of_type_physical_object(case)
+
+
+def conclusion_298609776593271728826836208156881692889(case) -> List[PhysicalObject]:
+    def robot_contained_objects_of_type_physical_object(case: Robot) -> List[PhysicalObject]:
+        """Get possible value(s) for Robot.contained_objects  of type PhysicalObject."""
+        contained_objects: List[PhysicalObject] = []
+        for part in case.parts:
+            contained_objects.extend(part.contained_objects)
+        return contained_objects
+    return robot_contained_objects_of_type_physical_object(case)
+
+

ripple_down_rules-0.6.60/examples/part_containment_rdr/robot_rdr.py

@@ -0,0 +1,17 @@
+from typing_extensions import Any, Dict
+from ripple_down_rules.helpers import general_rdr_classify
+from ripple_down_rules.datastructures.case import Case, create_case
+from relational_model import Robot
+from . import robot_contained_objects_mcrdr as contained_objects_classifier
+
+name = 'contained_objects'
+case_type = Robot
+case_name = 'Robot'
+classifiers_dict = dict()
+classifiers_dict['contained_objects'] = contained_objects_classifier
+
+
+def classify(case: Robot, **kwargs) -> Dict[str, Any]:
+    if not isinstance(case, Case):
+        case = create_case(case, max_recursion_idx=3)
+    return general_rdr_classify(classifiers_dict, case, **kwargs)

{ripple_down_rules-0.6.51 → 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.51 → 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.51 → 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.51 → 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]