ripple-down-rules 0.6.46__py3-none-any.whl → 0.6.48__py3-none-any.whl

ripple_down_rules/__init__.py

@@ -1,5 +1,17 @@
-__version__ = "0.6.46"
+__version__ = "0.6.48"
 
 import logging
+import sys
+
 logger = logging.Logger("rdr")
-logger.setLevel(logging.INFO)
+logger.setLevel(logging.INFO)
+
+try:
+    from PyQt6.QtWidgets import QApplication
+    app = QApplication(sys.argv)
+except ImportError:
+    pass
+
+from .datastructures.dataclasses import CaseQuery
+from .rdr_decorators import RDRDecorator
+from .rdr import MultiClassRDR, SingleClassRDR, GeneralRDR

ripple_down_rules/helpers.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import sys
 from types import ModuleType
 from typing import Tuple
 
@@ -90,7 +91,7 @@ def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDow
     :param rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
     """
     model_name = get_func_rdr_model_name(func)
-    model_path = os.path.join(model_dir, model_name, "rdr_metadata", f"{model_name}.json")
+    model_path = os.path.join(model_dir, model_name, f"{model_name}.py")
     if os.path.exists(model_path):
         rdr = rdr_type.load(load_dir=model_dir, model_name=model_name)
     else:
@@ -116,3 +117,13 @@ def get_an_updated_case_copy(case: Case, conclusion: Callable, attribute_name: s
         output = {attribute_name: output}
     update_case(temp_case_query, output)
     return case_cp
+
+def enable_gui():
+    """
+    Enable the GUI for Ripple Down Rules if available.
+    """
+    try:
+        from .user_interface.gui import RDRCaseViewer
+        viewer = RDRCaseViewer()
+    except ImportError:
+        pass

ripple_down_rules/rdr.py

@@ -46,7 +46,8 @@ from .utils import draw_tree, make_set, SubclassJSONSerializer, make_list, get_t
     is_value_conflicting, extract_function_source, extract_imports, get_full_class_name, \
     is_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types, render_tree, \
     get_types_to_import_from_func_type_hints, get_function_return_type, get_file_that_ends_with, \
-    get_and_import_python_module, get_and_import_python_modules_in_a_package, get_type_from_type_hint
+    get_and_import_python_module, get_and_import_python_modules_in_a_package, get_type_from_type_hint, \
+    are_results_subclass_of_types
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -103,6 +104,16 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         self.viewer: Optional[RDRCaseViewer] = RDRCaseViewer.instances[0]\
             if RDRCaseViewer and any(RDRCaseViewer.instances) else None
         self.input_node: Optional[Rule] = None
+        self.update_model()
+
+    def update_model(self):
+        """
+        Update the model from the model directory if it exists.
+        """
+        if self.save_dir is not None and self.model_name is not None:
+            model_path = os.path.join(self.save_dir, self.model_name)
+            if os.path.exists(model_path):
+                self.update_from_python(model_path, update_rule_tree=True)
 
     def write_rdr_metadata_to_pyton_file(self, file: TextIOWrapper):
         """
@@ -218,13 +229,10 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         if os.path.exists(json_file + ".json"):
             rdr = cls.from_json_file(json_file)
         try:
-            acronym = cls.get_acronym().lower()
-            python_file_name = get_file_that_ends_with(model_dir, f"_{acronym}.py")
-            python_file_path = os.path.join(model_dir, python_file_name)
             if rdr is None:
-                rdr = cls.from_python(model_dir, parent_package_name=package_name, python_file_path=python_file_path)
+                rdr = cls.from_python(model_dir, parent_package_name=package_name)
             else:
