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

ripple_down_rules-0.5.90/.gitignore

@@ -0,0 +1,2 @@
+*.pyc
+*.egg-info

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

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

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

{ripple_down_rules-0.5.88 → ripple_down_rules-0.5.90}/src/ripple_down_rules/datastructures/case.py

@@ -329,9 +329,9 @@ def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, ob
 
 def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] = None,
                                   current_conclusions: Optional[Dict[str, Any]] = None,
-                                  last_evaluated_rule: Optional[Rule] = None) -> None:
+                                  last_evaluated_rule: Optional[Rule] = None) -> str:
     """
-    Show the data of the new case and if last evaluated rule exists also show that of the corner case.
+    Get the the data to show of the new case and if last evaluated rule exists also show that of the corner case.
 
     :param case: The new case.
     :param targets: The target attribute of the case.
@@ -341,9 +341,10 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
     corner_case = None
     targets = {f"target_{name}": value for name, value in targets.items()} if targets else {}
     current_conclusions = {name: value for name, value in current_conclusions.items()} if current_conclusions else {}
+    information = ""
     if last_evaluated_rule:
         action = "Refinement" if last_evaluated_rule.fired else "Alternative"
-        print(f"{action} needed for rule: {last_evaluated_rule}\n")
+        information += f"{action} needed for rule: {last_evaluated_rule}\n"
         corner_case = last_evaluated_rule.corner_case
 
     corner_row_dict = None
@@ -367,6 +368,6 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
         corner_conclusion = last_evaluated_rule.conclusion(case)
         corner_row_dict.update({corner_conclusion.__class__.__name__: corner_conclusion})
         all_table_rows.append(corner_row_dict)
-        # print(table_rows_as_str(corner_row_dict))
-    print("\n" + "=" * 50)
-    print(table_rows_as_str(all_table_rows))
+    information += "\n" + "=" * 50 + "\n"
+    information += "\n" + table_rows_as_str(all_table_rows) + "\n"
+    return information

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

@@ -225,12 +225,13 @@ class Human(Expert):
     def ask_for_conditions(self, case_query: CaseQuery,
                            last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
+        data_to_show = None
         if (not self.use_loaded_answers or len(self.all_expert_answers) == 0) and self.user_prompt.viewer is None:
-            show_current_and_corner_cases(case_query.case, {case_query.attribute_name: case_query.target_value},
+            data_to_show = show_current_and_corner_cases(case_query.case, {case_query.attribute_name: case_query.target_value},
                                           last_evaluated_rule=last_evaluated_rule)
-        return self._get_conditions(case_query)
+        return self._get_conditions(case_query, data_to_show)
 
-    def _get_conditions(self, case_query: CaseQuery) \
+    def _get_conditions(self, case_query: CaseQuery, data_to_show: Optional[str] = None) \
             -> CallableExpression:
         """
         Ask the expert to provide the differentiating features between two cases or unique features for a case
@@ -251,7 +252,7 @@ class Human(Expert):
             case_query.scope.update(loaded_scope)
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
-            user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions)
+            user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions, prompt_str=data_to_show)
         if user_input == 'exit':
             exit()
         if not self.use_loaded_answers:
@@ -283,9 +284,10 @@ class Human(Expert):
             except IndexError:
                 self.use_loaded_answers = False
         if not self.use_loaded_answers:
+            data_to_show = None
             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)
+                data_to_show = show_current_and_corner_cases(case_query.case)
+            expert_input, expression = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conclusion, prompt_str=data_to_show)
             if expert_input is None:
                 self.all_expert_answers.append(({}, None))
             elif expert_input != 'exit':

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

@@ -20,14 +20,14 @@ 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
+from threading import RLock
 
 
 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
