Upload 7 files

ParseFeedbackAtomicFlow.py

@@ -0,0 +1,98 @@
+from typing import Dict, Any
+from aiflows.base_flows.atomic import AtomicFlow
+import time
+import subprocess
+
+
+class ParseFeedbackAtomicFlow(AtomicFlow):
+    """This flow parses the feedback from the user. The flow is supposed to be called after the CodeFileEdit or PlanFileEdit flow.
+    The flow will open the file in VSCode and wait for the user to edit the file. Once the user closes the file, the flow will parse the file and return the content of the file.
+    
+    *Input Interface*:
+    - `temp_code_file_location`: Notice that if we are parsing the plan file, this should be changed to `temp_plan_file_location`.
+    
+    *Output Interface*:
+    - `code`: The content of the code file.
+    - `feedback`: The feedback from the user.
+    """
+    def _read_content(self, file_location, file_type):
+        if file_type == "code":
+            header_string = "# Code:\n"
+        elif file_type == "plan":
+            header_string = "Plan:\n"
+        else:
+            raise NotImplemented
+
+        with open(file_location, "r") as file:
+            content = file.read()
+
+        start_index = content.find(header_string)
+        if start_index == -1:
+            raise ValueError(f"Format error: {header_string} tag not found.")
+
+        end_index = content.find("\n############\n")
+        if end_index == -1 or end_index < start_index:
+            raise ValueError(f"Format error: {file_type} section is malformed.")
+
+        ret = content[start_index + len(header_string):end_index].strip()
+
+        return ret
+
+    def _parse_user_thoughts(self, file_location):
+        with open(file_location, "r") as file:
+            content = file.read()
+
+        delimiter = "\n############\n"
+        parts = content.split(delimiter)
+        if len(parts) < 2:
+            raise ValueError("Format error: Unable to find the thoughts section.")
+
+        thoughts_section = parts[1].strip()
+
+        thoughts_index = thoughts_section.find("Thoughts:")
+        if thoughts_index == -1:
+            raise ValueError("Format error: 'Thoughts:' tag not found.")
+
+        thoughts = thoughts_section[thoughts_index + len("Thoughts:"):].strip()
+
+        if thoughts == '':
+            thoughts = 'Looks good, go on.'
+
+        return thoughts
+
+    def _check_input(self, input_data: Dict[str, Any]):
+        code_file_exists = "temp_code_file_location" in input_data
+        plan_file_exists = "temp_plan_file_location" in input_data
+        if code_file_exists == False and plan_file_exists == False:
+            raise AssertionError("Neither code file nor plan file is passed to ParseFeedbackAtomicFlow")
+        elif code_file_exists and plan_file_exists:
+            raise AssertionError("Both code file and plan file are passed to ParseFeedbackAtomic, which one to parse?")
+
+    def _open_file_and_wait_for_file_update(self, file_location, check_interval=1):
+        process = subprocess.Popen(["code", "--wait", file_location])
+        while True:
+            if process.poll() is not None:
+                break
+            time.sleep(check_interval)
+        
+    def run(
+            self,
+            input_data: Dict[str, Any]
+    ):
+        response = {}
+        self._check_input(input_data)
+        if "temp_code_file_location" in input_data:
+            temp_code_file_location = input_data['temp_code_file_location']
+            self._open_file_and_wait_for_file_update(temp_code_file_location)
+            code_content = self._read_content(temp_code_file_location, "code")
+            user_thoughts = self._parse_user_thoughts(temp_code_file_location)
+            response = {"code": code_content, "feedback": user_thoughts}
+
+        elif "temp_plan_file_location" in input_data:
+            plan_file_location = input_data["temp_plan_file_location"]
+            self._open_file_and_wait_for_file_update(plan_file_location)
+            plan_content = self._read_content(plan_file_location, "plan")
+            user_thoughts = self._parse_user_thoughts(plan_file_location)
+            response = {"plan": plan_content, "feedback": user_thoughts}
+
+        return response

ParseFeedbackAtomicFlow.yaml

