Upload 3 files

CodeGeneratorAtomicFlow.py

@@ -0,0 +1,53 @@
+import json
+from copy import deepcopy
+from typing import Any, Dict
+from flow_modules.aiflows.ChatFlowModule import ChatAtomicFlow
+
+
+
+class CodeGeneratorAtomicFlow(ChatAtomicFlow):
+    """Generates code and docstrings with given goal (from controller)"""
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.hint_for_model = """
+        Make sure your response is in the following format:
+              Response Format:
+              {
+              "language_of_code": "language of the code",
+              "code": "String of the code and docstrings corresponding to the goal",
+              }
+        """
+
+    @classmethod
+    def instantiate_from_config(cls, config):
+        flow_config = deepcopy(config)
+
+        kwargs = {"flow_config": flow_config}
+
+        # ~~~ Set up prompts ~~~
+        kwargs.update(cls._set_up_prompts(flow_config))
+
+        # ~~~ Set up backend ~~~
+        kwargs.update(cls._set_up_backend(flow_config))
+
+        # ~~~ Instantiate flow ~~~
+        return cls(**kwargs)
+
+    def _update_input(self, input_data: Dict[str, Any]):
+        if 'goal' in input_data:
+            input_data['goal'] += self.hint_for_model
+
+    def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        self._update_input(input_data)
+        api_output = super().run(input_data)["api_output"].strip()
+        try:
+            response = json.loads(api_output)
+            return response
+        except json.decoder.JSONDecodeError:
+            new_input_data = input_data.copy()
+            new_input_data['goal'] += ("The previous respond cannot be parsed with json.loads, it could be the "
+                                       "backslashes used for escaping single quotes in the string arguments of the "
+                                       "Python code are not properly escaped themselves within the JSON context. "
+                                       "Make sure your next response is in JSON format.")
+            new_api_output = super().run(new_input_data)["api_output"].strip()
+            return json.loads(new_api_output)

CodeGeneratorAtomicFlow.yaml

@@ -0,0 +1,84 @@
+name: "CodeGeneratorAtomicFlow"
+description: "Writes code with given instruction"
+enable_cache: True
+
+input_interface_non_initialized: # initial input keys
+  - "goal"
+
+input_interface_initialized: # input_keys
+  - "goal"
+
+#######################################################
+# Output keys
+#######################################################
+
+output_interface:
+  - 'language_of_code'
+  - 'code'
+
+#######################################################
+system_message_prompt_template:
+  _target_: flows.prompt_template.JinjaPrompt
+  template: |2-
+    You are a world class programmer that can complete any goal with code. All code you write should be functions.
+    
+    Your function will then be imported and called by an executor to finish the goal.
+    
+    Your task is to write functions and their respective docstrings for the given goal, you do not need to worry abot the execution part.
+     
+    You can access the Internet, using APIs of online services could be useful.
+    
+    **It's important that all code you write must be functions to achieve certain goals.**
+    
+    **It's important that you make imports within functions.**
+    
+    **Make sure the function names, parameter names are self-explanatory.**
+    
+    **When you write a function, also write its docstring right after the function name, so that the user can understand the function.**
+    
+    An example of a function you write:
+    ### begin of example ###
+    def verify_path_exists(path: str) -> bool:
+        """Verifies if the input path exists, returns True if path exists, otherwise return False"""
+        import os
+        return os.path.exists(path)
+    ### end of example ###
+    
+    You are capable of **any** task.
+    
+
+    Performance Evaluation:
+    1. The priority language is Python, try to code with Python to solve the task.
+    2. All code you write must be functions.
+    3. Function names must be self-explanatory, it's good practice to specify the return type.
+    4. Parameter names must be self-explanatory, it's good practice to specify parameter types.
+    5. All imports must be done within the function body.
+    6. All functions must have docstrings.
+    
+    **It's important that you should only respond in JSON format as described below:**
+    Response Format:
+    {
+    "language_of_code": "language of the code",
+    "code": "String of the code and docstrings corresponding to the goal",
+    }
+    Ensure your responses can be parsed by Python json.loads
+    
+    **It's important that you make imports inside of the function body, but not outside of it.**
+    
+    **It's important that the code you generate can be written by Python write, and is human-readable. The written file must also be indented and formatted, so that it is human-readable.**
+
+human_message_prompt_template:
+  _target_: flows.prompt_template.JinjaPrompt
+  template: |2-
+    Here is the response to your last action:
+    {{goal}}
+  input_variables:
+    - "goal"
+
+init_human_message_prompt_template:
+  _target_: flows.prompt_template.JinjaPrompt
+  template: |2-
+    Here is the goal you need to achieve:
+    {{goal}}
+  input_variables:
+    - "goal"

__init__.py

@@ -0,0 +1,8 @@
+dependencies = [
+    {"url": "aiflows/ChatFlowModule", "revision": "a749ad10ed39776ba6721c37d0dc22af49ca0f17"},
+]
+from flows import flow_verse
+
+flow_verse.sync_dependencies(dependencies)
+
+from .CodeGeneratorAtomicFlow import CodeGeneratorAtomicFlow