|
### Structure of ExtendLibraryFlow |
|
|
|
``` |
|
goal, memory_files (dict) |
|
| |
|
v |
|
+-------------------+ |
|
| MemoryReading | Reads in the content of the memory files |
|
| Flow | |
|
+-------------------+ |
|
| |
|
| (memory_content) |
|
| |
|
v |
|
+-------------------+ |
|
| PlanWriter | Writes a step-by-step plan to achieve the goal |
|
+-------------------+ |
|
| |
|
| (plan) |
|
| |
|
v |
|
+-------------------+ |
|
| CtrlExMemFlow | Illustrated below. Carries out the plan in an controller-executor fashion, |
|
| | with memory management mechanisms. |
|
+-------------------+ |
|
| |
|
(summary, result) |
|
|
|
``` |
|
|
|
Here is the structure of the `CtrlExMemFlow`: |
|
``` |
|
plan, memory_files, memory_content, goal |
|
| |
|
v |
|
+---------------+ |
|
| Controller | --------<<<<-----------+ |
|
+---------------+ | |
|
| | |
|
| (command, command args) | |
|
| | |
|
v | |
|
+------------------+ | |
|
| Executor | Each branch is an | |
|
| (Tree Structure) | executor | |
|
+------------------+ | |
|
| ^ |
|
| (execution results) ^ |
|
| ^ |
|
v ^ |
|
+---------------+ ^ |
|
| MemWriteFlow | Updates memory files ^ |
|
+---------------+ ^ |
|
| ^ |
|
| (summary) | |
|
| | |
|
v | |
|
+---------------+ | |
|
| MemReadFlow | Reads updated memory | |
|
+---------------+ | |
|
| | |
|
| (updated memory content) | |
|
| | |
|
+-> goes back to the Controller>-+ |
|
|
|
``` |
|
Structure of the Executors: |
|
``` |
|
+-------------------+ |
|
| Branching | |
|
| Executor | |
|
+-------------------+ |
|
/ | | | \ |
|
/ | | | \ |
|
/ | | | \ |
|
/ | | | \ |
|
write_code ask_user re_plan update_plan save_code |
|
|
|
``` |
|
|
|
Memory files of ExtendLibraryFlow: |
|
- 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. |
|
|
|
|
|
# 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> |
|
|
|
# SaveCodeAtomicFlow |
|
|
|
<a id="SaveCodeAtomicFlow.SaveCodeAtomicFlow"></a> |
|
|
|
## SaveCodeAtomicFlow Objects |
|
|
|
```python |
|
class SaveCodeAtomicFlow(AtomicFlow) |
|
``` |
|
|
|
This flow appends the code to the code library file. |
|
*Input Interface*: |
|
- `code` (str): the code to be appended to the code library |
|
- `memory_files` (dict): the dictionary of memory files |
|
|
|
*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 |
|
|
|
<a id="SaveCodeAtomicFlow.SaveCodeAtomicFlow.run"></a> |
|
|
|
#### run |
|
|
|
```python |
|
def run(input_data: Dict[str, Any]) |
|
``` |
|
|
|
Run the flow |
|
|
|
**Arguments**: |
|
|
|
- `input_data`: the input data |
|
|
|
**Returns**: |
|
|
|
the output data |
|
|
|
<a id="ExtLibAskUserFlow"></a> |
|
|
|
# ExtLibAskUserFlow |
|
|
|
<a id="ExtLibAskUserFlow.ExtLibAskUserFlow"></a> |
|
|
|
## ExtLibAskUserFlow Objects |
|
|
|
```python |
|
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*: |
|
- `question`: The question asked by the controller |
|
|
|
*Expected Behaviour*: |
|
- The question is displayed, and the user gives feedback by inputing string. |
|
|
|
*Expected Ouput*: |
|
- `result`: The input of the user. |
|
- `summary`: The summary that will be written by the caller. |
|
|
|
<a id="ExtendLibraryFlow"></a> |
|
|
|
# ExtendLibraryFlow |
|
|
|
<a id="ExtendLibraryFlow.ExtendLibraryFlow"></a> |
|
|
|
## ExtendLibraryFlow Objects |
|
|
|
```python |
|
class ExtendLibraryFlow(AbstractBossFlow) |
|
``` |
|
|
|
ExtendLibraryFlow is one branch executor of CoderFlow. At a higher level, it takes the goal |
|
from the Coder, writes functions in an interactive way, test the code and append the newly written function to |
|
the code library. |
|
|
|
Workflow of ExtendLibrary: |
|
0. Coder calls ExtendLibrary with a goal. |
|
1. MemoryReading reads logs, plan, and code library. |
|
2. Planner makes a plan based on the goal. |
|
3. Write code in an interactive fashion. |
|
4. Test code. |
|
5. Finish, writes code to the library. |
|
Step 3-5 is done via prompting the controller. |
|
|
|
*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). |
|
|
|
<a id="UpdatePlanAtomicFlow"></a> |
|
|
|
# UpdatePlanAtomicFlow |
|
|
|
<a id="UpdatePlanAtomicFlow.UpdatePlanAtomicFlow"></a> |
|
|
|
## UpdatePlanAtomicFlow Objects |
|
|
|
```python |
|
class UpdatePlanAtomicFlow(AtomicFlow) |
|
``` |
|
|
|
Refer to: https://huggingface.co/Tachi67/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py |
|
|
|
<a id="run_ExtendLibrary"></a> |
|
|
|
# run\_ExtendLibrary |
|
|
|
<a id="CtrlExMem_ExtLib"></a> |
|
|
|
# CtrlExMem\_ExtLib |
|
|
|
<a id="CtrlExMem_ExtLib.CtrlExMem_ExtLib"></a> |
|
|
|
## CtrlExMem\_ExtLib Objects |
|
|
|
```python |
|
class CtrlExMem_ExtLib(CtrlExMemFlow) |
|
``` |
|
|
|
This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule. |
|
See: https://huggingface.co/Tachi67/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="ControllerFlow_ExtLib"></a> |
|
|
|
# ControllerFlow\_ExtLib |
|
|
|
<a id="ControllerFlow_ExtLib.ControllerFlow_ExtLib"></a> |
|
|
|
## ControllerFlow\_ExtLib Objects |
|
|
|
```python |
|
class ControllerFlow_ExtLib(ChatAtomicFlow) |
|
``` |
|
|
|
Refer to: https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Controller_JarvisFlow.py |
|
|
|
<a id="__init__"></a> |
|
|
|
# \_\_init\_\_ |
|
|
|
|