ripple-down-rules 0.5.86__tar.gz → 0.5.88__tar.gz

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/PKG-INFO

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

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

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/src/ripple_down_rules/experts.py

@@ -252,6 +252,8 @@ class Human(Expert):
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
             user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions)
+        if user_input == 'exit':
+            exit()
         if not self.use_loaded_answers:
             self.all_expert_answers.append((condition.scope, user_input))
             if self.answers_save_path is not None:
@@ -284,11 +286,13 @@ class Human(Expert):
             if self.user_prompt.viewer is None:
                 show_current_and_corner_cases(case_query.case)
             expert_input, expression = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conclusion)
-            if expression is None:
+            if expert_input is None:
                 self.all_expert_answers.append(({}, None))
-            else:
+            elif expert_input != 'exit':
                 self.all_expert_answers.append((expression.scope, expert_input))
-            if self.answers_save_path is not None:
+            if self.answers_save_path is not None and expert_input != 'exit':
                 self.save_answers()
+        if expert_input == 'exit':
+            exit()
         case_query.target = expression
         return expression

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/src/ripple_down_rules/rdr_decorators.py

@@ -29,7 +29,6 @@ class RDRDecorator:
                  output_name: str = "output_",
                  fit: bool = True,
                  expert: Optional[Expert] = None,
-                 ask_always: bool = False,
                  update_existing_rules: bool = True,
                  viewer: Optional[RDRCaseViewer] = None,
                  package_name: Optional[str] = None):
@@ -44,7 +43,6 @@ class RDRDecorator:
             classification mode. This means that the RDR will classify the function's output based on the RDR model.
         :param expert: The expert that will be used to prompt the user for the correct output. If None, a Human
             expert will be used.
-        :param ask_always: If True, the function will ask the user for a target if it doesn't exist.
         :param update_existing_rules: If True, the function will update the existing RDR rules
          even if they gave an output.
         :param viewer: The viewer to use for the RDR model. If None, no viewer will be used.
@@ -59,7 +57,6 @@ class RDRDecorator:
         self.output_name = output_name
         self.fit: bool = fit
         self.expert: Optional[Expert] = expert
-        self.ask_always = ask_always
         self.update_existing_rules = update_existing_rules
         self.viewer = viewer
         self.package_name = package_name
@@ -76,7 +73,7 @@ class RDRDecorator:
                 self.initialize_rdr_model_name_and_load(func)
             if self.expert is None:
                 self.expert = Human(viewer=self.viewer,
-                                    answers_save_path=self.rdr_models_dir + f'/expert_answers')
+                                    answers_save_path=self.rdr_models_dir + f'/{self.model_name}/expert_answers')
 
             func_output = {self.output_name: func(*args, **kwargs)}
 
@@ -86,7 +83,6 @@ class RDRDecorator:
                                                                 self.mutual_exclusive,
                                                                 *args, **kwargs)
                 output = self.rdr.fit_case(case_query, expert=self.expert,
-                                           ask_always_for_target=self.ask_always,
                                            update_existing_rules=self.update_existing_rules,
                                            viewer=self.viewer)
             else:
@@ -170,7 +166,7 @@ class RDRDecorator:
         """
         Save the RDR model to the specified directory.
         """
-        self.rdr.save(self.rdr_models_dir, package_name=self.package_name)
+        self.rdr.save(self.rdr_models_dir, self.model_name, package_name=self.package_name)
 
     def load(self):
         """
@@ -190,4 +186,4 @@ class RDRDecorator:
         """
         Update the RDR model from a python file.
         """
-        self.rdr.update_from_python(self.rdr_models_dir, self.model_name, package_name=self.package_name)
+        self.rdr.update_from_python(self.rdr_models_dir, package_name=self.package_name)

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/src/ripple_down_rules/user_interface/ipython_custom_shell.py

@@ -134,7 +134,9 @@ class IPythonShell:
         """
         Update the user input from the code lines captured in the shell.
         """
-        if self.shell.all_lines[0].replace('return', '').strip() == '':
+        if self.shell.all_lines[-1] in ['quit', 'exit']:
+            self.user_input = 'exit'
+        elif self.shell.all_lines[0].replace('return', '').strip() == '':
             self.user_input = None
         else:
             self.all_code_lines = extract_dependencies(self.shell.all_lines)

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/src/ripple_down_rules/user_interface/prompt.py

@@ -20,12 +20,15 @@ from ..datastructures.dataclasses import CaseQuery
 from ..datastructures.enums import PromptFor
 from .ipython_custom_shell import IPythonShell
 from ..utils import make_list
+from threading import Lock
 
 
 class UserPrompt:
     """
     A class to handle user prompts for the RDR.
     """
+    shell_lock: Lock = Lock()  # To ensure that only one thread can access the shell at a time
+
     def __init__(self, viewer: Optional[RDRCaseViewer] = None):
         """
         Initialize the UserPrompt class.
