Upload 6 files

MemoryWritingAtomicFlow.py

@@ -9,15 +9,39 @@ class MemoryWritingAtomicFlow(AtomicFlow):
     
     *Output Interface*:
     - `MemWrite_output` (str): message that whether memory write was successful
+
+    *Configuration Parameters*:
+    - `input_interface`: the input interface of the atomic flow
+    - `output_interface`: the output interface of the atomic flow
     """
     def __init__(self, **kwargs):
+        """
+        Initialize the atomic flow.
+        :param kwargs: additional key-value arguments to pass to the atomic flow
+        :type kwargs: Dict[str, Any]
+        """
         super().__init__(**kwargs)
         self.supported_memories = ["summary"]
     def _check_input(self, input_data: Dict[str, Any]):
+        """
+        Check whether the input data is valid.
+        :param input_data: the input data to check
+        :type input_data: Dict[str, Any]
+        :raises AssertionError: if memory_files is not passed to MemoryWritingAtomicFlow
+        :raises AssertionError: if input data is not supported by MemoryWritingAtomicFlow
+        """
         assert "memory_files" in input_data, "memory_files not passed to MemoryWritingAtomicFlow"
         assert any(item in input_data for item in self.supported_memories), "no memories to write"
 
     def _call(self, input_data: Dict[str, Any]):
+        """
+        Write memory to memory files.
+        :param input_data: the input data to write
+        :type input_data: Dict[str, Any]
+        :return: the output data
+        :rtype: Dict[str, Any]
+        :raises AssertionError: if logs is not in memory_files
+        """
         try:
             if "summary" in input_data:
                 assert "logs" in input_data["memory_files"], "there is summary to write, but no logs file in memory_files"
@@ -34,5 +58,12 @@ class MemoryWritingAtomicFlow(AtomicFlow):
             self,
             input_data: Dict[str, Any]
     ):
+        """
+        Run the atomic flow.
+        :param input_data: the input data to run
+        :type input_data: Dict[str, Any]
+        :return: the output data
+        :rtype: Dict[str, Any]
+        """
         self._check_input(input_data)
         return self._call(input_data)

README.md

@@ -2,6 +2,8 @@
 
 * [MemoryWritingAtomicFlow](#MemoryWritingAtomicFlow)
   * [MemoryWritingAtomicFlow](#MemoryWritingAtomicFlow.MemoryWritingAtomicFlow)
+    * [\_\_init\_\_](#MemoryWritingAtomicFlow.MemoryWritingAtomicFlow.__init__)
+    * [run](#MemoryWritingAtomicFlow.MemoryWritingAtomicFlow.run)
 * [run\_memwrite](#run_memwrite)
 * [\_\_init\_\_](#__init__)
 
@@ -17,7 +19,7 @@
 class MemoryWritingAtomicFlow(AtomicFlow)
 ```
 
-This class is used to write memory to memory files. For now, it writes summary to the 'logs' file.
+This class is used to write memory to memory files.
 
 *Input Interface*:
 - `summary` (str): summary to write to memory file (logs)
@@ -26,6 +28,42 @@ This class is used to write memory to memory files. For now, it writes summary t
 *Output Interface*:
 - `MemWrite_output` (str): message that whether memory write was successful
 
+*Configuration Parameters*:
+- `input_interface`: the input interface of the atomic flow
+- `output_interface`: the output interface of the atomic flow
+
+<a id="MemoryWritingAtomicFlow.MemoryWritingAtomicFlow.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(**kwargs)
+```
+
+Initialize the atomic flow.
+
+**Arguments**:
+
+- `kwargs` (`Dict[str, Any]`): additional key-value arguments to pass to the atomic flow
+
+<a id="MemoryWritingAtomicFlow.MemoryWritingAtomicFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any])
+```
+
+Run the atomic flow.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): the input data to run
+
+**Returns**:
+
+`Dict[str, Any]`: the output data
+
 <a id="run_memwrite"></a>
 
 # run\_memwrite