add more docs and comments

ControllerFlow_ExtLib.py

@@ -13,12 +13,49 @@ class Command:
     description: str
     input_args: List[str]
 
+
 class ControllerFlow_ExtLib(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 for a detailed doc.
+    This flow inherits from ChatAtomicFlow and is used as a controller of the ExtendLibraryFlow.
+
+    *Input Interface Non Initialized*:
+    - `goal`
+    - `memory_files`
+    - `plan`
+    - `logs`
+
+    *Input Interface Initialized*:
+    - `goal`
+    - `memory_files`
+    - `plan`
+    - `logs`
+    - `result`
+
+    *Output Interface*:
+    - `command`
+    - `command_args`
+
+    *Configuration Parameters*:
+    - `input_interface_non_initialized`: a list of input interface names when the conversation starts.
+    - `input_interface_initialized`: a list of input interface names when the conversation is initialized.
+    - `output_interface`: the output of the controller, it is the command and the command arguments.
+    - `commands`: a list of commands that the controller can call. Each command has a name, a description, and a list of input arguments.
+    - `system_message_prompt_template`: the system message prompt template.
+    - `init_human_message_prompt_template`: the initial human (user) message prompt template.
+    - `human_message_prompt_template`: the human (user) message prompt template.
+    - `previous_messages`: the sliding window of previous messages.
+
+
+    """
     def __init__(
             self,
             commands: List[Command],
             **kwargs):
+        """
+        The constructor of the ControllerFlow_ExtLib class.
+        :param commands: a list of commands that the controller can call. Each command has a name, a description, and a list of input arguments.
+        :param kwargs: the configuration parameters of the ControllerFlow_ExtLib class.
+        """
         super().__init__(**kwargs)
         self.system_message_prompt_template = self.system_message_prompt_template.partial(
             commands=self._build_commands_manual(commands),
@@ -39,6 +76,13 @@ class ControllerFlow_ExtLib(ChatAtomicFlow):
 
     @staticmethod
     def _build_commands_manual(commands: List[Command]) -> str:
+        """
+        Build the manual for the commands.
+        :param commands: a list of commands that the controller can call. Each command has a name, a description, and a list of input arguments.
+        :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(
@@ -47,11 +91,27 @@ class ControllerFlow_ExtLib(ChatAtomicFlow):
         return ret
 
     def _get_plan_file_location(self, input_data: Dict[str, Any]):
+        """ Get the plan file location from the input data.
+        :param input_data: the input data.
+        :raise AssertionError: if the plan file location is not passed to the controller.
+        :raise AssertionError: if the plan file location is not in the memory files.
+        :raise AssertionError: if the plan is not in the memory files.
+        :type input_data: Dict[str, Any]
+        :return: the plan file location.
+        :rtype: str
+        """
         assert "memory_files" in input_data, "memory_files not passed to Extlib/Controller"
         assert "plan" in input_data["memory_files"], "plan not in memory files"
         return input_data["memory_files"]["plan"]
 
     def _get_plan_content(self, input_data: Dict[str, Any]):
+        """ Get the plan content from the input data.
+        :param input_data: the input data.
+        :raise AssertionError: if the plan is not passed to the controller.
+        :type input_data: Dict[str, Any]
+        :return: the plan content.
+        :rtype: str
+        """
         assert "plan" in input_data, "plan not passed to Extlib/Controller"
         plan_content = input_data["plan"]
         if len(plan_content) == 0:
@@ -59,6 +119,13 @@ class ControllerFlow_ExtLib(ChatAtomicFlow):
         return plan_content
 
     def _get_logs_content(self, input_data: Dict[str, Any]):
+        """ Get the logs content from the input data.
+        :param input_data: the input data.
+        :raise AssertionError: if the logs is not passed to the controller.
+        :type input_data: Dict[str, Any]
+        :return: the logs content.
+        :rtype: str
+        """
         assert "logs" in input_data, "logs not passed to Extlib/Controller"
         logs_content = input_data["logs"]
         if len(logs_content) == 0:
@@ -67,6 +134,12 @@ class ControllerFlow_ExtLib(ChatAtomicFlow):
 
     @classmethod
     def instantiate_from_config(cls, config):
+        """Instantiate the flow from a configuration.
+        :param config: the configuration.
+        :type config: Dict[str, Any]
+        :return: the instantiated flow.
+        :rtype: ControllerFlow_ExtLib
+        """
         flow_config = deepcopy(config)
 
         kwargs = {"flow_config": flow_config}
@@ -89,6 +162,10 @@ class ControllerFlow_ExtLib(ChatAtomicFlow):
         return cls(**kwargs)
 
     def _update_prompts_and_input(self, input_data: Dict[str, Any]):
+        """Update the prompts and the input data. The system prompts are updated with the new memory.
+        :param input_data: the input data.
+        :type input_data: Dict[str, Any]
+        """
         if 'goal' in input_data:
             input_data['goal'] += self.hint_for_model
         if 'result' in input_data:
@@ -103,6 +180,12 @@ class ControllerFlow_ExtLib(ChatAtomicFlow):
         )
 
     def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Run 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 ~~~

CtrlExMem_ExtLib.py

@@ -5,17 +5,23 @@ from aiflows.base_flows import CircularFlow
 
 class CtrlExMem_ExtLib(CtrlExMemFlow):
     """This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule.
-    See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+
+    See: https://huggingface.co/aiflows/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+
     *Input Interface*:
     - `plan`
     - `logs`
     - `memory_files`
     - `goal`
+
     *Output Interface*
     - `result` (str): The result of the flow, the result will be returned to the caller.
     - `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow.
+
     """
     def _on_reach_max_round(self):
+        """This method is called when the flow reaches the maximum amount of rounds.
+        """
         self._state_update_dict({
             "result": "the maximum amount of rounds was reached before the extend library flow has done the job",
             "summary": "ExtendLibraryFlow: the maximum amount of rounds was reached before the flow has done the job",
@@ -24,6 +30,14 @@ class CtrlExMem_ExtLib(CtrlExMemFlow):
 
     @CircularFlow.output_msg_payload_processor
     def detect_finish_or_continue(self, output_payload: Dict[str, Any], src_flow) -> Dict[str, Any]:
+        """This method is called when the flow receives a message from the child flow.
+        :param output_payload: The output payload of the child flow.
+        :type output_payload: Dict[str, Any]
+        :param src_flow: The child flow.
+        :type src_flow: AbstractBossFlowModule
+        :return: The processed output payload.
+        :rtype: Dict[str, Any]
+        """
         command = output_payload["command"]
         if command == "finish":
             return {

ExtLibAskUserFlow.py

@@ -8,23 +8,33 @@ from aiflows.utils import logging
 
 log = logging.get_logger(f"aiflows.{__name__}")
 
-# TODO: extract this flow to a seperate flow module for modularity.
 class ExtLibAskUserFlow(HumanStandardInputFlow):
     """This class is used to ask for user feedback whenever the controller is unsure of something, or need confirmation, etc.
 
-    *Expected Input*:
+    *Input Interface*:
     - `question`: The question asked by the controller
 
     *Expected Behaviour*:
-    - The question is displayed, and the user gives feedback by inputing string.
+    - The question is displayed, and the user gives feedback by input string.
 
-    *Expected Ouput*:
+    *Output Interface*:
     - `result`: The input of the user.
     - `summary`: The summary that will be written by the caller.
+
+    *Configuration Parameters*:
+    - `query_message_prompt_template`: The template of the message that is displayed to the user.
+    - `request_multi_line_input`: Whether the user should be able to input multiple lines. Default: False.
+    - `end_of_input_string`: The string that the user can input to indicate that he/she is done with the input. Default: EOI
+
     """
     def run(self,
             input_data: Dict[str, Any]) -> Dict[str, Any]:
-
+        """Run the flow module.
+        :param input_data: The input data.
+        :type input_data: Dict[str, Any]
+        :return: The output data.
+        :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'],

ExtendLibraryFlow.py

@@ -17,13 +17,29 @@ class ExtendLibraryFlow(AbstractBossFlow):
     5. Finish, writes code to the library.
     Step 3-5 is done via prompting the controller.
 
+    ExtendLibraryFlow inherits from AbstractBossFlow, visit https://huggingface.co/aiflows/AbstractBossFlowModule/
+
     *Input Interface (expected input)*
     - `goal` (str): The goal from the caller (source flow, i.e. CoderFlow)
+
     *Output Interface (expected output)*
     - `result` (str): The result of the flow, the result will be returned to the caller (i.e. CoderFlow).
     - `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow (i.e. CoderFlow).
+
+    *Configuration Parameters*:
+    - `memory_files`: The memory files to be read by the flow. By convention, the memory files should contain plan, logs, and code library.
+    - `input_interface`: The input interface of the flow. By default, they should be `goal`.
+    - `output_interface`: The output interface of the flow. By default, they should be `result` and `summary`.
+    - `subflows_config`: Configurations w/ the subflows.
+
     """
     def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Run 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,32 @@
-### Structure of ExtendLibraryFlow
+# Table of Contents
+
+* [Structure of ExtendLibraryFlow](#structure-of-extendlibraryflow)
+* [SaveCodeAtomicFlow](#SaveCodeAtomicFlow)
+  * [SaveCodeAtomicFlow](#SaveCodeAtomicFlow.SaveCodeAtomicFlow)
+    * [run](#SaveCodeAtomicFlow.SaveCodeAtomicFlow.run)
+* [ExtLibAskUserFlow](#ExtLibAskUserFlow)
+  * [ExtLibAskUserFlow](#ExtLibAskUserFlow.ExtLibAskUserFlow)
+    * [run](#ExtLibAskUserFlow.ExtLibAskUserFlow.run)
+* [ExtendLibraryFlow](#ExtendLibraryFlow)
+  * [ExtendLibraryFlow](#ExtendLibraryFlow.ExtendLibraryFlow)
+    * [run](#ExtendLibraryFlow.ExtendLibraryFlow.run)
+* [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow)
+  * [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow.UpdatePlanAtomicFlow)
+    * [run](#UpdatePlanAtomicFlow.UpdatePlanAtomicFlow.run)
+* [run\_ExtendLibrary](#run_ExtendLibrary)
+* [CtrlExMem\_ExtLib](#CtrlExMem_ExtLib)
+  * [CtrlExMem\_ExtLib](#CtrlExMem_ExtLib.CtrlExMem_ExtLib)
+    * [detect\_finish\_or\_continue](#CtrlExMem_ExtLib.CtrlExMem_ExtLib.detect_finish_or_continue)
+* [ControllerFlow\_ExtLib](#ControllerFlow_ExtLib)
+  * [ControllerFlow\_ExtLib](#ControllerFlow_ExtLib.ControllerFlow_ExtLib)
+    * [\_\_init\_\_](#ControllerFlow_ExtLib.ControllerFlow_ExtLib.__init__)
+    * [instantiate\_from\_config](#ControllerFlow_ExtLib.ControllerFlow_ExtLib.instantiate_from_config)
+    * [run](#ControllerFlow_ExtLib.ControllerFlow_ExtLib.run)
+* [\_\_init\_\_](#__init__)
+
+
+
+# Structure of ExtendLibraryFlow
 
 ```
      goal, memory_files (dict)
@@ -79,35 +107,19 @@ write_code    ask_user re_plan update_plan   save_code
 ```
 
 Memory files of ExtendLibraryFlow:
-- plan_extlib.txt
-- logs_extlib.txt
-- library.py
+- `plan_extlib.txt`
+- `logs_extlib.txt`
+- `library.py`
 
 About the branches:
-- [write_code](https://huggingface.co/Tachi67/CodeWriterFlowModule): Generates code in an interactive way, the user is able to edit or provide feedback during the process of writing code.
-- [ask_user](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py): Ask user for info / confirmation, etc.
-- [re_plan](https://huggingface.co/Tachi67/ReplanningFlowModule): One branch of the executors, when something goes wrong, re-draft the plan.
-- [update_plan](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/UpdatePlanAtomicFlow.py): One branch of the executors, when the controller realizes that one (or some, depending on the LLM's response) step of the plan is (are) done, it generates a new plan that marks the step(s) as done.
-- [save_code](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/SaveCodeAtomicFlow.py): Writes the wriiten & tested code to the code library.
+- [write_code](https://huggingface.co/aiflows/CodeWriterFlowModule): Generates code in an interactive way, the user is able to edit or provide feedback during the process of writing code.
+- [ask_user](https://huggingface.co/aiflows/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py): Ask user for info / confirmation, etc.
+- [re_plan](https://huggingface.co/aiflows/ReplanningFlowModule): One branch of the executors, when something goes wrong, re-draft the plan.
+- [update_plan](https://huggingface.co/aiflows/JarvisFlowModule/blob/main/UpdatePlanAtomicFlow.py): One branch of the executors, when the controller realizes that one (or some, depending on the LLM's response) step of the plan is (are) done, it generates a new plan that marks the step(s) as done.
+- [save_code](https://huggingface.co/aiflows/ExtendLibraryFlowModule/blob/main/SaveCodeAtomicFlow.py): Writes the written & tested code to the code library.
 
 
-# Table of Contents
 
-* [SaveCodeAtomicFlow](#SaveCodeAtomicFlow)
-  * [SaveCodeAtomicFlow](#SaveCodeAtomicFlow.SaveCodeAtomicFlow)
-    * [run](#SaveCodeAtomicFlow.SaveCodeAtomicFlow.run)
-* [ExtLibAskUserFlow](#ExtLibAskUserFlow)
-  * [ExtLibAskUserFlow](#ExtLibAskUserFlow.ExtLibAskUserFlow)
-* [ExtendLibraryFlow](#ExtendLibraryFlow)
-  * [ExtendLibraryFlow](#ExtendLibraryFlow.ExtendLibraryFlow)
-* [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow)
-  * [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow.UpdatePlanAtomicFlow)
-* [run\_ExtendLibrary](#run_ExtendLibrary)
-* [CtrlExMem\_ExtLib](#CtrlExMem_ExtLib)
-  * [CtrlExMem\_ExtLib](#CtrlExMem_ExtLib.CtrlExMem_ExtLib)
-* [ControllerFlow\_ExtLib](#ControllerFlow_ExtLib)
-  * [ControllerFlow\_ExtLib](#ControllerFlow_ExtLib.ControllerFlow_ExtLib)
-* [\_\_init\_\_](#__init__)
 
 <a id="SaveCodeAtomicFlow"></a>
 
@@ -130,6 +142,10 @@ This flow appends the code to the code library file.
 - `result` (str): the result of the flow, to be returned to the controller of the caller
 - `summary` (str): the summary of the flow, to be appended to logs
 
+*Configuration Parameters*:
+- `input_interface`: the input interface of the flow
+- `output_interface`: the output interface of the flow
+
 <a id="SaveCodeAtomicFlow.SaveCodeAtomicFlow.run"></a>
 
 #### run
@@ -142,11 +158,11 @@ Run the flow
 
 **Arguments**:
 
-- `input_data`: the input data
+- `input_data` (`dict`): the input data
 
 **Returns**:
 
-the output data
+`dict`: the output data
 
 <a id="ExtLibAskUserFlow"></a>
 
@@ -162,16 +178,39 @@ class ExtLibAskUserFlow(HumanStandardInputFlow)
 
 This class is used to ask for user feedback whenever the controller is unsure of something, or need confirmation, etc.
 
-*Expected Input*:
+*Input Interface*:
 - `question`: The question asked by the controller
 
 *Expected Behaviour*:
-- The question is displayed, and the user gives feedback by inputing string.
+- The question is displayed, and the user gives feedback by input string.
 
-*Expected Ouput*:
+*Output Interface*:
 - `result`: The input of the user.
 - `summary`: The summary that will be written by the caller.
 
+*Configuration Parameters*:
+- `query_message_prompt_template`: The template of the message that is displayed to the user.
+- `request_multi_line_input`: Whether the user should be able to input multiple lines. Default: False.
+- `end_of_input_string`: The string that the user can input to indicate that he/she is done with the input. Default: EOI
+
+<a id="ExtLibAskUserFlow.ExtLibAskUserFlow.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.
+
+**Returns**:
+
+`Dict[str, Any]`: The output data.
+
 <a id="ExtendLibraryFlow"></a>
 
 # ExtendLibraryFlow
@@ -197,12 +236,39 @@ Workflow of ExtendLibrary:
 5. Finish, writes code to the library.
 Step 3-5 is done via prompting the controller.
 
+ExtendLibraryFlow inherits from AbstractBossFlow, visit https://huggingface.co/aiflows/AbstractBossFlowModule/
+
 *Input Interface (expected input)*
 - `goal` (str): The goal from the caller (source flow, i.e. CoderFlow)
+
 *Output Interface (expected output)*
 - `result` (str): The result of the flow, the result will be returned to the caller (i.e. CoderFlow).
 - `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow (i.e. CoderFlow).
 
+*Configuration Parameters*:
+- `memory_files`: The memory files to be read by the flow. By convention, the memory files should contain plan, logs, and code library.
+- `input_interface`: The input interface of the flow. By default, they should be `goal`.
+- `output_interface`: The output interface of the flow. By default, they should be `result` and `summary`.
+- `subflows_config`: Configurations w/ the subflows.
+
+<a id="ExtendLibraryFlow.ExtendLibraryFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+Run 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="UpdatePlanAtomicFlow"></a>
 
 # UpdatePlanAtomicFlow
@@ -215,7 +281,35 @@ Step 3-5 is done via prompting the controller.
 class UpdatePlanAtomicFlow(AtomicFlow)
 ```
 
-Refer to: https://huggingface.co/Tachi67/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py
+Refer to: https://huggingface.co/aiflows/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py
+This flow updates the plan file with the updated plan.
+*Input Interface*:
+- `updated_plan` (str): the updated plan
+
+*Output Interface*:
+- `result` (str): the result of the flow, to be returned to the controller of the caller
+
+*Configuration Parameters*:
+- `input_interface`: the input interface of the flow
+- `output_interface`: the output interface of the flow
+
+<a id="UpdatePlanAtomicFlow.UpdatePlanAtomicFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any])
+```
+
+Run the flow
+
+**Arguments**:
+
+- `input_data` (`dict`): the input data
+
+**Returns**:
+
+`dict`: the output data
 
 <a id="run_ExtendLibrary"></a>
 
@@ -234,16 +328,40 @@ class CtrlExMem_ExtLib(CtrlExMemFlow)
 ```
 
 This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule.
-See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+
+See: https://huggingface.co/aiflows/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+
 *Input Interface*:
 - `plan`
 - `logs`
 - `memory_files`
 - `goal`
+
 *Output Interface*
 - `result` (str): The result of the flow, the result will be returned to the caller.
 - `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow.
 
+<a id="CtrlExMem_ExtLib.CtrlExMem_ExtLib.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 method is called when the flow receives a message from the child flow.
+
+**Arguments**:
+
+- `output_payload` (`Dict[str, Any]`): The output payload of the child flow.
+- `src_flow` (`AbstractBossFlowModule`): The child flow.
+
+**Returns**:
+
+`Dict[str, Any]`: The processed output payload.
+
 <a id="ControllerFlow_ExtLib"></a>
 
 # ControllerFlow\_ExtLib
@@ -256,7 +374,87 @@ See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFl
 class ControllerFlow_ExtLib(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 for a detailed doc.
+This flow inherits from ChatAtomicFlow and is used as a controller of the ExtendLibraryFlow.
+
+*Input Interface Non Initialized*:
+- `goal`
+- `memory_files`
+- `plan`
+- `logs`
+
+*Input Interface Initialized*:
+- `goal`
+- `memory_files`
+- `plan`
+- `logs`
+- `result`
+
+*Output Interface*:
+- `command`
+- `command_args`
+
+*Configuration Parameters*:
+- `input_interface_non_initialized`: a list of input interface names when the conversation starts.
+- `input_interface_initialized`: a list of input interface names when the conversation is initialized.
+- `output_interface`: the output of the controller, it is the command and the command arguments.
+- `commands`: a list of commands that the controller can call. Each command has a name, a description, and a list of input arguments.
+- `system_message_prompt_template`: the system message prompt template.
+- `init_human_message_prompt_template`: the initial human (user) message prompt template.
+- `human_message_prompt_template`: the human (user) message prompt template.
+- `previous_messages`: the sliding window of previous messages.
+
+<a id="ControllerFlow_ExtLib.ControllerFlow_ExtLib.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(commands: List[Command], **kwargs)
+```
+
+The constructor of the ControllerFlow_ExtLib class.
+
+**Arguments**:
+
+- `commands`: a list of commands that the controller can call. Each command has a name, a description, and a list of input arguments.
+- `kwargs`: the configuration parameters of the ControllerFlow_ExtLib class.
+
+<a id="ControllerFlow_ExtLib.ControllerFlow_ExtLib.instantiate_from_config"></a>
+
+#### instantiate\_from\_config
+
+```python
+@classmethod
+def instantiate_from_config(cls, config)
+```
+
+Instantiate the flow from a configuration.
+
+**Arguments**:
+
+- `config` (`Dict[str, Any]`): the configuration.
+
+**Returns**:
+
+`ControllerFlow_ExtLib`: the instantiated flow.
+
+<a id="ControllerFlow_ExtLib.ControllerFlow_ExtLib.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+Run the flow.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): the input data.
+
+**Returns**:
+
+`Dict[str, Any]`: the output of the flow.
 
 <a id="__init__"></a>
 

SaveCodeAtomicFlow.py

@@ -11,10 +11,17 @@ class SaveCodeAtomicFlow(AtomicFlow):
     *Output Interface*:
     - `result` (str): the result of the flow, to be returned to the controller of the caller
     - `summary` (str): the summary of the flow, to be appended to logs
+
+    *Configuration Parameters*:
+    - `input_interface`: the input interface of the flow
+    - `output_interface`: the output interface of the flow
+
     """
     def _check_input(self, input_data: Dict[str, Any]):
         """Check if the input data is valid
         :param input_data: the input data
+        :type input_data: dict
+        :raises AssertionError: if the input data is invalid
         :return: None
         """
         assert "code" in input_data, "code is not passed to SaveCodeAtomicFlow"
@@ -28,7 +35,9 @@ class SaveCodeAtomicFlow(AtomicFlow):
     def _call(self, input_data: Dict[str, Any]):
         """The internal logic of the flow
         :param input_data: the input data
+        :type input_data: dict
         :return: the output data
+        :rtype: dict
         """
         try:
             code_to_append = input_data["code"]
@@ -52,7 +61,9 @@ class SaveCodeAtomicFlow(AtomicFlow):
     ):
         """Run the flow
         :param input_data: the input data
+        :type input_data: dict
         :return: the output data
+        :rtype: dict
         """
         self._check_input(input_data)
         return self._call(input_data)

UpdatePlanAtomicFlow.py

@@ -1,12 +1,35 @@
 from typing import Dict, Any
 from aiflows.base_flows.atomic import AtomicFlow
 class UpdatePlanAtomicFlow(AtomicFlow):
-    """Refer to: https://huggingface.co/Tachi67/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py"""
+    """Refer to: https://huggingface.co/aiflows/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py
+    This flow updates the plan file with the updated plan.
+    *Input Interface*:
+    - `updated_plan` (str): the updated plan
+
+    *Output Interface*:
+    - `result` (str): the result of the flow, to be returned to the controller of the caller
+
+    *Configuration Parameters*:
+    - `input_interface`: the input interface of the flow
+    - `output_interface`: the output interface of the flow
+    """
     def _check_input(self, input_data: Dict[str, Any]):
+        """Check if the input data is valid
+        :param input_data: the input data
+        :type input_data: dict
+        :raises AssertionError: if the input data is invalid
+        :return: None
+        """
         assert "memory_files" in input_data, "memory_files not passed to UpdatePlanAtomicFlow"
         assert "plan" in input_data["memory_files"], "plan not in memory_files"
 
     def _call(self, input_data: Dict[str, Any]):
+        """The internal logic of the flow
+        :param input_data: the input data
+        :type input_data: dict
+        :return: the output data
+        :rtype: dict
+        """
         try:
             plan_file_location = input_data["memory_files"]["plan"]
             plan_to_write = input_data["updated_plan"]
@@ -26,5 +49,11 @@ class UpdatePlanAtomicFlow(AtomicFlow):
             self,
             input_data: Dict[str, Any]
     ):
+        """Run the flow
+        :param input_data: the input data
+        :type input_data: dict
+        :return: the output data
+        :rtype: dict
+        """
         self._check_input(input_data)
         return self._call(input_data)