@@ -58,6 +61,10 @@ class UserPrompt:
                 else:
                     self.print_func(f"{Fore.RED}Conditions must be provided. Please try again.{Style.RESET_ALL}")
                     continue
+            elif user_input == "exit":
+                self.print_func(f"{Fore.YELLOW}Exiting.{Style.RESET_ALL}")
+                return user_input, None
+                
             prev_user_input = '\n'.join(user_input.split('\n')[2:-1])
             conclusion_type = bool if prompt_for == PromptFor.Conditions else case_query.attribute_type
             callable_expression = CallableExpression(user_input, conclusion_type, expression_tree=expression_tree,
@@ -139,19 +146,9 @@ class UserPrompt:
         """
         while True:
             if user_input is None:
-                if self.viewer is None:
-                    shell = IPythonShell() if shell is None else shell
-                    shell.run()
-                    user_input = shell.user_input
-                else:
-                    app = QApplication.instance()
-                    if app is None:
-                        raise RuntimeError("QApplication instance is None. Please run the application first.")
-                    self.viewer.show()
-                    app.exec()
-                    user_input = self.viewer.user_input
-                if user_input is None:
-                    return None, None
+                user_input = self.start_shell_and_get_user_input(shell=shell)
+                if user_input is None or user_input == 'exit':
+                    return user_input, None
                 self.print_func(f"{Fore.GREEN}Captured User input: {Style.RESET_ALL}")
                 highlighted_code = highlight(user_input, PythonLexer(), TerminalFormatter())
                 self.print_func(highlighted_code)
@@ -162,3 +159,24 @@ class UserPrompt:
                 logging.error(msg)
                 self.print_func(f"{Fore.RED}{msg}{Style.RESET_ALL}")
                 user_input = None
+
+    def start_shell_and_get_user_input(self, shell: Optional[IPythonShell] = None) -> Optional[str]:
+        """
+        Start the shell and get user input.
+
+        :param shell: The Ipython shell to use for prompting the user.
+        :return: The user input.
+        """
+        with self.shell_lock:
+            if self.viewer is None:
+                shell = IPythonShell() if shell is None else shell
+                shell.run()
+                user_input = shell.user_input
+            else:
+                app = QApplication.instance()
+                if app is None:
+                    raise RuntimeError("QApplication instance is None. Please run the application first.")
+                self.viewer.show()
+                app.exec()
+                user_input = self.viewer.user_input
+            return user_input

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/src/ripple_down_rules/user_interface/template_file_creator.py

@@ -222,10 +222,9 @@ class TemplateFileCreator:
             if list in self.output_type:
                 output_type_imports.append(List)
         import_types = list(self.case_query.scope.values())
-        # imports = [i for i in imports if ("get_ipython" not in i)]
         import_types.extend(case_type_imports)
         import_types.extend(output_type_imports)
-        imports = get_imports_from_types(import_types)
+        imports = get_imports_from_types(import_types, excluded_modules=["IPython.core.interactiveshell"])
         imports = set(imports)
         return '\n'.join(imports)
 

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/src/ripple_down_rules/utils.py

@@ -905,50 +905,60 @@ def get_path_starting_from_latest_encounter_of(path: str, package_name: str) ->
 
 def get_imports_from_types(type_objs: Iterable[Type],
                            target_file_path: Optional[str] = None,
-                           package_name: Optional[str] = None) -> List[str]:
+                           package_name: Optional[str] = None,
+                           exclueded_names: Optional[List[str]] = None,
+                           excluded_modules: Optional[List[str]] = None) -> List[str]:
     """
     Format import lines from type objects.
 
     :param type_objs: A list of type objects to format.
     :param target_file_path: The file path to which the imports should be relative.
     :param package_name: The name of the package to use for relative imports.
+    :param exclueded_names: A list of names to exclude from the imports.
+    :param excluded_modules: A list of modules to exclude from the imports.
+    :return: A list of formatted import lines.
     """
-
+    excluded_modules = [] if excluded_modules is None else excluded_modules
+    exclueded_names = [] if exclueded_names is None else exclueded_names
     module_to_types = defaultdict(list)
-    module_to_path = {}
-    other_imports = []
     for tp in type_objs:
         try:
             if isinstance(tp, type) or is_typing_type(tp):
                 module = tp.__module__
-                file = getattr(tp, '__file__', None)
                 name = tp.__qualname__
             elif callable(tp):
                 module, name = get_function_import_data(tp)
-                file = get_method_file_name(tp)
             elif hasattr(type(tp), "__module__"):
                 module = type(tp).__module__
-                file = getattr(tp, '__file__', None)
                 name = type(tp).__qualname__
             else:
                 continue
-            if module is None or module == 'builtins' or module.startswith('_'):
+            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
             module_to_types[module].append(name)
-            if file:
-                module_to_path[module] = file
         except AttributeError:
             continue
 
     lines = []
+    stem_imports = []
     for module, names in module_to_types.items():
-        joined = ", ".join(sorted(set(names)))
+        filtered_names = set()
+        for name in set(names):
+            if '.' in name:
+                stem = '.'.join(name.split('.')[1:])
+                name_to_import = name.split('.')[0]
+                filtered_names.add(name_to_import)
+                stem_imports.append(f"{stem} = {name_to_import}.{stem}")
+            else:
+                filtered_names.add(name)
+        joined = ", ".join(sorted(set(filtered_names)))
         import_path = module
         if (target_file_path is not None) and (package_name is not None) and (package_name in module):
             import_path = get_relative_import(target_file_path, module=module, package_name=package_name)
         lines.append(f"from {import_path} import {joined}")
-    if other_imports:
-        lines.extend(other_imports)
+    lines.extend(stem_imports)
     return sorted(lines)
 
 
@@ -1376,6 +1386,7 @@ def table_rows_as_str(row_dicts: List[Dict[str, Any]], columns_per_row: int = 20
     :param row_dicts: The rows to print.
     :param columns_per_row: The maximum number of columns per row.
     """
+    max_line_sze = 100
     all_row_dicts_items = [list(row_dict.items()) for row_dict in row_dicts]
     # make items a list of n rows such that each row has a max size of 4
     all_items = [all_items[i:i + columns_per_row] for all_items in all_row_dicts_items
@@ -1388,9 +1399,9 @@ def table_rows_as_str(row_dicts: List[Dict[str, Any]], columns_per_row: int = 20
     keys_values = [list(r[0]) + list(r[1]) if len(r) > 1 else r[0] for r in keys_values]
     all_table_rows = []
     row_values = [list(map(lambda v: str(v) if v is not None else "", row)) for row in keys_values]
-    row_values = [list(map(lambda v: v[:150] + '...' if len(v) > 150 else v, row)) for row in row_values]
+    row_values = [list(map(lambda v: v[:max_line_sze] + '...' if len(v) > max_line_sze else v, row)) for row in row_values]
     row_values = [list(map(lambda v: v.lower() if v in ["True", "False"] else v, row)) for row in row_values]
-    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=[150] * 2)
+    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=[max_line_sze] * 2)
     all_table_rows.append(table)
     return "\n".join(all_table_rows)
 

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.86
+Version: 0.5.88
 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.86 → ripple_down_rules-0.5.88}/test/test_rdr.py