+    shell_lock: RLock = RLock()  # To ensure that only one thread can access the shell at a time
 
     def __init__(self, viewer: Optional[RDRCaseViewer] = None):
         """
@@ -52,8 +52,8 @@ class UserPrompt:
         prev_user_input: Optional[str] = None
         callable_expression: Optional[CallableExpression] = None
         while True:
-            user_input, expression_tree = self.prompt_user_about_case(case_query, prompt_for, prompt_str,
-                                                                 code_to_modify=prev_user_input)
+            with self.shell_lock:
+                user_input, expression_tree = self.prompt_user_about_case(case_query, prompt_for, prompt_str, code_to_modify=prev_user_input)
             if user_input is None:
                 if prompt_for == PromptFor.Conclusion:
                     self.print_func(f"{Fore.YELLOW}No conclusion provided. Exiting.{Style.RESET_ALL}")
@@ -95,22 +95,26 @@ class UserPrompt:
         :param code_to_modify: The code to modify. If given will be used as a start for user to modify.
         :return: The user input, and the executable expression that was parsed from the user input.
         """
-        if prompt_str is None:
-            if prompt_for == PromptFor.Conclusion:
-                prompt_str = f"Give possible value(s) for:"
-            else:
-                prompt_str = f"Give conditions on when can the rule be evaluated for:"
+        self.print_func("Entered shell")
+        prompt_str = f"{Fore.WHITE}{prompt_str}" if prompt_str is not None else ''
+        if prompt_for == PromptFor.Conclusion:
+            prompt_str += f"\n{Fore.MAGENTA}Give possible value(s) for:"
+        else:
+            prompt_str += f"\n{Fore.MAGENTA}Give conditions on when can the rule be evaluated for:"
         case_query.scope.update({'case': case_query.case})
         shell = None
         if self.viewer is None:
             prompt_str = self.construct_prompt_str_for_shell(case_query, prompt_for, prompt_str)
             shell = IPythonShell(header=prompt_str, prompt_for=prompt_for, case_query=case_query,
-                                 code_to_modify=code_to_modify)
+                                    code_to_modify=code_to_modify)
         else:
 
             self.viewer.update_for_case_query(case_query, prompt_str,
-                                              prompt_for=prompt_for, code_to_modify=code_to_modify)
-        return self.prompt_user_input_and_parse_to_expression(shell=shell)
+                                                prompt_for=prompt_for, code_to_modify=code_to_modify)
+        user_input, expression_tree = self.prompt_user_input_and_parse_to_expression(shell=shell)
+        self.print_func("Exited shell")
+        return user_input, expression_tree
+
 
 
     def construct_prompt_str_for_shell(self, case_query: CaseQuery, prompt_for: PromptFor,
@@ -128,9 +132,9 @@ class UserPrompt:
             prompt_str += (f"\ne.g. `{Fore.GREEN}return {Fore.BLUE}len{Fore.RESET}(case.attribute) > {Fore.BLUE}0` "
                            f"{Fore.MAGENTA}\nOR `{Fore.GREEN}return {Fore.YELLOW}True`{Fore.MAGENTA} (If you want the"
                            f" rule to be always evaluated) \n"
-                           f"You can also do {Fore.YELLOW}%edit{Fore.MAGENTA} for more complex conditions.")
+                           f"You can also do {Fore.YELLOW}%edit{Fore.MAGENTA} for more complex conditions.\n")
 
-        prompt_str = f"{Fore.MAGENTA}{prompt_str}{Fore.YELLOW}\n(Write %help for guide){Fore.RESET}"
+        prompt_str = f"{Fore.MAGENTA}{prompt_str}{Fore.YELLOW}\n(Write %help for guide){Fore.RESET}\n"
         return prompt_str
 
 
@@ -167,16 +171,15 @@ class UserPrompt:
         :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
+        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.88 → ripple_down_rules-0.5.90}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.88
+Version: 0.5.90
 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.88 → ripple_down_rules-0.5.90}/src/ripple_down_rules.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+.gitignore
 LICENSE
 README.md
 pyproject.toml