ripple-down-rules 0.5.85__py3-none-any.whl → 0.5.87__py3-none-any.whl

ripple_down_rules/__init__.py

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

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/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/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/user_interface/prompt.py

@@ -58,6 +58,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,
@@ -150,8 +154,8 @@ class UserPrompt:
                     self.viewer.show()
                     app.exec()
                     user_input = self.viewer.user_input
-                if user_input is None:
-                    return None, None
+                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)

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/utils.py

@@ -863,14 +863,14 @@ def get_relative_import(target_file_path, imported_module_path: Optional[str] =
     # Convert to absolute paths
     target_path = Path(target_file_path).resolve()
     if package_name is not None:
-        target_path = Path(get_path_starting_from(str(target_path), package_name))
+        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")
     imported_path = Path(imported_module_path).resolve()
     if package_name is not None:
-        imported_path = Path(get_path_starting_from(str(imported_path), package_name))
+        imported_path = Path(get_path_starting_from_latest_encounter_of(str(imported_path), package_name))
 
     # Compute relative path from target to imported module
     rel_path = os.path.relpath(imported_path.parent, target_path.parent)
@@ -878,15 +878,18 @@ 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 != '.']
+
 
     # Join the parts and add the module name
-    joined_parts = "".join(rel_parts) + f".{imported_path.stem}"
+    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
 
     return joined_parts
 
 
-def get_path_starting_from(path: str, package_name: str) -> Optional[str]:
+def get_path_starting_from_latest_encounter_of(path: str, package_name: str) -> Optional[str]:
     """
     Get the path starting from the package name.
 
@@ -895,57 +898,67 @@ def get_path_starting_from(path: str, package_name: str) -> Optional[str]:
     :return: The path starting from the package name or None if not found.
     """
     if package_name in path:
-        idx = path.index(package_name)
+        idx = path.rfind(package_name)
         return path[idx:]
     return None
 
 
 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)
 
 
@@ -1373,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
@@ -1385,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.85.dist-info → ripple_down_rules-0.5.87.dist-info}/METADATA

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

@@ -1,11 +1,11 @@
-ripple_down_rules/__init__.py,sha256=49RvNTpGUXv7fYtLSLpbwGCoAhuRvpyyEmnErrZRwHs,100
-ripple_down_rules/experts.py,sha256=bwozulI1rv0uyaMZQqEgapDO-s8wvW0D6Jqxmvu5fik,12610
+ripple_down_rules/__init__.py,sha256=GkugTXRcQu2cnGcyrT7Ra2SGmRhDvnkbdHlrvXqCmfw,100
+ripple_down_rules/experts.py,sha256=J4VaYPKrAMNcoP0JRenZpx9IHLLoeFdl0QZKZzjFFkM,12768
 ripple_down_rules/helpers.py,sha256=v4oE7C5PfQUVJfSUs1FfLHEwrJXEHJLn4vJhJMvyCR8,4453
 ripple_down_rules/rdr.py,sha256=C6bvlq6MsKa2Mym1wW6JUMj705aCaoihTP279TM6eT0,55218
-ripple_down_rules/rdr_decorators.py,sha256=amXUjgc-rfYxPKFW16Xm8Z9vfaaslNl5OvDOg9fKaTg,9447
+ripple_down_rules/rdr_decorators.py,sha256=pj7SwswB9UVdv4-c8pzcOsGTG0Elt7JEG6k65fsnOdk,9202
 ripple_down_rules/rules.py,sha256=iVevv6iZ-6L2IPI0ZYbBjxBymXEQMmJGRFhiKUS-NmA,20352
 ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=VMOjMU2YyhUMDfBSZSjQlqi6ka-0cu014hl3OGTu3pQ,60962
+ripple_down_rules/utils.py,sha256=KvD-uqPfHw5THsIrR0D52oKqKggvKk5sfachARDg7PM,61978
 ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
 ripple_down_rules/datastructures/callable_expression.py,sha256=f3wUPTrLa1INO-1qfgVz87ryrCABronfyq0_JKWoZCs,12800
 ripple_down_rules/datastructures/case.py,sha256=1zSaXUljaH6z3SgMGzYPoDyjotNam791KpYgvxuMh90,15463
@@ -13,12 +13,12 @@ ripple_down_rules/datastructures/dataclasses.py,sha256=qoTFHV8Hi-X8VtfC9VdvH4tif
 ripple_down_rules/datastructures/enums.py,sha256=ce7tqS0otfSTNAOwsnXlhsvIn4iW_Y_N3TNebF3YoZs,5700
 ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/user_interface/gui.py,sha256=_lgZAUXxxaBUFQJAHjA5TBPp6XEvJ62t-kSN8sPsocE,27379
-ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=Jrf7NxOdlrwGXH0Xyz3vzQprY-PNx9etfePOTpm2Gu8,6479
+ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=6v99tlNcfRyZpnPxq3FfqgFgxbJ5zkA2jVAXamTH1C0,6575
 ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
-ripple_down_rules/user_interface/prompt.py,sha256=AkkltdDIaioN43lkRKDPKSjJcmdSSGZDMYz7AL7X9lE,8082
-ripple_down_rules/user_interface/template_file_creator.py,sha256=xWUt-RHRqrvoMo74o-bMLo8xNxil68wgbOZAMADZp2A,13570
-ripple_down_rules-0.5.85.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.5.85.dist-info/METADATA,sha256=1tFTBGloFOMxSnYhJT6h5obVH_-UNfKQumICBkDmmwU,48214
-ripple_down_rules-0.5.85.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.5.85.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.5.85.dist-info/RECORD,,
+ripple_down_rules/user_interface/prompt.py,sha256=Liu24-wuL12mg2xI7FBvnL6T1eyykCcMZ3AeKkkYwpA,8283
+ripple_down_rules/user_interface/template_file_creator.py,sha256=ELHYhZEjHsMdG5ebbOghfZtPBpPtuJDWQRAkLpfcSFM,13553
+ripple_down_rules-0.5.87.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.87.dist-info/METADATA,sha256=L_EDvPOt6ibGEoNS6qgGXSFQ5zJkJdpPCKlB937_vzc,48214
+ripple_down_rules-0.5.87.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.5.87.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.87.dist-info/RECORD,,