Upload 12 files

ExecuteCodeAtomicFlow.py

@@ -17,8 +17,19 @@ class ExecuteCodeAtomicFlow(InterpreterAtomicFlow):
     *Output Interface*:
     - interpreter_output: The output of the execution of the code.
     - code_ran: The code that was executed.
+
+    *Configuration Parameters*:
+    - `input_interface`: The input interface of the atomic flow.
+    - `output_interface`: The output interface of the atomic flow.
+
     """
     def _prepare_code(self, input_data: Dict[str, Any]):
+        """
+        This method reads the code from the file and stores it in the input_data dictionary.
+        :param input_data: The input_data dictionary.
+        :type input_data: Dict[str, Any]
+        :return: None
+        """
         file_location = input_data["temp_code_file_location"]
         start_marker = "# Code:\n"
         end_marker = "############"
@@ -36,14 +47,33 @@ class ExecuteCodeAtomicFlow(InterpreterAtomicFlow):
         input_data["code"] = code_str
 
     def _check_input(self, input_data: Dict[str, Any]):
+        """
+        This method checks if the input_data dictionary contains the required keys.
+        :param input_data: The input_data dictionary.
+        :type input_data: Dict[str, Any]
+        :raises AssertionError: If the input_data dictionary does not contain the required keys.
+        :return: None
+        """
         assert "temp_code_file_location" in input_data, "temp_code_file_location not passed to ExecuteCodeAtomicFlow"
         assert "language" in input_data, "language not passed to ExecuteCodeAtomicFlow"
 
     def _delete_file(self, file_location):
+        """
+        This method deletes the file at the given location.
+        :param file_location: The location of the file to be deleted.
+        :type file_location: str
+        :return: None
+        """
         if os.path.exists(file_location):
             os.remove(file_location)
 
     def _open_file_and_wait_for_upd(self, file_location):
+        """
+        This method opens the file at the given location in VSCode and waits for the user to save the file.
+        :param file_location: The location of the file to be opened.
+        :type file_location: str
+        :return: None
+        """
         process = subprocess.Popen(["code", "--wait", file_location])
         while True:
             if process.poll() is not None:
@@ -53,6 +83,13 @@ class ExecuteCodeAtomicFlow(InterpreterAtomicFlow):
     def run(
             self,
             input_data: Dict[str, Any]):
+        """
+        This method is called when the atomic flow is called.
+        :param input_data: The input_data dictionary.
+        :type input_data: Dict[str, Any]
+        :return: The output of the execution of the code.
+        :rtype: Dict[str, Any]
+        """
         self._check_input(input_data)
         file_loc = input_data["temp_code_file_location"]
         self._open_file_and_wait_for_upd(file_loc)

README.md

@@ -4,8 +4,10 @@
   * [RunCodeFlow](#RunCodeFlow.RunCodeFlow)
 * [ExecuteCodeAtomicFlow](#ExecuteCodeAtomicFlow)
   * [ExecuteCodeAtomicFlow](#ExecuteCodeAtomicFlow.ExecuteCodeAtomicFlow)
+    * [run](#ExecuteCodeAtomicFlow.ExecuteCodeAtomicFlow.run)
 * [RunCodeAskUserFlow](#RunCodeAskUserFlow)
   * [RunCodeAskUserFlow](#RunCodeAskUserFlow.RunCodeAskUserFlow)
+    * [run](#RunCodeAskUserFlow.RunCodeAskUserFlow.run)
 * [library](#library)
 * [run](#run)
 * [RunCodeFileEditAtomicFlow](#RunCodeFileEditAtomicFlow)
@@ -37,6 +39,13 @@ Finally, the flow asks the user for feedback on the execution of the code.
 - summary: The summary of the execution of the code. (To be written to the logs of the caller flow)
 - result: The result of the execution of the code. (To be returned to the controller of the caller flow)
 
+*Configuration Parameters*:
+- `input_interface`: The input interface of the flow. (Default: `['code', 'language', 'memory_files']`)
+- `output_interface`: The output interface of the flow. (Default: `['summary', 'result']`)
+- `subflows_config`: The configuration of the subflows of the flow.
+- `early_exit_key`: The key to be pressed to exit the flow early.
+- `topology`: The topology of the subflows.
+
 <a id="ExecuteCodeAtomicFlow"></a>
 
 # ExecuteCodeAtomicFlow
@@ -61,6 +70,28 @@ from the file and executes it. It then returns the output of the execution.
 - interpreter_output: The output of the execution of the code.
 - code_ran: The code that was executed.
 
+*Configuration Parameters*:
+- `input_interface`: The input interface of the atomic flow.
+- `output_interface`: The output interface of the atomic flow.
+
+<a id="ExecuteCodeAtomicFlow.ExecuteCodeAtomicFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any])
+```
+
+This method is called when the atomic flow is called.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): The input_data dictionary.
+
+**Returns**:
+
+`Dict[str, Any]`: The output of the execution of the code.
+
 <a id="RunCodeAskUserFlow"></a>
 
 # RunCodeAskUserFlow
@@ -73,7 +104,40 @@ from the file and executes it. It then returns the output of the execution.
 class RunCodeAskUserFlow(HumanStandardInputFlow)
 ```
 
-Refer to: https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py
+Refer to: https://huggingface.co/aiflows/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py
+
+*Input Interface*:
+- `question`: The question asked
+
+*Expected Behaviour*:
+- The question is displayed, and the user gives feedback by input string.
+
+*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="RunCodeAskUserFlow.RunCodeAskUserFlow.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="library"></a>
 
@@ -95,7 +159,20 @@ Refer to: https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLi
 class RunCodeFileEditAtomicFlow(CodeFileEditAtomicFlow)
 ```
 
-Refer to: https://huggingface.co/Tachi67/CodeFileEditFlowModule
+Refer to: https://huggingface.co/aiflows/CodeFileEditFlowModule
+
+*Input Interface*:
+- `code`: str
+- `language_of_code`: str
+- `memory_files`: Dict[str, str]
+
+*Output Interface*:
+- `code_editor_output`: str
+- `temp_code_file_location`: str
+
+*Configuration Parameters*:
+- `input_interface`: The input interface of the atomic flow.
+- `output_interface`: The output interface of the atomic flow.
 
 <a id="__init__"></a>
 

RunCodeAskUserFlow.py

@@ -10,10 +10,32 @@ log = logging.get_logger(f"aiflows.{__name__}")
 
 
 class RunCodeAskUserFlow(HumanStandardInputFlow):
-    """Refer to: https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py"""
+    """Refer to: https://huggingface.co/aiflows/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py
+
+    *Input Interface*:
+    - `question`: The question asked
+
+    *Expected Behaviour*:
+    - The question is displayed, and the user gives feedback by input string.
+
+    *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'],

