ripple-down-rules 0.6.27__tar.gz → 0.6.29__tar.gz

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.27
+Version: 0.6.29
 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.29/src/ripple_down_rules/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.6.29"
+
+import logging
+logger = logging.Logger("rdr")
+logger.setLevel(logging.INFO)

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -120,7 +120,9 @@ class CallableExpression(SubclassJSONSerializer):
             self.user_defined_name = user_input.split('(')[0].replace('def ', '')
         else:
             self.user_defined_name = user_input
-        self._user_input: str = encapsulate_user_input(user_input, self.get_encapsulating_function())
+        if f"def {self.encapsulating_function_name}" not in user_input:
+            user_input = encapsulate_user_input(user_input, self.get_encapsulating_function())
+        self._user_input: str = user_input
         if conclusion_type is not None:
             if is_iterable(conclusion_type):
                 conclusion_type = tuple(conclusion_type)
@@ -308,7 +310,7 @@ def parse_string_to_expression(expression_str: str) -> AST:
     :param expression_str: The string which will be parsed.
     :return: The parsed expression.
     """
-    if not expression_str.startswith(CallableExpression.get_encapsulating_function()):
+    if not expression_str.startswith(f"def {CallableExpression.encapsulating_function_name}"):
         expression_str = encapsulate_user_input(expression_str, CallableExpression.get_encapsulating_function())
     mode = 'exec' if expression_str.startswith('def') else 'eval'
     tree = ast.parse(expression_str, mode=mode)

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules/datastructures/enums.py

@@ -7,6 +7,19 @@ from typing_extensions import List, Dict, Any, Type
 from ripple_down_rules.utils import SubclassJSONSerializer
 
 
+class ExitStatus(Enum):
+    """
+    Describes the status at exit of the user interface.
+    """
+    CLOSE = auto()
+    """
+    The user wants to stop the program.
+    """
+    SUCCESS = auto()
+    """
+    The user completed the task successfully.
+    """
+
 class InteractionMode(Enum):
     """
     The interaction mode of the RDR.

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules/experts.py

@@ -6,6 +6,8 @@ import logging
 import os
 import uuid
 from abc import ABC, abstractmethod
+from textwrap import dedent, indent
+from typing import Tuple, Dict
 
 from typing_extensions import Optional, TYPE_CHECKING, List
 
@@ -13,6 +15,7 @@ from .datastructures.callable_expression import CallableExpression
 from .datastructures.enums import PromptFor
 from .datastructures.dataclasses import CaseQuery
 from .datastructures.case import show_current_and_corner_cases
+from .user_interface.template_file_creator import TemplateFileCreator
 from .utils import extract_imports, extract_function_source, get_imports_from_scope, encapsulate_user_input
 
 try:
@@ -46,14 +49,12 @@ class Expert(ABC):
                  answers_save_path: Optional[str] = None):
         self.all_expert_answers = []
         self.use_loaded_answers = use_loaded_answers
-        self.append = append
+        self.append = True
         self.answers_save_path = answers_save_path
         if answers_save_path is not None and os.path.exists(answers_save_path + '.py'):
             if use_loaded_answers:
                 self.load_answers(answers_save_path)
-            else:
-                os.remove(answers_save_path + '.py')
-            self.append = True
+            os.remove(answers_save_path + '.py')
 
     @abstractmethod
     def ask_for_conditions(self, case_query: CaseQuery, last_evaluated_rule: Optional[Rule] = None) \
@@ -89,28 +90,26 @@ class Expert(ABC):
                                 "answers_save_path attribute.")
         if path is None:
             path = self.answers_save_path
-        if os.path.exists(path + '.json'):
-            os.remove(path + '.json')
         if os.path.exists(path + '.py'):
             os.remove(path + '.py')
         self.all_expert_answers = []
 
