add more docs & comments

CodeTestingAtomicFlow.py

@@ -13,14 +13,28 @@ class CodeTestingAtomicFlow(InterpreterAtomicFlow):
     
     *Output Interface*:
     - `feedback`: Feedback from the test (i.e. test results).
+
+    *Configuration Parameters*:
+    - `input_interface`: the input interface of the atomic flow.
+    - `output_interface`: the output interface of the atomic flow.
     """
     def _open_file_and_wait_for_file_update(self, file_location, check_interval=1):
+        """Opens the file in VSCode and waits for the file to be updated.
+        :param file_location: The location of the file to be opened.
+        :type file_location: str
+        :param check_interval: The interval at which the file is checked for updates.
+        :type check_interval: int
+        """
         process = subprocess.Popen(["code", "--wait", file_location])
         while True:
             if process.poll() is not None:
                 break
             time.sleep(check_interval)
     def _prepare_code_and_lang(self, input_data: Dict[str, Any]):
+        """Prepares the code and language to be passed to the interpreter.
+        :param input_data: The input data to the atomic flow.
+        :type input_data: Dict[str, Any]
+        """
         file_location = input_data["temp_code_file_location"]
         input_data["language"] = "python"
         with open(file_location, "r") as file:
@@ -28,15 +42,30 @@ class CodeTestingAtomicFlow(InterpreterAtomicFlow):
         input_data["code"] = code_str
 
     def _check_input(self, input_data: Dict[str, Any]):
+        """Checks if the input data contains the required keys.
+        :param input_data: The input data to the atomic flow.
+        :type input_data: Dict[str, Any]
+        :raises AssertionError: If the input data does not contain the required keys.
+        """
         assert "temp_code_file_location" in input_data, "temp_code_file_location not passed to CodeTestingAtomicFlow"
 
     def _delete_file(self, file_location):
+        """Deletes the file at the given location.
+        :param file_location: The location of the file to be deleted.
+        :type file_location: str
+        """
         if os.path.exists(file_location):
             os.remove(file_location)
 
     def run(
             self,
             input_data: Dict[str, Any]):
+        """Runs the atomic flow.
+        :param input_data: The input data to the atomic flow.
+        :type input_data: Dict[str, Any]
+        :return: The output data of the atomic flow.
+        :rtype: Dict[str, Any]
+        """
         self._check_input(input_data)
         file_loc = input_data["temp_code_file_location"]
         self._open_file_and_wait_for_file_update(file_loc)

README.md

@@ -1,11 +1,29 @@
-### Structure of TestCodeFlow
+# Table of Contents
+
+* [Structure of TestCodeFlow](#structure-of-testcodeflow)
+* [TestCodeFlow](#TestCodeFlow)
+  * [TestCodeFlow](#TestCodeFlow.TestCodeFlow)
+    * [\_\_init\_\_](#TestCodeFlow.TestCodeFlow.__init__)
+    * [instantiate\_from\_config](#TestCodeFlow.TestCodeFlow.instantiate_from_config)
+    * [run](#TestCodeFlow.TestCodeFlow.run)
+* [TestCodeFileEditAtomicFlow](#TestCodeFileEditAtomicFlow)
+  * [TestCodeFileEditAtomicFlow](#TestCodeFileEditAtomicFlow.TestCodeFileEditAtomicFlow)
+* [run](#run)
+* [\_\_init\_\_](#__init__)
+* [CodeTestingAtomicFlow](#CodeTestingAtomicFlow)
+  * [CodeTestingAtomicFlow](#CodeTestingAtomicFlow.CodeTestingAtomicFlow)
+    * [run](#CodeTestingAtomicFlow.CodeTestingAtomicFlow.run)
+
+
+
+# Structure of TestCodeFlow
 
 ```
                code
                 |
                 v
         +-------------------+
-        |  TestCodeFileEdit | Edit a temp code file with the code to be tested and necessary imports (manually added): https://huggingface.co/Tachi67/TestCodeFlowModule/blob/main/TestCodeFileEditAtomicFlow.py
+        |  TestCodeFileEdit | Edit a temp code file with the code to be tested and necessary imports (manually added): https://huggingface.co/aiflows/TestCodeFlowModule/blob/main/TestCodeFileEditAtomicFlow.py
         +-------------------+                        
                 |                                
                 | (temp_code_file_location)        
@@ -23,17 +41,8 @@
 
 ```
 Memory_files: 
-- library.py
-
-# Table of Contents
+- `library.py`
 
-* [TestCodeFlow](#TestCodeFlow)
-  * [TestCodeFlow](#TestCodeFlow.TestCodeFlow)
-* [TestCodeFileEditAtomicFlow](#TestCodeFileEditAtomicFlow)
-  * [TestCodeFileEditAtomicFlow](#TestCodeFileEditAtomicFlow.TestCodeFileEditAtomicFlow)
-* [\_\_init\_\_](#__init__)
-* [CodeTestingAtomicFlow](#CodeTestingAtomicFlow)
-  * [CodeTestingAtomicFlow](#CodeTestingAtomicFlow.CodeTestingAtomicFlow)
 
 <a id="TestCodeFlow"></a>
 
@@ -61,6 +70,65 @@ This class is used to test code. It is a sequential flow that runs the following
 *Output Interface*:
 - `feedback` (str): The test results.
 
+*Configuration Parameters*:
+- `memory_files`: The memory files to be used in the flow, typically we need to have the code library as memory file here.
+- `input_interface`: The input interface of the flow.
+- `output_interface`: The output interface of the flow.
+- `subflows_config`: The subflows configuration.
+- `topology`: The topology of the subflows.
+
+<a id="TestCodeFlow.TestCodeFlow.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(memory_files: Dict[str, Any], **kwargs)
+```
+
+This function instantiates the class.
+
+**Arguments**:
+
+- `memory_files` (`Dict[str, Any]`): The memory files to be used in the flow, typically we need to have the code library as memory file here.
+- `kwargs` (`Any`): The keyword arguments.
+
+<a id="TestCodeFlow.TestCodeFlow.instantiate_from_config"></a>
+
+#### instantiate\_from\_config
+
+```python
+@classmethod
+def instantiate_from_config(cls, config)
+```
+
+This function instantiates the class from a configuration dictionary.
+
+**Arguments**:
+
+- `config` (`Dict[str, Any]`): The configuration dictionary.
+
+**Returns**:
+
+`TestCodeFlow`: The instantiated class.
+
+<a id="TestCodeFlow.TestCodeFlow.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 data.
+
 <a id="TestCodeFileEditAtomicFlow"></a>
 
 # TestCodeFileEditAtomicFlow
@@ -73,7 +141,19 @@ This class is used to test code. It is a sequential flow that runs the following
 class TestCodeFileEditAtomicFlow(CodeFileEditAtomicFlow)
 ```
 
-Refer to: https://huggingface.co/Tachi67/CodeFileEditFlowModule/tree/main
+Refer to: https://huggingface.co/aiflows/CodeFileEditFlowModule/tree/main
+
+*Input Interface*:
+- `code`: str
+- `memory_files`: Dict[str, str]
+
+*Output Interface*:
+- `code_editor_output`: str, the code editor output
+- `temp_code_file_location`: str, the location of the temporary code file
+
+<a id="run"></a>
+
+# run
 
 <a id="__init__"></a>
 
@@ -99,3 +179,25 @@ This class inherits from InterpreterAtomicFlow and is used to test code.
 *Output Interface*:
 - `feedback`: Feedback from the test (i.e. test results).
 
+*Configuration Parameters*:
+- `input_interface`: the input interface of the atomic flow.
+- `output_interface`: the output interface of the atomic flow.
+
+<a id="CodeTestingAtomicFlow.CodeTestingAtomicFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any])
+```
+
+Runs the atomic flow.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): The input data to the atomic flow.
+
+**Returns**:
+
+`Dict[str, Any]`: The output data of the atomic flow.
+

TestCodeFileEditAtomicFlow.py

@@ -3,8 +3,25 @@ from typing import Dict, Any
 from flow_modules.aiflows.CodeFileEditFlowModule import CodeFileEditAtomicFlow
 
 class TestCodeFileEditAtomicFlow(CodeFileEditAtomicFlow):
-    """Refer to: https://huggingface.co/Tachi67/CodeFileEditFlowModule/tree/main"""
+    """Refer to: https://huggingface.co/aiflows/CodeFileEditFlowModule/tree/main
+
+    *Input Interface*:
+    - `code`: str
+    - `memory_files`: Dict[str, str]
+
+    *Output Interface*:
+    - `code_editor_output`: str, the code editor output
+    - `temp_code_file_location`: str, the location of the temporary code file
+
+    """
     def _generate_import_statement(self, code_lib_location):