@@ -0,0 +1,13 @@
+name: "ParseFeedbackAtomicFlow"
+description: "A flow used to parse user feedback from a plan file or a code file"
+_target_: flow_modules.aiflows.ParseFeedbackFlowModule.ParseFeedbackAtomicFlow.instantiate_from_default_config
+
+
+# Should be changed when the ParseFeedbackAtomicFlow is used to parse a plan file.
+input_interface:
+  - "temp_code_file_location"
+
+# Should be changed when the ParseFeedbackAtomicFlow is used to parse a plan file.
+output_interface:
+  - "code"
+  - "feedback"

README.md

@@ -1,3 +1,32 @@
----
-license: mit
----
+# Table of Contents
+
+* [ParseFeedbackAtomicFlow](#ParseFeedbackAtomicFlow)
+  * [ParseFeedbackAtomicFlow](#ParseFeedbackAtomicFlow.ParseFeedbackAtomicFlow)
+* [\_\_init\_\_](#__init__)
+
+<a id="ParseFeedbackAtomicFlow"></a>
+
+# ParseFeedbackAtomicFlow
+
+<a id="ParseFeedbackAtomicFlow.ParseFeedbackAtomicFlow"></a>
+
+## ParseFeedbackAtomicFlow Objects
+
+```python
+class ParseFeedbackAtomicFlow(AtomicFlow)
+```
+
+This flow parses the feedback from the user. The flow is supposed to be called after the CodeFileEdit or PlanFileEdit flow.
+The flow will open the file in VSCode and wait for the user to edit the file. Once the user closes the file, the flow will parse the file and return the content of the file.
+
+*Input Interface*:
+- `temp_code_file_location`: Notice that if we are parsing the plan file, this should be changed to `temp_plan_file_location`.
+
+*Output Interface*:
+- `code`: The content of the code file.
+- `feedback`: The feedback from the user.
+
+<a id="__init__"></a>
+
+# \_\_init\_\_
+

__init__.py

@@ -0,0 +1 @@
+from .ParseFeedbackAtomicFlow import ParseFeedbackAtomicFlow

example_code_file.py

@@ -0,0 +1,9 @@
+# Code:
+# This is the initial code that needs review or modification.
+# For example, a simple Python function:
+def example_function(x):
+    return x * x
+
+############
+
+# Thoughts: lgtm

pip_requirements.txt

@@ -0,0 +1,15 @@
+colorama==0.4.6
+pytest==7.3.1
+pytest-cov==4.1.0
+hydra-core==1.3.2
+hydra-colorlog==1.1.0
+wrapt-timeout-decorator==1.3.12.2
+diskcache==5.6.1
+openai==1.0.0
+huggingface_hub==0.19.4
+jsonlines==3.1.0
+jinja2==3.1.2
+mock==5.0.2
+rich==12.6.0
+litellm==1.0.0
+aiflows

run.py

@@ -0,0 +1,45 @@
+import os
+
+import hydra
+
+from aiflows.messages import InputMessage
+from aiflows.utils.general_helpers import read_yaml_file
+
+from aiflows import logging
+from aiflows.flow_cache import CACHING_PARAMETERS, clear_cache
+
+CACHING_PARAMETERS.do_caching = False  # Set to True in order to disable caching
+# clear_cache() # Uncomment this line to clear the cache
+
+logging.set_verbosity_debug()
+logging.auto_set_dir()
+
+dependencies = [
+    {"url": "aiflows/ParseFeedbackFlowModule", "revision": "main"},
+]
+
+from aiflows import flow_verse
+
+flow_verse.sync_dependencies(dependencies)
+
+if __name__ == "__main__":
+    current_dir = os.getcwd()
+    cfg_path = os.path.join(current_dir, "ParseFeedbackAtomicFlow.yaml")
+    cfg = read_yaml_file(cfg_path)
+
+
+    # ~~~ instantiating the flow and input data ~~~
+    ParseFeedbackFlow = hydra.utils.instantiate(cfg, _recursive_=False, _convert_="partial")
+    input_data = {
+        "temp_code_file_location": os.path.join(current_dir, "example_code_file.py")
+    }
+    input_message = InputMessage.build(
+        data_dict=input_data,
+        src_flow="Launcher",
+        dst_flow=ParseFeedbackFlow.name
+    )
+
+    # ~~~ calling the flow ~~~
+    output_message = ParseFeedbackFlow(input_message)
+
+    print(output_message.data)