-    def save_answers(self, path: Optional[str] = None):
+    def save_answers(self, path: Optional[str] = None, expert_answers: Optional[List[Tuple[Dict, str]]] = None):
         """
         Save the expert answers to a file.
 
         :param path: The path to save the answers to.
+        :param expert_answers: The expert answers to save.
         """
+        expert_answers = expert_answers if expert_answers else self.all_expert_answers
+        if not any(expert_answers):
+            return
         if path is None and self.answers_save_path is None:
             raise ValueError("No path provided to save expert answers, either provide a path or set the "
                                 "answers_save_path attribute.")
         if path is None:
             path = self.answers_save_path
-        is_json = os.path.exists(path + '.json')
-        if is_json:
-            self._save_to_json(path)
-        else:
-            self._save_to_python(path)
+        self._save_to_python(path, expert_answers=expert_answers)
 
     def _save_to_json(self, path: str):
         """
@@ -127,12 +126,14 @@ class Expert(ABC):
         with open(path + '.json', "w") as f:
             json.dump(all_answers, f)
 
-    def _save_to_python(self, path: str):
+    def _save_to_python(self, path: str, expert_answers: Optional[List[Tuple[Dict, str]]] = None):
         """
         Save the expert answers to a Python file.
 
         :param path: The path to save the answers to.
+        :param expert_answers: The expert answers to save.
         """
+        expert_answers = expert_answers if expert_answers else self.all_expert_answers
         dir_name = os.path.dirname(path)
         if not os.path.exists(dir_name + '/__init__.py'):
             os.makedirs(dir_name, exist_ok=True)
@@ -145,18 +146,13 @@ class Expert(ABC):
                 current_file_data = f.read()
         action = 'a' if self.append and current_file_data is not None else 'w'
         with open(path + '.py', action) as f:
-            for scope, func_source in self.all_expert_answers:
+            for scope, func_source in expert_answers:
                 if len(scope) > 0:
                     imports = '\n'.join(get_imports_from_scope(scope)) + '\n\n\n'
                 else:
                     imports = ''
-                if func_source is not None:
-                    uid = uuid.uuid4().hex
-                    func_source = encapsulate_user_input(func_source, CallableExpression.get_encapsulating_function(f'_{uid}'))
-                else:
+                if func_source is None:
                     func_source = 'pass  # No user input provided for this case.\n'
-                if current_file_data is not None and func_source[1:] in current_file_data:
-                    continue
                 f.write(imports + func_source + '\n' + '\n\n\n\'===New Answer===\'\n\n\n')
 
     def load_answers(self, path: Optional[str] = None):
@@ -170,11 +166,10 @@ class Expert(ABC):
                                 "answers_save_path attribute.")
         if path is None:
             path = self.answers_save_path
-        is_json = os.path.exists(path + '.json')
-        if is_json:
-            self._load_answers_from_json(path)
-        elif os.path.exists(path + '.py'):
+        if os.path.exists(path + '.py'):
             self._load_answers_from_python(path)
+        elif os.path.exists(path + '.json'):
+            self._load_answers_from_json(path)
 
     def _load_answers_from_json(self, path: str):
         """
@@ -195,15 +190,15 @@ class Expert(ABC):
         file_path = path + '.py'
         with open(file_path, "r") as f:
             all_answers = f.read().split('\n\n\n\'===New Answer===\'\n\n\n')[:-1]
-        all_function_sources = list(extract_function_source(file_path, []).values())
-        all_function_sources_names = list(extract_function_source(file_path, []).keys())
+        all_function_sources = extract_function_source(file_path, [], as_list=True)
         for i, answer in enumerate(all_answers):
             answer = answer.strip('\n').strip()
             if 'def ' not in answer and 'pass' in answer:
                 self.all_expert_answers.append(({}, None))
                 continue
             scope = extract_imports(tree=ast.parse(answer))