+        """
+        Generate the import statement for the code library.
+        :param code_lib_location: the location of the code library
+        :type code_lib_location: str
+        :return: the import statement
+        :rtype: str
+        """
         module_dir = os.path.dirname(code_lib_location)
         module_name = os.path.splitext(os.path.basename(code_lib_location))[0]
 
@@ -16,6 +33,15 @@ class TestCodeFileEditAtomicFlow(CodeFileEditAtomicFlow):
         return import_code
 
     def _generate_content(self, code_lib_location, code_str) -> str:
+        """
+        Generate the content of the temporary code file.
+        :param code_lib_location: the location of the code library
+        :type code_lib_location: str
+        :param code_str: the code string
+        :type code_str: str
+        :return: the content of the temporary code file
+        :rtype: str
+        """
         import_code_lib_str = self._generate_import_statement(code_lib_location)
         content = (
                 "# Don't touch this import statement \n"
@@ -33,11 +59,24 @@ class TestCodeFileEditAtomicFlow(CodeFileEditAtomicFlow):
         return content
 
     def _generate_temp_file_location(self, code_lib_location):
+        """
+        Generate the location of the temporary code file.
+        :param code_lib_location: the location of the code library
+        :type code_lib_location: str
+        :return: the location of the temporary code file
+        :rtype: str
+        """
         directory = os.path.dirname(code_lib_location)
         ret = os.path.join(directory, 'temp_tests.py')
         return ret
 
     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[str, Any]
+        :raises AssertionError: if code or memory_files is not passed to TestCodeFileEditAtomicFlow
+        """
         assert "code" in input_data, "code is not passed to TestCodeFileEditAtomicFlow"
         assert "memory_files" in input_data, "memory_files is not passed to TestCodeFileEditAtomicFlow"
 

TestCodeFlow.py

@@ -21,6 +21,14 @@ class TestCodeFlow(SequentialFlow):
     
     *Output Interface*:
     - `feedback` (str): The test results.
+
+    *Configuration Parameters*:
+    - `memory_files`: The memory files to be used in the flow, typically we need to have the code library as memory file here.
+    - `input_interface`: The input interface of the flow.
+    - `output_interface`: The output interface of the flow.
+    - `subflows_config`: The subflows configuration.
+    - `topology`: The topology of the subflows.
+
     """
     REQUIRED_KEYS_CONFIG = ["max_rounds", "early_exit_key", "topology", "memory_files"]
 
@@ -29,11 +37,25 @@ class TestCodeFlow(SequentialFlow):
             memory_files: Dict[str, Any],
             **kwargs
     ):
+        """
+        This function instantiates the class.
+        :param memory_files: The memory files to be used in the flow, typically we need to have the code library as memory file here.
+        :type memory_files: Dict[str, Any]
+        :param kwargs: The keyword arguments.
+        :type kwargs: Any
+        """
         super().__init__(**kwargs)
         self.memory_files = memory_files
 
     @classmethod
     def instantiate_from_config(cls, config):
+        """
+        This function instantiates the class from a configuration dictionary.
+        :param config: The configuration dictionary.
+        :type config: Dict[str, Any]
+        :return: The instantiated class.
+        :rtype: TestCodeFlow
+        """
         flow_config = deepcopy(config)
 
         kwargs = {"flow_config": flow_config}
@@ -49,6 +71,13 @@ class TestCodeFlow(SequentialFlow):
         return cls(**kwargs)
 
     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 data.
+        :rtype: Dict[str, Any]
+        """
         # ~~~ sets the input_data in the flow_state dict ~~~
         self._state_update_dict(update_data=input_data)