ripple-down-rules 0.6.28__py3-none-any.whl → 0.6.29__py3-none-any.whl

ripple_down_rules/__init__.py

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

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/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))
 
@@ -249,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':
@@ -260,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.
@@ -279,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/rdr.py

@@ -230,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)}
@@ -308,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]]:
         """
@@ -319,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:
@@ -348,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/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.28.dist-info → ripple_down_rules-0.6.29.dist-info}/METADATA

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

@@ -1,13 +1,13 @@
-ripple_down_rules/__init__.py,sha256=XvJJjrncdmKjrvKVVILZq7uuTOYiohoP3iLBN_oKp_M,99
-ripple_down_rules/experts.py,sha256=bQfDB7RZE_CANVkpBMb9bi8ZWFwk5p7hn1AzjpaO5ow,12877
+ripple_down_rules/__init__.py,sha256=RxW-6bq3pIBXNaQQI3F99LSjv47e0QeXHfOWv0IKvdM,99
+ripple_down_rules/experts.py,sha256=irsHfjs_xXljB9g4aA29OB9kXh1q9skWQmYkld-DGvY,14184
 ripple_down_rules/helpers.py,sha256=X1psHOqrb4_xYN4ssQNB8S9aRKKsqgihAyWJurN0dqk,5499
-ripple_down_rules/rdr.py,sha256=hVqfCRrru6TUnqzY7yGMjiNnxUIFjfL2U7txmGNjeGI,61661
+ripple_down_rules/rdr.py,sha256=Azd2w8otHrmlvXw-tql7M6iaVWNhjZsxivMQ_NmbxBk,61925
 ripple_down_rules/rdr_decorators.py,sha256=xoBGsIJMkJYUdsrsEaPZqoAsGuXkuVZAKCoP-xD2Iv8,11668
 ripple_down_rules/rules.py,sha256=N4dEx-xyqxGZpoEYzRd9P5u97_DcDEVLY_UiNhZ4E7g,28726
 ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=9xW0N2cB7X4taVANtLg-kVTPS-6ajWZylKkTqw2PKw4,73825
+ripple_down_rules/utils.py,sha256=TUUNwNwxjPepOl-CiLQkFLe75NKmJR87l5A0U6RecJ0,74642
 ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=P3o-z54Jt4rtIczeFWiuHFTNqMzYEOm94OyOP535D6Q,13378
+ripple_down_rules/datastructures/callable_expression.py,sha256=IrlnufVsKrUDLVkc2owoFQ05oSOby3HiGuNXoFVj4Dw,13494
 ripple_down_rules/datastructures/case.py,sha256=PJ7_-AdxYic6BO5z816piFODj6nU5J6Jt1YzTFH-dds,15510
 ripple_down_rules/datastructures/dataclasses.py,sha256=kI3Kv8GiVR8igMgA_BlKN6djUYxC2mLecvyh19pqQQA,10998
 ripple_down_rules/datastructures/enums.py,sha256=CvcROl8fE7A6uTbMfs2lLpyxwS_ZFtFcQlBDDKFfoHc,6059
@@ -17,8 +17,8 @@ ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=yp-F8YRWGhj1PLB3
 ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
 ripple_down_rules/user_interface/prompt.py,sha256=nLIAviClSmVCY80vQgTazDPs4a1AYmNQmT7sksLDJpE,9449
 ripple_down_rules/user_interface/template_file_creator.py,sha256=kwBbFLyN6Yx2NTIHPSwOoytWgbJDYhgrUOVFw_jkDQ4,13522
-ripple_down_rules-0.6.28.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.6.28.dist-info/METADATA,sha256=fPfcVvFD7eEuG5FKX26HRRWPJkZatA0mfWdarnTqPa8,48294
-ripple_down_rules-0.6.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.6.28.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.6.28.dist-info/RECORD,,
+ripple_down_rules-0.6.29.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.6.29.dist-info/METADATA,sha256=ntefL7_Z_J2ncA_Jfo0qBt9cO5_0ax2JJM4Os1ucM98,48294
+ripple_down_rules-0.6.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.6.29.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.6.29.dist-info/RECORD,,