-            function_source = all_function_sources[i].replace(all_function_sources_names[i],
+            func_name = all_function_sources[i].split('def ')[1].split('(')[0]
+            function_source = all_function_sources[i].replace(func_name,
                                                               CallableExpression.encapsulating_function_name)
             self.all_expert_answers.append((scope, function_source))
 
@@ -213,14 +208,12 @@ class Human(Expert):
     The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
     """
 
-    def __init__(self, viewer: Optional[RDRCaseViewer] = None, **kwargs):
+    def __init__(self, **kwargs):
         """
         Initialize the Human expert.
-
-        :param viewer: The RDRCaseViewer instance to use for prompting the user.
         """
         super().__init__(**kwargs)
-        self.user_prompt = UserPrompt(viewer)
+        self.user_prompt = UserPrompt()
 
     def ask_for_conditions(self, case_query: CaseQuery,
                            last_evaluated_rule: Optional[Rule] = None) \
@@ -251,6 +244,8 @@ class Human(Expert):
         if user_input is not None:
             case_query.scope.update(loaded_scope)
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
+            if self.answers_save_path is not None and not any(loaded_scope):
+                self.convert_json_answer_to_python_answer(case_query, user_input, condition, PromptFor.Conditions)
         else:
             user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions, prompt_str=data_to_show)
         if user_input == 'exit':
@@ -262,6 +257,20 @@ class Human(Expert):
         case_query.conditions = condition
         return condition
 
+    def convert_json_answer_to_python_answer(self, case_query: CaseQuery, user_input: str,
+                                             callable_expression: CallableExpression,
+                                             prompt_for: PromptFor):
+        case_query.scope['case'] = case_query.case
+        tfc = TemplateFileCreator(case_query, prompt_for=prompt_for)
+        code = tfc.build_boilerplate_code()
+        if user_input.startswith('def'):
+            user_input = '\n'.join(user_input.split('\n')[1:])
+            user_input = indent(dedent(user_input), " " * 4).strip()
+            code = code.replace('pass', user_input)
+        else:
+            code = code.replace('pass', f"return {user_input}")
+        self.save_answers(expert_answers=[({}, code)])
+
     def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
         """
         Ask the expert to provide a conclusion for the case.
@@ -281,13 +290,17 @@ class Human(Expert):
                     expression = CallableExpression(expert_input, case_query.attribute_type,
                                                     scope=case_query.scope,
                                                     mutually_exclusive=case_query.mutually_exclusive)
+                    if self.answers_save_path is not None and not any(loaded_scope):
+                        self.convert_json_answer_to_python_answer(case_query, expert_input, expression,
+                                                                  PromptFor.Conclusion)
             except IndexError:
                 self.use_loaded_answers = False
         if not self.use_loaded_answers:
             data_to_show = None
             if self.user_prompt.viewer is None:
                 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)
+            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.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules/rdr.py

@@ -83,23 +83,18 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     Whether the output of the classification of this rdr allows only one possible conclusion or not.
     """
 
-    def __init__(self, start_rule: Optional[Rule] = None, viewer: Optional[RDRCaseViewer] = None,
+    def __init__(self, start_rule: Optional[Rule] = None,
                  save_dir: Optional[str] = None, model_name: Optional[str] = None):
         """
         :param start_rule: The starting rule for the classifier.
