Upload 10 files

PlanWriterAskUserFlow.py

@@ -11,11 +11,30 @@ log = logging.get_logger(f"aiflows.{__name__}")
 
 class PlanWriterAskUserFlow(HumanStandardInputFlow):
     """
-    Refer to: https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py
+    Refer to: https://huggingface.co/aiflows/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py
+    This flow is used to ask the user a question and get a response.
+
+    *Input Interface*:
+    - `question`
+
+    *Output Interface*:
+    - `feedback`
+    - `plan`
+
+    *Configuration Parameters*:
+    - `query_message_prompt_template`: The message template to prompt the user for input.
+    - `request_multi_line_input_flag`: Whether to request multi-line input from the user.
+    - `end_of_input_string`: The string to enter to indicate the end of input.
     """
     def run(self,
             input_data: Dict[str, Any]) -> Dict[str, Any]:
-
+        """
+        Run the flow module.
+        :param input_data: The input data to the flow module.
+        :type input_data: Dict[str, Any]
+        :return: The output data from the flow module.
+        :rtype: 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'],

PlanWriterCtrlFlow.py

@@ -14,12 +14,45 @@ class Command:
     input_args: List[str]
 
 class PlanWriterCtrlFlow(ChatAtomicFlow):
-    """Refer to: https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Controller_JarvisFlow.py
+    """Refer to: https://huggingface.co/aiflows/JarvisFlowModule/blob/main/Controller_JarvisFlow.py
+    This flow is a controller flow that controls the PlanWriterFlow.
+
+    *Input Interface Non Initialized*:
+    - `goal`: str
+
+    *Input Interface Initialized*:
+    - `feedback`: str
+    - `goal`: str
+    - `plan`: str
+
+    *Output Interface*:
+    - `command`: str
+    - `command_args`: Dict[str, Any]
+
+    *Configuration Parameters*:
+    - `input_interface_non_initialized`: List[str] = ["goal"]
+    - `input_interface_initialized`: List[str] = ["feedback", "goal", "plan"]
+    - `output_interface`: List[str] = ["command", "command_args"]
+    - `backend`: Dict[str, Any] : backend of the LLM
+    - `commands`: List[Dict[str, Any]] : commands that the LLM can execute
+    - `system_message_prompt_template`: str : the template of the system message prompt
+    - `init_human_message_prompt_template`: str : the template of the initial human message prompt
+    - `human_message_prompt_template`: str : the template of the human message prompt
+    - `previous_messages`: Dict[str, Any] : the previous messages of the conversation (sliding window)
+
     """
+
     def __init__(
             self,
             commands: List[Command],
             **kwargs):