-                rdr.update_from_python(model_dir, package_name=package_name)
+                rdr.update_from_python(model_dir, parent_package_name=package_name)
             rdr.to_json_file(json_file)
         except (FileNotFoundError, ValueError, SyntaxError, ModuleNotFoundError) as e:
             logger.warning(f"Could not load the python file for the model {model_name} from {model_dir}. "
@@ -237,18 +245,22 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         return rdr
 
     @classmethod
-    @abstractmethod
-    def from_python(cls, model_dir: str, python_file_path: Optional[str] = None,
+    def from_python(cls, model_path: str,
+                    python_file_path: Optional[str] = None,
                     parent_package_name: Optional[str] = None) -> Self:
         """
-        Load the classifier from a python file.
+        Load the RDR classifier from a generated python file.
 
-        :param model_dir: The path to the directory where the generated python file is located.
-        :param python_file_path: The path to the python file to load the classifier from.
+        :param model_path: The directory where the generated python file is located.
+        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
         :param parent_package_name: The name of the package that contains the RDR classifier function, this
         is required in case of relative imports in the generated python file.
+        :return: An instance of the RDR classifier.
         """
-        pass
+        rdr = cls()
+        rdr.update_from_python(model_path, parent_package_name=parent_package_name, python_file_path=python_file_path,
+                               update_rule_tree=True)
+        return rdr
 
     @abstractmethod
     def _write_to_python(self, model_dir: str, package_name: Optional[str] = None):
@@ -558,13 +570,17 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         pass
 
     @abstractmethod
-    def update_from_python(self, model_dir: str, package_name: Optional[str] = None):
+    def update_from_python(self, model_dir: str, parent_package_name: Optional[str] = None,
+                           python_file_path: Optional[str] = None,
+                           update_rule_tree: bool = False):
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the generated python file is located.
-        :param package_name: The name of the package that contains the RDR classifier function, this
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
         is required in case of relative imports in the generated python file.
+        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
+        :param update_rule_tree: Whether to update the rule tree from the python file or not.
         """
         pass
 
@@ -805,24 +821,6 @@ class MultiClassTreeBuilder(TreeBuilder):
 
 class RDRWithCodeWriter(RippleDownRules, ABC):
 
-    @classmethod
-    def from_python(cls, model_path: str,
-                    python_file_path: Optional[str] = None,
-                    parent_package_name: Optional[str] = None) -> Self:
-        """
-        Load the RDR classifier from a generated python file.
-
-        :param model_path: The directory where the generated python file is located.
-        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
-        :param parent_package_name: The name of the package that contains the RDR classifier function, this
-        is required in case of relative imports in the generated python file.
-        :return: An instance of the RDR classifier.
-        """
-        rule_tree_root = cls.read_rule_tree_from_python(model_path, python_file_path=python_file_path)
-        rdr = cls(start_rule=rule_tree_root)
-        rdr.update_from_python(model_path, package_name=parent_package_name, python_file_path=python_file_path)
-        return rdr
-
     @classmethod
     def read_rule_tree_from_python(cls, model_path: str, python_file_path: Optional[str] = None) -> Rule:
         """
@@ -864,16 +862,19 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             return []
         return [r for r in [self.start_rule] + list(self.start_rule.descendants) if r.conditions is not None]
 
-    def update_from_python(self, model_dir: str, package_name: Optional[str] = None,
-                           python_file_path: Optional[str] = None):
+    def update_from_python(self, model_dir: str, parent_package_name: Optional[str] = None,
+                           python_file_path: Optional[str] = None, update_rule_tree: bool = False):
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the generated python file is located.
-        :param package_name: The name of the package that contains the RDR classifier function, this
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
         is required in case of relative imports in the generated python file.
         :param python_file_path: The path to the generated python file that contains the RDR classifier function.
+        :param update_rule_tree: Whether to update the rule tree from the python file or not.
         """
+        if update_rule_tree:
+            self.start_rule = self.read_rule_tree_from_python(model_dir, python_file_path=python_file_path)
         all_rules = self.all_rules
         condition_func_names = [rule.generated_conditions_function_name for rule in all_rules]
         conclusion_func_names = [rule.generated_conclusion_function_name for rule in all_rules
@@ -883,24 +884,24 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         main_module, defs_module, cases_module = self.get_and_import_model_python_modules(
                                                         model_dir,
                                                         python_file_path=python_file_path,
-                                                        parent_package_name=package_name)
+                                                        parent_package_name=parent_package_name)
         self.generated_python_file_name = Path(main_module.__file__).name.replace(".py", "")
 
         self.update_rdr_metadata_from_python(main_module)
 
         functions_source = extract_function_source(defs_module.__file__,
                                                    all_func_names, include_signature=True)
-        scope = extract_imports(defs_module.__file__, package_name=package_name)
+        scope = extract_imports(defs_module.__file__, package_name=parent_package_name)
 
         cases_source, cases_scope = None, None
         if cases_module:
             with open(cases_module.__file__, "r") as f:
                 cases_source = f.read()
-            cases_scope = extract_imports(cases_module.__file__, package_name=package_name)
+            cases_scope = extract_imports(cases_module.__file__, package_name=parent_package_name)
 
         with open(main_module.__file__, "r") as f:
             main_source = f.read()
-        main_scope = extract_imports(main_module.__file__, package_name=package_name)
+        main_scope = extract_imports(main_module.__file__, package_name=parent_package_name)
         attribute_name_line = [l for l in main_source.split('\n') if "attribute_name = " in l]
         conclusion_name = None
         if len(attribute_name_line) > 0:
@@ -1328,7 +1329,7 @@ class MultiClassRDR(RDRWithCodeWriter):
                     evaluated_rule.last_conclusion = rule_conclusion
                     if case_query is not None:
                         rule_conclusion_types = set(map(type, make_list(rule_conclusion)))
-                        if any(rule_conclusion_types.intersection(set(case_query.core_attribute_type))):
+                        if are_results_subclass_of_types(rule_conclusion_types, case_query.core_attribute_type):
                             evaluated_rule.contributed_to_case_query = True
                 self.add_conclusion(rule_conclusion)
             evaluated_rule = next_rule
@@ -1571,21 +1572,9 @@ class GeneralRDR(RippleDownRules):
         is required in case of relative imports in the generated python file.
         :return: An instance of the class.
         """
-        if python_file_path is None:
-            main_python_file_path = cls.get_generated_python_file_path(model_dir)
-        else:
-            main_python_file_path = python_file_path
-        main_module = get_and_import_python_module(main_python_file_path, parent_package_name=parent_package_name)
-        classifiers_dict = main_module.classifiers_dict
-        start_rules_dict = {}
-        for rdr_name, rdr_module in classifiers_dict.items():
-            rdr_acronym = rdr_module.__name__.split('_')[-1]
-            rdr_type = cls.get_rdr_type_from_acronym(rdr_acronym)
-            rdr_model_path = main_python_file_path.replace('_rdr.py', f'_{rdr_name}_{rdr_acronym}.py')
-            rdr = rdr_type.from_python(model_dir, python_file_path=rdr_model_path, parent_package_name=parent_package_name)
-            start_rules_dict[rdr_name] = rdr
-        grdr = cls(category_rdr_map=start_rules_dict)
-        grdr.update_rdr_metadata_from_python(main_module)
+        grdr = cls()
+        grdr.update_from_python(model_dir, parent_package_name=parent_package_name, python_file_path=python_file_path,
+                                update_rule_tree=True)
         return grdr
 
     @classmethod
@@ -1709,16 +1698,38 @@ class GeneralRDR(RippleDownRules):
             new_rdr.case_name = data["case_name"]
         return new_rdr
 
-    def update_from_python(self, model_dir: str, package_name: Optional[str] = None) -> None:
+    def update_from_python(self, model_dir: str, parent_package_name: Optional[str] = None,
+                           python_file_path: Optional[str] = None,
+                           update_rule_tree: bool = False) -> None:
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the model is stored.
-        :param package_name: The name of the package that contains the RDR classifier function, this
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
         is required in case of relative imports in the generated python file.
+        :param python_file_path: The path to the python file, if not provided, it will be generated from the model_dir.
+        :param update_rule_tree: Whether to update the rule tree from the python file or not.
         """
-        for rdr in self.start_rules_dict.values():
-            rdr.update_from_python(model_dir, package_name=package_name)
+        if update_rule_tree:
+            if python_file_path is None:
+                main_python_file_path = self.get_generated_python_file_path(model_dir)
+            else:
+                main_python_file_path = python_file_path
+            main_module = get_and_import_python_module(main_python_file_path, parent_package_name=parent_package_name)
+            classifiers_dict = main_module.classifiers_dict
+            self.start_rules_dict = {}
+            for rdr_name, rdr_module in classifiers_dict.items():
+                rdr_acronym = rdr_module.__name__.split('_')[-1]
+                rdr_type = self.get_rdr_type_from_acronym(rdr_acronym)
+                rdr_model_path = main_python_file_path.replace('_rdr.py', f'_{rdr_name}_{rdr_acronym}.py')
+                rdr = rdr_type.from_python(model_dir, python_file_path=rdr_model_path,
+                                           parent_package_name=parent_package_name)
+                self.start_rules_dict[rdr_name] = rdr
+
+            self.update_rdr_metadata_from_python(main_module)
+        else:
+            for rdr in self.start_rules_dict.values():
+                rdr.update_from_python(model_dir, parent_package_name=parent_package_name)
 
     def _write_to_python(self, model_dir: str, package_name: Optional[str] = None) -> None:
         """

ripple_down_rules/rdr_decorators.py

@@ -5,9 +5,11 @@ of the RDRs.
 """
 import os.path
 from functools import wraps
+from typing import get_origin
 
 from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union, Sequence
 
+from .utils import get_type_from_type_hint
 from .datastructures.case import Case
 from .datastructures.dataclasses import CaseQuery
 from .experts import Expert, Human
@@ -18,7 +20,7 @@ try:
 except ImportError:
     RDRCaseViewer = None
 from .utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
-    get_method_class_if_exists, str_to_snake_case
+    get_method_class_if_exists, str_to_snake_case, make_list
 
 
 class RDRDecorator:
@@ -77,7 +79,7 @@ class RDRDecorator:
             lambda f: f  # Default to no fitting decorator
         self.generate_dot_file = generate_dot_file
         self.not_none_output_found: bool = False
-        self.load()
+        self.origin_type: Optional[Type] = None
 
     def decorator(self, func: Callable) -> Callable:
 
@@ -86,6 +88,10 @@ class RDRDecorator:
 
             if self.model_name is None:
                 self.initialize_rdr_model_name_and_load(func)
+            if self.origin_type is None and not self.mutual_exclusive:
+                self.origin_type = get_origin(get_type_hints(func)['return'])
+                if self.origin_type:
+                    self.origin_type = get_type_from_type_hint(self.origin_type)
 
             func_output = {self.output_name: func(*args, **kwargs)}
 
@@ -125,6 +131,8 @@ class RDRDecorator:
                             self.not_none_output_found = True
 
             if self.output_name in output:
+                if self.origin_type == list:
+                    return make_list(output[self.output_name])
                 return output[self.output_name]
             else:
                 return func_output[self.output_name]
@@ -211,14 +219,10 @@ class RDRDecorator:
         """
         Load the RDR model from the specified directory.
         """
-        self.rdr = None
-        if self.model_name is not None:
-            self.rdr = GeneralRDR.load(self.rdr_models_dir, self.model_name, package_name=self.package_name)
-        if self.rdr is None:
-            self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name)
+        self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name)
 
     def update_from_python(self):
         """
         Update the RDR model from a python file.
         """
-        self.rdr.update_from_python(self.rdr_models_dir, package_name=self.package_name)
+        self.rdr.update_from_python(self.rdr_models_dir, parent_package_name=self.package_name)

ripple_down_rules/user_interface/ipython_custom_shell.py

@@ -165,7 +165,7 @@ class IPythonShell:
         """
         if self.shell.all_lines[-1] in ['quit', 'exit']:
             self.user_input = 'exit'
-        elif self.shell.all_lines[0].replace('return', '').strip() == '':
+        elif self.shell.all_lines[-1].replace('return', '').strip() == '':
             self.user_input = None
         else:
             self.all_code_lines = extract_dependencies(self.shell.all_lines)

{ripple_down_rules-0.6.46.dist-info → ripple_down_rules-0.6.48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.46
+Version: 0.6.48
 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.46.dist-info → ripple_down_rules-0.6.48.dist-info}/RECORD

@@ -1,9 +1,9 @@
-ripple_down_rules/__init__.py,sha256=BK-q-yssQG0Y05Fkmc-Gm7xHrKf32lFrbtphnAm2XD8,99
+ripple_down_rules/__init__.py,sha256=IIYp1vwC-NyqQshOebhowV9ynnc5PEZ-NFCbXeL057w,375
 ripple_down_rules/experts.py,sha256=KXwWCmDrCffu9HW3yNewqWc1e5rnPI5Rnc981w_5M7U,17896
 ripple_down_rules/failures.py,sha256=ZPypPwKjyVcJkY9YG6p538ld8ZzpdW6CrC1RmJi44Ek,42
-ripple_down_rules/helpers.py,sha256=X1psHOqrb4_xYN4ssQNB8S9aRKKsqgihAyWJurN0dqk,5499
-ripple_down_rules/rdr.py,sha256=Dq5bEuBuf3vct_I6Y3WmTtoTUzNsvHXNYvF5DFoKO14,83468
-ripple_down_rules/rdr_decorators.py,sha256=ehK9YFYCh21fnbuzOX000yBwVDXL-QqYuEfKoWNYyDU,11468
+ripple_down_rules/helpers.py,sha256=sVU1Q7HPbMh57X8zDYP6vj1maDoaVAvnXHpUYIbr_As,5715
+ripple_down_rules/rdr.py,sha256=M7CEjHIegJWiDZtn-B8Qf9CpMvplAkrFX3HiiyGQC7M,84292
+ripple_down_rules/rdr_decorators.py,sha256=sbrbo5qfhnY9dIge4sFlkn4p8yPNBWWQ1Nq-NvMDx20,11756
 ripple_down_rules/rules.py,sha256=L4Ws-x3g5ljE0GrDt4LAib2qtR1C1_Ra4cRcIB-IQDI,28702
 ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
 ripple_down_rules/utils.py,sha256=5UL4h-m5Q4l7RyCYqmUmDDxUAkFqPYpFa3QldDYoJUE,80752
@@ -14,12 +14,12 @@ ripple_down_rules/datastructures/dataclasses.py,sha256=3vX52WrAHgVyw0LUSgSBOVFaQ
 ripple_down_rules/datastructures/enums.py,sha256=CvcROl8fE7A6uTbMfs2lLpyxwS_ZFtFcQlBDDKFfoHc,6059
 ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/user_interface/gui.py,sha256=K6cvA9TOXIDpk0quGCamrWqDRlvz0QruDaTj4Y4PWWI,28544
-ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=RLdPqPxx-a0Sh74UZWyRBuxS_OKeXJnzoDfms4i-Aus,7710
+ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=GQf5Je5szkPH17g42zHQ3cKy_MATywXV2bCpwSKKsZE,7711
 ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
 ripple_down_rules/user_interface/prompt.py,sha256=WPbw_8_-8SpF2ISyRZRuFwPKBEuGC4HaX3lbCPFHhh8,10314
 ripple_down_rules/user_interface/template_file_creator.py,sha256=uSbosZS15MOR3Nv7M3MrFuoiKXyP4cBId-EK3I6stHM,13660
-ripple_down_rules-0.6.46.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.6.46.dist-info/METADATA,sha256=9BzQNnZOCR9GYOIM3DuKycWbsZzjyhRhFz22IVcUCOU,48294
-ripple_down_rules-0.6.46.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.6.46.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.6.46.dist-info/RECORD,,
+ripple_down_rules-0.6.48.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.6.48.dist-info/METADATA,sha256=rkNl0nbm5W3NGX6q5io1EOkLHYgY0mtWdE_F0Y0u7Jk,48294
+ripple_down_rules-0.6.48.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.6.48.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.6.48.dist-info/RECORD,,