-        :param viewer: The viewer gui to use for the classifier. If None, no viewer is used.
         :param save_dir: The directory to save the classifier to.
         """
         self.model_name: Optional[str] = model_name
         self.save_dir = save_dir
         self.start_rule = start_rule
         self.fig: Optional[Figure] = None
-        self.viewer: Optional[RDRCaseViewer] = viewer
-        if viewer is None and RDRCaseViewer is not None:
-            if len(RDRCaseViewer.instances) > 0:
-                self.viewer = RDRCaseViewer.instances[0]
-                logger.error("No viewer was provided, but there is already an existing viewer. "
-                             "Using the existing viewer.")
+        self.viewer: Optional[RDRCaseViewer] = RDRCaseViewer.instances[0]\
+            if RDRCaseViewer and any(RDRCaseViewer.instances) else None
         self.input_node: Optional[Rule] = None
 
     @property
@@ -107,10 +102,10 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         return self._viewer
 
     @viewer.setter
-    def viewer(self, value):
-        self._viewer = value
-        if value is not None:
-            value.set_save_function(self.save)
+    def viewer(self, viewer):
+        self._viewer = viewer
+        if viewer:
+            viewer.set_save_function(self.save)
 
     def render_evaluated_rule_tree(self, filename: str, show_full_tree: bool = False) -> None:
         if show_full_tree:
@@ -235,7 +230,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         num_rules: int = 0
         while not stop_iterating:
             for case_query in case_queries:
-                pred_cat = self.fit_case(case_query, expert=expert, **kwargs_for_fit_case)
+                pred_cat = self.fit_case(case_query, expert=expert, clear_expert_answers=False,
+                                         **kwargs_for_fit_case)
                 if case_query.target is None:
                     continue
                 target = {case_query.attribute_name: case_query.target(case_query.case)}
@@ -313,6 +309,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                  update_existing_rules: bool = True,
                  scenario: Optional[Callable] = None,
                  ask_now: Callable = lambda _: True,
+                 clear_expert_answers: bool = True,
                  **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
@@ -324,7 +321,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param update_existing_rules: Whether to update the existing same conclusion type rules that already gave
         some conclusions with the type required by the case query.
         :param scenario: The scenario at which the case was created, this is used to recreate the case if needed.
-        :ask_now: Whether to ask the expert for refinements or alternatives.
+        :param ask_now: Whether to ask the expert for refinements or alternatives.
+        :param clear_expert_answers: Whether to clear expert answers after saving the new rule.
         :return: The category that the case belongs to.
         """
         if case_query is None:
@@ -335,8 +333,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         self.case_name = case_query.case_name if self.case_name is None else self.case_name
         case_query.scenario = scenario if case_query.scenario is None else case_query.scenario
 
