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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.51
+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/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.51 → ripple_down_rules-0.6.52}/src/ripple_down_rules/__init__.py

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

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