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

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/.gitignore

@@ -1,2 +1,4 @@
 *.pyc
 *.egg-info
+*.pkl
+build/

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

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

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

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/src/ripple_down_rules/helpers.py

@@ -36,7 +36,7 @@ def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDow
         new_conclusions = {}
         for attribute_name, rdr in classifiers_dict.items():
             pred_atts = rdr.classify(case_cp, case_query=case_query)
-            if pred_atts is None:
+            if pred_atts is None and type(None) not in rdr.conclusion_type:
                 continue
             if rdr.mutually_exclusive:
                 if attribute_name not in conclusions or \

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

@@ -139,13 +139,15 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         model_dir = os.path.join(load_dir, model_name)
         json_file = os.path.join(model_dir, cls.metadata_folder, model_name)
         rdr = cls.from_json_file(json_file)
+        rdr.save_dir = load_dir
+        rdr.model_name = model_name
         try:
             rdr.update_from_python(model_dir, package_name=package_name)
+            rdr.to_json_file(json_file)
         except (FileNotFoundError, ValueError) 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_dir = load_dir
-        rdr.model_name = model_name
+            rdr.save(save_dir=load_dir, model_name=model_name, package_name=package_name)
         return rdr
 
     @abstractmethod
@@ -296,7 +298,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param update_existing: Whether to update rules that gave the required type of conclusions.
         :return: True if the rdr should ask the expert, False otherwise.
         """
-        if conclusions is None:
+        if conclusions is None and type(None) not in case_query.core_attribute_type:
             return True
         elif is_iterable(conclusions) and len(conclusions) == 0:
             return True
@@ -571,8 +573,9 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         :return: The type of the conclusion of the RDR classifier.
         """
         all_types = []
-        for rule in [self.start_rule] + list(self.start_rule.descendants):
-            all_types.extend(list(rule.conclusion.conclusion_type))
+        if self.start_rule is not None:
+            for rule in [self.start_rule] + list(self.start_rule.descendants):
+                all_types.extend(list(rule.conclusion.conclusion_type))
         return tuple(set(all_types))
 
     @property

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/src/ripple_down_rules/rdr_decorators.py

@@ -120,7 +120,7 @@ class RDRDecorator:
         func_args_type_hints = get_type_hints(func)
         output_name = list(func_output.keys())[0]
         func_args_type_hints.update({output_name: Union[tuple(output_type)]})
-        return CaseQuery(case, output_name, Union[tuple(output_type)],
+        return CaseQuery(case, output_name, tuple(output_type),
                          mutual_exclusive, scope=scope,
                          is_function=True, function_args_type_hints=func_args_type_hints)
 

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/src/ripple_down_rules/user_interface/ipython_custom_shell.py

@@ -128,7 +128,7 @@ class IPythonShell:
                 break
             except Exception as e:
                 logging.error(e)
-                print(f"{Fore.RED}ERROR::{e}{Style.RESET_ALL}")
+                print(f"{Fore.RED}ERROR:: {e}{Style.RESET_ALL}")
 
     def update_user_input_from_code_lines(self):
         """

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/src/ripple_down_rules/user_interface/template_file_creator.py

@@ -225,7 +225,6 @@ class TemplateFileCreator:
         import_types.extend(case_type_imports)
         import_types.extend(output_type_imports)
         imports = get_imports_from_types(import_types, excluded_modules=["IPython.core.interactiveshell"])
-        imports = set(imports)
         return '\n'.join(imports)
 
     @staticmethod

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

@@ -85,30 +85,6 @@ def are_results_subclass_of_types(result_types: List[Any], types_: List[Type]) -
     return True
 
 
-def _get_imports_from_types(types: List[Type]) -> List[str]:
-    """
-    Get the import statements for a list of types.
-
-    :param types: The types to get the import statements for.
-    :return: The import statements as a string.
-    """
-    imports = map(get_import_from_type, types)
-    return list({i for i in imports if i is not None})
-
-
-def get_import_from_type(type_: Type) -> Optional[str]:
-    """
-    Get the import statement for a given type.
-
-    :param type_: The type to get the import statement for.
-    :return: The import statement as a string.
-    """
-    if hasattr(type_, "__module__") and hasattr(type_, "__name__"):
-        if type_.__module__ == "builtins":
-            return
-        return f"from {type_.__module__} import {type_.__name__}"
-
-
 def get_imports_from_scope(scope: Dict[str, Any]) -> List[str]:
     """
     Get the imports from the given scope.
@@ -116,12 +92,7 @@ def get_imports_from_scope(scope: Dict[str, Any]) -> List[str]:
     :param scope: The scope to get the imports from.
     :return: The imports as a string.
     """
-    imports = []
-    for k, v in scope.items():
-        if not hasattr(v, "__module__") or not hasattr(v, "__name__") or v.__module__ is None:
-            continue
-        imports.append(f"from {v.__module__} import {v.__name__}")
-    return imports
+    return get_imports_from_types(list(scope.values()))
 
 
 def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = None,
@@ -861,16 +832,18 @@ def get_relative_import(target_file_path, imported_module_path: Optional[str] =
     :return: A relative import path as a string.
     """
     # Convert to absolute paths
-    target_path = Path(target_file_path).resolve()
-    if package_name is not None:
-        target_path = Path(get_path_starting_from_latest_encounter_of(str(target_path), package_name))
     if module is not None:
         imported_module_path = sys.modules[module].__file__
     if imported_module_path is None:
         raise ValueError("Either imported_module_path or module must be provided")
+    target_path = Path(target_file_path).resolve()
+    imported_file_name = Path(imported_module_path).name
+    target_file_name = Path(target_file_path).name
+    if package_name is not None:
+        target_path = Path(get_path_starting_from_latest_encounter_of(str(target_path), package_name, [target_file_name]))
     imported_path = Path(imported_module_path).resolve()
     if package_name is not None:
-        imported_path = Path(get_path_starting_from_latest_encounter_of(str(imported_path), package_name))
+        imported_path = Path(get_path_starting_from_latest_encounter_of(str(imported_path), package_name, [imported_file_name]))
 
     # Compute relative path from target to imported module
     rel_path = os.path.relpath(imported_path.parent, target_path.parent)
@@ -878,29 +851,45 @@ 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 != '.']
 
 
     # Join the parts and add the module name