+        """
+        This function initializes the flow.
+        :param commands: List[Command] : commands that the LLM can execute
+        :type commands: List[Command]
+        :param kwargs: other parameters
+        :type kwargs: Dict[str, Any]
+        """
         super().__init__(**kwargs)
         self.system_message_prompt_template = self.system_message_prompt_template.partial(
             commands=self._build_commands_manual(commands),
@@ -37,6 +70,13 @@ class PlanWriterCtrlFlow(ChatAtomicFlow):
 
     @staticmethod
     def _build_commands_manual(commands: List[Command]) -> str:
+        """
+        This function builds the manual for the commands.
+        :param commands: List[Command] : commands that the LLM can execute
+        :type commands: List[Command]
+        :return: the manual for the commands
+        :rtype: str
+        """
         ret = ""
         for i, command in enumerate(commands):
             command_input_json_schema = json.dumps(
@@ -46,6 +86,13 @@ class PlanWriterCtrlFlow(ChatAtomicFlow):
 
     @classmethod
     def instantiate_from_config(cls, config):
+        """
+        This function instantiates the flow from the config.
+        :param config: the config of the flow
+        :type config: Dict[str, Any]
+        :return: the instantiated flow
+        :rtype: ChatAtomicFlow
+        """
         flow_config = deepcopy(config)
 
         kwargs = {"flow_config": flow_config}
@@ -68,12 +115,26 @@ class PlanWriterCtrlFlow(ChatAtomicFlow):
         return cls(**kwargs)
 
     def _update_prompts_and_input(self, input_data: Dict[str, Any]):
+        """
+        This function updates the prompts and input data.
+        :param input_data: the input data
+        :type input_data: Dict[str, Any]
+        :return: None
+        :rtype: None
+        """
         if 'goal' in input_data:
             input_data['goal'] += self.hint_for_model
         if 'feedback' in input_data:
             input_data['feedback'] += self.hint_for_model
 
     def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        This function runs the flow.
+        :param input_data: the input data
+        :type input_data: Dict[str, Any]
+        :return: the output of the flow
+        :rtype: Dict[str, Any]
+        """
         self._update_prompts_and_input(input_data)
         
         # ~~~when conversation is initialized, append the updated system prompts to the chat history ~~~

PlanWriterFlow.py

@@ -7,7 +7,7 @@ from aiflows.base_flows import CircularFlow
 
 class PlanWriterFlow(ContentWriterFlow):
     """This flow inherits from ContentWriterFlow.
-    In the subflow of the executor, we specify the InteractivePlanGneFlow (https://huggingface.co/Tachi67/InteractivePlanGenFlowModule)
+    In the subflow of the executor, we specify the InteractivePlanGneFlow (https://huggingface.co/aiflows/InteractivePlanGenFlowModule)
 
     *Input Interface*:
     - `goal`
@@ -17,8 +17,20 @@ class PlanWriterFlow(ContentWriterFlow):
     - `result`
     - `summary`
     - `status`
+
+    *Configuration Parameters*:
+    - Also refer to superclass ContentWriterFlow (https://huggingface.co/aiflows/ContentWriterFlowModule)
+    - `input_interface`: the input interface of the flow
+    - `output_interface`: the output interface of the flow
+    - `subflows_config`: the configuration of the subflows
+    - `early_exit_key`: the key in the flow state that indicates the early exit condition
+    - `topology`: the topology of the flow
+
     """
     def _on_reach_max_round(self):
+        """This function is called when the flow reaches the maximum amount of rounds.
+        It decides whether to terminate the flow or continue running.
+        """
         self._state_update_dict({
             "plan": "The maximum amount of rounds was reached before the model generated the plan.",
             "status": "unfinished"
@@ -26,6 +38,15 @@ class PlanWriterFlow(ContentWriterFlow):
 
     @CircularFlow.output_msg_payload_processor
     def detect_finish_or_continue(self, output_payload: Dict[str, Any], src_flow) -> Dict[str, Any]:
+        """This function is called when the subflow finishes running.
+        configured in the topology of the subflow config.
+        :param output_payload: the output payload of the subflow
+        :type output_payload: Dict[str, Any]
+        :param src_flow: the subflow that generates the output payload
+        :type src_flow: Flow
+        :return: the processed output payload
+        :rtype: 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
@@ -74,6 +95,13 @@ class PlanWriterFlow(ContentWriterFlow):
             return output_payload
 
     def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        This function runs the flow.
+        :param input_data: the input data of the flow
+        :type input_data: Dict[str, Any]
+        :return: the output data of the flow
+        :rtype: Dict[str, Any]
+        """
         # ~~~ sets the input_data in the flow_state dict ~~~
         self._state_update_dict(update_data=input_data)
 

README.md

@@ -1,4 +1,24 @@
-### Structure of PlanWriterFlow
+# Table of Contents
+
+* [Structure of PlanWriterFlow](#structure-of-planwriterflow)
+* [run\_planwriter](#run_planwriter)
+* [PlanWriterAskUserFlow](#PlanWriterAskUserFlow)
+  * [PlanWriterAskUserFlow](#PlanWriterAskUserFlow.PlanWriterAskUserFlow)
+    * [run](#PlanWriterAskUserFlow.PlanWriterAskUserFlow.run)
+* [PlanWriterFlow](#PlanWriterFlow)
+  * [PlanWriterFlow](#PlanWriterFlow.PlanWriterFlow)
+    * [detect\_finish\_or\_continue](#PlanWriterFlow.PlanWriterFlow.detect_finish_or_continue)
+    * [run](#PlanWriterFlow.PlanWriterFlow.run)
+* [\_\_init\_\_](#__init__)
+* [PlanWriterCtrlFlow](#PlanWriterCtrlFlow)
+  * [PlanWriterCtrlFlow](#PlanWriterCtrlFlow.PlanWriterCtrlFlow)
+    * [\_\_init\_\_](#PlanWriterCtrlFlow.PlanWriterCtrlFlow.__init__)
+    * [instantiate\_from\_config](#PlanWriterCtrlFlow.PlanWriterCtrlFlow.instantiate_from_config)
+    * [run](#PlanWriterCtrlFlow.PlanWriterCtrlFlow.run)
+
+
+
+# Structure of PlanWriterFlow
 
 ```
                goal
@@ -39,23 +59,15 @@ 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.
+- [ask_user](https://huggingface.co/aiflows/PlanWriterFlowModule/blob/main/PlanWriterAskUserFlow.py): Ask user for info / confirmation, etc.
+- [write_plan](https://huggingface.co/aiflows/InteractivePlanGenFlowModule): Generates plan (user edit is allowed) and fetches user feedback.
 
 How it works:
 Controller calls write_plan until user is satisfied in the feedback, finish.
 
 
-# Table of Contents
 
-* [run\_planwriter](#run_planwriter)
-* [PlanWriterAskUserFlow](#PlanWriterAskUserFlow)
-  * [PlanWriterAskUserFlow](#PlanWriterAskUserFlow.PlanWriterAskUserFlow)
-* [PlanWriterFlow](#PlanWriterFlow)
-  * [PlanWriterFlow](#PlanWriterFlow.PlanWriterFlow)
-* [\_\_init\_\_](#__init__)
-* [PlanWriterCtrlFlow](#PlanWriterCtrlFlow)
-  * [PlanWriterCtrlFlow](#PlanWriterCtrlFlow.PlanWriterCtrlFlow)
+
 
 <a id="run_planwriter"></a>
 
@@ -73,7 +85,38 @@ Controller calls write_plan until user is satisfied in the feedback, finish.
 class PlanWriterAskUserFlow(HumanStandardInputFlow)
 ```
 
-Refer to: https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py
+Refer to: https://huggingface.co/aiflows/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py
+This flow is used to ask the user a question and get a response.
+
+*Input Interface*:
+- `question`
+
+*Output Interface*:
+- `feedback`
+- `plan`
+
+*Configuration Parameters*:
+- `query_message_prompt_template`: The message template to prompt the user for input.
+- `request_multi_line_input_flag`: Whether to request multi-line input from the user.
+- `end_of_input_string`: The string to enter to indicate the end of input.
+
+<a id="PlanWriterAskUserFlow.PlanWriterAskUserFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+Run the flow module.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): The input data to the flow module.
+
+**Returns**:
+
+`Dict[str, Any]`: The output data from the flow module.
 
 <a id="PlanWriterFlow"></a>
 
@@ -88,7 +131,7 @@ class PlanWriterFlow(ContentWriterFlow)
 ```
 
 This flow inherits from ContentWriterFlow.
-In the subflow of the executor, we specify the InteractivePlanGneFlow (https://huggingface.co/Tachi67/InteractivePlanGenFlowModule)
+In the subflow of the executor, we specify the InteractivePlanGneFlow (https://huggingface.co/aiflows/InteractivePlanGenFlowModule)
 
 *Input Interface*:
 - `goal`
@@ -99,6 +142,55 @@ In the subflow of the executor, we specify the InteractivePlanGneFlow (https://h
 - `summary`
 - `status`
 
+*Configuration Parameters*:
+- Also refer to superclass ContentWriterFlow (https://huggingface.co/aiflows/ContentWriterFlowModule)
+- `input_interface`: the input interface of the flow
+- `output_interface`: the output interface of the flow
+- `subflows_config`: the configuration of the subflows
+- `early_exit_key`: the key in the flow state that indicates the early exit condition
+- `topology`: the topology of the flow
+
+<a id="PlanWriterFlow.PlanWriterFlow.detect_finish_or_continue"></a>
+
+#### detect\_finish\_or\_continue
+
+```python
+@CircularFlow.output_msg_payload_processor
+def detect_finish_or_continue(output_payload: Dict[str, Any],
+                              src_flow) -> Dict[str, Any]
+```
+
+This function is called when the subflow finishes running.
+
+configured in the topology of the subflow config.
+
+**Arguments**:
+
+- `output_payload` (`Dict[str, Any]`): the output payload of the subflow
+- `src_flow` (`Flow`): the subflow that generates the output payload
+
+**Returns**:
+
+`Dict[str, Any]`: the processed output payload
+
+<a id="PlanWriterFlow.PlanWriterFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+This function runs the flow.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): the input data of the flow
+
+**Returns**:
+
+`Dict[str, Any]`: the output data of the flow
+
 <a id="__init__"></a>
 
 # \_\_init\_\_
@@ -115,5 +207,81 @@ In the subflow of the executor, we specify the InteractivePlanGneFlow (https://h
 class PlanWriterCtrlFlow(ChatAtomicFlow)
 ```
 
-Refer to: https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Controller_JarvisFlow.py
+Refer to: https://huggingface.co/aiflows/JarvisFlowModule/blob/main/Controller_JarvisFlow.py
+This flow is a controller flow that controls the PlanWriterFlow.
+
+*Input Interface Non Initialized*:
+- `goal`: str
+
+*Input Interface Initialized*:
+- `feedback`: str
+- `goal`: str
+- `plan`: str
+
+*Output Interface*:
+- `command`: str
+- `command_args`: Dict[str, Any]
+
+*Configuration Parameters*:
+- `input_interface_non_initialized`: List[str] = ["goal"]
+- `input_interface_initialized`: List[str] = ["feedback", "goal", "plan"]
+- `output_interface`: List[str] = ["command", "command_args"]
+- `backend`: Dict[str, Any] : backend of the LLM
+- `commands`: List[Dict[str, Any]] : commands that the LLM can execute
+- `system_message_prompt_template`: str : the template of the system message prompt
+- `init_human_message_prompt_template`: str : the template of the initial human message prompt
+- `human_message_prompt_template`: str : the template of the human message prompt
+- `previous_messages`: Dict[str, Any] : the previous messages of the conversation (sliding window)
+
+<a id="PlanWriterCtrlFlow.PlanWriterCtrlFlow.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(commands: List[Command], **kwargs)
+```
+
+This function initializes the flow.
+
+**Arguments**:
+
+- `commands` (`List[Command]`): List[Command] : commands that the LLM can execute
+- `kwargs` (`Dict[str, Any]`): other parameters
+
+<a id="PlanWriterCtrlFlow.PlanWriterCtrlFlow.instantiate_from_config"></a>
+
+#### instantiate\_from\_config
+
+```python
+@classmethod
+def instantiate_from_config(cls, config)
+```
+
+This function instantiates the flow from the config.
+
+**Arguments**:
+
+- `config` (`Dict[str, Any]`): the config of the flow
+
+**Returns**:
+
+`ChatAtomicFlow`: the instantiated flow
+
+<a id="PlanWriterCtrlFlow.PlanWriterCtrlFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+This function runs the flow.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): the input data
+
+**Returns**:
+
+`Dict[str, Any]`: the output of the flow