ripple-down-rules 0.5.94__tar.gz → 0.5.96__tar.gz

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/PKG-INFO

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

@@ -1,4 +1,4 @@
-__version__ = "0.5.94"
+__version__ = "0.5.96"
 
 import logging
 logger = logging.Logger("rdr")

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -267,10 +267,16 @@ class CallableExpression(SubclassJSONSerializer):
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> CallableExpression:
+        scope = {}
+        for k, v in data['scope'].items():
+            try:
+                scope[k] = get_type_from_string(v)
+            except ModuleNotFoundError:
+                pass
         return cls(user_input=data["user_input"],
                    conclusion_type=tuple(get_type_from_string(t) for t in data["conclusion_type"])
                    if data["conclusion_type"] else None,
-                   scope={k: get_type_from_string(v) for k, v in data["scope"].items()},
+                   scope=scope,
                    conclusion=SubclassJSONSerializer.from_json(data["conclusion"]),
                    mutually_exclusive=data["mutually_exclusive"])
 

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -139,7 +139,7 @@ class CaseQuery:
             attribute_types_str = f"Union[{', '.join([t.__name__ for t in self.core_attribute_type])}]"
         else:
             attribute_types_str = self.core_attribute_type[0].__name__
-        if list in self.attribute_type:
+        if all(t in self.attribute_type for t in [list, set]) and len(self.core_attribute_type) > 2:
             return f"List[{attribute_types_str}]"
         else:
             return attribute_types_str

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/src/ripple_down_rules/rdr.py

@@ -4,6 +4,7 @@ import importlib
 import os
 from abc import ABC, abstractmethod
 from copy import copy
+from types import NoneType
 
 from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
 from . import logger
@@ -144,7 +145,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         try:
             rdr.update_from_python(model_dir, package_name=package_name)
             rdr.to_json_file(json_file)
-        except (FileNotFoundError, ValueError) as e:
+        except (FileNotFoundError, ValueError, SyntaxError) as e:
             logger.warning(f"Could not load the python file for the model {model_name} from {model_dir}. "
                            f"Make sure the file exists and is valid.")
             rdr.save(save_dir=load_dir, model_name=model_name, package_name=package_name)
@@ -546,6 +547,8 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         main_types = set()
         main_types.add(self.case_type)
         main_types.update(make_set(self.conclusion_type))
+        main_types.update({Union, Optional})
+        defs_types.add(Union)
         main_types.update({Case, create_case})
         main_types = main_types.difference(defs_types)
         return main_types, defs_types, cases_types
@@ -689,9 +692,8 @@ class SingleClassRDR(RDRWithCodeWriter):
 
     def _write_to_python(self, model_dir: str, package_name: Optional[str] = None):
         super()._write_to_python(model_dir, package_name=package_name)