RunCodeFileEditAtomicFlow.py

@@ -3,9 +3,33 @@ from typing import Dict, Any
 from flow_modules.aiflows.CodeFileEditFlowModule import CodeFileEditAtomicFlow
 
 class RunCodeFileEditAtomicFlow(CodeFileEditAtomicFlow):
-    """Refer to: https://huggingface.co/Tachi67/CodeFileEditFlowModule"""
+    """Refer to: https://huggingface.co/aiflows/CodeFileEditFlowModule
+
+    *Input Interface*:
+    - `code`: str
+    - `language_of_code`: str
+    - `memory_files`: Dict[str, str]
+
+    *Output Interface*:
+    - `code_editor_output`: str
+    - `temp_code_file_location`: str
+
+    *Configuration Parameters*:
+    - `input_interface`: The input interface of the atomic flow.
+    - `output_interface`: The output interface of the atomic flow.
+
+    """
 
     def _generate_content(self, code_str, comment_sign) -> str:
+        """
+        Generate the content to write to the temp file.
+        :param code_str: The code string.
+        :type code_str: str
+        :param comment_sign: The comment sign for the language.
+        :type comment_sign: str
+        :return: The content to write to the temp file.
+        :rtype: str
+        """
         if comment_sign == "<!-- -->":
             instruction = (
                 "<!-- The below code will be executed.\n"
@@ -28,16 +52,41 @@ class RunCodeFileEditAtomicFlow(CodeFileEditAtomicFlow):
         return content
 
     def _generate_temp_file_location(self, code_lib_location, file_extension):
+        """
+        Generate the temp file location.
+        :param code_lib_location: The code library location.
+        :type code_lib_location: str
+        :param file_extension: The file extension.
+        :type file_extension: str
+        :return: The temp file location.
+        :rtype: str
+        """
         directory = os.path.dirname(code_lib_location)
         ret = os.path.join(directory, 'run_code_temp'+file_extension)
         return ret
 
     def _check_input(self, input_data: Dict[str, Any]):
+        """
+        Check the input data.
+        :param input_data: The input data.
+        :type input_data: Dict[str, Any]
+        :return: None
+        :rtype: None
+        :raises AssertionError: If the input data is not valid.
+        """
         assert "code" in input_data, "code is not passed to RunCodeFileEditAtomicFlow"
         assert "memory_files" in input_data, "memory_files is not passed to RunCodeFileEditAtomicFlow"
         assert "language" in input_data, "language is not passed to RunCodeFileEditAtomicFlow"
 
     def _generate_file_extension_and_comment_sign(self, language: str):
+        """
+        Generate the file extension and comment sign for the language.
+        :param language: The language.
+        :type language: str
+        :return: The file extension and comment sign.
+        :rtype: Dict[str, str]
+        :raises NotImplemented: If the language is not supported.
+        """
         details = {
             "python": {"extension": ".py", "comment": "#"},
             "bash": {"extension": ".sh", "comment": "#"},
@@ -53,6 +102,14 @@ class RunCodeFileEditAtomicFlow(CodeFileEditAtomicFlow):
         return details.get(language.lower())
 
     def _generate_input_to_writer(self, input_data: Dict[str, Any]):
+        """
+        Generate the input to the writer.
+        :param input_data: The input data.
+        :type input_data: Dict[str, Any]
+        :return: The input to the writer.
+        :rtype: Tuple[str, str]
+        :raises NotImplemented: If the language is not supported.
+        """
         code_str = input_data['code']
         code_lib_location = input_data["memory_files"]["code_library"]
         

RunCodeFlow.py

@@ -17,5 +17,13 @@ class RunCodeFlow(SequentialFlow):
     *Output Interface*:
     - summary: The summary of the execution of the code. (To be written to the logs of the caller flow)
     - result: The result of the execution of the code. (To be returned to the controller of the caller flow)
+
+    *Configuration Parameters*:
+    - `input_interface`: The input interface of the flow. (Default: `['code', 'language', 'memory_files']`)
+    - `output_interface`: The output interface of the flow. (Default: `['summary', 'result']`)
+    - `subflows_config`: The configuration of the subflows of the flow.
+    - `early_exit_key`: The key to be pressed to exit the flow early.
+    - `topology`: The topology of the subflows.
+
     """
     pass