@@ -69,7 +69,7 @@ class TestRDR(TestCase):
         scrdr, _ = get_fit_scrdr(self.all_cases, self.targets, draw_tree=False,
                                  expert_answers_dir=self.expert_answers_dir,
                                  expert_answers_file="scrdr_expert_answers_fit",
-                                 load_answers=True,
+                                 load_answers=False,
                                  scenario=self.test_fit_scrdr)
         # render_tree(scrdr.start_rule, use_dot_exporter=True,
         #             filename=self.test_results_dir + f"/scrdr")

{ripple_down_rules-0.5.86 → ripple_down_rules-0.5.88}/test/test_rdr_helpers_rdrs.py

@@ -10,7 +10,7 @@ from ripple_down_rules.utils import is_iterable, make_list
 save_dir = join(dirname(__file__), '..', 'src', 'ripple_down_rules')
 # viewer = RDRCaseViewer(save_dir=save_dir)
 viewer = None
-rdr_decorator: RDRDecorator = RDRDecorator(save_dir, (bool,), True, ask_always=True,
+rdr_decorator: RDRDecorator = RDRDecorator(save_dir, (bool,), True,
                                            fit=False,
                                            viewer=viewer)
 
@@ -18,7 +18,6 @@ rdr_decorator: RDRDecorator = RDRDecorator(save_dir, (bool,), True, ask_always=T
 @rdr_decorator.decorator
 def should_i_ask_the_expert_for_a_target(conclusions: Union[Any, Dict[str, Any]],
                                          case_query: CaseQuery,
-                                         ask_always: bool,
                                          update_existing: bool) -> bool:
     """
     Determine if the rdr should ask the expert for the target of a given case query.
@@ -29,9 +28,7 @@ def should_i_ask_the_expert_for_a_target(conclusions: Union[Any, Dict[str, Any]]
     :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 ask_always:
-        return True
-    elif conclusions is None:
+    if conclusions is None:
         return True
     elif is_iterable(conclusions) and len(conclusions) == 0:
         return True