-    joined_parts = "".join(dot_parts) + ".".join(non_dot_parts) + f".{imported_path.stem}"
-    joined_parts = f".{joined_parts}" if not joined_parts.startswith(".") else joined_parts
+    # 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
 
     return joined_parts
 
 
-def get_path_starting_from_latest_encounter_of(path: str, package_name: str) -> Optional[str]:
+def get_path_starting_from_latest_encounter_of(path: str, package_name: str, should_contain: List[str]) -> str:
     """
     Get the path starting from the package name.
 
     :param path: The full path to the file.
     :param package_name: The name of the package to start from.
-    :return: The path starting from the package name or None if not found.
-    """
-    if package_name in path:
-        idx = path.rfind(package_name)
-        return path[idx:]
-    return None
+    :param should_contain: The names of the files or directorys to look for.
+    :return: The path starting from the package name that contains all the names in should_contain, otherwise raise an error.
+    :raise ValueError: If the path does not contain all the names in should_contain.
+    """
+    path_parts = path.split(os.path.sep)
+    if package_name not in path_parts:
+        raise ValueError(f"Could not find {package_name} in {path}")
+    idx = path_parts.index(package_name)
+    prev_idx = idx
+    while all(sc in path_parts[idx:] for sc in should_contain):
+        prev_idx = idx
+        try:
+            idx = path_parts.index(package_name, idx + 1)
+        except ValueError:
+            break
+    if all(sc in path_parts[idx:] for sc in should_contain):
+        path_parts = path_parts[prev_idx:]
+        return os.path.join(*path_parts)
+    else:
+        raise ValueError(f"Could not find {should_contain} in {path}")
 
 
 def get_imports_from_types(type_objs: Iterable[Type],
@@ -959,7 +948,7 @@ def get_imports_from_types(type_objs: Iterable[Type],
             import_path = get_relative_import(target_file_path, module=module, package_name=package_name)
         lines.append(f"from {import_path} import {joined}")
     lines.extend(stem_imports)
-    return sorted(lines)
+    return lines
 
 
 def get_method_args_as_dict(method: Callable, *args, **kwargs) -> Dict[str, Any]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.92
+Version: 0.5.94
 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.92 → ripple_down_rules-0.5.94}/test/test_results/datasets_physical_object_is_a_robot/rdr_metadata/datasets_physical_object_is_a_robot.json

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

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/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

@@ -12,11 +12,11 @@
                         "builtins.bool"
                     ],
                     "scope": {
-                        "PhysicalObject": "test.datasets.PhysicalObject",
-                        "Robot": "test.datasets.Robot",
                         "Dict": "typing.Dict",
                         "List": "typing.List",
-                        "Union": "typing.Union"
+                        "Union": "typing.Union",
+                        "PhysicalObject": "test.datasets.PhysicalObject",
+                        "Robot": "test.datasets.Robot"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",
@@ -33,11 +33,11 @@
                         "builtins.list"
                     ],
                     "scope": {
-                        "PhysicalObject": "test.datasets.PhysicalObject",
-                        "Robot": "test.datasets.Robot",
                         "Dict": "typing.Dict",
                         "List": "typing.List",
-                        "Union": "typing.Union"
+                        "Union": "typing.Union",
+                        "PhysicalObject": "test.datasets.PhysicalObject",
+                        "Robot": "test.datasets.Robot"
                     },
                     "conclusion": {
                         "_type": "builtins.NoneType",

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

@@ -1,5 +1,5 @@
-from ...datasets import PhysicalObject, Robot
 from typing import Dict
+from ...datasets import PhysicalObject, Robot
 
 
 def conditions_226969243620390858682731042391766665817(case):

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

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

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/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,6 +1,6 @@
-from ripple_down_rules.datastructures.case import Case, create_case
 from ripple_down_rules.utils import make_set
 from typing import Set, Union
+from ripple_down_rules.datastructures.case import Case, create_case
 from .physical_object_select_objects_that_are_parts_of_robot_output__mcrdr_defs import *
 
 

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/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,5 +1,5 @@
-from ...datasets import PhysicalObject, Robot
 from typing import Dict, List, Union
+from ...datasets import PhysicalObject, Robot
 
 
 def conditions_164855806603893754507167918997373216146(case):

{ripple_down_rules-0.5.92 → ripple_down_rules-0.5.94}/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 ripple_down_rules.datastructures.case import Case, create_case
-from ripple_down_rules.helpers import general_rdr_classify
 from typing import Any, Dict
+from ripple_down_rules.helpers import general_rdr_classify
+from ripple_down_rules.datastructures.case import Case, create_case
 from . import physical_object_select_objects_that_are_parts_of_robot_output__mcrdr as output__classifier
 
 classifiers_dict = dict()