evelynmitchell
1 year ago
committed by
GitHub
commit
8e08408baa
@ -0,0 +1,133 @@
|
||||
import inspect
|
||||
import os
|
||||
import threading
|
||||
|
||||
from dotenv import load_dotenv
|
||||
from scripts.auto_tests_docs.docs import DOCUMENTATION_WRITER_SOP
|
||||
from swarms import OpenAIChat
|
||||
from swarms.structs.agent import Agent
|
||||
from swarms.structs.autoscaler import AutoScaler
|
||||
from swarms.structs.base import BaseStructure
|
||||
from swarms.structs.base_swarm import AbstractSwarm
|
||||
from swarms.structs.base_workflow import BaseWorkflow
|
||||
from swarms.structs.concurrent_workflow import ConcurrentWorkflow
|
||||
from swarms.structs.conversation import Conversation
|
||||
from swarms.structs.groupchat import GroupChat, GroupChatManager
|
||||
from swarms.structs.model_parallizer import ModelParallelizer
|
||||
from swarms.structs.multi_agent_collab import MultiAgentCollaboration
|
||||
from swarms.structs.nonlinear_workflow import NonlinearWorkflow
|
||||
from swarms.structs.recursive_workflow import RecursiveWorkflow
|
||||
from swarms.structs.schemas import (
|
||||
Artifact,
|
||||
ArtifactUpload,
|
||||
StepInput,
|
||||
TaskInput,
|
||||
)
|
||||
from swarms.structs.sequential_workflow import SequentialWorkflow
|
||||
from swarms.structs.swarm_net import SwarmNetwork
|
||||
from swarms.structs.utils import (
|
||||
distribute_tasks,
|
||||
extract_key_from_json,
|
||||
extract_tokens_from_text,
|
||||
find_agent_by_id,
|
||||
find_token_in_text,
|
||||
parse_tasks,
|
||||
)
|
||||
|
||||
|
||||
load_dotenv()
|
||||
|
||||
api_key = os.getenv("OPENAI_API_KEY")
|
||||
|
||||
model = OpenAIChat(
|
||||
model_name="gpt-4-1106-preview",
|
||||
openai_api_key=api_key,
|
||||
max_tokens=4000,
|
||||
)
|
||||
|
||||
|
||||
def process_documentation(
|
||||
item,
|
||||
module: str = "swarms.structs",
|
||||
docs_folder_path: str = "docs/swarms/structs",
|
||||
):
|
||||
"""
|
||||
Process the documentation for a given class or function using OpenAI model and save it in a Python file.
|
||||
"""
|
||||
doc = inspect.getdoc(item)
|
||||
source = inspect.getsource(item)
|
||||
is_class = inspect.isclass(item)
|
||||
item_type = "Class Name" if is_class else "Name"
|
||||
input_content = (
|
||||
f"{item_type}:"
|
||||
f" {item.__name__}\n\nDocumentation:\n{doc}\n\nSource"
|
||||
f" Code:\n{source}"
|
||||
)
|
||||
|
||||
# Process with OpenAI model
|
||||
processed_content = model(
|
||||
DOCUMENTATION_WRITER_SOP(input_content, module)
|
||||
)
|
||||
|
||||
doc_content = f"# {item.__name__}\n\n{processed_content}\n"
|
||||
|
||||
# Create the directory if it doesn't exist
|
||||
dir_path = docs_folder_path
|
||||
os.makedirs(dir_path, exist_ok=True)
|
||||
|
||||
# Write the processed documentation to a Python file
|
||||
file_path = os.path.join(dir_path, f"{item.__name__.lower()}.md")
|
||||
with open(file_path, "w") as file:
|
||||
file.write(doc_content)
|
||||
|
||||
print(
|
||||
f"Processed documentation for {item.__name__}. at {file_path}"
|
||||
)
|
||||
|
||||
|
||||
def main(module: str = "docs/swarms/structs"):
|
||||
items = [
|
||||
Agent,
|
||||
SequentialWorkflow,
|
||||
AutoScaler,
|
||||
Conversation,
|
||||
TaskInput,
|
||||
Artifact,
|
||||
ArtifactUpload,
|
||||
StepInput,
|
||||
SwarmNetwork,
|
||||
ModelParallelizer,
|
||||
MultiAgentCollaboration,
|
||||
AbstractSwarm,
|
||||
GroupChat,
|
||||
GroupChatManager,
|
||||
parse_tasks,
|
||||
find_agent_by_id,
|
||||
distribute_tasks,
|
||||
find_token_in_text,
|
||||
extract_key_from_json,
|
||||
extract_tokens_from_text,
|
||||
ConcurrentWorkflow,
|
||||
RecursiveWorkflow,
|
||||
NonlinearWorkflow,
|
||||
BaseWorkflow,
|
||||
BaseStructure,
|
||||
]
|
||||
|
||||
threads = []
|
||||
for item in items:
|
||||
thread = threading.Thread(
|
||||
target=process_documentation, args=(item,)
|
||||
)
|
||||
threads.append(thread)
|
||||
thread.start()
|
||||
|
||||
# Wait for all threads to complete
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
|
||||
print(f"Documentation generated in {module} directory.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,35 @@
|
||||
from typing import Callable, Any
|
||||
import logging
|
||||
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def block(
|
||||
function: Callable[..., Any],
|
||||
device: str = None,
|
||||
verbose: bool = False,
|
||||
) -> Callable[..., Any]:
|
||||
"""
|
||||
A decorator that transforms a function into a block.
|
||||
|
||||
Args:
|
||||
function (Callable[..., Any]): The function to transform.
|
||||
|
||||
Returns:
|
||||
Callable[..., Any]: The transformed function.
|
||||
"""
|
||||
def wrapper(*args, **kwargs):
|
||||
# Here you can add code to execute the function on various hardwares
|
||||
# For now, we'll just call the function normally
|
||||
try:
|
||||
return function(*args, **kwargs)
|
||||
except Exception as error:
|
||||
logger.error(f"Error in {function.__name__}: {error}")
|
||||
raise error
|
||||
|
||||
# Set the wrapper function's name and docstring to those of the original function
|
||||
wrapper.__name__ = function.__name__
|
||||
wrapper.__doc__ = function.__doc__
|
||||
|
||||
return wrapper
|
||||
@ -0,0 +1,19 @@
|
||||
from tracemalloc import start
|
||||
from typing import Any, Callable, Dict, List, Union
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
@dataclass
|
||||
class BlockDevice:
|
||||
device: str
|
||||
cluster: str
|
||||
description: str
|
||||
|
||||
def __init__(self, device: str, cluster: str, description: str):
|
||||
self.device = device
|
||||
self.cluster = cluster
|
||||
self.description = description
|
||||
|
||||
def __str__(self):
|
||||
return f"BlockDevice(device={self.device}, cluster={self.cluster}, description={self.description})"
|
||||
|
||||
@ -0,0 +1,65 @@
|
||||
from typing import (
|
||||
Any,
|
||||
Dict,
|
||||
Optional,
|
||||
)
|
||||
|
||||
from swarms.structs.base import BaseStructure
|
||||
|
||||
|
||||
class BlocksDict(BaseStructure):
|
||||
"""
|
||||
A class representing a dictionary of blocks.
|
||||
|
||||
Args:
|
||||
name (str): The name of the blocks dictionary.
|
||||
description (str): The description of the blocks dictionary.
|
||||
blocks (Dict[str, Any]): The dictionary of blocks.
|
||||
parent (Optional[Any], optional): The parent of the blocks dictionary. Defaults to None.
|
||||
**kwargs: Additional keyword arguments.
|
||||
|
||||
Attributes:
|
||||
parent (Optional[Any]): The parent of the blocks dictionary.
|
||||
blocks (Dict[str, Any]): The dictionary of blocks.
|
||||
|
||||
Methods:
|
||||
add(key: str, block: Any): Add a block to the dictionary.
|
||||
remove(key: str): Remove a block from the dictionary.
|
||||
get(key: str): Get a block from the dictionary.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
name: str,
|
||||
description: str,
|
||||
blocks: Dict[str, Any],
|
||||
parent: Optional[Any] = None,
|
||||
**kwargs,
|
||||
):
|
||||
super().__init__(name=name, description=description, **kwargs)
|
||||
self.parent = parent
|
||||
self.blocks = blocks
|
||||
|
||||
def add(self, key: str, block: Any):
|
||||
self.blocks[key] = block
|
||||
|
||||
def remove(self, key: str):
|
||||
del self.blocks[key]
|
||||
|
||||
def get(self, key: str):
|
||||
return self.blocks.get(key)
|
||||
|
||||
def update(self, key: str, block: Any):
|
||||
self.blocks[key] = block
|
||||
|
||||
def keys(self):
|
||||
return list(self.blocks.keys())
|
||||
|
||||
def values(self):
|
||||
return list(self.blocks.values())
|
||||
|
||||
def items(self):
|
||||
return list(self.blocks.items())
|
||||
|
||||
def clear(self):
|
||||
self.blocks.clear()
|
||||
@ -0,0 +1,138 @@
|
||||
from typing import (
|
||||
Any,
|
||||
List,
|
||||
Optional,
|
||||
)
|
||||
|
||||
from swarms.structs.base import BaseStructure
|
||||
|
||||
|
||||
class BlocksList(BaseStructure):
|
||||
"""
|
||||
A class representing a list of blocks.
|
||||
|
||||
Args:
|
||||
name (str): The name of the blocks list.
|
||||
description (str): The description of the blocks list.
|
||||
blocks (List[Any]): The list of blocks.
|
||||
parent (Optional[Any], optional): The parent of the blocks list. Defaults to None.
|
||||
**kwargs: Additional keyword arguments.
|
||||
|
||||
Attributes:
|
||||
parent (Optional[Any]): The parent of the blocks list.
|
||||
blocks (List[Any]): The list of blocks.
|
||||
|
||||
Methods:
|
||||
add(block: Any): Add a block to the list.
|
||||
remove(block: Any): Remove a block from the list.
|
||||
update(block: Any): Update a block in the list.
|
||||
get(index: int): Get a block at the specified index.
|
||||
get_all(): Get all blocks in the list.
|
||||
get_by_name(name: str): Get blocks by name.
|
||||
get_by_type(type: str): Get blocks by type.
|
||||
get_by_id(id: str): Get blocks by ID.
|
||||
get_by_parent(parent: str): Get blocks by parent.
|
||||
get_by_parent_id(parent_id: str): Get blocks by parent ID.
|
||||
get_by_parent_name(parent_name: str): Get blocks by parent name.
|
||||
get_by_parent_type(parent_type: str): Get blocks by parent type.
|
||||
get_by_parent_description(parent_description: str): Get blocks by parent description.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
name: str,
|
||||
description: str,
|
||||
blocks: List[Any],
|
||||
parent: Optional[Any] = None,
|
||||
**kwargs,
|
||||
):
|
||||
super().__init__(name=name, description=description, **kwargs)
|
||||
self.parent = parent
|
||||
self.blocks = blocks
|
||||
|
||||
def add(self, block: Any):
|
||||
self.blocks.append(block)
|
||||
|
||||
def remove(self, block: Any):
|
||||
self.blocks.remove(block)
|
||||
|
||||
def update(self, block: Any):
|
||||
self.blocks[self.blocks.index(block)] = block
|
||||
|
||||
def get(self, index: int):
|
||||
return self.blocks[index]
|
||||
|
||||
def get_all(self):
|
||||
return self.blocks
|
||||
|
||||
def get_by_name(self, name: str):
|
||||
return [block for block in self.blocks if block.name == name]
|
||||
|
||||
def get_by_type(self, type: str):
|
||||
return [block for block in self.blocks if block.type == type]
|
||||
|
||||
def get_by_id(self, id: str):
|
||||
return [block for block in self.blocks if block.id == id]
|
||||
|
||||
def get_by_parent(self, parent: str):
|
||||
return [
|
||||
block for block in self.blocks if block.parent == parent
|
||||
]
|
||||
|
||||
def get_by_parent_id(self, parent_id: str):
|
||||
return [
|
||||
block
|
||||
for block in self.blocks
|
||||
if block.parent_id == parent_id
|
||||
]
|
||||
|
||||
def get_by_parent_name(self, parent_name: str):
|
||||
return [
|
||||
block
|
||||
for block in self.blocks
|
||||
if block.parent_name == parent_name
|
||||
]
|
||||
|
||||
def get_by_parent_type(self, parent_type: str):
|
||||
return [
|
||||
block
|
||||
for block in self.blocks
|
||||
if block.parent_type == parent_type
|
||||
]
|
||||
|
||||
def get_by_parent_description(self, parent_description: str):
|
||||
return [
|
||||
block
|
||||
for block in self.blocks
|
||||
if block.parent_description == parent_description
|
||||
]
|
||||
|
||||
def __len__(self):
|
||||
return len(self.blocks)
|
||||
|
||||
def __getitem__(self, index):
|
||||
return self.blocks[index]
|
||||
|
||||
def __setitem__(self, index, value):
|
||||
self.blocks[index] = value
|
||||
|
||||
def __delitem__(self, index):
|
||||
del self.blocks[index]
|
||||
|
||||
def __iter__(self):
|
||||
return iter(self.blocks)
|
||||
|
||||
def __reversed__(self):
|
||||
return reversed(self.blocks)
|
||||
|
||||
def __contains__(self, item):
|
||||
return item in self.blocks
|
||||
|
||||
def __str__(self):
|
||||
return f"{self.name}({self.blocks})"
|
||||
|
||||
def __repr__(self):
|
||||
return f"{self.name}({self.blocks})"
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.blocks == other.blocks
|
||||
@ -1,3 +1,23 @@
|
||||
from swarms.tools.tool_func_doc_scraper import scrape_tool_func_docs
|
||||
from swarms.tools.code_executor import CodeExecutor
|
||||
from swarms.tools.tool_utils import (
|
||||
tool_find_by_name,
|
||||
extract_tool_commands,
|
||||
parse_and_execute_tools,
|
||||
execute_tools,
|
||||
)
|
||||
from swarms.tools.tool import BaseTool, Tool, StructuredTool, tool
|
||||
|
||||
__all__ = ["scrape_tool_func_docs"]
|
||||
|
||||
__all__ = [
|
||||
"scrape_tool_func_docs",
|
||||
"CodeExecutor",
|
||||
"tool_find_by_name",
|
||||
"extract_tool_commands",
|
||||
"parse_and_execute_tools",
|
||||
"execute_tools",
|
||||
"BaseTool",
|
||||
"Tool",
|
||||
"StructuredTool",
|
||||
"tool",
|
||||
]
|
||||
|
||||
@ -0,0 +1,111 @@
|
||||
import os
|
||||
import tempfile
|
||||
import subprocess
|
||||
|
||||
|
||||
class CodeExecutor:
|
||||
"""
|
||||
A class for executing code snippets.
|
||||
|
||||
Args:
|
||||
code (str, optional): The code snippet to be executed. Defaults to None.
|
||||
|
||||
Methods:
|
||||
is_python_code(code: str = None) -> bool:
|
||||
Checks if the given code is Python code.
|
||||
|
||||
run_python(code: str = None) -> str:
|
||||
Executes the given Python code and returns the output.
|
||||
|
||||
run(code: str = None) -> str:
|
||||
Executes the given code and returns the output.
|
||||
|
||||
__call__() -> str:
|
||||
Executes the code and returns the output.
|
||||
"""
|
||||
|
||||
def __init__(self, code: str = None):
|
||||
self.code = code
|
||||
|
||||
def is_python_code(self, code: str = None) -> bool:
|
||||
"""
|
||||
Checks if the given code is Python code.
|
||||
|
||||
Args:
|
||||
code (str, optional): The code to be checked. Defaults to None.
|
||||
|
||||
Returns:
|
||||
bool: True if the code is Python code, False otherwise.
|
||||
"""
|
||||
code = code or self.code
|
||||
return code.strip().startswith("python")
|
||||
|
||||
def run_python(self, code: str = None) -> str:
|
||||
"""
|
||||
Executes the given Python code and returns the output.
|
||||
|
||||
Args:
|
||||
code (str, optional): The Python code to be executed. Defaults to None.
|
||||
|
||||
Returns:
|
||||
str: The output of the code execution.
|
||||
"""
|
||||
code = code or self.code
|
||||
try:
|
||||
# Create a temporary file
|
||||
with tempfile.NamedTemporaryFile(
|
||||
suffix=".py", delete=False
|
||||
) as temp:
|
||||
temp.write(code.encode())
|
||||
temp_filename = temp.name
|
||||
|
||||
# Execute the temporary file
|
||||
output = subprocess.check_output(
|
||||
f"python {temp_filename}",
|
||||
shell=True,
|
||||
)
|
||||
|
||||
# Delete the temporary file
|
||||
os.remove(temp_filename)
|
||||
|
||||
return output.decode("utf-8")
|
||||
except subprocess.CalledProcessError as error:
|
||||
return error.output.decode("utf-8")
|
||||
except Exception as error:
|
||||
return str(error)
|
||||
|
||||
def run(self, code: str = None) -> str:
|
||||
"""
|
||||
Executes the given code and returns the output.
|
||||
|
||||
Args:
|
||||
code (str, optional): The code to be executed. Defaults to None.
|
||||
|
||||
Returns:
|
||||
str: The output of the code execution.
|
||||
"""
|
||||
code = code or self.code
|
||||
try:
|
||||
output = subprocess.check_output(
|
||||
code,
|
||||
shell=True,
|
||||
)
|
||||
return output.decode("utf-8")
|
||||
except subprocess.CalledProcessError as e:
|
||||
return e.output.decode("utf-8")
|
||||
except Exception as e:
|
||||
return str(e)
|
||||
|
||||
def __call__(self) -> str:
|
||||
"""
|
||||
Executes the code and returns the output.
|
||||
|
||||
Returns:
|
||||
str: The output of the code execution.
|
||||
"""
|
||||
return self.run()
|
||||
|
||||
|
||||
# model = CodeExecutor()
|
||||
# out = model.run("python3")
|
||||
# print(out)
|
||||
Loading…
Reference in new issue