-        expert = expert or Human(viewer=self.viewer,
-                                 answers_save_path=self.save_dir + '/expert_answers'
+        expert = expert or Human(answers_save_path=self.save_dir + '/expert_answers'
                                  if self.save_dir else None)
         if case_query.target is None:
             case_query_cp = copy(case_query)
@@ -354,7 +351,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
         if self.save_dir is not None:
             self.save()
-            expert.clear_answers()
+            if clear_expert_answers:
+                expert.clear_answers()
 
         return fit_case_result
 

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules/rdr_decorators.py

@@ -96,8 +96,7 @@ class RDRDecorator:
                 if len(self.parsed_output_type) == 0:
                     self.parsed_output_type = self.parse_output_type(func, self.output_type, *args)
                 if self.expert is None:
-                    self.expert = Human(viewer=self.viewer,
-                                        answers_save_path=self.rdr_models_dir + f'/{self.model_name}/expert_answers')
+                    self.expert = Human(answers_save_path=self.rdr_models_dir + f'/{self.model_name}/expert_answers')
                 case_query = self.create_case_query_from_method(func, func_output,
                                                                 self.parsed_output_type,
                                                                 self.mutual_exclusive,

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules/user_interface/gui.py

@@ -21,7 +21,7 @@ except ImportError as e:
 from typing_extensions import Optional, Any, List, Dict, Callable
 
 from ..datastructures.dataclasses import CaseQuery
-from ..datastructures.enums import PromptFor
+from ..datastructures.enums import PromptFor, ExitStatus
 from .template_file_creator import TemplateFileCreator
 from ..utils import is_iterable, contains_return_statement, encapsulate_code_lines_into_a_function
 from .object_diagram import generate_object_graph
@@ -283,11 +283,13 @@ class RDRCaseViewer(QMainWindow):
     attributes_widget: Optional[QWidget] = None
     save_function: Optional[Callable[str, str], None] = None
     instances: List[RDRCaseViewer] = []
+    exit_status: ExitStatus = ExitStatus.CLOSE
 
     def __init__(self, parent=None,
                  save_dir: Optional[str] = None,
                  save_model_name: Optional[str] = None):
         super().__init__(parent)
+        self.exit_status = ExitStatus.CLOSE
         self.instances.clear()
         self.instances.append(self)
         self.save_dir = save_dir
@@ -328,7 +330,7 @@ class RDRCaseViewer(QMainWindow):
 
         # Add both to main layout
         main_layout.addWidget(self.attributes_widget, stretch=1)
-        main_layout.addWidget(middle_widget, stretch=1)
+        main_layout.addWidget(middle_widget, stretch=2)
         main_layout.addWidget(self.obj_diagram_viewer, stretch=2)
 
     def set_save_function(self, save_function: Callable[[str, str], None]) -> None:
@@ -474,6 +476,7 @@ class RDRCaseViewer(QMainWindow):
         return button_widget
 
     def _accept(self):
+        self.exit_status = ExitStatus.SUCCESS
         # close the window
         self.close()
 

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules/user_interface/prompt.py

@@ -4,7 +4,7 @@ from _ast import AST
 
 try:
     from PyQt6.QtWidgets import QApplication
-    from .gui import RDRCaseViewer
+    from .gui import RDRCaseViewer, style
 except ImportError:
     QApplication = None
     RDRCaseViewer = None
@@ -17,7 +17,7 @@ from typing_extensions import Optional, Tuple
 
 from ..datastructures.callable_expression import CallableExpression, parse_string_to_expression
 from ..datastructures.dataclasses import CaseQuery
-from ..datastructures.enums import PromptFor
+from ..datastructures.enums import PromptFor, ExitStatus
 from .ipython_custom_shell import IPythonShell
 from ..utils import make_list
 from threading import RLock
@@ -29,15 +29,12 @@ class UserPrompt:
     """
     shell_lock: RLock = RLock()  # To ensure that only one thread can access the shell at a time
 
-    def __init__(self, viewer: Optional[RDRCaseViewer] = None):
+    def __init__(self):
         """
         Initialize the UserPrompt class.
-
-        :param viewer: The RDRCaseViewer instance to use for prompting the user.
         """
-        self.viewer = viewer
-        self.print_func = print if viewer is None else viewer.print
-
+        self.viewer = RDRCaseViewer.instances[0] if RDRCaseViewer and any(RDRCaseViewer.instances) else None
+        self.print_func = self.viewer.print if self.viewer else print
 
     def prompt_user_for_expression(self, case_query: CaseQuery, prompt_for: PromptFor, prompt_str: Optional[str] = None) \
             -> Tuple[Optional[str], Optional[CallableExpression]]:
@@ -99,19 +96,20 @@ class UserPrompt:
         :return: The user input, and the executable expression that was parsed from the user input.
         """
         self.print_func("Entered shell")
-        prompt_str = f"{Fore.WHITE}{prompt_str}" if prompt_str is not None else ''
+        initial_prompt_str = f"{prompt_str}\n" if prompt_str is not None else ''
         if prompt_for == PromptFor.Conclusion:
-            prompt_str += f"\n{Fore.MAGENTA}Give possible value(s) for:"
+            prompt_for_str = f"Give possible value(s) for:"
         else:
-            prompt_str += f"\n{Fore.MAGENTA}Give conditions on when can the rule be evaluated for:"
+            prompt_for_str = f"Give conditions for:"
         case_query.scope.update({'case': case_query.case})
         shell = None
         if self.viewer is None:
+            prompt_str = f"{Fore.WHITE}{initial_prompt_str}{Fore.MAGENTA}{prompt_for_str}"
             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)
         else:
-
+            prompt_str = initial_prompt_str + prompt_for_str
             self.viewer.update_for_case_query(case_query, prompt_str,
                                                 prompt_for=prompt_for, code_to_modify=code_to_modify)
         user_input, expression_tree = self.prompt_user_input_and_parse_to_expression(shell=shell)
@@ -176,6 +174,8 @@ class UserPrompt:
         """
         if self.viewer is None:
             shell = IPythonShell() if shell is None else shell
+            if not hasattr(shell.shell, "auto_match"):
+                shell.shell.auto_match = True  # or True, depending on your preference
             shell.run()
             user_input = shell.user_input
         else:
@@ -184,5 +184,7 @@ class UserPrompt:
                 raise RuntimeError("QApplication instance is None. Please run the application first.")
             self.viewer.show()
             app.exec()
+            if self.viewer.exit_status == ExitStatus.CLOSE:
+                exit(0)
             user_input = self.viewer.user_input
         return user_input

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules/utils.py

@@ -146,7 +146,8 @@ def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = N
 def extract_function_source(file_path: str,
                             function_names: List[str], join_lines: bool = True,
                             return_line_numbers: bool = False,
-                            include_signature: bool = True) \
+                            include_signature: bool = True,
+                            as_list: bool = False) \
         -> Union[Dict[str, Union[str, List[str]]],
         Tuple[Dict[str, Union[str, List[str]]], Dict[str, Tuple[int, int]]]]:
     """
@@ -157,6 +158,8 @@ def extract_function_source(file_path: str,
     :param join_lines: Whether to join the lines of the function.
     :param return_line_numbers: Whether to return the line numbers of the function.
     :param include_signature: Whether to include the function signature in the source code.
+    :param as_list: Whether to return a list of function sources instead of dict (useful when there is multiple
+     functions with same name).
     :return: A dictionary mapping function names to their source code as a string if join_lines is True,
      otherwise as a list of strings.
     """
@@ -167,7 +170,9 @@ def extract_function_source(file_path: str,
     tree = ast.parse(source)
     function_names = make_list(function_names)
     functions_source: Dict[str, Union[str, List[str]]] = {}
+    functions_source_list: List[Union[str, List[str]]] = []
     line_numbers: Dict[str, Tuple[int, int]] = {}
+    line_numbers_list: List[Tuple[int, int]] = []
     for node in tree.body:
         if isinstance(node, ast.FunctionDef) and (node.name in function_names or len(function_names) == 0):
             # Get the line numbers of the function
@@ -175,16 +180,24 @@ def extract_function_source(file_path: str,
             func_lines = lines[node.lineno - 1:node.end_lineno]
             if not include_signature:
                 func_lines = func_lines[1:]
-            line_numbers[node.name] = (node.lineno, node.end_lineno)
-            functions_source[node.name] = dedent("\n".join(func_lines)) if join_lines else func_lines
-            if (len(functions_source) >= len(function_names)) and (not len(function_names) == 0):
-                break
-    if len(functions_source) < len(function_names):
+            if as_list:
+                line_numbers_list.append((node.lineno, node.end_lineno))
+            else:
+                line_numbers[node.name] = (node.lineno, node.end_lineno)
+            parsed_function = dedent("\n".join(func_lines)) if join_lines else func_lines
+            if as_list:
+                functions_source_list.append(parsed_function)
+            else:
+                functions_source[node.name] = parsed_function
+            if len(function_names) > 0:
+                if len(functions_source) >= len(function_names) or len(functions_source_list) >= len(function_names):
+                    break
+    if len(functions_source) < len(function_names) and len(functions_source_list) < len(function_names):
         logger.warning(f"Could not find all functions in {file_path}: {function_names} not found, "
                 f"functions not found: {set(function_names) - set(functions_source.keys())}")
     if return_line_numbers:
-        return functions_source, line_numbers
-    return functions_source
+        return functions_source if not as_list else functions_source_list, line_numbers if not as_list else line_numbers_list
+    return functions_source if not as_list else functions_source_list
 
 
 def encapsulate_user_input(user_input: str, func_signature: str, func_doc: Optional[str] = None) -> str:

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/src/ripple_down_rules.egg-info/PKG-INFO

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

@@ -103,18 +103,24 @@ test/conf/world/handles_and_containers.py
 test/factories/__init__.py
 test/factories/world/__init__.py
 test/factories/world/handles_and_containers.py
+test/test_expert_answers/__init__.py
 test/test_expert_answers/correct_drawer_rdr_expert_answers_fit.json
 test/test_expert_answers/drawer_cabinet_expert_answers_fit.json
 test/test_expert_answers/grdr_expert_answers_classify.json
 test/test_expert_answers/grdr_expert_answers_fit.json
+test/test_expert_answers/grdr_expert_answers_fit.py
 test/test_expert_answers/grdr_expert_answers_fit_extra.json
 test/test_expert_answers/grdr_expert_answers_fit_no_targets.json
+test/test_expert_answers/grdr_expert_answers_fit_no_targets.py
 test/test_expert_answers/mcrdr_expert_answers_classify.json
 test/test_expert_answers/mcrdr_expert_answers_fit_no_targets.json
+test/test_expert_answers/mcrdr_expert_answers_fit_no_targets.py
 test/test_expert_answers/mcrdr_expert_answers_stop_only_fit.json
+test/test_expert_answers/mcrdr_expert_answers_stop_only_fit.py
 test/test_expert_answers/mcrdr_extra_expert_answers_classify.json
 test/test_expert_answers/mcrdr_extra_expert_answers_fit.json
 test/test_expert_answers/mcrdr_multi_line_expert_answers_fit.json
+test/test_expert_answers/mcrdr_multi_line_expert_answers_fit.py
 test/test_expert_answers/mcrdr_stop_only_answers_fit.json
 test/test_expert_answers/mcrdr_stop_plus_rule_answers_fit.json
 test/test_expert_answers/mcrdr_stop_plus_rule_combined_expert_answers_fit.json
@@ -123,8 +129,11 @@ test/test_expert_answers/mutagenic_expert_answers.json
 test/test_expert_answers/relational_scrdr_expert_answers_classify.json
 test/test_expert_answers/scrdr_expert_answers_classify.json
 test/test_expert_answers/scrdr_expert_answers_fit.json
+test/test_expert_answers/scrdr_expert_answers_fit.py
 test/test_expert_answers/scrdr_expert_answers_fit_no_targets.json
+test/test_expert_answers/scrdr_expert_answers_fit_no_targets.py
 test/test_expert_answers/scrdr_multi_line_expert_answers_fit.json
+test/test_expert_answers/scrdr_multi_line_expert_answers_fit.py
 test/test_expert_answers/scrdr_world_expert_answers_fit.json
 test/test_generated_rdrs/__init__.py
 test/test_helpers/__init__.py

{ripple_down_rules-0.6.27 → ripple_down_rules-0.6.29}/test/conftest.py

@@ -21,8 +21,9 @@ from ripple_down_rules.rdr import GeneralRDR
 
 app: Optional[QApplication] = None
 viewer: Optional[RDRCaseViewer] = None
+use_gui: bool = False
 
-if RDRCaseViewer is not None and QApplication is not None:
+if RDRCaseViewer is not None and QApplication is not None and use_gui:
     app = QApplication(sys.argv)
     viewer = RDRCaseViewer(save_dir="./test_generated_rdrs")
 
@@ -69,7 +70,7 @@ def view_rdr(handles_and_containers_world, views=(Drawer, Cabinet),
              save_answers: bool = False,
              append: bool = False) -> GeneralRDR:
     world = handles_and_containers_world
-    expert = Human(use_loaded_answers=use_loaded_answers, append=append, viewer=viewer)
+    expert = Human(use_loaded_answers=use_loaded_answers, append=append)
     filename = os.path.join(os.getcwd(), "test_expert_answers/view_rdr_expert_answers_fit")
     if use_loaded_answers:
         expert.load_answers(filename)