-        if self.default_conclusion is not None:
-            with open(model_dir + f"/{self.generated_python_file_name}.py", "a") as f:
-                f.write(f"{' ' * 4}else:\n{' ' * 8}return {self.default_conclusion}\n")
+        with open(model_dir + f"/{self.generated_python_file_name}.py", "a") as f:
+            f.write(f"{' ' * 4}else:\n{' ' * 8}return {self.default_conclusion}\n")
 
     def write_rules_as_source_code_to_file(self, rule: SingleClassRule, filename: str, parent_indent: str = "",
                                            defs_file: Optional[str] = None, cases_file: Optional[str] = None,
@@ -719,7 +721,19 @@ class SingleClassRDR(RDRWithCodeWriter):
 
     @property
     def conclusion_type_hint(self) -> str:
-        return self.conclusion_type[0].__name__
+        all_types = set(list(self.conclusion_type) + [type(self.default_conclusion)])
+        if NoneType in all_types:
+            return f"Optional[{', '.join([t.__name__ for t in all_types if t is not NoneType])}]"
+        return f"Union[{', '.join([t.__name__ for t in all_types])}]"
+
+    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+        main_types, def_types, case_types = super()._get_types_to_import()
+        main_types.add(type(self.default_conclusion))
+        def_types.add(type(self.default_conclusion))
+        if self.default_conclusion is None:
+            main_types.add(Optional)
+            def_types.add(Optional)
+        return main_types, def_types, case_types
 
     @property
     def conclusion_type(self) -> Tuple[Type]:
@@ -857,8 +871,8 @@ class MultiClassRDR(RDRWithCodeWriter):
 
     def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
         main_types, defs_types, cases_types = super()._get_types_to_import()
-        main_types.update({Set, Union, make_set})
-        defs_types.add(Union)
+        main_types.update({Set, make_set})
+        defs_types.update({List, Set})
         return main_types, defs_types, cases_types
 
     def update_start_rule(self, case_query: CaseQuery, expert: Expert):

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/src/ripple_down_rules/rules.py

@@ -4,6 +4,7 @@ import logging
 import re
 from abc import ABC, abstractmethod
 from pathlib import Path
+from types import NoneType
 from uuid import uuid4
 
 from anytree import NodeMixin
@@ -162,6 +163,22 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             # use regex to replace the function name
             new_function_name = f"def conclusion_{self.uid}"
             conclusion_lines[0] = re.sub(r"def (\w+)", new_function_name, conclusion_lines[0])
+            # add type hint
+            if len(self.conclusion.conclusion_type) == 1:
+                hint = self.conclusion.conclusion_type[0].__name__
+            else:
+                if (all(t in self.conclusion.conclusion_type for t in [list, set])
+                        and len(self.conclusion.conclusion_type) > 2):
+                    type_names = [t.__name__ for t in self.conclusion.conclusion_type if t not in [list, set]]
+                    hint = f"List[{', '.join(type_names)}]"
+                else:
+                    if NoneType in self.conclusion.conclusion_type:
+                        type_names = [t.__name__ for t in self.conclusion.conclusion_type if t is not NoneType]
+                        hint = f"Optional[{', '.join(type_names)}]"
+                    else:
+                        type_names = [t.__name__ for t in self.conclusion.conclusion_type]
+                        hint = f"Union[{', '.join(type_names)}]"
+            conclusion_lines[0] = conclusion_lines[0].replace("):", f") -> {hint}:")
             func_call = f"{parent_indent}    return {new_function_name.replace('def ', '')}(case)\n"
             return "\n".join(conclusion_lines).strip(' '), func_call
         else:
@@ -184,6 +201,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             # use regex to replace the function name
             new_function_name = f"def conditions_{self.uid}"
             conditions_lines[0] = re.sub(r"def (\w+)", new_function_name, conditions_lines[0])
+            # add type hint
+            conditions_lines[0] = conditions_lines[0].replace('):', ') -> bool:')
             def_code = "\n".join(conditions_lines)
             with open(defs_file, 'a') as f:
                 f.write(def_code.strip() + "\n\n\n")

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/src/ripple_down_rules/utils.py

@@ -851,15 +851,11 @@ def get_relative_import(target_file_path, imported_module_path: Optional[str] =
     # Convert path to Python import format
     rel_parts = [part.replace('..', '.') for part in Path(rel_path).parts]
     rel_parts = rel_parts if rel_parts else ['']
-    # dot_parts = [part for part in rel_parts if part == '.']
-    # non_dot_parts = [part for part in rel_parts if part != '.']
+    dot_parts = [part for part in rel_parts if part == '.']
+    non_dot_parts = [part for part in rel_parts if part != '.'] + [imported_path.stem]
 
-
-    # Join the parts and add the module name
-    # joined_parts = "".join(dot_parts) + ".".join(non_dot_parts) + f".{imported_path.stem}"
-    joined_parts = "." + "".join(rel_parts)
-    joined_parts += imported_path.stem if joined_parts.endswith(".") else f".{imported_path.stem}"
-    # joined_parts = f".{joined_parts}" if not joined_parts.startswith(".") else joined_parts
+    # Join the parts
+    joined_parts = "." + "".join(dot_parts) + ".".join(non_dot_parts)
 
     return joined_parts
 
@@ -922,10 +918,14 @@ def get_imports_from_types(type_objs: Iterable[Type],
                 name = type(tp).__qualname__
             else:
                 continue
+            if name == "NoneType":
+                module = "types"
             if module is None or module == 'builtins' or module.startswith('_')\
                 or module in sys.builtin_module_names or module in excluded_modules or "<" in module \
                     or name in exclueded_names:
                 continue
+            if module == "typing":
+                module = "typing_extensions"
             module_to_types[module].append(name)
         except AttributeError:
             continue
@@ -1055,7 +1055,19 @@ def get_type_from_string(type_path: str):
     :param type_path: The path to the type.
     """
     module_path, class_name = type_path.rsplit(".", 1)
-    module = importlib.import_module(module_path)
+    try:
+        module = importlib.import_module(module_path)
+    except ModuleNotFoundError:
+        module_path_parts = module_path.split(".")
+        idx = -1
+        while True:
+            try:
+                module = importlib.import_module('.'.join(module_path_parts[:idx]))
+                break
+            except ModuleNotFoundError:
+                idx -= 1
+                if abs(idx) > len(module_path_parts):
+                    raise
     if module == builtins and class_name == 'NoneType':
         return type(None)
     return getattr(module, class_name)

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.94
+Version: 0.5.96
 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.5.94 → ripple_down_rules-0.5.96}/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_output__scrdr.py

@@ -1,4 +1,6 @@
 from ripple_down_rules.datastructures.case import Case, create_case
+from types import NoneType
+from typing_extensions import Optional
 from .physical_object_is_a_robot_output__scrdr_defs import *
 
 
@@ -7,9 +9,11 @@ conclusion_type = (bool,)
 mutually_exclusive = True
 
 
-def classify(case: Dict, **kwargs) -> bool:
+def classify(case: Dict, **kwargs) -> Optional[bool]:
     if not isinstance(case, Case):
         case = create_case(case, max_recursion_idx=3)
 
     if conditions_226969243620390858682731042391766665817(case):
         return conclusion_226969243620390858682731042391766665817(case)
+    else:
+        return None

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_output__scrdr_defs.py

@@ -1,15 +1,16 @@
-from typing import Dict
+from types import NoneType
 from ...datasets import PhysicalObject, Robot
+from typing_extensions import Dict, Optional, Union
 
 
-def conditions_226969243620390858682731042391766665817(case):
+def conditions_226969243620390858682731042391766665817(case) -> bool:
     def conditions_for_physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:
         """Get conditions on whether it's possible to conclude a value for PhysicalObject_is_a_robot.output_  of type ."""
         return True
     return conditions_for_physical_object_is_a_robot(**case)
 
 
-def conclusion_226969243620390858682731042391766665817(case):
+def conclusion_226969243620390858682731042391766665817(case) -> bool:
     def physical_object_is_a_robot(self_: PhysicalObject, output_: bool) -> bool:
         """Get possible value(s) for PhysicalObject_is_a_robot.output_  of type ."""
         return isinstance(self_, Robot)

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_rdr.py

@@ -1,6 +1,6 @@
-from typing import Any, Dict
-from ripple_down_rules.helpers import general_rdr_classify
+from typing_extensions import Any, Dict
 from ripple_down_rules.datastructures.case import Case, create_case
+from ripple_down_rules.helpers import general_rdr_classify
 from . import physical_object_is_a_robot_output__scrdr as output__classifier
 
 classifiers_dict = dict()

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/test/test_results/datasets_physical_object_is_a_robot/rdr_metadata/datasets_physical_object_is_a_robot.json

@@ -12,9 +12,12 @@
                         "builtins.bool"
                     ],
                     "scope": {
-                        "Dict": "typing.Dict",
                         "PhysicalObject": "test.datasets.PhysicalObject",
-                        "Robot": "test.datasets.Robot"
+                        "Robot": "test.datasets.Robot",
+                        "NoneType": "builtins.NoneType",
+                        "Dict": "typing.Dict",
+                        "Optional": "typing.Optional",
+                        "Union": "typing.Union"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",
@@ -29,9 +32,12 @@
                         "builtins.bool"
                     ],
                     "scope": {
-                        "Dict": "typing.Dict",
                         "PhysicalObject": "test.datasets.PhysicalObject",
-                        "Robot": "test.datasets.Robot"
+                        "Robot": "test.datasets.Robot",
+                        "NoneType": "builtins.NoneType",
+                        "Dict": "typing.Dict",
+                        "Optional": "typing.Optional",
+                        "Union": "typing.Union"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_output__mcrdr.py

@@ -1,11 +1,11 @@
-from ripple_down_rules.utils import make_set
-from typing import Set, Union
+from typing_extensions import Optional, Set
 from ripple_down_rules.datastructures.case import Case, create_case
+from ripple_down_rules.utils import make_set
 from .physical_object_select_objects_that_are_parts_of_robot_output__mcrdr_defs import *
 
 
 attribute_name = 'output_'
-conclusion_type = (set, PhysicalObject, list,)
+conclusion_type = (set, list, PhysicalObject,)
 mutually_exclusive = False
 
 

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_output__mcrdr_defs.py

@@ -1,15 +1,15 @@
-from typing import Dict, List, Union
+from typing_extensions import Dict, List, Set, Union
 from ...datasets import PhysicalObject, Robot
 
 
-def conditions_164855806603893754507167918997373216146(case):
+def conditions_164855806603893754507167918997373216146(case) -> bool:
     def conditions_for_physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> bool:
         """Get conditions on whether it's possible to conclude a value for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject."""
         return robot is not None
     return conditions_for_physical_object_select_objects_that_are_parts_of_robot(**case)
 
 
-def conclusion_164855806603893754507167918997373216146(case):
+def conclusion_164855806603893754507167918997373216146(case) -> List[PhysicalObject]:
     def physical_object_select_objects_that_are_parts_of_robot(self_: PhysicalObject, objects: List[PhysicalObject], robot: Robot, output_: PhysicalObject) -> List[PhysicalObject]:
         """Get possible value(s) for PhysicalObject_select_objects_that_are_parts_of_robot.output_  of type PhysicalObject."""
         robot_parts = [obj for obj in objects if obj in robot.parts]

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_rdr.py

@@ -1,6 +1,6 @@
-from typing import Any, Dict
-from ripple_down_rules.helpers import general_rdr_classify
+from typing_extensions import Any, Dict
 from ripple_down_rules.datastructures.case import Case, create_case
+from ripple_down_rules.helpers import general_rdr_classify
 from . import physical_object_select_objects_that_are_parts_of_robot_output__mcrdr as output__classifier
 
 classifiers_dict = dict()

{ripple_down_rules-0.5.94 → ripple_down_rules-0.5.96}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/rdr_metadata/datasets_physical_object_select_objects_that_are_parts_of_robot.json

@@ -14,6 +14,7 @@
                     "scope": {
                         "Dict": "typing.Dict",
                         "List": "typing.List",
+                        "Set": "typing.Set",
                         "Union": "typing.Union",
                         "PhysicalObject": "test.datasets.PhysicalObject",
                         "Robot": "test.datasets.Robot"
@@ -35,6 +36,7 @@
                     "scope": {
                         "Dict": "typing.Dict",
                         "List": "typing.List",
+                        "Set": "typing.Set",
                         "Union": "typing.Union",
                         "PhysicalObject": "test.datasets.PhysicalObject",
                         "Robot": "test.datasets.Robot"