Upload 10 files

NewPlanGenFlow.py

@@ -0,0 +1,16 @@
+import json
+from copy import deepcopy
+from typing import Any, Dict
+from flow_modules.aiflows.PlanGeneratorFlowModule import PlanGeneratorAtomicFlow
+
+
+class NewPlanGenFlow(PlanGeneratorAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.hint_for_model = """
+        Make sure your response is in the following format:
+              Response Format:
+              {
+              "new_plan": "A new plan, refined from previous plan, with given requirements",
+              }
+        """

NewPlanGenFlow.yaml

@@ -0,0 +1,94 @@
+name: "NewPlanGenFlow"
+description: "Plan Generator of ReplanningFlow, writes a new plan given requirements"
+_target_: flow_modules.aiflows.ReplanningFlowModule.NewPlanGenFlow.instantiate_from_default_config
+enable_cache: True
+
+input_interface_non_initialized: # initial input keys
+  - "goal" # info on the old plan, entered by the controller
+  - "old_plan" # previous plan
+
+
+input_interface_initialized: # input_keys
+  - "goal"
+  - "old_plan" # previous plan
+
+#######################################################
+# Output keys
+#######################################################
+
+output_interface:
+  - 'new_plan' # new plan
+
+#######################################################
+system_message_prompt_template:
+  _target_: aiflows.prompt_template.JinjaPrompt
+  template: |2-
+    You are a re-planner of a coding department, you are given an old plan written by your colleagues.
+  
+    You will be given information regarding the old plan, e.g. what was wrong with the old plan, what to refine with the old plan.
+    
+    Your task is to edit and re-plan, based on the old plan and the new information that is being given to you.
+    
+    The new plan you write is intended for the coders, each step of the new plan tells the coders what function to write.
+    
+    The details of your task are:
+      1. Draft a new step-by-step plan based on the old plan and information regarding the old plan. Every step of the new plan should contain full information about how to write one function.
+      2. Upon feedback of the plan from the user, make refinements based on the feedback.
+    
+    Resources:
+      1. The old plan:
+        {{old_plan}}
+    
+    Notice that:
+      1. **Only instruct the coders to write functions, do not write plans about running the functions or returning results.** 
+      2. **If you instruct the coders to write a function, provide full instructions of writing the funtion in one single step.**
+    
+    The coding department is able to access the Internet, so it may be useful to use some online services via APIs.
+    
+    An example of old plan, input information and output plan you should have:
+    ### begin of old plan ###
+    1. Write a function that fetches a company's stock prices from the last 6 months from "google stocks"
+    ### end of old plan ###
+    
+    ### begin of input information###
+    Here's the information on the old plan:
+    data source "google stocks" is deprecated, should try a new one.
+    ### end of input information###
+    
+    ### begin of output new plan ###
+    1. Write a function that fetches a company's stock prices from the last 6 months from "yahoo finance"
+    ### end of output new plan ###
+    
+    You are capable of **any** task.
+    
+    Performance Evaluation:
+    1. Your new plan should finish exactly the same task as the old one.
+    2. Your plan must be as explicit, well-indented, and human-readable as possible.
+    3. Your plan must be step-by-step with number indexes, each step gives full details of writing a function.
+    4. You should make plans with as few steps as possible.
+    
+    **It's important that you should only respond in JSON format as described below:**
+    Response Format:
+    {
+    "new_plan": "A new plan, refined from previous plan, with given requirements",
+    }
+    Ensure your responses can be parsed by Python json.loads
+
+  input_variables:
+    - "old_plan"
+
+human_message_prompt_template:
+  _target_: aiflows.prompt_template.JinjaPrompt
+  template: |2-
+    Here is the response to your last action:
+    {{goal}}
+  input_variables:
+    - "goal"
+
+init_human_message_prompt_template:
+  _target_: aiflows.prompt_template.JinjaPrompt
+  template: |2-
+    Here's the information on the old plan:
+    {{goal}}
+  input_variables:
+    - "goal"

README.md

@@ -1,3 +1,111 @@
----
-license: mit
----
+### Structure of ReplanningFlow
+
+```
+goal (info on the old plan), plan (old plan), plan_file_location
+                |
+                v
+        +---------------+
+        |  Controller   | --------<<<<-----------+
+        +---------------+                        |
+                |                                |
+                | (command, command args)        |
+                |                                |
+                v                                |
+        +------------------+                     |
+        |   Executor       |  Each branch is an  |
+        | (Tree Structure) |  executor           |
+        +------------------+                     |
+                |                                ^
+                | (summary)                      |
+                |                                |
+                v                                |             
+                |                                |
+                +-> goes back to the Controller>-+
+
+```
+
+Structure of the Executors:
+```
+         +-------------------+
+         |   Branching       |
+         |    Executor       |
+         +-------------------+
+        /                    \
+       /                      \
+      /                        \
+     /                          \
+write_plan                    ask_user
+
+```
+
+About the branches:
+- [ask_user](https://huggingface.co/Tachi67/PlanWriterFlowModule/blob/main/PlanWriterAskUserFlow.py): Ask user for info / confirmation, etc.
+- [write_plan](https://huggingface.co/Tachi67/InteractivePlanGenFlowModule): Generates plan (user edit is allowed) and fetches user feedback.
+  - The PlanGenerator of write_plan is replaced with [NewPlanGenFlow](https://huggingface.co/Tachi67/ReplanningFlowModule/blob/main/NewPlanGenFlow.py) to re-plan instead of write plan.
+
+How it works:
+Controller calls write_plan until user is satisfied in the feedback, finish.
+
+
+# Table of Contents
+
+* [run\_replanning](#run_replanning)
+* [ReplanningAskUserFlow](#ReplanningAskUserFlow)
+  * [ReplanningAskUserFlow](#ReplanningAskUserFlow.ReplanningAskUserFlow)
+* [NewPlanGenFlow](#NewPlanGenFlow)
+* [ReplanningFlow](#ReplanningFlow)
+  * [ReplanningFlow](#ReplanningFlow.ReplanningFlow)
+* [\_\_init\_\_](#__init__)
+
+<a id="run_replanning"></a>
+
+# run\_replanning
+
+<a id="ReplanningAskUserFlow"></a>
+
+# ReplanningAskUserFlow
+
+<a id="ReplanningAskUserFlow.ReplanningAskUserFlow"></a>
+
+## ReplanningAskUserFlow Objects
+
+```python
+class ReplanningAskUserFlow(HumanStandardInputFlow)
+```
+
+Refer to: https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py
+
+<a id="NewPlanGenFlow"></a>
+
+# NewPlanGenFlow
+
+<a id="ReplanningFlow"></a>
+
+# ReplanningFlow
+
+<a id="ReplanningFlow.ReplanningFlow"></a>
+
+## ReplanningFlow Objects
+
+```python
+class ReplanningFlow(PlanWriterFlow)
+```
+
+This flow inherits from PlanWriterFlow.
+ By changing prompts and injecting proper information to the controller and the PlanGenerator, we are able to achieve the replanning.
+
+*Input Interface*:
+- `goal` (str): information on the old plan (e.g. what is wrong)
+- `plan` (str): the old plan
+- `plan_file_location` (str): the location of the old plan file
+
+*Output Interface*:
+- `plan` (str): the new plan
+- `status`: "finished" or "unfinished"
+- `summary` (str): summary of the flow, will be written to the log file of the caller flow.
+- `result` (str): result of the flow, will be passed to the controller of the caller flow.
+
+<a id="__init__"></a>
+
+# \_\_init\_\_
+

ReplanningAskUserFlow.py

@@ -0,0 +1,32 @@
+from flow_modules.aiflows.HumanStandardInputFlowModule import HumanStandardInputFlow
+
+from typing import Dict, Any
+
+from aiflows.messages import UpdateMessage_Generic
+
+from aiflows.utils import logging
+
+log = logging.get_logger(f"aiflows.{__name__}")
+
+
+class ReplanningAskUserFlow(HumanStandardInputFlow):
+    """Refer to: https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py"""
+    def run(self,
+            input_data: Dict[str, Any]) -> Dict[str, Any]:
+
+        query_message = self._get_message(self.query_message_prompt_template, input_data)
+        state_update_message = UpdateMessage_Generic(
+            created_by=self.flow_config['name'],
+            updated_flow=self.flow_config["name"],
+            data={"query_message": query_message},
+        )
+        self._log_message(state_update_message)
+
+        log.info(query_message)
+        human_input = self._read_input()
+
+        response = {}
+        response["feedback"] = human_input
+        response["new_plan"] = "no new plan was written"
+
+        return response

ReplanningAskUserFlow.yaml

@@ -0,0 +1,9 @@
+_target_: flow_modules.aiflows.ReplanningFlowModule.ReplanningAskUserFlow.instantiate_from_default_config
+request_multi_line_input_flag: False
+end_of_input_string: EOI
+
+query_message_prompt_template:
+  template: |2-
+    {{question}}
+  input_variables:
+    - "question"

ReplanningFlow.py

@@ -0,0 +1,80 @@
+from typing import Dict, Any
+import os
+from aiflows.base_flows import CircularFlow
+from flow_modules.aiflows.PlanWriterFlowModule import PlanWriterFlow
+
+class ReplanningFlow(PlanWriterFlow):
+    """This flow inherits from PlanWriterFlow.
+     By changing prompts and injecting proper information to the controller and the PlanGenerator, we are able to achieve the replanning.
+
+    *Input Interface*:
+    - `goal` (str): information on the old plan (e.g. what is wrong)
+    - `plan` (str): the old plan
+    - `plan_file_location` (str): the location of the old plan file
+    
+    *Output Interface*:
+    - `plan` (str): the new plan
+    - `status`: "finished" or "unfinished"
+    - `summary` (str): summary of the flow, will be written to the log file of the caller flow.
+    - `result` (str): result of the flow, will be passed to the controller of the caller flow.
+    """
+    def _on_reach_max_round(self):
+        self._state_update_dict({
+            "plan": "The maximum amount of rounds was reached before the model generated the plan.",
+            "status": "unfinished",
+            "summary": "Replanning: The maximum amount of rounds was reached before the model generated the plan.",
+        })
+
+
+    @CircularFlow.output_msg_payload_processor
+    def detect_finish_or_continue(self, output_payload: Dict[str, Any], src_flow) -> Dict[str, Any]:
+        command = output_payload["command"]
+        if command == "finish":
+            # ~~~ fetch temp file location, plan content, memory file (of upper level flow e.g. ExtLib) from flow state
+            keys_to_fetch_from_state = ["temp_plan_file_location", "new_plan", "plan_file_location"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            temp_plan_file_location = fetched_state["temp_plan_file_location"]
+            new_plan_content = fetched_state["new_plan"]
+            plan_file_location = fetched_state["plan_file_location"]
+
+            # ~~~ delete the temp plan file ~~~
+            if os.path.exists(temp_plan_file_location):
+                os.remove(temp_plan_file_location)
+
+            # ~~~ write plan content to plan file ~~~
+            with open(plan_file_location, 'w') as file:
+                file.write(new_plan_content)
+
+            # ~~~ return the plan content ~~~
+            return {
+                "EARLY_EXIT": True,
+                "plan": new_plan_content,
+                "result": "New plan was generated and has overriden the previous plan",
+                "summary": "ReplanningFlow: " + output_payload["command_args"]["summary"] + f" new plan is written to {plan_file_location}",
+                "status": "finished"
+            }
+        elif command == "manual_finish":
+            # ~~~ delete the temp plan file ~~~
+            keys_to_fetch_from_state = ["temp_plan_file_location"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            temp_plan_file_location = fetched_state["temp_plan_file_location"]
+            if os.path.exists(temp_plan_file_location):
+                os.remove(temp_plan_file_location)
+            # ~~~ return the manual quit status ~~~
+            return {
+                "EARLY_EXIT": True,
+                "new_plan": "no new plan was generated",
+                "result": "The replanner was explicitly terminated by the user, no new plan was generated.",
+                "summary": "ReplanningFlow: Replanner was terminated explicitly by the user, process is unfinished",
+                "status": "unfinished"
+            }
+        elif command == "write_plan":
+            keys_to_fetch_from_state = ["plan", "plan_file_location"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            old_plan = fetched_state["plan"]
+            plan_file_location = fetched_state["plan_file_location"]
+            output_payload["command_args"]["old_plan"] = old_plan
+            output_payload["command_args"]["plan_file_location"] = plan_file_location
+            return output_payload
+        else:
+            return output_payload

ReplanningFlow.yaml

@@ -0,0 +1,186 @@
+name: "ReplanningFlow"
+description: "Re-plan given old plan and new information"
+
+_target_: flow_modules.aiflows.ReplanningFlowModule.ReplanningFlow.instantiate_from_default_config
+
+input_interface:
+  - "goal" # info on the old plan
+  - "plan" # the old plan
+  - "plan_file_location"
+
+output_interface:
+  - "plan"
+  - "status"
+  - "summary"
+  - "result"
+
+### Subflows specification
+subflows_config:
+  Controller:
+    _target_: flow_modules.aiflows.PlanWriterFlowModule.PlanWriterCtrlFlow.instantiate_from_default_config
+    backend:
+      api_infos: ???
+      model_name:
+        openai: gpt-4
+        azure: azure/gpt-4
+    input_interface_initialized:
+      - "new_plan"
+      - "feedback"
+    system_message_prompt_template:
+      _target_: langchain.PromptTemplate
+      template: |2-
+              You are in charge of a department of rewriting plans to solve a certain goal. You work with a re-planner, who does all the re-planning job.
+
+              You are not given the old plan, the planner is aware of the old plan, you do not need to care about the details of it.
+             
+              Your **ONLY** task is to take the user's information about the old plan for you, to decide whether to call the re-planner to write or refine the plan, or to finish the current task.
+
+              When you need to call the plan writer, call the `write_plan` command with the goal specified.
+              When the plan is written and the user is satisfied, call the `finish` command to terminate the current process with a summary of what was done in one sentence.
+              Whenever you are in doubt, or need to confirm something to the user, call `ask_user` with the question.
+
+              You **must not** write plans yourself. You only decide whether to call the planner with specified goals or to finish.
+
+              Your workflow:
+              0. Whenever the user demands to quit or terminate the current process, call `manual_finish` command.
+              1. Upon user request, call the `write_plan` with the information given.
+              2. The planner will write the plan. The user will examine the plan, and provide feedback.
+              3. Depending on the feedback of the user:
+                3.1. The user provides feedback on how to change the plan, **call the planner with user's specific requirements again, to ask the planner to refine the plan**. Go back to step 2.
+                3.2. The user does not provide details about refining the plan, for example, just stating the fact that the user has updated the plan, **this means the user is satisfied with the plan written, call the `finish` command.**
+                3.3. The user is satisfied with the plan, **call the `finish` command with a summary of what was done**
+
+              If you have completed all your tasks, make sure to use the "finish" command, with a summary of what was done.
+
+              Constraints:
+              1. Exclusively use the commands listed in double quotes e.g. "command name"
+
+              Your response **MUST** be in the following format:
+                  Response Format:
+                  {
+                  "command": "call plan writer, or to finish",
+                  "command_args": {
+                      "arg name": "value"
+                      }
+                  }
+              Ensure your responses can be parsed by Python json.loads
+
+
+              Available Functions:
+              {{commands}}
+      input_variables: [ "commands" ]
+      template_format: jinja2
+
+    human_message_prompt_template:
+      _target_: aiflows.prompt_template.JinjaPrompt
+      template: |2-
+        Here is the new plan written by the planner, it might have been updated by the user, depending on the user's feedback:
+        {{new_plan}}
+        Here is the feedback from the user:
+        {{feedback}}
+      input_variables:
+        - "new_plan"
+        - "feedback"
+      template_format: jinja2
+
+    init_human_message_prompt_template:
+      _target_: aiflows.prompt_template.JinjaPrompt
+      template: |2-
+        Here is the information about the old plan:
+        {{goal}}
+      input_variables:
+        - "goal"
+      template_format: jinja2
+
+  Executor:
+    _target_: aiflows.base_flows.BranchingFlow.instantiate_from_default_config
+    subflows_config:
+      write_plan:
+        _target_: flow_modules.aiflows.InteractivePlanGenFlowModule.InteractivePlanGenFlow.instantiate_from_default_config
+        output_interface:
+          - "new_plan"
+          - "feedback"
+          - "temp_plan_file_location"
+        subflows_config:
+          PlanGenerator:
+            _target_: flow_modules.aiflows.ReplanningFlowModule.NewPlanGenFlow.instantiate_from_default_config
+            backend:
+              api_infos: ???
+              model_name:
+                openai: gpt-4
+                azure: azure/gpt-4
+          PlanFileEditor:
+            _target_: flow_modules.aiflows.PlanFileEditFlowModule.PlanFileEditAtomicFlow.instantiate_from_default_config
+            input_interface:
+              - "new_plan"
+              - "plan_file_location"
+          ParseFeedback:
+            _target_: flow_modules.aiflows.ParseFeedbackFlowModule.ParseFeedbackAtomicFlow.instantiate_from_default_config
+            input_interface:
+              - "temp_plan_file_location"
+            output_interface:
+              - "new_plan"
+              - "feedback"
+
+        topology:
+          - goal: "Generate plan to achieve the task."
+            input_interface:
+              _target_: aiflows.interfaces.KeyInterface
+              additional_transformations:
+                - _target_: aiflows.data_transformations.KeyMatchInput
+            flow: PlanGenerator
+            reset: false
+
+          - goal: "Write the plan generated to a temp file with instructions to the user"
+            input_interface:
+              _target_: aiflows.interfaces.KeyInterface
+              additional_transformations:
+                - _target_: aiflows.data_transformations.KeyMatchInput
+            flow: PlanFileEditor
+            reset: false
+
+          - goal: "Parse user feedback from the temp file"
+            input_interface:
+              _target_: aiflows.interfaces.KeyInterface
+              additional_transformations:
+                - _target_: aiflows.data_transformations.KeyMatchInput
+            flow: ParseFeedback
+            output_interface:
+              _target_: aiflows.interfaces.KeyInterface
+              keys_to_rename:
+                plan: new_plan
+            reset: false
+
+      ask_user:
+        _target_: flow_modules.aiflows.ReplanningFlowModule.ReplanningAskUserFlow.instantiate_from_default_config
+
+
+early_exit_key: "EARLY_EXIT"
+
+topology:
+  - goal: "Select the next action and prepare the input for the executor."
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: Controller
+    output_interface:
+      _target_: ReplanningFlow.detect_finish_or_continue
+    reset: false
+
+  - goal: "Execute the action specified by the Controller."
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      keys_to_rename:
+        command: branch
+        command_args: branch_input_data
+      keys_to_select: ["branch", "branch_input_data"]
+    flow: Executor
+    output_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      keys_to_rename:
+        branch_output_data.new_plan: new_plan
+        branch_output_data.feedback: feedback
+        branch_output_data.temp_plan_file_location: temp_plan_file_location
+      keys_to_delete: ["branch_output_data"]
+    reset: false

__init__.py

@@ -0,0 +1,15 @@
+dependencies = [
+    {"url": "aiflows/PlanGeneratorFlowModule", "revision": "main"},
+    {"url": "aiflows/InteractivePlanGenFlowModule", "revision": "main"},
+    {"url": "aiflows/PlanWriterFlowModule", "revision": "main"},
+    {"url": "aiflows/PlanFileEditFlowModule", "revision": "main"},
+    {"url": "aiflows/ParseFeedbackFlowModule", "revision": "main"},
+    {"url": "aiflows/HumanStandardInputFlowModule", "revision": "4ff043522c89a964ea3a928ce09811c51a2b5b98"}
+]
+
+from aiflows import flow_verse
+flow_verse.sync_dependencies(dependencies)
+
+from .NewPlanGenFlow import NewPlanGenFlow
+from .ReplanningFlow import ReplanningFlow
+from .ReplanningAskUserFlow import ReplanningAskUserFlow

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_replanning.py

@@ -0,0 +1,65 @@
+import os
+
+import hydra
+
+from aiflows.backends.api_info import ApiInfo
+from aiflows.messages import InputMessage
+from aiflows.utils.general_helpers import read_yaml_file, quick_load
+
+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/ReplanningFlowModule", "revision": "main"},
+    {"url": "aiflows/PlanGeneratorFlowModule", "revision": "main"},
+    {"url": "aiflows/InteractivePlanGenFlowModule", "revision": "main"},
+    {"url": "aiflows/PlanWriterFlowModule", "revision": "main"},
+    {"url": "aiflows/PlanFileEditFlowModule", "revision": "main"},
+    {"url": "aiflows/ParseFeedbackFlowModule", "revision": "main"},
+    {"url": "aiflows/HumanStandardInputFlowModule", "revision": "4ff043522c89a964ea3a928ce09811c51a2b5b98"}
+]
+
+from aiflows import flow_verse
+
+flow_verse.sync_dependencies(dependencies)
+
+if __name__ == "__main__":
+    # ~~~ make sure to set the openai api key in the envs ~~~
+    key = os.getenv("OPENAI_API_KEY")
+    api_information = [ApiInfo(backend_used="openai", api_key=os.getenv("OPENAI_API_KEY"))]
+    path_to_output_file = None
+
+    # ~~~ setting api information into config ~~~
+    current_dir = os.getcwd()
+    cfg_path = os.path.join(current_dir, "ReplanningFlow.yaml")
+    cfg = read_yaml_file(cfg_path)
+    quick_load(cfg, api_information)
+
+
+    # ~~~ instantiating the flow and input data ~~~
+    ReplanningFlow = hydra.utils.instantiate(cfg, _recursive_=False, _convert_="partial")
+
+    # ~~~ creating the plan file location (of the upper level flow e.g. ExtLib)
+    plan_file_location = os.path.join(current_dir, "ExtLib_plan.txt")
+    with open(plan_file_location, 'w') as file:
+        pass
+
+    input_data = {
+        "goal": "data source OpenWeatherMap is deprecated",
+        "plan": "1. Write a function that fetches today's weather at Lausanne from OpenWeatherMap. \n 2. Write a funtion that prints the fetched data in a formatted way.",
+        "plan_file_location": plan_file_location
+    }
+    input_message = InputMessage.build(
+        data_dict=input_data,
+        src_flow="Launcher",
+        dst_flow=ReplanningFlow.name
+    )
+
+    # ~~~ calling the flow ~~~
+    output_message = ReplanningFlow(input_message)