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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.50
+Version: 0.6.52
 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

ripple_down_rules-0.6.52/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.52/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.52/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.52/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.52/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.52/examples/part_containment_rdr/__init__.py

@@ -0,0 +1 @@
+from . import *

ripple_down_rules-0.6.52/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.52/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.52/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.52/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.52/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.50 → ripple_down_rules-0.6.52}/src/ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.50"
+__version__ = "0.6.52"
 
 import logging
 import sys

{ripple_down_rules-0.6.50 → ripple_down_rules-0.6.52}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -130,8 +130,10 @@ class CallableExpression(SubclassJSONSerializer):
                 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 not mutually_exclusive:
-            self.expected_types.update({list, 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)
@@ -149,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)
@@ -160,7 +164,6 @@ 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.expected_types):
                         raise ValueError(f"Not all result types {output_types} are subclasses of expected types"
                                          f" {self.conclusion_type}")

{ripple_down_rules-0.6.50 → ripple_down_rules-0.6.52}/src/ripple_down_rules/rdr_decorators.py

@@ -102,8 +102,7 @@ class RDRDecorator:
     """
     This is used to refer to the output value of the decorated function, this is used as part of the case as input to 
     the rdr model, but is never used in the rule logic to prevent cycles from happening. The correct way to use the 
-    output of an rdr in the rules logic is in the case when mutually exclusive is False, or through refinements of 
-    existing rules when mutually exclusive is True, which happens automatically by the rdr prompting for refinements.
+    output of an rdr is through refinement rules which happens automatically by the rdr prompting for refinements.
     """
     _not_none_output_found: bool = field(init=False, default=False)
     """

{ripple_down_rules-0.6.50 → ripple_down_rules-0.6.52}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.50
+Version: 0.6.52
 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

{ripple_down_rules-0.6.50 → ripple_down_rules-0.6.52}/src/ripple_down_rules.egg-info/SOURCES.txt

@@ -30,6 +30,18 @@ examples/decorator_model.py
 examples/relational_example.py
 examples/relational_model.py
 examples/test_relational_example.py
+examples/decorator_model_robot_get_contained_objects/__init__.py
+examples/decorator_model_robot_get_contained_objects/robot_get_contained_objects_output__mcrdr.py
+examples/decorator_model_robot_get_contained_objects/robot_get_contained_objects_output__mcrdr_cases.py
+examples/decorator_model_robot_get_contained_objects/robot_get_contained_objects_output__mcrdr_defs.py
+examples/decorator_model_robot_get_contained_objects/robot_get_contained_objects_rdr.py
+examples/decorator_model_robot_get_contained_objects/rdr_metadata/decorator_model_robot_get_contained_objects.json
+examples/part_containment_rdr/__init__.py
+examples/part_containment_rdr/robot_contained_objects_mcrdr.py
+examples/part_containment_rdr/robot_contained_objects_mcrdr_cases.py
+examples/part_containment_rdr/robot_contained_objects_mcrdr_defs.py
+examples/part_containment_rdr/robot_rdr.py
+examples/part_containment_rdr/rdr_metadata/part_containment_rdr.json
 images/scrdr.dot
 images/scrdr.png
 images/thinking_pr2.jpg

ripple_down_rules-0.6.52/test/test_results/__init__.py

@@ -0,0 +1 @@
+from . import *

ripple_down_rules-0.6.52/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/__init__.py

@@ -0,0 +1 @@
+# This is an empty init file to make the directory a package.

ripple_down_rules-0.6.50/test/test_results/__init__.py

@@ -1 +0,0 @@
-# This is an empty __init__.py file to make the directory a package.