Merge branch 'kyegomez:master' into yikes

.github/workflows/code_quality_control.yml

@@ -0,0 +1,30 @@
+name: Linting and Formatting
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  lint_and_format:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v3
+        with:
+          python-version: 3.x
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Find Python files
+        run: find swarms -name "*.py" -type f -exec autopep8 --in-place --aggressive --aggressive {} +
+
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/cos_integration.yml

@@ -0,0 +1,42 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.x
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Run unit tests
+        run: pytest tests/unit
+
+      - name: Run integration tests
+        run: pytest tests/integration
+
+      - name: Run code coverage
+        run: pytest --cov=swarms tests/
+
+      - name: Run linters
+        run: pylint swarms
+
+      - name: Build documentation
+        run: make docs
+
+      - name: Validate documentation
+        run: sphinx-build -b linkcheck docs build/docs
+
+      - name: Run performance tests
+        run: pytest tests/performance

.github/workflows/docs_test.yml

@@ -0,0 +1,28 @@
+name: Documentation Tests
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v3
+        with:
+          python-version: 3.x
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Build documentation
+        run: make docs
+
+      - name: Validate documentation
+        run: sphinx-build -b linkcheck docs build/docs

.github/workflows/lints.yml

@@ -0,0 +1,25 @@
+name: Linting
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v3
+        with:
+          python-version: 3.x
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Run linters
+        run: pylint swarms

.github/workflows/pr_request_checks.yml

@@ -0,0 +1,27 @@
+name: Pull Request Checks
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.x
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Run tests and checks
+        run: |
+          pytest tests/unit
+          pylint swarms

.github/workflows/testing.yml

@@ -0,0 +1,25 @@
+name: Unit Tests
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v3
+        with:
+          python-version: 3.x
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Run unit tests
+        run: pytest tests/

docs/swarms/agents/abstract_agent.md

@@ -0,0 +1,90 @@
+`AbsractAgent` Class: A Deep Dive
+========================
+
+The `AbstractAgent` class is a fundamental building block in the design of AI systems. It encapsulates the behavior of an AI entity, allowing it to interact with other agents and perform actions. The class is designed to be flexible and extensible, enabling the creation of agents with diverse behaviors.
+
+## Architecture
+------------
+
+The architecture of the `AbstractAgent` class is centered around three main components: the agent's name, tools, and memory.
+
+-   The `name` is a string that uniquely identifies the agent. This is crucial for communication between agents and for tracking their actions.
+
+-   The `tools` are a list of `Tool` objects that the agent uses to perform its tasks. These could include various AI models, data processing utilities, or any other resources that the agent needs to function. The `tools` method is used to initialize these tools.
+
+-   The `memory` is a `Memory` object that the agent uses to store and retrieve information. This could be used, for example, to remember past actions or to store the state of the environment. The `memory` method is used to initialize the memory.
+
+The `AbstractAgent` class also includes several methods that define the agent's behavior. These methods are designed to be overridden in subclasses to implement specific behaviors.
+
+## Methods
+-------
+
+### `reset`
+
+The `reset` method is used to reset the agent's state. This could involve clearing the agent's memory, resetting its tools, or any other actions necessary to bring the agent back to its initial state. This method is abstract and must be overridden in subclasses.
+
+### `run` and `_arun`
+
+The `run` method is used to execute a task. The task is represented as a string, which could be a command, a query, or any other form of instruction that the agent can interpret. The `_arun` method is the asynchronous version of `run`, allowing tasks to be executed concurrently.
+
+### `chat` and `_achat`
+
+The `chat` method is used for communication between agents. It takes a list of messages as input, where each message is a dictionary. The `_achat` method is the asynchronous version of `chat`, allowing messages to be sent and received concurrently.
+
+### `step` and `_astep`
+
+The `step` method is used to advance the agent's state by one step in response to a message. The `_astep` method is the asynchronous version of `step`, allowing the agent's state to be updated concurrently.
+
+## Usage E#xamples
+--------------
+
+### Example 1: Creating an Agent
+
+```
+from swarms.agents.base import AbtractAgent
+
+agent = Agent(name="Agent1")
+print(agent.name)  # Output: Agent1
+```
+
+
+In this example, we create an instance of `AbstractAgent` named "Agent1" and print its name.
+
+### Example 2: Initializing Tools and Memory
+
+```
+from swarms.agents.base import AbtractAgent
+
+agent = Agent(name="Agent1")
+tools = [Tool1(), Tool2(), Tool3()]
+memory_store = Memory()
+
+agent.tools(tools)
+agent.memory(memory_store)
+```
+
+
+In this example, we initialize the tools and memory of "Agent1". The tools are a list of `Tool` instances, and the memory is a `Memory` instance.
+
+### Example 3: Running an Agent
+
+```
+from swarms.agents.base import AbtractAgent
+
+agent = Agent(name="Agent1")
+task = "Task1"
+
+agent.run(task)
+```
+
+
+In this example, we run "Agent1" with a task named "Task1".
+
+Notes
+-----
+
+-   The `AbstractAgent` class is an abstract class, which means it cannot be instantiated directly. Instead, it should be subclassed, and at least the `reset`, `run`, `chat`, and `step` methods should be overridden.
+-   The `run`, `chat`, and `step` methods are designed to be flexible and can be adapted to a wide range of tasks and behaviors. For example, the `run` method could be used to execute a machine learning model, the `chat` method could be used to send and receive messages in a chatbot, and the `step` method could be used to update the agent's state in a reinforcement learning environment.
+-   The `_arun`, `_achat`, and `_astep` methods are asynchronous versions of the `run`, `chat`, and `step` methods, respectively. They return a coroutine that can be awaited using the `await` keyword. This allows multiple tasks to be executed concurrently, improving the efficiency of the agent.
+-   The `tools` and `memory` methods are used to initialize the agent's tools and memory, respectively. These methods can be overridden in subclasses to initialize specific tools and memory structures.
+-   The `reset` method is used to reset the agent's state. This method can be overridden in subclasses to define specific reset behaviors. For example, in a reinforcement learning agent, the

docs/swarms/structs/workflow.md

@@ -0,0 +1,200 @@
+# Module/Class Name: Workflow
+===========================
+
+The `Workflow` class is a part of the `swarms` library and is used to create and execute a workflow of tasks. It provides a way to define a sequence of tasks and execute them in order, with the output of each task being used as the input for the next task.
+
+## Overview and Introduction
+-------------------------
+
+The `Workflow` class is designed to simplify the execution of a series of tasks by providing a structured way to define and execute them. It allows for sequential execution of tasks, with the output of each task being passed as input to the next task. This makes it easy to create complex workflows and automate multi-step processes.
+
+
+## Class Definition: Workflow
+
+
+The `Workflow` class is a powerful tool provided by the `swarms` library that allows users to create and execute a sequence of tasks in a structured and automated manner. It simplifies the process of defining and executing complex workflows by providing a clear and intuitive interface.
+
+## Why Use Workflows?
+------------------
+
+Workflows are essential in many domains, including data processing, automation, and task management. They enable the automation of multi-step processes, where the output of one task serves as the input for the next task. By using workflows, users can streamline their work, reduce manual effort, and ensure consistent and reliable execution of tasks.
+
+The `Workflow` class provides a way to define and execute workflows in a flexible and efficient manner. It allows users to define the sequence of tasks, specify dependencies between tasks, and execute them in order. This makes it easier to manage complex processes and automate repetitive tasks.
+
+## How Does it Work?
+-----------------
+
+The `Workflow` class consists of two main components: the `Task` class and the `Workflow` class itself. Let's explore each of these components in detail.
+
+### Task Class
+
+The `Task` class represents an individual task within a workflow. Each task is defined by a string description. It contains attributes such as `parents`, `children`, `output`, and `structure`.
+
+The `parents` attribute is a list that stores references to the parent tasks of the current task. Similarly, the `children` attribute is a list that stores references to the child tasks of the current task. These attributes allow for the definition of task dependencies and the establishment of the workflow's structure.
+
+The `output` attribute stores the output of the task, which is generated when the task is executed. Initially, the output is set to `None`, indicating that the task has not been executed yet.
+
+The `structure` attribute refers to the `Workflow` object that the task belongs to. This attribute is set when the task is added to the workflow.
+
+The `Task` class also provides methods such as `add_child` and `execute`. The `add_child` method allows users to add child tasks to the current task, thereby defining the workflow's structure. The `execute` method is responsible for executing the task by running the associated agent's `run` method with the task as input. It returns the response generated by the agent's `run` method.
+
+### Workflow Class
+
+The `Workflow` class is the main class that orchestrates the execution of tasks in a workflow. It takes an agent object as input, which is responsible for executing the tasks. The agent object should have a `run` method that accepts a task as input and returns a response.
+
+The `Workflow` class provides methods such as `add`, `run`, and `context`. The `add` method allows users to add tasks to the workflow. It returns the newly created task object, which can be used to define task dependencies. The `run` method executes the workflow by running each task in order. It returns the last task in the workflow. The `context` method returns a dictionary containing the context information for a given task, including the parent output, parent task, and child task.
+
+The `Workflow` class also has attributes such as `tasks` and `parallel`. The `tasks` attribute is a list that stores references to all the tasks in the workflow. The `parallel` attribute is a boolean flag that determines whether the tasks should be executed in parallel or sequentially.
+
+When executing the workflow, the `run` method iterates over the tasks in the workflow and executes each task in order. If the `parallel` flag is set to `True`, the tasks are executed in parallel using a `ThreadPoolExecutor`. Otherwise, the tasks are executed sequentially.
+
+## Benefits and Use Cases
+----------------------
+
+The `Workflow` class provides several benefits and use cases:
+
+-   Automation: Workflows automate multi-step processes, reducing manual effort and increasing efficiency. By defining the sequence of tasks and their dependencies, users can automate repetitive tasks and ensure consistent execution.
+
+-   Flexibility: Workflows can be easily customized and modified to suit specific needs. Users can add, remove, or rearrange tasks as required, allowing for dynamic and adaptable workflows.
+
+-   Error Handling: Workflows provide a structured approach to error handling. If an error occurs during the execution of a task, the workflow can be designed to handle the error gracefully and continue with the remaining tasks.
+
+-   Collaboration: Workflows facilitate collaboration by providing a shared structure for task execution. Multiple users can contribute to the workflow by adding or modifying tasks, enabling teamwork and coordination.
+
+-   Reproducibility: Workflows ensure reproducibility by defining a clear sequence of tasks. By following the same workflow, users can achieve consistent results and easily reproduce previous analyses or processes.
+
+Overall, the `Workflow` class is a valuable tool for managing and executing complex processes. It simplifies the creation
+
+
+## Class Parameters
+----------------
+
+-   `agent` (Any): The agent object that will be used to execute the tasks. It should have a `run` method that takes a task as input and returns a response.
+-   `parallel` (bool): If `True`, the tasks will be executed in parallel using a `ThreadPoolExecutor`. Default: `False`.
+
+## Class Methods
+-------------
+
+### `add(task: str) -> Task`
+
+Adds a new task to the workflow.
+
+-   `task` (str): The task to be added.
+
+Returns:
+
+-   `Task`: The newly created task object.
+
+### `run(*args) -> Task`
+
+Executes the workflow by running each task in order.
+
+Returns:
+
+-   `Task`: The last task in the workflow.
+
+### `context(task: Task) -> Dict[str, Any]`
+
+Returns a dictionary containing the context information for a given task. The context includes the parent output, parent task, and child task.
+
+-   `task` (Task): The task for which the context information is required.
+
+Returns:
+
+-   `Dict[str, Any]`: A dictionary containing the context information.
+
+## Task Class
+----------
+
+The `Task` class is a nested class within the `Workflow` class. It represents an individual task in the workflow.
+
+### Task Parameters
+
+-   `task` (str): The task description.
+
+### Task Methods
+
+### `add_child(child: 'Workflow.Task')`
+
+Adds a child task to the current task.
+
+-   `child` ('Workflow.Task'): The child task to be added.
+
+### `execute() -> Any`
+
+Executes the task by running the associated agent's `run` method with the task as input.
+
+Returns:
+
+-   `Any`: The response from the agent's `run` method.
+
+
+## Functionality and Usage 
+-----------------------------------
+
+To use the `Workflow` class, follow these steps:
+
+1.  Create an instance of the `Workflow` class, providing an agent object that has a `run` method. This agent will be responsible for executing the tasks in the workflow.
+
+```
+from swarms import Workflow
+
+# Create an instance of the Workflow class
+workflow = Workflow(agent=my_agent)
+```
+
+
+1.  Add tasks to the workflow using the `add` method. Each task should be a string description.
+
+```
+# Add tasks to the workflow
+task1 = workflow.add("Task 1")
+task2 = workflow.add("Task 2")
+task3 = workflow.add("Task 3")
+```
+
+
+1.  Define the sequence of tasks by adding child tasks to each task using the `add_child` method.
+
+```
+# Define the sequence of tasks
+task1.add_child(task2)
+task2.add_child(task3)
+```
+
+
+1.  Execute the workflow using the `run` method. This will run each task in order, with the output of each task being passed as input to the next task.
+
+```
+# Execute the workflow
+workflow.run()
+```
+
+
+1.  Access the output of each task using the `output` attribute of the task object.
+
+```
+# Access the output of each task
+output1 = task1.output
+output2 = task2.output
+output3 = task3.output
+```
+
+
+1.  Optionally, you can run the tasks in parallel by setting the `parallel` parameter to `True` when creating the `Workflow` object.
+
+```
+# Create a parallel workflow
+parallel_workflow = Workflow(agent=my_agent, parallel=True)
+```
+
+
+1.  You can also access the context information for a task using the `context` method. This method returns a dictionary containing the parent output, parent task, and child task for the given task.
+
+```
+# Access the context information for a task
+context = workflow.context(task2)
+parent_output = context["parent_output"]
+parent_task = context["parent"]
+child_task = context["child"]
+```

docs/swarms/workers/abstract_worker.md

@@ -0,0 +1,258 @@
+# AbstractWorker Class
+====================
+
+The `AbstractWorker` class is an abstract class for AI workers. An AI worker can communicate with other workers and perform actions. Different workers can differ in what actions they perform in the `receive` method.
+
+## Class Definition
+----------------
+
+```
+class AbstractWorker:
+    """(In preview) An abstract class for AI worker.
+
+    An worker can communicate with other workers and perform actions.
+    Different workers can differ in what actions they perform in the `receive` method.
+    """
+```
+
+
+## Initialization
+--------------
+
+The `AbstractWorker` class is initialized with a single parameter:
+
+-   `name` (str): The name of the worker.
+
+```
+def __init__(
+    self,
+    name: str,
+):
+    """
+    Args:
+        name (str): name of the worker.
+    """
+    self._name = name
+```
+
+
+## Properties
+----------
+
+The `AbstractWorker` class has a single property:
+
+-   `name`: Returns the name of the worker.
+
+```
+@property
+def name(self):
+    """Get the name of the worker."""
+    return self._name
+```
+
+
+## Methods
+-------
+
+The `AbstractWorker` class has several methods:
+
+### `run`
+
+The `run` method is used to run the worker agent once. It takes a single parameter:
+
+-   `task` (str): The task to be run.
+
+```
+def run(
+    self,
+    task: str
+):
+    """Run the worker agent once"""
+```
+
+
+### `send`
+
+The `send` method is used to send a message to another worker. It takes three parameters:
+
+-   `message` (Union[Dict, str]): The message to be sent.
+-   `recipient` (AbstractWorker): The recipient of the message.
+-   `request_reply` (Optional[bool]): If set to `True`, the method will request a reply from the recipient.
+
+```
+def send(
+    self,
+    message: Union[Dict, str],
+    recipient: AbstractWorker,
+    request_reply: Optional[bool] = None
+):
+    """(Abstract method) Send a message to another worker."""
+```
+
+
+### `a_send`
+
+The `a_send` method is the asynchronous version of the `send` method. It takes the same parameters as the `send` method.
+
+```
+async def a_send(
+    self,
+    message: Union[Dict, str],
+    recipient: AbstractWorker,
+    request_reply: Optional[bool] = None
+):
+    """(Abstract async method) Send a message to another worker."""
+```
+
+
+### `receive`
+
+The `receive` method is used to receive a message from another worker. It takes three parameters:
+
+-   `message` (Union[Dict, str]): The message to be received.
+-   `sender` (AbstractWorker): The sender of the message.
+-   `request_reply` (Optional[bool]): If set to `True`, the method will request a reply from the sender.
+
+```
+def receive(
+    self,
+    message: Union[Dict, str],
+    sender: AbstractWorker,
+    request_reply: Optional[bool] = None
+):
+    """(Abstract method) Receive a message from another worker."""
+```
+
+
+### `a_receive`
+
+The `a_receive` method is the asynchronous version of the `receive` method. It takes the same parameters as the `receive` method.
+
+```
+async def a_receive(
+    self,
+    message: Union[Dict, str],
+    sender: AbstractWorker,
+    request_reply: Optional[bool] = None
+):
+    """(Abstract async method) Receive a message from another worker."""
+```
+
+
+### `reset`
+
+The `reset` method is used to reset the worker.
+
+```
+def reset(self):
+    """(Abstract method) Reset the worker."""
+```
+
+
+### `generate_reply`
+
+The `generate_reply` method is used to generate a reply based on the received messages. It takes two parameters:
+
+-   `messages` (Optional[List[Dict]]): A list of messages received.
+-   `sender` (AbstractWorker): The sender of the messages.
+
+The method returns a string, a dictionary, or `None`. If `None` is returned, no reply is generated.
+
+```
+def generate_reply(
+    self,
+    messages: Optional[List[Dict]] = None,
+    sender: AbstractWorker,
+    **kwargs,
+) -> Union[str, Dict, None]:
+    """(Abstract method) Generate a reply based on the received messages.
+
+    Args:
+        messages (list[dict]): a list of messages received.
+        sender: sender of an Agent instance.
+    Returns:
+        str or dict or None: the generated reply. If None, no reply is generated.
+    """
+```
+
+
+### `a_generate_reply`
+
+The `a_generate_reply` method is the asynchronous version of the `generate_reply` method. It
+
+takes the same parameters as the `generate_reply` method.
+
+```
+async def a_generate_reply(
+    self,
+    messages: Optional[List[Dict]] = None,
+    sender: AbstractWorker,
+    **kwargs,
+) -> Union[str, Dict, None]:
+    """(Abstract async method) Generate a reply based on the received messages.
+
+    Args:
+        messages (list[dict]): a list of messages received.
+        sender: sender of an Agent instance.
+    Returns:
+        str or dict or None: the generated reply. If None, no reply is generated.
+    """
+```
+
+
+Usage Examples
+--------------
+
+### Example 1: Creating an AbstractWorker
+
+```
+from swarms.worker.base import AbstractWorker
+
+worker = AbstractWorker(name="Worker1")
+print(worker.name)  # Output: Worker1
+```
+
+
+In this example, we create an instance of `AbstractWorker` named "Worker1" and print its name.
+
+### Example 2: Sending a Message
+
+```
+from swarms.worker.base import AbstractWorker
+
+worker1 = AbstractWorker(name="Worker1")
+worker2 = AbstractWorker(name="Worker2")
+
+message = {"content": "Hello, Worker2!"}
+worker1.send(message, worker2)
+```
+
+
+In this example, "Worker1" sends a message to "Worker2". The message is a dictionary with a single key-value pair.
+
+### Example 3: Receiving a Message
+
+```
+from swarms.worker.base import AbstractWorker
+
+worker1 = AbstractWorker(name="Worker1")
+worker2 = AbstractWorker(name="Worker2")
+
+message = {"content": "Hello, Worker2!"}
+worker1.send(message, worker2)
+
+received_message = worker2.receive(message, worker1)
+print(received_message)  # Output: {"content": "Hello, Worker2!"}
+```
+
+
+In this example, "Worker1" sends a message to "Worker2". "Worker2" then receives the message and prints it.
+
+Notes
+-----
+
+-   The `AbstractWorker` class is an abstract class, which means it cannot be instantiated directly. Instead, it should be subclassed, and at least the `send`, `receive`, `reset`, and `generate_reply` methods should be overridden.
+-   The `send` and `receive` methods are abstract methods, which means they must be implemented in any subclass of `AbstractWorker`.
+-   The `a_send`, `a_receive`, and `a_generate_reply` methods are asynchronous methods, which means they return a coroutine that can be awaited using the `await` keyword.
+-   The `generate_reply` method is used to generate a reply based on the received messages. The exact implementation of this method will depend on the specific requirements of your application.
+-   The `reset` method is used to reset the state of the worker. The exact implementation of this method will depend on the specific requirements of your application.

example.py

@@ -19,3 +19,4 @@ node = Worker(
 task = "What were the winning boston marathon times for the past 5 years (ending in 2022)? Generate a table of the year, name, country of origin, and times."
 response = node.run(task)
 print(response)
+

mkdocs.yml

@@ -77,20 +77,26 @@ nav:
     - Hiring: "hiring.md"
 - Swarms:
   - Overview: "swarms/index.md"
-  - AutoScaler: "swarms/swarms/autoscaler.md"
+  - swarms.swarms:
-  - Workers:
+    - AutoScaler: "swarms/swarms/autoscaler.md"
+  - swarms.workers:
     - Overview: "swarms/workers/index.md"
-  - Agents:
+    - AbstractWorker: "swarms/workers/abstract_worker.md"
-    - Base Models:
+  - swarms.agents:
-      - Overview: "swarms/models/index.md"
+    - AbstractAgent: "swarms/agents/abstract_agent.md"
-      - HuggingFaceLLM: "swarms/models/hf.md"
-      - Anthropic: "swarms/models/anthropic.md"
     - OmniModalAgent: "swarms/agents/omni_agent.md"
+  - swarms.models:
+    - Overview: "swarms/models/index.md"
+    - HuggingFaceLLM: "swarms/models/hf.md"
+    - Anthropic: "swarms/models/anthropic.md"
+  - swarms.structs:
+    - Overview: "swarms/structs/overview.md"
+    - Workflow: "swarms/structs/workflow.md"
+    
 - Examples:
     - Overview: "examples/index.md"
     - Agents:
       - OmniAgent: "examples/omni_agent.md"
-      
 - Applications:
     - CustomerSupport: 
       - Overview: "applications/customer_support.md"

playground/structs/nonlinear_worfklow.py

@@ -0,0 +1,18 @@
+from swarms.agents.base import agent
+from swarms.structs.nonlinear_worfklow import NonLinearWorkflow, Task
+
+prompt = "develop a feedforward network in pytorch"
+prompt2 = "Develop a self attention using pytorch"
+
+task1 = Task("task1", prompt)
+task2 = Task("task2", prompt2, parents=[task1])
+
+#add tasks to workflow
+workflow = NonLinearWorkflow(agent)
+
+#add tasks to tree
+workflow.add(task1)
+workflow.add(task2)
+
+#run
+workflow.run()

playground/structs/workflow.py

@@ -0,0 +1,8 @@
+from swarms.structs.workflow import Workflow, StringTask
+from langchain.llms import OpenAIChat
+
+
+llm = OpenAIChat()
+
+
+workflow = Workflow(llm)

playground/swarms/groupchat.py

@@ -44,7 +44,7 @@ nodes = [
 messages = [
     {
         "role": "system",
-        "context": f"Create an a small feedforward in pytorch",
+        "context": "Create an a small feedforward in pytorch",
     }
 ]
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "swarms"
-version = "1.7.7"
+version = "1.7.8"
 description = "Swarms - Pytorch"
 license = "MIT"
 authors = ["Kye Gomez <kye@apac.ai>"]
@@ -63,3 +63,11 @@ types-pytz = "^2023.3.0.0"
 black = "^23.1.0"
 types-chardet = "^5.0.4.6"
 mypy-protobuf = "^3.0.0"
+
+
+[tool.autopep8]
+max_line_length = 120
+ignore = "E501,W6"  # or ["E501", "W6"]
+in-place = true
+recursive = true
+aggressive = 3

requirements.txt

@@ -50,6 +50,7 @@ torchmetrics
 transformers
 webdataset
 yapf
+autopep8
 
 
 mkdocs

swarms/__init__.py

@@ -1,23 +1,23 @@
-#swarms
+# swarms
+from swarms import agents
+from swarms.swarms.orchestrate import Orchestrator
+from swarms import swarms
+from swarms import structs
+from swarms import models
+from swarms.workers.worker import Worker
+from swarms import workers
 from swarms.logo import logo2
 print(logo2)
 
 # worker
-from swarms import workers
-from swarms.workers.worker import Worker
 
-#boss
+# boss
 # from swarms.boss.boss_node import Boss
 
-#models
+# models
-from swarms import models
 
-#structs
+# structs
-from swarms import structs
 
 # swarms
-from swarms import swarms
-from swarms.swarms.orchestrate import Orchestrator
 
-#agents
+# agents
-from swarms import agents

swarms/agents/__init__.py

@@ -1,15 +1,14 @@
 
 """Agent Infrastructure, models, memory, utils, tools"""
 
-#agents
+# agents
 # from swarms.agents.profitpilot import ProfitPilot
 # from swarms.agents.aot import AoTAgent
 # from swarms.agents.multi_modal_visual_agent import MultiModalAgent
 from swarms.agents.omni_modal_agent import OmniModalAgent
 
 
-
+# utils
-#utils
 from swarms.agents.message import Message
 from swarms.agents.stream_response import stream
-# from swarms.agents.base import AbstractAgent
+from swarms.agents.base import AbstractAgent

swarms/agents/agent.py

@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Optional
-
-from langchain.chains.llm import LLMChain
-
-from swarms.agents.utils.Agent import AgentOutputParser
-from swarms.agents.utils.human_input import HumanInputRun
-from swarms.memory.base_memory import BaseChatMessageHistory, ChatMessageHistory
-from swarms.memory.document import Document
-from swarms.models.base import AbstractModel
-from swarms.models.prompts.agent_prompt_auto import (
-    MessageFormatter,
-    PromptConstructor,
-)
-from swarms.models.prompts.agent_prompt_generator import FINISH_NAME
-from swarms.models.prompts.base import (
-    AIMessage,
-    HumanMessage,
-    SystemMessage,
-)
-from swarms.tools.base import BaseTool
-
-
-class Agent:
-    """Base Agent class"""
-    def __init__(
-        self,
-        ai_name: str,
-        chain: LLMChain,
-        memory,
-        output_parser: AgentOutputParser,
-        tools: List[BaseTool],
-        feedback_tool: Optional[HumanInputRun] = None,
-        chat_history_memory: Optional[BaseChatMessageHistory] = None,
-    ):
-        self.ai_name = ai_name
-        self.chain = chain
-        self.memory = memory
-        self.next_action_count = 0
-        self.output_parser = output_parser
-        self.tools = tools
-        self.feedback_tool = feedback_tool
-        self.chat_history_memory = chat_history_memory or ChatMessageHistory()
-
-    @classmethod
-    def integrate(
-        cls,
-        ai_name: str,
-        ai_role: str,
-        memory,
-        tools: List[BaseTool],
-        llm: AbstractModel,
-        human_in_the_loop: bool = False,
-        output_parser: Optional[AgentOutputParser] = None,
-        chat_history_memory: Optional[BaseChatMessageHistory] = None,
-    ) -> Agent:
-        prompt_constructor = PromptConstructor(ai_name=ai_name,
-                                               ai_role=ai_role,
-                                               tools=tools)
-        message_formatter = MessageFormatter()
-        human_feedback_tool = HumanInputRun() if human_in_the_loop else None
-        chain = LLMChain(llm=llm, prompt_constructor=prompt_constructor, message_formatter=message_formatter)
-        return cls(
-            ai_name,
-            memory,
-            chain,
-            output_parser or AgentOutputParser(),
-            tools,
-            feedback_tool=human_feedback_tool,
-            chat_history_memory=chat_history_memory,
-        )
-
-    def run(self, goals: List[str]) -> str:
-        user_input = (
-            "Determine which next command to use, and respond using the format specified above:"
-        )
-        loop_count = 0
-        while True:
-            loop_count += 1
-
-            # Send message to AI, get response
-            assistant_reply = self.chain.run(
-                goals=goals,
-                messages=self.chat_history_memory.messages,
-                memory=self.memory,
-                user_input=user_input,
-            )
-
-            print(assistant_reply)
-            self.chat_history_memory.add_message(HumanMessage(content=user_input))
-            self.chat_history_memory.add_message(AIMessage(content=assistant_reply))
-
-            # Get command name and arguments
-            action = self.output_parser.parse(assistant_reply)
-            tools = {t.name: t for t in self.tools}
-            if action.name == FINISH_NAME:
-                return action.args["response"]
-            if action.name in tools:
-                tool = tools[action.name]
-                try:
-                    observation = tool.run(action.args)
-                except Exception as error:
-                    observation = (
-                        f"Validation Error in args: {str(error)}, args: {action.args}"
-                    )
-                except Exception as e:
-                    observation = (
-                        f"Error: {str(e)}, {type(e).__name__}, args: {action.args}"
-                    )
-                result = f"Command {tool.name} returned: {observation}"
-            elif action.name == "ERROR":
-                result = f"Error: {action.args}. "
-            else:
-                result = (
-                    f"""Unknown command '{action.name}'. 
-                    Please refer to the 'COMMANDS' list for available
-                    commands and only respond in the specified JSON format."""
-                )
-            memory_to_add = (
-                f"Assistant Reply: {assistant_reply} " f"\nResult: {result} "
-            )
-            if self.feedback_tool is not None:
-                feedback = f"\n{self.feedback_tool.run('Input: ')}"
-                if feedback in {"q", "stop"}:
-                    print("EXITING")
-                    return "EXITING"
-                memory_to_add += feedback
-
-            self.memory.add_documents([Document(page_content=memory_to_add)])
-            self.chat_history_memory.add_message(SystemMessage(content=result))
-
-

swarms/agents/aot.py

@@ -7,15 +7,16 @@ import openai
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+
 class OpenAI:
     def __init__(
-            self, 
+        self,
-            api_key, 
+        api_key,
-            strategy="cot", 
+        strategy="cot",
-            evaluation_strategy="value", 
+        evaluation_strategy="value",
-            api_base="", 
+        api_base="",
-            api_model="",
+        api_model="",
-        ):
+    ):
         if api_key == "" or api_key is None:
             api_key = os.environ.get("OPENAI_API_KEY", "")
         if api_key != "":
@@ -23,7 +24,7 @@ class OpenAI:
         else:
             raise Exception("Please provide OpenAI API key")
 
-        if api_base == ""or api_base is None:
+        if api_base == "" or api_base is None:
             api_base = os.environ.get("OPENAI_API_BASE", "")  # if not set, use the default base path of "https://api.openai.com/v1"
         if api_base != "":
             # e.g. https://api.openai.com/v1/ or your custom url
@@ -43,13 +44,13 @@ class OpenAI:
         self.evaluation_strategy = evaluation_strategy
 
     def run(
-            self, 
+        self,
-            prompt, 
+        prompt,
-            max_tokens, 
+        max_tokens,
-            temperature, 
+        temperature,
-            k=1, 
+        k=1,
-            stop=None
+        stop=None
-        ):
+    ):
         while True:
             try:
                 if self.use_chat_api:
@@ -75,7 +76,7 @@ class OpenAI:
                         temperature=temperature,
                     )
                 with open("openai.logs", 'a') as log_file:
-                    log_file.write("\n" + "-----------" + '\n' +"Prompt : "+ prompt+"\n")
+                    log_file.write("\n" + "-----------" + '\n' + "Prompt : " + prompt + "\n")
                 return response
             except openai.error.RateLimitError as e:
                 sleep_duratoin = os.environ.get("OPENAI_RATE_TIMEOUT", 30)
@@ -105,13 +106,13 @@ class OpenAI:
             return thoughts
 
     def generate_thoughts(
-            self, 
+        self,
-            state, 
+        state,
-            k, 
+        k,
-            initial_prompt, 
+        initial_prompt,
-            rejected_solutions=None
+        rejected_solutions=None
-        ):
+    ):
-        if (type(state) == str):
+        if (isinstance(state, str)):
             state_text = state
         else:
             state_text = '\n'.join(state)
@@ -134,7 +135,6 @@ class OpenAI:
         # print(f"Generated thoughts: {thoughts}")
         return thoughts
 
-        
     def generate_solution(self,
                           initial_prompt,
                           state,
@@ -169,7 +169,7 @@ class OpenAI:
         if self.evaluation_strategy == 'value':
             state_values = {}
             for state in states:
-                if (type(state) == str):
+                if (isinstance(state, str)):
                     state_text = state
                 else:
                     state_text = '\n'.join(state)
@@ -193,6 +193,8 @@ class OpenAI:
 
         else:
             raise ValueError("Invalid evaluation strategy. Choose 'value' or 'vote'.")
+
+
 class AoTAgent:
     def __init__(
         self,
@@ -203,7 +205,7 @@ class AoTAgent:
         backtracking_threshold=0.4,
         initial_prompt=None,
         openai_api_key: str = None,
-        model = None,
+        model=None,
     ):
         self.num_thoughts = num_thoughts
         self.max_steps = max_steps
@@ -245,7 +247,7 @@ class AoTAgent:
                 child = (state, next_state) if isinstance(state, str) else (*state, next_state)
                 self.dfs(child, step + 1)
 
-                #backtracking
+                # backtracking
                 best_value = max([value for _, value in self.output])
                 if best_value < self.backtracking_threshold:
                     self.output.pop()

swarms/agents/base.py

@@ -1,28 +1,64 @@
+from typing import Dict, List, Optional, Union
+
+
+class AbstractAgent:
+    """(In preview) An abstract class for AI agent.
+
+    An agent can communicate with other agents and perform actions.
+    Different agents can differ in what actions they perform in the `receive` method.
+
+    Agents are full and completed:
+
+    Agents = llm + tools + memory
+
+
+    """
 
-class AbsractAgent:
     def __init__(
         self,
-        llm,
+        name: str,
-        temperature
+        # tools: List[Tool],
-    ) -> None:
+        #memory: Memory
+    ):
+        """
+        Args:
+            name (str): name of the agent.
+        """
+        # a dictionary of conversations, default value is list
+        self._name = name
+
+    @property
+    def name(self):
+        """Get the name of the agent."""
+        return self._name
+
+    def tools(self, tools):
+        """init tools"""
+
+    def memory(self, memory_store):
+        """init memory"""
         pass
 
-    #single query
+    def reset(self):
+        """(Abstract method) Reset the agent."""
+
     def run(self, task: str):
-        pass
+        """Run the agent once"""
 
-    # conversational back and forth
+    def _arun(self, taks: str):
-    def chat(self, message: str):
+        """Run Async run"""
-        message_historys = []
-        message_historys.append(message)
 
-        reply = self.run(message)
+    def chat(self, messages: List[Dict]):
-        message_historys.append(reply)
+        """Chat with the agent"""
 
-        return message_historys
+    def _achat(
+        self,
+        messages: List[Dict]
+    ):
+        """Asynchronous Chat"""
 
-    def step(self, message):
+    def step(self, message: str):
-        pass
+        """Step through the agent"""
 
-    def reset(self):
+    def _astep(self, message: str):
-        pass
+        """Asynchronous step"""

swarms/agents/memory.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, List
 from swarms.memory.base_memory import BaseChatMemory, get_prompt_input_key
 from swarms.memory.base import VectorStoreRetriever
 
+
 class AgentMemory(BaseChatMemory):
     retriever: VectorStoreRetriever
     """VectorStoreRetriever object to connect to."""

swarms/agents/message.py

@@ -1,5 +1,6 @@
 import datetime
 
+
 class Message:
     """
     Represents a message with timestamp and optional metadata.

swarms/agents/models/__init__.py

@@ -3,5 +3,3 @@
 # from .GroundingDINO.groundingdino.util import box_ops, SLConfig
 # from .GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
 # from .segment_anything.segment_anything import build_sam, SamPredictor, SamAutomaticMaskGenerator
-
-

swarms/agents/models/groundingdino/datasets/transforms.py

@@ -38,7 +38,7 @@ def crop(image, target, region):
 
     if "masks" in target:
         # FIXME should we update the area here if there are no boxes?
-        target["masks"] = target["masks"][:, i : i + h, j : j + w]
+        target["masks"] = target["masks"][:, i: i + h, j: j + w]
         fields.append("masks")
 
     # remove elements for which the boxes or masks that have zero area

swarms/agents/models/groundingdino/models/GroundingDINO/__init__.py

@@ -11,4 +11,3 @@
 # Copied from DETR (https://github.com/facebookresearch/detr)
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
 # ------------------------------------------------------------------------
-

swarms/agents/models/groundingdino/models/GroundingDINO/backbone/backbone.py

@@ -139,7 +139,7 @@ class Backbone(BackboneBase):
         assert name not in ("resnet18", "resnet34"), "Only resnet50 and resnet101 are available."
         assert return_interm_indices in [[0, 1, 2, 3], [1, 2, 3], [3]]
         num_channels_all = [256, 512, 1024, 2048]
-        num_channels = num_channels_all[4 - len(return_interm_indices) :]
+        num_channels = num_channels_all[4 - len(return_interm_indices):]
         super().__init__(backbone, train_backbone, num_channels, return_interm_indices)
 
 
@@ -204,7 +204,7 @@ def build_backbone(args):
             use_checkpoint=use_checkpoint,
         )
 
-        bb_num_channels = backbone.num_features[4 - len(return_interm_indices) :]
+        bb_num_channels = backbone.num_features[4 - len(return_interm_indices):]
     else:
         raise NotImplementedError("Unknown backbone {}".format(args.backbone))
 

swarms/agents/models/groundingdino/models/GroundingDINO/backbone/swin_transformer.py

@@ -614,7 +614,7 @@ class SwinTransformer(nn.Module):
                 qk_scale=qk_scale,
                 drop=drop_rate,
                 attn_drop=attn_drop_rate,
-                drop_path=dpr[sum(depths[:i_layer]) : sum(depths[: i_layer + 1])],
+                drop_path=dpr[sum(depths[:i_layer]): sum(depths[: i_layer + 1])],
                 norm_layer=norm_layer,
                 # downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
                 downsample=downsamplelist[i_layer],

swarms/agents/models/groundingdino/models/GroundingDINO/bertwarper.py

@@ -203,8 +203,8 @@ def generate_masks_with_special_tokens(tokenized, special_tokens_list, tokenizer
             attention_mask[row, col, col] = True
             position_ids[row, col] = 0
         else:
-            attention_mask[row, previous_col + 1 : col + 1, previous_col + 1 : col + 1] = True
+            attention_mask[row, previous_col + 1: col + 1, previous_col + 1: col + 1] = True
-            position_ids[row, previous_col + 1 : col + 1] = torch.arange(
+            position_ids[row, previous_col + 1: col + 1] = torch.arange(
                 0, col - previous_col, device=input_ids.device
             )
 
@@ -248,12 +248,12 @@ def generate_masks_with_special_tokens_and_transfer_map(tokenized, special_token
             attention_mask[row, col, col] = True
             position_ids[row, col] = 0
         else:
-            attention_mask[row, previous_col + 1 : col + 1, previous_col + 1 : col + 1] = True
+            attention_mask[row, previous_col + 1: col + 1, previous_col + 1: col + 1] = True
-            position_ids[row, previous_col + 1 : col + 1] = torch.arange(
+            position_ids[row, previous_col + 1: col + 1] = torch.arange(
                 0, col - previous_col, device=input_ids.device
             )
             c2t_maski = torch.zeros((num_token), device=input_ids.device).bool()
-            c2t_maski[previous_col + 1 : col] = True
+            c2t_maski[previous_col + 1: col] = True
             cate_to_token_mask_list[row].append(c2t_maski)
         previous_col = col
 

swarms/agents/models/groundingdino/models/GroundingDINO/ms_deform_attn.py

@@ -27,7 +27,7 @@ from torch.nn.init import constant_, xavier_uniform_
 
 try:
     from groundingdino import _C
-except:
+except BaseException:
     warnings.warn("Failed to load custom C++ ops. Running on CPU mode Only!")
 
 
@@ -241,7 +241,6 @@ class MultiScaleDeformableAttention(nn.Module):
         level_start_index: Optional[torch.Tensor] = None,
         **kwargs
     ) -> torch.Tensor:
-
         """Forward Function of MultiScaleDeformableAttention
 
         Args:

swarms/agents/models/groundingdino/models/GroundingDINO/utils.py

@@ -70,7 +70,7 @@ def gen_encoder_output_proposals(
     proposals = []
     _cur = 0
     for lvl, (H_, W_) in enumerate(spatial_shapes):
-        mask_flatten_ = memory_padding_mask[:, _cur : (_cur + H_ * W_)].view(N_, H_, W_, 1)
+        mask_flatten_ = memory_padding_mask[:, _cur: (_cur + H_ * W_)].view(N_, H_, W_, 1)
         valid_H = torch.sum(~mask_flatten_[:, :, 0, 0], 1)
         valid_W = torch.sum(~mask_flatten_[:, 0, :, 0], 1)
 

swarms/agents/models/groundingdino/util/get_tokenlizer.py

@@ -1,6 +1,7 @@
 from transformers import AutoTokenizer, BertModel, RobertaModel
 import os
 
+
 def get_tokenlizer(text_encoder_type):
     if not isinstance(text_encoder_type, str):
         # print("text_encoder_type is not a str")

swarms/agents/models/groundingdino/util/slconfig.py

@@ -170,7 +170,7 @@ class SLConfig(object):
             elif isinstance(b, list):
                 try:
                     _ = int(k)
-                except:
+                except BaseException:
                     raise TypeError(
                         f"b is a list, " f"index {k} should be an int when input but {type(k)}"
                     )

swarms/agents/models/groundingdino/util/utils.py

@@ -268,6 +268,7 @@ def get_embedder(multires, i=0):
     }
 
     embedder_obj = Embedder(**embed_kwargs)
+
     def embed(x, eo=embedder_obj):
         return eo.embed(x)
     return embed, embedder_obj.out_dim

swarms/agents/models/groundingdino/util/visualizer.py

@@ -243,7 +243,7 @@ class COCOVisualizer:
             for ann in anns:
                 c = (np.random.random((1, 3)) * 0.6 + 0.4).tolist()[0]
                 if "segmentation" in ann:
-                    if type(ann["segmentation"]) == list:
+                    if isinstance(ann["segmentation"], list):
                         # polygon
                         for seg in ann["segmentation"]:
                             poly = np.array(seg).reshape((int(len(seg) / 2), 2))
@@ -252,7 +252,7 @@ class COCOVisualizer:
                     else:
                         # mask
                         t = self.imgs[ann["image_id"]]
-                        if type(ann["segmentation"]["counts"]) == list:
+                        if isinstance(ann["segmentation"]["counts"], list):
                             rle = maskUtils.frPyObjects(
                                 [ann["segmentation"]], t["height"], t["width"]
                             )
@@ -267,7 +267,7 @@ class COCOVisualizer:
                         for i in range(3):
                             img[:, :, i] = color_mask[i]
                         ax.imshow(np.dstack((img, m * 0.5)))
-                if "keypoints" in ann and type(ann["keypoints"]) == list:
+                if "keypoints" in ann and isinstance(ann["keypoints"], list):
                     # turn skeleton into zero-based index
                     sks = np.array(self.loadCats(ann["category_id"])[0]["skeleton"]) - 1
                     kp = np.array(ann["keypoints"])

swarms/agents/models/groundingdino/util/vl_utils.py

@@ -24,14 +24,14 @@ def create_positive_map_from_span(tokenized, token_span, max_text_len=256):
                     beg_pos = tokenized.char_to_token(beg + 1)
                     if beg_pos is None:
                         beg_pos = tokenized.char_to_token(beg + 2)
-                except:
+                except BaseException:
                     beg_pos = None
             if end_pos is None:
                 try:
                     end_pos = tokenized.char_to_token(end - 2)
                     if end_pos is None:
                         end_pos = tokenized.char_to_token(end - 3)
-                except:
+                except BaseException:
                     end_pos = None
             if beg_pos is None or end_pos is None:
                 continue
@@ -41,7 +41,7 @@ def create_positive_map_from_span(tokenized, token_span, max_text_len=256):
                 positive_map[j, beg_pos] = 1
                 break
             else:
-                positive_map[j, beg_pos : end_pos + 1].fill_(1)
+                positive_map[j, beg_pos: end_pos + 1].fill_(1)
 
     return positive_map / (positive_map.sum(-1)[:, None] + 1e-6)
 

swarms/agents/models/segment_anything/segment_anything/__init__.py

@@ -3,4 +3,3 @@
 
 # This source code is licensed under the license found in the
 # LICENSE file in the root directory of this source tree.
-

swarms/agents/models/segment_anything/segment_anything/modeling/__init__.py

@@ -3,4 +3,3 @@
 
 # This source code is licensed under the license found in the
 # LICENSE file in the root directory of this source tree.
-

swarms/agents/models/segment_anything/segment_anything/modeling/mask_decoder.py

@@ -131,7 +131,7 @@ class MaskDecoder(nn.Module):
         # Run the transformer
         hs, src = self.transformer(src, pos_src, tokens)
         iou_token_out = hs[:, 0, :]
-        mask_tokens_out = hs[:, 1 : (1 + self.num_mask_tokens), :]
+        mask_tokens_out = hs[:, 1: (1 + self.num_mask_tokens), :]
 
         # Upscale mask embeddings and predict masks using the mask tokens
         src = src.transpose(1, 2).view(b, c, h, w)

swarms/agents/models/segment_anything/segment_anything/utils/amg.py

@@ -101,7 +101,7 @@ def batch_iterator(batch_size: int, *args) -> Generator[List[Any], None, None]:
     ), "Batched iteration must have inputs of all the same size."
     n_batches = len(args[0]) // batch_size + int(len(args[0]) % batch_size != 0)
     for b in range(n_batches):
-        yield [arg[b * batch_size : (b + 1) * batch_size] for arg in args]
+        yield [arg[b * batch_size: (b + 1) * batch_size] for arg in args]
 
 
 def mask_to_rle_pytorch(tensor: torch.Tensor) -> List[Dict[str, Any]]:
@@ -142,7 +142,7 @@ def rle_to_mask(rle: Dict[str, Any]) -> np.ndarray:
     idx = 0
     parity = False
     for count in rle["counts"]:
-        mask[idx : idx + count] = parity
+        mask[idx: idx + count] = parity
         idx += count
         parity ^= True
     mask = mask.reshape(w, h)

swarms/agents/multi_modal_visual_agent.py

@@ -1,3 +1,4 @@
+from swarms.agents.message import Message
 import os
 import random
 import torch
@@ -36,8 +37,7 @@ import matplotlib.pyplot as plt
 import wget
 
 
-
+# prompts
-#prompts
 VISUAL_AGENT_PREFIX = """
 Worker Multi-Modal Agent is designed to be able to assist with
 a wide range of text and visual related tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics.
@@ -239,6 +239,7 @@ def get_new_image_name(org_img_name, func_name="update"):
     new_file_name = f'{this_new_uuid}_{func_name}_{recent_prev_file_name}_{most_org_file_name}.png'
     return os.path.join(head, new_file_name)
 
+
 class InstructPix2Pix:
     def __init__(self, device):
         print(f"Initializing InstructPix2Pix to {device}")
@@ -352,7 +353,7 @@ class CannyText2Image:
         self.seed = -1
         self.a_prompt = 'best quality, extremely detailed'
         self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
-                            'fewer digits, cropped, worst quality, low quality'
+            'fewer digits, cropped, worst quality, low quality'
 
     @prompts(name="Generate Image Condition On Canny Image",
              description="useful when you want to generate a new real image from both the user description and a canny image."
@@ -409,7 +410,7 @@ class LineText2Image:
         self.seed = -1
         self.a_prompt = 'best quality, extremely detailed'
         self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
-                            'fewer digits, cropped, worst quality, low quality'
+            'fewer digits, cropped, worst quality, low quality'
 
     @prompts(name="Generate Image Condition On Line Image",
              description="useful when you want to generate a new real image from both the user description "
@@ -467,7 +468,7 @@ class HedText2Image:
         self.seed = -1
         self.a_prompt = 'best quality, extremely detailed'
         self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
-                            'fewer digits, cropped, worst quality, low quality'
+            'fewer digits, cropped, worst quality, low quality'
 
     @prompts(name="Generate Image Condition On Soft Hed Boundary Image",
              description="useful when you want to generate a new real image from both the user description "
@@ -525,7 +526,7 @@ class ScribbleText2Image:
         self.seed = -1
         self.a_prompt = 'best quality, extremely detailed'
         self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
-                            'fewer digits, cropped, worst quality, low quality'
+            'fewer digits, cropped, worst quality, low quality'
 
     @prompts(name="Generate Image Condition On Sketch Image",
              description="useful when you want to generate a new real image from both the user description and "
@@ -581,7 +582,7 @@ class PoseText2Image:
         self.unconditional_guidance_scale = 9.0
         self.a_prompt = 'best quality, extremely detailed'
         self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,' \
-                            ' fewer digits, cropped, worst quality, low quality'
+            ' fewer digits, cropped, worst quality, low quality'
 
     @prompts(name="Generate Image Condition On Pose Image",
              description="useful when you want to generate a new real image from both the user description "
@@ -604,6 +605,7 @@ class PoseText2Image:
               f"Output Image: {updated_image_path}")
         return updated_image_path
 
+
 class SegText2Image:
     def __init__(self, device):
         print(f"Initializing SegText2Image to {device}")
@@ -618,7 +620,7 @@ class SegText2Image:
         self.seed = -1
         self.a_prompt = 'best quality, extremely detailed'
         self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,' \
-                            ' fewer digits, cropped, worst quality, low quality'
+            ' fewer digits, cropped, worst quality, low quality'
 
     @prompts(name="Generate Image Condition On Segmentations",
              description="useful when you want to generate a new real image from both the user description and segmentations. "
@@ -677,7 +679,7 @@ class DepthText2Image:
         self.seed = -1
         self.a_prompt = 'best quality, extremely detailed'
         self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,' \
-                            ' fewer digits, cropped, worst quality, low quality'
+            ' fewer digits, cropped, worst quality, low quality'
 
     @prompts(name="Generate Image Condition On Depth",
              description="useful when you want to generate a new real image from both the user description and depth image. "
@@ -748,7 +750,7 @@ class NormalText2Image:
         self.seed = -1
         self.a_prompt = 'best quality, extremely detailed'
         self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,' \
-                            ' fewer digits, cropped, worst quality, low quality'
+            ' fewer digits, cropped, worst quality, low quality'
 
     @prompts(name="Generate Image Condition On Normal Map",
              description="useful when you want to generate a new real image from both the user description and normal map. "
@@ -800,7 +802,7 @@ class Segmenting:
         print(f"Inintializing Segmentation to {device}")
         self.device = device
         self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
-        self.model_checkpoint_path = os.path.join("checkpoints","sam")
+        self.model_checkpoint_path = os.path.join("checkpoints", "sam")
 
         self.download_parameters()
         self.sam = build_sam(checkpoint=self.model_checkpoint_path).to(device)
@@ -813,12 +815,10 @@ class Segmenting:
     def download_parameters(self):
         url = "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth"
         if not os.path.exists(self.model_checkpoint_path):
-            wget.download(url,out=self.model_checkpoint_path)
+            wget.download(url, out=self.model_checkpoint_path)
-
-        
-    def show_mask(self, mask: np.ndarray,image: np.ndarray,
-                random_color: bool = False, transparency=1) -> np.ndarray:
 
+    def show_mask(self, mask: np.ndarray, image: np.ndarray,
+                  random_color: bool = False, transparency=1) -> np.ndarray:
         """Visualize a mask on top of an image.
         Args:
             mask (np.ndarray): A 2D array of shape (H, W).
@@ -839,16 +839,14 @@ class Segmenting:
 
         image = cv2.addWeighted(image, 0.7, mask_image.astype('uint8'), transparency, 0)
 
-
         return image
 
     def show_box(self, box, ax, label):
         x0, y0 = box[0], box[1]
         w, h = box[2] - box[0], box[3] - box[1]
-        ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2)) 
+        ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0, 0, 0, 0), lw=2))
         ax.text(x0, y0, label)
 
-    
     def get_mask_with_boxes(self, image_pil, image, boxes_filt):
 
         size = image_pil.size
@@ -862,10 +860,10 @@ class Segmenting:
         transformed_boxes = self.sam_predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(self.device)
 
         masks, _, _ = self.sam_predictor.predict_torch(
-            point_coords = None,
+            point_coords=None,
-            point_labels = None,
+            point_labels=None,
-            boxes = transformed_boxes.to(self.device),
+            boxes=transformed_boxes.to(self.device),
-            multimask_output = False,
+            multimask_output=False,
         )
         return masks
 
@@ -895,7 +893,7 @@ class Segmenting:
             self.sam_predictor.set_image(img)
 
     def show_points(self, coords: np.ndarray, labels: np.ndarray,
-                image: np.ndarray) -> np.ndarray:
+                    image: np.ndarray) -> np.ndarray:
         """Visualize points on top of an image.
 
         Args:
@@ -916,7 +914,6 @@ class Segmenting:
                 image, p.astype(int), radius=3, color=(255, 0, 0), thickness=-1)
         return image
 
-
     def segment_image_with_click(self, img, is_positive: bool):
 
         self.sam_predictor.set_image(img)
@@ -940,7 +937,7 @@ class Segmenting:
         return img
 
     def segment_image_with_coordinate(self, img, is_positive: bool,
-                            coordinate: tuple):
+                                      coordinate: tuple):
         '''
             Args:
                 img (numpy.ndarray): the given image, shape: H x W x 3.
@@ -971,7 +968,6 @@ class Segmenting:
                 multimask_output=False,
             )
 
-
         img = self.show_mask(masks[0], img, random_color=False, transparency=0.3)
 
         img = self.show_points(input_point, input_label, img)
@@ -989,11 +985,11 @@ class Segmenting:
                          "or perform segmentation on this image, "
                          "or segment all the object in this image."
                          "The input to this tool should be a string, representing the image_path")
-    def inference_all(self,image_path):
+    def inference_all(self, image_path):
         image = cv2.imread(image_path)
         image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
         masks = self.mask_generator.generate(image)
-        plt.figure(figsize=(20,20))
+        plt.figure(figsize=(20, 20))
         plt.imshow(image)
         if len(masks) == 0:
             return
@@ -1005,7 +1001,7 @@ class Segmenting:
             img = np.ones((m.shape[0], m.shape[1], 3))
             color_mask = np.random.random((1, 3)).tolist()[0]
             for i in range(3):
-                img[:,:,i] = color_mask[i]
+                img[:, :, i] = color_mask[i]
             ax.imshow(np.dstack((img, m)))
 
         updated_image_path = get_new_image_name(image_path, func_name="segment-image")
@@ -1016,13 +1012,14 @@ class Segmenting:
         )
         return updated_image_path
 
+
 class Text2Box:
     def __init__(self, device):
         print(f"Initializing ObjectDetection to {device}")
         self.device = device
         self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
-        self.model_checkpoint_path = os.path.join("checkpoints","groundingdino")
+        self.model_checkpoint_path = os.path.join("checkpoints", "groundingdino")
-        self.model_config_path = os.path.join("checkpoints","grounding_config.py")
+        self.model_config_path = os.path.join("checkpoints", "grounding_config.py")
         self.download_parameters()
         self.box_threshold = 0.3
         self.text_threshold = 0.25
@@ -1031,12 +1028,13 @@ class Text2Box:
     def download_parameters(self):
         url = "https://github.com/IDEA-Research/GroundingDINO/releases/download/v0.1.0-alpha/groundingdino_swint_ogc.pth"
         if not os.path.exists(self.model_checkpoint_path):
-            wget.download(url,out=self.model_checkpoint_path)
+            wget.download(url, out=self.model_checkpoint_path)
         config_url = "https://raw.githubusercontent.com/IDEA-Research/GroundingDINO/main/groundingdino/config/GroundingDINO_SwinT_OGC.py"
         if not os.path.exists(self.model_config_path):
-            wget.download(config_url,out=self.model_config_path)
+            wget.download(config_url, out=self.model_config_path)
-    def load_image(self,image_path):
+
-         # load image
+    def load_image(self, image_path):
+        # load image
         image_pil = Image.open(image_path).convert("RGB")  # load image
 
         transform = T.Compose(
@@ -1146,9 +1144,9 @@ class Text2Box:
 
         size = image_pil.size
         pred_dict = {
-        "boxes": boxes_filt,
+            "boxes": boxes_filt,
-        "size": [size[1], size[0]],  # H,W
+            "size": [size[1], size[0]],  # H,W
-        "labels": pred_phrases,}
+            "labels": pred_phrases, }
 
         image_with_box = self.plot_boxes_to_image(image_pil, pred_dict)[0]
 
@@ -1168,14 +1166,17 @@ class Inpainting:
         self.torch_dtype = torch.float16 if 'cuda' in self.device else torch.float32
 
         self.inpaint = StableDiffusionInpaintPipeline.from_pretrained(
-            "runwayml/stable-diffusion-inpainting", revision=self.revision, torch_dtype=self.torch_dtype,safety_checker=StableDiffusionSafetyChecker.from_pretrained('CompVis/stable-diffusion-safety-checker')).to(device)
+            "runwayml/stable-diffusion-inpainting", revision=self.revision, torch_dtype=self.torch_dtype, safety_checker=StableDiffusionSafetyChecker.from_pretrained('CompVis/stable-diffusion-safety-checker')).to(device)
+
     def __call__(self, prompt, image, mask_image, height=512, width=512, num_inference_steps=50):
         update_image = self.inpaint(prompt=prompt, image=image.resize((width, height)),
-                                     mask_image=mask_image.resize((width, height)), height=height, width=width, num_inference_steps=num_inference_steps).images[0]
+                                    mask_image=mask_image.resize((width, height)), height=height, width=width, num_inference_steps=num_inference_steps).images[0]
         return update_image
 
+
 class InfinityOutPainting:
-    template_model = True # Add this line to show this is a template model.
+    template_model = True  # Add this line to show this is a template model.
+
     def __init__(self, ImageCaptioning, Inpainting, VisualQuestionAnswering):
         self.llm = OpenAI(temperature=0)
         self.ImageCaption = ImageCaptioning
@@ -1195,7 +1196,7 @@ class InfinityOutPainting:
 
     def get_BLIP_caption(self, image):
         inputs = self.ImageCaption.processor(image, return_tensors="pt").to(self.ImageCaption.device,
-                                                                                self.ImageCaption.torch_dtype)
+                                                                            self.ImageCaption.torch_dtype)
         out = self.ImageCaption.model.generate(**inputs)
         BLIP_caption = self.ImageCaption.processor.decode(out[0], skip_special_tokens=True)
         return BLIP_caption
@@ -1247,8 +1248,8 @@ class InfinityOutPainting:
             temp_mask.paste(0, (x, y, x + old_img.width, y + old_img.height))
             resized_temp_canvas, resized_temp_mask = self.resize_image(temp_canvas), self.resize_image(temp_mask)
             image = self.inpaint(prompt=prompt, image=resized_temp_canvas, mask_image=resized_temp_mask,
-                                              height=resized_temp_canvas.height, width=resized_temp_canvas.width,
+                                 height=resized_temp_canvas.height, width=resized_temp_canvas.width,
-                                              num_inference_steps=50).resize(
+                                 num_inference_steps=50).resize(
                 (temp_canvas.width, temp_canvas.height), Image.ANTIALIAS)
             image = blend_gt2pt(old_img, image)
             old_img = image
@@ -1272,29 +1273,28 @@ class InfinityOutPainting:
         return updated_image_path
 
 
-
 class ObjectSegmenting:
-    template_model = True # Add this line to show this is a template model.
+    template_model = True  # Add this line to show this is a template model.
-    def __init__(self,  Text2Box:Text2Box, Segmenting:Segmenting):
+
+    def __init__(self, Text2Box: Text2Box, Segmenting: Segmenting):
         # self.llm = OpenAI(temperature=0)
         self.grounding = Text2Box
         self.sam = Segmenting
 
-
     @prompts(name="Segment the given object",
-            description="useful when you only want to segment the certain objects in the picture"
+             description="useful when you only want to segment the certain objects in the picture"
-                        "according to the given text"  
+             "according to the given text"
-                        "like: segment the cat,"
+             "like: segment the cat,"
-                        "or can you segment an obeject for me"
+             "or can you segment an obeject for me"
-                        "The input to this tool should be a comma separated string of two, "
+             "The input to this tool should be a comma separated string of two, "
-                        "representing the image_path, the text description of the object to be found")
+             "representing the image_path, the text description of the object to be found")
     def inference(self, inputs):
         image_path, det_prompt = inputs.split(",")
         print(f"image_path={image_path}, text_prompt={det_prompt}")
         image_pil, image = self.grounding.load_image(image_path)
 
         boxes_filt, pred_phrases = self.grounding.get_grounding_boxes(image, det_prompt)
-        updated_image_path = self.sam.segment_image_with_boxes(image_pil,image_path,boxes_filt,pred_phrases)
+        updated_image_path = self.sam.segment_image_with_boxes(image_pil, image_path, boxes_filt, pred_phrases)
         print(
             f"\nProcessed ObejectSegmenting, Input Image: {image_path}, Object to be Segment {det_prompt}, "
             f"Output Image: {updated_image_path}")
@@ -1310,7 +1310,7 @@ class ObjectSegmenting:
         if type(masks) == torch.Tensor:
             x = masks
         elif type(masks) == np.ndarray:
-            x = torch.tensor(masks,dtype=int)
+            x = torch.tensor(masks, dtype=int)
         else:
             raise TypeError("the type of the input masks must be numpy.ndarray or torch.tensor")
         x = x.squeeze(dim=1)
@@ -1341,7 +1341,6 @@ class ObjectSegmenting:
         for mask in masks:
             image = self.sam.show_mask(mask[0].cpu().numpy(), image, random_color=True, transparency=0.3)
 
-
         Image.fromarray(merged_mask)
 
         return merged_mask
@@ -1349,14 +1348,15 @@ class ObjectSegmenting:
 
 class ImageEditing:
     template_model = True
-    def __init__(self, Text2Box:Text2Box, Segmenting:Segmenting, Inpainting:Inpainting):
+
+    def __init__(self, Text2Box: Text2Box, Segmenting: Segmenting, Inpainting: Inpainting):
         print("Initializing ImageEditing")
         self.sam = Segmenting
         self.grounding = Text2Box
         self.inpaint = Inpainting
 
-    def pad_edge(self,mask,padding):
+    def pad_edge(self, mask, padding):
-        #mask Tensor [H,W]
+        # mask Tensor [H,W]
         mask = mask.numpy()
         true_indices = np.argwhere(mask)
         mask_array = np.zeros_like(mask, dtype=bool)
@@ -1364,7 +1364,7 @@ class ImageEditing:
             padded_slice = tuple(slice(max(0, i - padding), i + padding + 1) for i in idx)
             mask_array[padded_slice] = True
         new_mask = (mask_array * 255).astype(np.uint8)
-        #new_mask
+        # new_mask
         return new_mask
 
     @prompts(name="Remove Something From The Photo",
@@ -1377,11 +1377,11 @@ class ImageEditing:
         return self.inference_replace_sam(f"{image_path},{to_be_removed_txt},background")
 
     @prompts(name="Replace Something From The Photo",
-            description="useful when you want to replace an object from the object description or "
+             description="useful when you want to replace an object from the object description or "
-                        "location with another object from its description. "
+             "location with another object from its description. "
-                        "The input to this tool should be a comma separated string of three, "
+             "The input to this tool should be a comma separated string of three, "
-                        "representing the image_path, the object to be replaced, the object to be replaced with ")
+             "representing the image_path, the object to be replaced, the object to be replaced with ")
-    def inference_replace_sam(self,inputs):
+    def inference_replace_sam(self, inputs):
         image_path, to_be_replaced_txt, replace_with_txt = inputs.split(",")
 
         print(f"image_path={image_path}, to_be_replaced_txt={to_be_replaced_txt}")
@@ -1393,9 +1393,9 @@ class ImageEditing:
         masks = self.sam.get_mask_with_boxes(image_pil, image, boxes_filt)
         mask = torch.sum(masks, dim=0).unsqueeze(0)
         mask = torch.where(mask > 0, True, False)
-        mask = mask.squeeze(0).squeeze(0).cpu() #tensor
+        mask = mask.squeeze(0).squeeze(0).cpu()  # tensor
 
-        mask = self.pad_edge(mask,padding=20) #numpy
+        mask = self.pad_edge(mask, padding=20)  # numpy
         mask_image = Image.fromarray(mask)
 
         updated_image = self.inpaint(prompt=replace_with_txt, image=image_pil,
@@ -1408,19 +1408,21 @@ class ImageEditing:
             f"Output Image: {updated_image_path}")
         return updated_image_path
 
+
 class BackgroundRemoving:
     '''
         using to remove the background of the given picture
     '''
     template_model = True
-    def __init__(self,VisualQuestionAnswering:VisualQuestionAnswering, Text2Box:Text2Box, Segmenting:Segmenting):
+
+    def __init__(self, VisualQuestionAnswering: VisualQuestionAnswering, Text2Box: Text2Box, Segmenting: Segmenting):
         self.vqa = VisualQuestionAnswering
-        self.obj_segmenting = ObjectSegmenting(Text2Box,Segmenting)
+        self.obj_segmenting = ObjectSegmenting(Text2Box, Segmenting)
 
     @prompts(name="Remove the background",
              description="useful when you want to extract the object or remove the background,"
                          "the input should be a string image_path"
-                                )
+             )
     def inference(self, image_path):
         '''
             given a image, return the picture only contains the extracted main object
@@ -1450,7 +1452,7 @@ class BackgroundRemoving:
         vqa_input = f"{image_path}, what is the main object in the image?"
         text_prompt = self.vqa.inference(vqa_input)
 
-        mask = self.obj_segmenting.get_mask(image_path,text_prompt)
+        mask = self.obj_segmenting.get_mask(image_path, text_prompt)
 
         return mask
 
@@ -1476,7 +1478,7 @@ class MultiModalVisualAgent:
         for class_name, module in globals().items():
             if getattr(module, 'template_model', False):
                 template_required_names = {
-                    k for k in inspect.signature(module.__init__).parameters.keys() if k!='self'
+                    k for k in inspect.signature(module.__init__).parameters.keys() if k != 'self'
                 }
 
                 loaded_names = set([type(e).__name__ for e in self.models.values()])
@@ -1509,7 +1511,7 @@ class MultiModalVisualAgent:
         agent_suffix = self.suffix
         agent_format_instructions = self.format_instructions
 
-        if lang=='English':
+        if lang == 'English':
             PREFIX, FORMAT_INSTRUCTIONS, SUFFIX = agent_prefix, agent_format_instructions, agent_suffix
         else:
             PREFIX, FORMAT_INSTRUCTIONS, SUFFIX = VISUAL_AGENT_PREFIX_CN, VISUAL_AGENT_FORMAT_INSTRUCTIONS_CN, VISUAL_AGENT_SUFFIX_CN
@@ -1578,10 +1580,7 @@ class MultiModalVisualAgent:
         self.memory.clear()
 
 
-
+# usage
-
-###### usage
-from swarms.agents.message import Message
 
 
 class MultiModalAgent:
@@ -1619,6 +1618,7 @@ class MultiModalAgent:
 
 
     """
+
     def __init__(
         self,
         load_dict,
@@ -1641,11 +1641,10 @@ class MultiModalAgent:
         self.language = language
         self.history = []
 
-    
     def run_text(
         self,
         text: str = None,
-        language = "english"
+        language="english"
     ):
         """Run text through the model"""
 
@@ -1661,7 +1660,7 @@ class MultiModalAgent:
     def run_img(
         self,
         image_path: str,
-        language = "english"
+        language="english"
     ):
         """If language is None"""
         if language is None:
@@ -1701,7 +1700,7 @@ class MultiModalAgent:
         if language is None:
             language = self.default_language
 
-        #add users message to the history
+        # add users message to the history
         self.history.append(
             Message(
                 "User",
@@ -1709,12 +1708,12 @@ class MultiModalAgent:
             )
         )
 
-        #process msg
+        # process msg
         try:
             self.agent.init_agent(language)
             response = self.agent.run_text(msg)
 
-            #add agent's response to the history
+            # add agent's response to the history
             self.history.append(
                 Message(
                     "Agent",
@@ -1722,7 +1721,7 @@ class MultiModalAgent:
                 )
             )
 
-            #if streaming is = True
+            # if streaming is = True
             if streaming:
                 return self._stream_response(response)
             else:
@@ -1731,7 +1730,7 @@ class MultiModalAgent:
         except Exception as error:
             error_message = f"Error processing message: {str(error)}"
 
-            #add error to history
+            # add error to history
             self.history.append(
                 Message(
                     "Agent",
@@ -1762,5 +1761,3 @@ class MultiModalAgent:
             self.agent.clear_memory()
         except Exception as e:
             return f"Error cleaning memory: {str(e)}"
-    
-

swarms/agents/multi_modal_workers/omni_agent/get_token_ids.py

@@ -34,18 +34,22 @@ max_length = {
     "ada": 2049
 }
 
+
 def count_tokens(model_name, text):
     return len(encodings[model_name].encode(text))
 
+
 def get_max_context_length(model_name):
     return max_length[model_name]
 
+
 def get_token_ids_for_task_parsing(model_name):
     text = '''{"task": "text-classification",  "token-classification", "text2text-generation", "summarization", "translation",  "question-answering", "conversational", "text-generation", "sentence-similarity", "tabular-classification", "object-detection", "image-classification", "image-to-image", "image-to-text", "text-to-image", "visual-question-answering", "document-question-answering", "image-segmentation", "text-to-speech", "text-to-video", "automatic-speech-recognition", "audio-to-audio", "audio-classification", "canny-control", "hed-control", "mlsd-control", "normal-control", "openpose-control", "canny-text-to-image", "depth-text-to-image", "hed-text-to-image", "mlsd-text-to-image", "normal-text-to-image", "openpose-text-to-image", "seg-text-to-image", "args", "text", "path", "dep", "id", "<GENERATED>-"}'''
     res = encodings[model_name].encode(text)
     res = list(set(res))
     return res
 
+
 def get_token_ids_for_choose_model(model_name):
     text = '''{"id": "reason"}'''
     res = encodings[model_name].encode(text)

swarms/agents/multi_modal_workers/omni_agent/model_server.py

@@ -56,8 +56,7 @@ from transformers import (
 )
 
 
-
+# logs
-#logs
 warnings.filterwarnings("ignore")
 parser = argparse.ArgumentParser()
 parser.add_argument("--config", type=str, default="configs/config.default.yaml")
@@ -100,7 +99,7 @@ def load_pipes(local_deployment):
     controlnet_sd_pipes = {}
     if local_deployment in ["full"]:
         other_pipes = {
-            "nlpconnect/vit-gpt2-image-captioning":{
+            "nlpconnect/vit-gpt2-image-captioning": {
                 "model": VisionEncoderDecoderModel.from_pretrained(f"{local_fold}/nlpconnect/vit-gpt2-image-captioning"),
                 "feature_extractor": ViTImageProcessor.from_pretrained(f"{local_fold}/nlpconnect/vit-gpt2-image-captioning"),
                 "tokenizer": AutoTokenizer.from_pretrained(f"{local_fold}/nlpconnect/vit-gpt2-image-captioning"),
@@ -139,7 +138,7 @@ def load_pipes(local_deployment):
                 "device": device
             },
             "lambdalabs/sd-image-variations-diffusers": {
-                "model": DiffusionPipeline.from_pretrained(f"{local_fold}/lambdalabs/sd-image-variations-diffusers"), #torch_dtype=torch.float16
+                "model": DiffusionPipeline.from_pretrained(f"{local_fold}/lambdalabs/sd-image-variations-diffusers"),  # torch_dtype=torch.float16
                 "device": device
             },
             # "CompVis/stable-diffusion-v1-4": {
@@ -165,7 +164,7 @@ def load_pipes(local_deployment):
             #     "model": WaveformEnhancement.from_hparams(source="speechbrain/mtl-mimic-voicebank", savedir="models/mtl-mimic-voicebank"),
             #     "device": device
             # },
-            "microsoft/speecht5_vc":{
+            "microsoft/speecht5_vc": {
                 "processor": SpeechT5Processor.from_pretrained(f"{local_fold}/microsoft/speecht5_vc"),
                 "model": SpeechT5ForSpeechToSpeech.from_pretrained(f"{local_fold}/microsoft/speecht5_vc"),
                 "vocoder": SpeechT5HifiGan.from_pretrained(f"{local_fold}/microsoft/speecht5_hifigan"),
@@ -295,7 +294,6 @@ def load_pipes(local_deployment):
             model.load_state_dict(torch.load(f"{local_fold}/lllyasviel/ControlNet/annotator/ckpts/mlsd_large_512_fp32.pth"), strict=True)
             return MLSDdetector(model)
 
-
         hed_network = Network(f"{local_fold}/lllyasviel/ControlNet/annotator/ckpts/network-bsds500.pth")
 
         controlnet_sd_pipes = {
@@ -317,37 +315,37 @@ def load_pipes(local_deployment):
             "canny-control": {
                 "model": CannyDetector()
             },
-            "lllyasviel/sd-controlnet-canny":{
+            "lllyasviel/sd-controlnet-canny": {
                 "control": controlnet,
                 "model": controlnetpipe,
                 "device": device
             },
-            "lllyasviel/sd-controlnet-depth":{
+            "lllyasviel/sd-controlnet-depth": {
                 "control": ControlNetModel.from_pretrained(f"{local_fold}/lllyasviel/sd-controlnet-depth", torch_dtype=torch.float16),
                 "model": controlnetpipe,
                 "device": device
             },
-            "lllyasviel/sd-controlnet-hed":{
+            "lllyasviel/sd-controlnet-hed": {
                 "control": ControlNetModel.from_pretrained(f"{local_fold}/lllyasviel/sd-controlnet-hed", torch_dtype=torch.float16),
                 "model": controlnetpipe,
                 "device": device
             },
-            "lllyasviel/sd-controlnet-mlsd":{
+            "lllyasviel/sd-controlnet-mlsd": {
                 "control": ControlNetModel.from_pretrained(f"{local_fold}/lllyasviel/sd-controlnet-mlsd", torch_dtype=torch.float16),
                 "model": controlnetpipe,
                 "device": device
             },
-            "lllyasviel/sd-controlnet-openpose":{
+            "lllyasviel/sd-controlnet-openpose": {
                 "control": ControlNetModel.from_pretrained(f"{local_fold}/lllyasviel/sd-controlnet-openpose", torch_dtype=torch.float16),
                 "model": controlnetpipe,
                 "device": device
             },
-            "lllyasviel/sd-controlnet-scribble":{
+            "lllyasviel/sd-controlnet-scribble": {
                 "control": ControlNetModel.from_pretrained(f"{local_fold}/lllyasviel/sd-controlnet-scribble", torch_dtype=torch.float16),
                 "model": controlnetpipe,
                 "device": device
             },
-            "lllyasviel/sd-controlnet-seg":{
+            "lllyasviel/sd-controlnet-seg": {
                 "control": ControlNetModel.from_pretrained(f"{local_fold}/lllyasviel/sd-controlnet-seg", torch_dtype=torch.float16),
                 "model": controlnetpipe,
                 "device": device
@@ -356,6 +354,7 @@ def load_pipes(local_deployment):
     pipes = {**standard_pipes, **other_pipes, **controlnet_sd_pipes}
     return pipes
 
+
 pipes = load_pipes(local_deployment)
 
 end = time.time()
@@ -363,10 +362,12 @@ during = end - start
 
 print(f"[ ready ] {during}s")
 
+
 @app.route('/running', methods=['GET'])
 def running():
     return jsonify({"running": True})
 
+
 @app.route('/status/<path:model_id>', methods=['GET'])
 def status(model_id):
     disabled_models = ["microsoft/trocr-base-printed", "microsoft/trocr-base-handwritten"]
@@ -377,6 +378,7 @@ def status(model_id):
         print(f"[ check {model_id} ] failed")
         return jsonify({"loaded": False})
 
+
 @app.route('/models/<path:model_id>', methods=['POST'])
 def models(model_id):
     while "using" in pipes[model_id] and pipes[model_id]["using"]:
@@ -392,7 +394,7 @@ def models(model_id):
     if "device" in pipes[model_id]:
         try:
             pipe.to(pipes[model_id]["device"])
-        except:
+        except BaseException:
             pipe.device = torch.device(pipes[model_id]["device"])
             pipe.model.to(pipes[model_id]["device"])
 
@@ -424,7 +426,7 @@ def models(model_id):
         if model_id.endswith("-control"):
             image = load_image(request.get_json()["img_url"])
             if "scribble" in model_id:
-                control = pipe(image, scribble = True)
+                control = pipe(image, scribble=True)
             elif "canny" in model_id:
                 control = pipe(image, low_threshold=100, high_threshold=200)
             else:
@@ -445,10 +447,10 @@ def models(model_id):
                     (224, 224),
                     interpolation=transforms.InterpolationMode.BICUBIC,
                     antialias=False,
-                    ),
+                ),
                 transforms.Normalize(
-                [0.48145466, 0.4578275, 0.40821073],
+                    [0.48145466, 0.4578275, 0.40821073],
-                [0.26862954, 0.26130258, 0.27577711]),
+                    [0.26862954, 0.26130258, 0.27577711]),
             ])
             inp = tform(im).to(pipes[model_id]["device"]).unsqueeze(0)
             out = pipe(inp, guidance_scale=3)
@@ -475,7 +477,7 @@ def models(model_id):
             generated_text = pipes[model_id]["tokenizer"].batch_decode(generated_ids, skip_special_tokens=True)[0]
             result = {"generated text": generated_text}
         # image to text: OCR
-        if model_id == "microsoft/trocr-base-printed" or  model_id == "microsoft/trocr-base-handwritten":
+        if model_id == "microsoft/trocr-base-printed" or model_id == "microsoft/trocr-base-handwritten":
             image = load_image(request.get_json()["img_url"]).convert("RGB")
             pixel_values = pipes[model_id]["processor"](image, return_tensors="pt").pixel_values
             pixel_values = pixel_values.to(pipes[model_id]["device"])
@@ -503,7 +505,7 @@ def models(model_id):
             img_url = request.get_json()["img_url"]
             result = pipe(question=question, image=img_url)
 
-        #DQA
+        # DQA
         if model_id == "impira/layoutlm-document-qa":
             question = request.get_json()["text"]
             img_url = request.get_json()["img_url"]
@@ -558,7 +560,7 @@ def models(model_id):
         # ASR
         if model_id == "openai/whisper-base" or model_id == "microsoft/speecht5_asr":
             audio_url = request.get_json()["audio_url"]
-            result = { "text": pipe(audio_url)["text"]}
+            result = {"text": pipe(audio_url)["text"]}
 
         # audio to audio
         if model_id == "JorisCos/DCCRNet_Libri1Mix_enhsingle_16k":
@@ -621,7 +623,7 @@ def models(model_id):
         try:
             pipe.to("cpu")
             torch.cuda.empty_cache()
-        except:
+        except BaseException:
             pipe.device = torch.device("cpu")
             pipe.model.to("cpu")
             torch.cuda.empty_cache()

swarms/agents/multi_modal_workers/omni_agent/omni_chat.py

@@ -22,7 +22,7 @@ from huggingface_hub.inference_api import InferenceApi
 from PIL import Image, ImageDraw
 from pydub import AudioSegment
 
-#tokenizations
+# tokenizations
 encodings = {
     "gpt-4": tiktoken.get_encoding("cl100k_base"),
     "gpt-4-32k": tiktoken.get_encoding("cl100k_base"),
@@ -57,18 +57,22 @@ max_length = {
     "ada": 2049
 }
 
+
 def count_tokens(model_name, text):
     return len(encodings[model_name].encode(text))
 
+
 def get_max_context_length(model_name):
     return max_length[model_name]
 
+
 def get_token_ids_for_task_parsing(model_name):
     text = '''{"task": "text-classification",  "token-classification", "text2text-generation", "summarization", "translation",  "question-answering", "conversational", "text-generation", "sentence-similarity", "tabular-classification", "object-detection", "image-classification", "image-to-image", "image-to-text", "text-to-image", "visual-question-answering", "document-question-answering", "image-segmentation", "text-to-speech", "text-to-video", "automatic-speech-recognition", "audio-to-audio", "audio-classification", "canny-control", "hed-control", "mlsd-control", "normal-control", "openpose-control", "canny-text-to-image", "depth-text-to-image", "hed-text-to-image", "mlsd-text-to-image", "normal-text-to-image", "openpose-text-to-image", "seg-text-to-image", "args", "text", "path", "dep", "id", "<GENERATED>-"}'''
     res = encodings[model_name].encode(text)
     res = list(set(res))
     return res
 
+
 def get_token_ids_for_choose_model(model_name):
     text = '''{"id": "reason"}'''
     res = encodings[model_name].encode(text)
@@ -76,13 +80,7 @@ def get_token_ids_for_choose_model(model_name):
     return res
 
 
-
-
-
-
-
 #########
-
 parser = argparse.ArgumentParser()
 parser.add_argument("--config", type=str, default="swarms/agents/workers/multi_modal_workers/omni_agent/config.yml")
 parser.add_argument("--mode", type=str, default="cli")
@@ -176,14 +174,14 @@ inference_mode = config["inference_mode"]
 
 # check the local_inference_endpoint
 Model_Server = None
-if inference_mode!="huggingface":
+if inference_mode != "huggingface":
     Model_Server = "http://" + config["local_inference_endpoint"]["host"] + ":" + str(config["local_inference_endpoint"]["port"])
     message = f"The server of local inference endpoints is not running, please start it first. (or using `inference_mode: huggingface` in {args.config} for a feature-limited experience)"
     try:
         r = requests.get(Model_Server + "/running")
         if r.status_code != 200:
             raise ValueError(message)
-    except:
+    except BaseException:
         raise ValueError(message)
 
 
@@ -222,6 +220,7 @@ elif "HUGGINGFACE_ACCESS_TOKEN" in os.environ and os.getenv("HUGGINGFACE_ACCESS_
 else:
     raise ValueError(f"Incorrect HuggingFace token. Please check your {args.config} file.")
 
+
 def convert_chat_to_completion(data):
     messages = data.pop('messages', [])
     tprompt = ""
@@ -231,11 +230,11 @@ def convert_chat_to_completion(data):
     final_prompt = ""
     for message in messages:
         if message['role'] == "user":
-            final_prompt += ("<im_start>"+ "user" + "\n" + message['content'] + "<im_end>\n")
+            final_prompt += ("<im_start>" + "user" + "\n" + message['content'] + "<im_end>\n")
         elif message['role'] == "assistant":
-            final_prompt += ("<im_start>"+ "assistant" + "\n" + message['content'] + "<im_end>\n")
+            final_prompt += ("<im_start>" + "assistant" + "\n" + message['content'] + "<im_end>\n")
         else:
-            final_prompt += ("<im_start>"+ "system" + "\n" + message['content'] + "<im_end>\n")
+            final_prompt += ("<im_start>" + "system" + "\n" + message['content'] + "<im_end>\n")
     final_prompt = tprompt + final_prompt
     final_prompt = final_prompt + "<im_start>assistant"
     data["prompt"] = final_prompt
@@ -243,6 +242,7 @@ def convert_chat_to_completion(data):
     data['max_tokens'] = data.get('max_tokens', max(get_max_context_length(LLM) - count_tokens(LLM_encoding, final_prompt), 1))
     return data
 
+
 def send_request(data):
     api_key = data.pop("api_key")
     api_type = data.pop("api_type")
@@ -269,36 +269,41 @@ def send_request(data):
     else:
         return response.json()["choices"][0]["message"]["content"].strip()
 
+
 def replace_slot(text, entries):
     for key, value in entries.items():
         if not isinstance(value, str):
             value = str(value)
-        text = text.replace("{{" + key +"}}", value.replace('"', "'").replace('\n', ""))
+        text = text.replace("{{" + key + "}}", value.replace('"', "'").replace('\n', ""))
     return text
 
+
 def find_json(s):
     s = s.replace("\'", "\"")
     start = s.find("{")
     end = s.rfind("}")
-    res = s[start:end+1]
+    res = s[start:end + 1]
     res = res.replace("\n", "")
     return res
 
+
 def field_extract(s, field):
     try:
         field_rep = re.compile(f'{field}.*?:.*?"(.*?)"', re.IGNORECASE)
         extracted = field_rep.search(s).group(1).replace("\"", "\'")
-    except:
+    except BaseException:
         field_rep = re.compile(f'{field}:\ *"(.*?)"', re.IGNORECASE)
         extracted = field_rep.search(s).group(1).replace("\"", "\'")
     return extracted
 
+
 def get_id_reason(choose_str):
     reason = field_extract(choose_str, "reason")
     id = field_extract(choose_str, "id")
     choose = {"id": id, "reason": reason}
     return id.strip(), reason.strip(), choose
 
+
 def record_case(success, **args):
     if success:
         f = open("logs/log_success.jsonl", "a")
@@ -308,6 +313,7 @@ def record_case(success, **args):
     f.write(json.dumps(log) + "\n")
     f.close()
 
+
 def image_to_bytes(img_url):
     img_byte = io.BytesIO()
     img_url.split(".")[-1]
@@ -315,6 +321,7 @@ def image_to_bytes(img_url):
     img_data = img_byte.getvalue()
     return img_data
 
+
 def resource_has_dep(command):
     args = command["args"]
     for _, v in args.items():
@@ -322,6 +329,7 @@ def resource_has_dep(command):
             return True
     return False
 
+
 def fix_dep(tasks):
     for task in tasks:
         args = task["args"]
@@ -335,6 +343,7 @@ def fix_dep(tasks):
             task["dep"] = [-1]
     return tasks
 
+
 def unfold(tasks):
     flag_unfold_task = False
     try:
@@ -361,6 +370,7 @@ def unfold(tasks):
 
     return tasks
 
+
 def chitchat(messages, api_key, api_type, api_endpoint):
     data = {
         "model": LLM,
@@ -371,6 +381,7 @@ def chitchat(messages, api_key, api_type, api_endpoint):
     }
     return send_request(data)
 
+
 def parse_task(context, input, api_key, api_type, api_endpoint):
     demos_or_presteps = parse_task_demos_or_presteps
     messages = json.loads(demos_or_presteps)
@@ -404,6 +415,7 @@ def parse_task(context, input, api_key, api_type, api_endpoint):
     }
     return send_request(data)
 
+
 def choose_model(input, task, metas, api_key, api_type, api_endpoint):
     prompt = replace_slot(choose_model_prompt, {
         "input": input,
@@ -423,7 +435,7 @@ def choose_model(input, task, metas, api_key, api_type, api_endpoint):
         "model": LLM,
         "messages": messages,
         "temperature": 0,
-        "logit_bias": {item: config["logit_bias"]["choose_model"] for item in choose_model_highlight_ids}, # 5
+        "logit_bias": {item: config["logit_bias"]["choose_model"] for item in choose_model_highlight_ids},  # 5
         "api_key": api_key,
         "api_type": api_type,
         "api_endpoint": api_endpoint
@@ -454,18 +466,19 @@ def response_results(input, results, api_key, api_type, api_endpoint):
     }
     return send_request(data)
 
+
 def huggingface_model_inference(model_id, data, task):
-    task_url = f"https://api-inference.huggingface.co/models/{model_id}" # InferenceApi does not yet support some tasks
+    task_url = f"https://api-inference.huggingface.co/models/{model_id}"  # InferenceApi does not yet support some tasks
     inference = InferenceApi(repo_id=model_id, token=config["huggingface"]["token"])
 
     # NLP tasks
     if task == "question-answering":
-        inputs = {"question": data["text"], "context": (data["context"] if "context" in data else "" )}
+        inputs = {"question": data["text"], "context": (data["context"] if "context" in data else "")}
         result = inference(inputs)
     if task == "sentence-similarity":
         inputs = {"source_sentence": data["text1"], "target_sentence": data["text2"]}
         result = inference(inputs)
-    if task in ["text-classification",  "token-classification", "text2text-generation", "summarization", "translation", "conversational", "text-generation"]:
+    if task in ["text-classification", "token-classification", "text2text-generation", "summarization", "translation", "conversational", "text-generation"]:
         inputs = data["text"]
         result = inference(inputs)
 
@@ -537,7 +550,7 @@ def huggingface_model_inference(model_id, data, task):
         for label in predicted:
             box = label["box"]
             draw.rectangle(((box["xmin"], box["ymin"]), (box["xmax"], box["ymax"])), outline=color_map[label["label"]], width=2)
-            draw.text((box["xmin"]+5, box["ymin"]-15), label["label"], fill=color_map[label["label"]])
+            draw.text((box["xmin"] + 5, box["ymin"] - 15), label["label"], fill=color_map[label["label"]])
         name = str(uuid.uuid4())[:4]
         image.save(f"public/images/{name}.jpg")
         result = {}
@@ -586,6 +599,7 @@ def huggingface_model_inference(model_id, data, task):
             result = {"generated audio": f"/audios/{name}.{type}"}
     return result
 
+
 def local_model_inference(model_id, data, task):
     task_url = f"{Model_Server}/models/{model_id}"
 
@@ -617,7 +631,7 @@ def local_model_inference(model_id, data, task):
     if task == "question-answering" or task == "sentence-similarity":
         response = requests.post(task_url, json=data)
         return response.json()
-    if task in ["text-classification",  "token-classification", "text2text-generation", "summarization", "translation", "conversational", "text-generation"]:
+    if task in ["text-classification", "token-classification", "text2text-generation", "summarization", "translation", "conversational", "text-generation"]:
         response = requests.post(task_url, json=data)
         return response.json()
 
@@ -664,7 +678,7 @@ def local_model_inference(model_id, data, task):
         for label in predicted:
             box = label["box"]
             draw.rectangle(((box["xmin"], box["ymin"]), (box["xmax"], box["ymax"])), outline=color_map[label["label"]], width=2)
-            draw.text((box["xmin"]+5, box["ymin"]-15), label["label"], fill=color_map[label["label"]])
+            draw.text((box["xmin"] + 5, box["ymin"] - 15), label["label"], fill=color_map[label["label"]])
         name = str(uuid.uuid4())[:4]
         image.save(f"public/images/{name}.jpg")
         results = {}
@@ -713,11 +727,11 @@ def model_inference(model_id, data, hosted_on, task):
     except Exception as e:
         print(e)
         traceback.print_exc()
-        inference_result = {"error":{"message": str(e)}}
+        inference_result = {"error": {"message": str(e)}}
     return inference_result
 
 
-def get_model_status(model_id, url, headers, queue = None):
+def get_model_status(model_id, url, headers, queue=None):
     endpoint_type = "huggingface" if "huggingface" in url else "local"
     if "huggingface" in url:
         r = requests.get(url, headers=headers, proxies=PROXY)
@@ -732,6 +746,7 @@ def get_model_status(model_id, url, headers, queue = None):
             queue.put((model_id, False, None))
         return False
 
+
 def get_avaliable_models(candidates, topk=5):
     all_available_models = {"local": [], "huggingface": []}
     threads = []
@@ -766,6 +781,7 @@ def get_avaliable_models(candidates, topk=5):
 
     return all_available_models
 
+
 def collect_result(command, choose, inference_result):
     result = {"task": command}
     result["inference result"] = inference_result
@@ -865,11 +881,11 @@ def run_task(input, command, results, api_key, api_type, api_endpoint):
             logger.debug(f"chosen model: {choose}")
         else:
             logger.warning(f"Task {command['task']} is not available. ControlNet need to be deployed locally.")
-            record_case(success=False, **{"input": input, "task": command, "reason": f"Task {command['task']} is not available. ControlNet need to be deployed locally.", "op":"message"})
+            record_case(success=False, **{"input": input, "task": command, "reason": f"Task {command['task']} is not available. ControlNet need to be deployed locally.", "op": "message"})
             inference_result = {"error": "service related to ControlNet is not available."}
             results[id] = collect_result(command, "", inference_result)
             return False
-    elif task in ["summarization", "translation", "conversational", "text-generation", "text2text-generation"]: # ChatGPT Can do
+    elif task in ["summarization", "translation", "conversational", "text-generation", "text2text-generation"]:  # ChatGPT Can do
         best_model_id = "ChatGPT"
         reason = "ChatGPT performs well on some NLP tasks as well."
         choose = {"id": best_model_id, "reason": reason}
@@ -883,7 +899,7 @@ def run_task(input, command, results, api_key, api_type, api_endpoint):
     else:
         if task not in MODELS_MAP:
             logger.warning(f"no available models on {task} task.")
-            record_case(success=False, **{"input": input, "task": command, "reason": f"task not support: {command['task']}", "op":"message"})
+            record_case(success=False, **{"input": input, "task": command, "reason": f"task not support: {command['task']}", "op": "message"})
             inference_result = {"error": f"{command['task']} not found in available tasks."}
             results[id] = collect_result(command, "", inference_result)
             return False
@@ -895,7 +911,7 @@ def run_task(input, command, results, api_key, api_type, api_endpoint):
 
         if len(all_avaliable_model_ids) == 0:
             logger.warning(f"no available models on {command['task']}")
-            record_case(success=False, **{"input": input, "task": command, "reason": f"no available models: {command['task']}", "op":"message"})
+            record_case(success=False, **{"input": input, "task": command, "reason": f"no available models: {command['task']}", "op": "message"})
             inference_result = {"error": f"no available models on {command['task']} task."}
             results[id] = collect_result(command, "", inference_result)
             return False
@@ -932,30 +948,31 @@ def run_task(input, command, results, api_key, api_type, api_endpoint):
             except Exception:
                 logger.warning(f"the response [ {choose_str} ] is not a valid JSON, try to find the model id and reason in the response.")
                 choose_str = find_json(choose_str)
-                best_model_id, reason, choose  = get_id_reason(choose_str)
+                best_model_id, reason, choose = get_id_reason(choose_str)
                 hosted_on = "local" if best_model_id in all_avaliable_models["local"] else "huggingface"
     inference_result = model_inference(best_model_id, args, hosted_on, command['task'])
 
     if "error" in inference_result:
         logger.warning(f"Inference error: {inference_result['error']}")
-        record_case(success=False, **{"input": input, "task": command, "reason": f"inference error: {inference_result['error']}", "op":"message"})
+        record_case(success=False, **{"input": input, "task": command, "reason": f"inference error: {inference_result['error']}", "op": "message"})
         results[id] = collect_result(command, choose, inference_result)
         return False
 
     results[id] = collect_result(command, choose, inference_result)
     return True
 
-def chat_huggingface(messages, api_key, api_type, api_endpoint, return_planning = False, return_results = False):
+
+def chat_huggingface(messages, api_key, api_type, api_endpoint, return_planning=False, return_results=False):
     start = time.time()
     context = messages[:-1]
     input = messages[-1]["content"]
-    logger.info("*"*80)
+    logger.info("*" * 80)
     logger.info(f"input: {input}")
 
     task_str = parse_task(context, input, api_key, api_type, api_endpoint)
 
     if "error" in task_str:
-        record_case(success=False, **{"input": input, "task": task_str, "reason": f"task parsing error: {task_str['error']['message']}", "op":"report message"})
+        record_case(success=False, **{"input": input, "task": task_str, "reason": f"task parsing error: {task_str['error']['message']}", "op": "report message"})
         return {"message": task_str["error"]["message"]}
 
     task_str = task_str.strip()
@@ -966,7 +983,7 @@ def chat_huggingface(messages, api_key, api_type, api_endpoint, return_planning
     except Exception as e:
         logger.debug(e)
         response = chitchat(messages, api_key, api_type, api_endpoint)
-        record_case(success=False, **{"input": input, "task": task_str, "reason": "task parsing fail", "op":"chitchat"})
+        record_case(success=False, **{"input": input, "task": task_str, "reason": "task parsing fail", "op": "chitchat"})
         return {"message": response}
 
     if task_str == "[]":  # using LLM response for empty task
@@ -1028,10 +1045,11 @@ def chat_huggingface(messages, api_key, api_type, api_endpoint, return_planning
     during = end - start
 
     answer = {"message": response}
-    record_case(success=True, **{"input": input, "task": task_str, "results": results, "response": response, "during": during, "op":"response"})
+    record_case(success=True, **{"input": input, "task": task_str, "results": results, "response": response, "during": during, "op": "response"})
     logger.info(f"response: {response}")
     return answer
 
+
 def test():
     # single round examples
     inputs = [
@@ -1041,11 +1059,11 @@ def test():
         "please dub for me: 'Iron Man is a superhero appearing in American comic books published by Marvel Comics. The character was co-created by writer and editor Stan Lee, developed by scripter Larry Lieber, and designed by artists Don Heck and Jack Kirby.'"
         "Given an image: https://huggingface.co/datasets/mishig/sample_images/resolve/main/palace.jpg, please answer the question: What is on top of the building?",
         "Please generate a canny image based on /examples/f.jpg"
-        ]
+    ]
 
     for input in inputs:
         messages = [{"role": "user", "content": input}]
-        chat_huggingface(messages, API_KEY, API_TYPE, API_ENDPOINT, return_planning = False, return_results = False)
+        chat_huggingface(messages, API_KEY, API_TYPE, API_ENDPOINT, return_planning=False, return_results=False)
 
     # multi rounds example
     messages = [
@@ -1053,7 +1071,8 @@ def test():
         {"role": "assistant", "content": """Sure. I understand your request. Based on the inference results of the models, I have generated a canny image for you. The workflow I used is as follows: First, I used the image-to-text model (nlpconnect/vit-gpt2-image-captioning) to convert the image /examples/f.jpg to text. The generated text is "a herd of giraffes and zebras grazing in a field". Second, I used the canny-control model (canny-control) to generate a canny image from the text. Unfortunately, the model failed to generate the canny image. Finally, I used the canny-text-to-image model (lllyasviel/sd-controlnet-canny) to generate a canny image from the text. The generated image is located at /images/f16d.png. I hope this answers your request. Is there anything else I can help you with?"""},
         {"role": "user", "content": """then based on the above canny image and a prompt "a photo of a zoo", generate a new image."""},
     ]
-    chat_huggingface(messages, API_KEY, API_TYPE, API_ENDPOINT, return_planning = False, return_results = False)
+    chat_huggingface(messages, API_KEY, API_TYPE, API_ENDPOINT, return_planning=False, return_results=False)
+
 
 def cli():
     messages = []

swarms/agents/neural_architecture_search_worker.py

@@ -10,5 +10,3 @@ class Replicator:
 
     def run(self, task):
         pass
-
-

swarms/agents/omni_modal_agent.py

@@ -30,6 +30,7 @@ class Step:
         self.args = args
         self.tool = tool
 
+
 class Plan:
     def __init__(
         self,
@@ -44,9 +45,6 @@ class Plan:
         return str(self)
 
 
-
-
-
 class OmniModalAgent:
     """
     OmniModalAgent
@@ -72,6 +70,7 @@ class OmniModalAgent:
     agent = OmniModalAgent(llm)
     response = agent.run("Hello, how are you? Create an image of how your are doing!")
     """
+
     def __init__(
         self,
         llm: BaseLanguageModel,
@@ -105,7 +104,6 @@ class OmniModalAgent:
         # self.task_executor = TaskExecutor
         self.history = []
 
-
     def run(
         self,
         input: str
@@ -149,7 +147,7 @@ class OmniModalAgent:
 
         """
 
-        #add users message to the history
+        # add users message to the history
         self.history.append(
             Message(
                 "User",
@@ -157,11 +155,11 @@ class OmniModalAgent:
             )
         )
 
-        #process msg
+        # process msg
         try:
             response = self.agent.run(msg)
 
-            #add agent's response to the history
+            # add agent's response to the history
             self.history.append(
                 Message(
                     "Agent",
@@ -169,7 +167,7 @@ class OmniModalAgent:
                 )
             )
 
-            #if streaming is = True
+            # if streaming is = True
             if streaming:
                 return self._stream_response(response)
             else:
@@ -178,7 +176,7 @@ class OmniModalAgent:
         except Exception as error:
             error_message = f"Error processing message: {str(error)}"
 
-            #add error to history
+            # add error to history
             self.history.append(
                 Message(
                     "Agent",
@@ -203,5 +201,3 @@ class OmniModalAgent:
         """
         for token in response.split():
             yield token
-
-

swarms/agents/profitpilot.py

@@ -132,12 +132,6 @@ class SalesConversationChain(LLMChain):
         return cls(prompt=prompt, llm=llm, verbose=verbose)
 
 
-    
-
-
-
-
-
 # Set up a knowledge base
 def setup_knowledge_base(product_catalog: str = None):
     """
@@ -173,21 +167,19 @@ def get_tools(product_catalog):
             description="useful for when you need to answer questions about product information",
         ),
 
-        #Interpreter
+        # Interpreter
         Tool(
             name="Code Interepeter",
             func=compile,
             description="Useful when you need to run code locally, such as Python, Javascript, Shell, and more."
         )
 
-        #omnimodal agent
+        # omnimodal agent
     ]
 
     return tools
 
 
-
-
 class CustomPromptTemplateForTools(StringPromptTemplate):
     # The template to use
     template: str
@@ -238,7 +230,7 @@ class SalesConvoOutputParser(AgentOutputParser):
         regex = r"Action: (.*?)[\n]*Action Input: (.*)"
         match = re.search(regex, text)
         if not match:
-            ## TODO - this is not entirely reliable, sometimes results in an error.
+            # TODO - this is not entirely reliable, sometimes results in an error.
             return AgentFinish(
                 {
                     "output": "I apologize, I was unable to find the answer to your question. Is there anything else I can help with?"
@@ -405,7 +397,7 @@ class ProfitPilot(Chain, BaseModel):
             tool_names = [tool.name for tool in tools]
 
             # WARNING: this output parser is NOT reliable yet
-            ## It makes assumptions about output from LLM which can break and throw an error
+            # It makes assumptions about output from LLM which can break and throw an error
             output_parser = SalesConvoOutputParser(ai_prefix=kwargs["salesperson_name"])
 
             sales_agent_with_tools = LLMSingleActionAgent(

swarms/artifacts/error_artifact.py

@@ -17,4 +17,3 @@ class ErrorArtifact(BaseArtifact):
         from griptape.schemas import ErrorArtifactSchema
 
         return dict(ErrorArtifactSchema().dump(self))
-    

swarms/artifacts/main.py

@@ -5,6 +5,7 @@ import json
 from typing import Optional
 from pydantic import BaseModel, Field, StrictStr
 
+
 class Artifact(BaseModel):
     """
 
@@ -63,5 +64,3 @@ class Artifact(BaseModel):
         )
 
         return _obj
-
-

swarms/boss/boss_node.py

@@ -14,6 +14,7 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 
 # ---------- Boss Node ----------
 
+
 class Boss:
     """
     The Bose class is responsible for creating and executing tasks using the BabyAGI model.
@@ -37,17 +38,18 @@ class Boss:
     # Run the Bose to process the objective
     boss.run()
     """
+
     def __init__(
-            self, 
+        self,
-            objective: str, 
+        objective: str,
-            api_key=None, 
+        api_key=None,
-            max_iterations=5, 
+        max_iterations=5,
-            human_in_the_loop=None, 
+        human_in_the_loop=None,
-            boss_system_prompt="You are a boss planner in a swarm...", 
+        boss_system_prompt="You are a boss planner in a swarm...",
-            llm_class=OpenAI, 
+        llm_class=OpenAI,
-            worker_node=None, 
+        worker_node=None,
-            verbose=False
+        verbose=False
-        ):
+    ):
         # Store parameters
         self.api_key = api_key or os.getenv("OPENAI_API_KEY")
         self.objective = objective

swarms/embeddings/openai.py

@@ -345,7 +345,7 @@ class OpenAIEmbeddings(BaseModel, Embeddings):
                 disallowed_special=self.disallowed_special,
             )
             for j in range(0, len(token), self.embedding_ctx_length):
-                tokens.append(token[j : j + self.embedding_ctx_length])
+                tokens.append(token[j: j + self.embedding_ctx_length])
                 indices.append(i)
 
         batched_embeddings: List[List[float]] = []
@@ -364,7 +364,7 @@ class OpenAIEmbeddings(BaseModel, Embeddings):
         for i in _iter:
             response = embed_with_retry(
                 self,
-                input=tokens[i : i + _chunk_size],
+                input=tokens[i: i + _chunk_size],
                 **self._invocation_params,
             )
             batched_embeddings.extend(r["embedding"] for r in response["data"])
@@ -426,7 +426,7 @@ class OpenAIEmbeddings(BaseModel, Embeddings):
                 disallowed_special=self.disallowed_special,
             )
             for j in range(0, len(token), self.embedding_ctx_length):
-                tokens.append(token[j : j + self.embedding_ctx_length])
+                tokens.append(token[j: j + self.embedding_ctx_length])
                 indices.append(i)
 
         batched_embeddings: List[List[float]] = []
@@ -434,7 +434,7 @@ class OpenAIEmbeddings(BaseModel, Embeddings):
         for i in range(0, len(tokens), _chunk_size):
             response = await async_embed_with_retry(
                 self,
-                input=tokens[i : i + _chunk_size],
+                input=tokens[i: i + _chunk_size],
                 **self._invocation_params,
             )
             batched_embeddings.extend(r["embedding"] for r in response["data"])

swarms/embeddings/pegasus.py

@@ -8,11 +8,11 @@ from pegasus import Pegasus
 
 class PegasusEmbedding:
     def __init__(
-            self, 
+        self,
-            modality: str, 
+        modality: str,
-            multi_process: bool = False, 
+        multi_process: bool = False,
-            n_processes: int = 4
+        n_processes: int = 4
-        ):
+    ):
         self.modality = modality
         self.multi_process = multi_process
         self.n_processes = n_processes
@@ -28,4 +28,3 @@ class PegasusEmbedding:
         except Exception as e:
             logging.error(f"Failed to generate embeddings. Error: {e}")
             raise
-

swarms/hivemind/hivemind.py

@@ -1,6 +1,6 @@
 #  workers in unison
-#kye gomez jul 13 4:01pm, can scale up the number of swarms working on a probkem with `hivemind(swarms=4, or swarms=auto which will scale the agents depending on the complexity)`
+# kye gomez jul 13 4:01pm, can scale up the number of swarms working on a probkem with `hivemind(swarms=4, or swarms=auto which will scale the agents depending on the complexity)`
-#this needs to change, we need to specify exactly what needs to be imported
+# this needs to change, we need to specify exactly what needs to be imported
 # add typechecking, documentation, and deeper error handling
 # TODO: MANY WORKERS
 
@@ -12,13 +12,14 @@ from swarms.swarms.swarms import HierarchicalSwarm
 
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 
+
 class HiveMind:
     def __init__(
-            self, 
+        self,
-            openai_api_key="", 
+        openai_api_key="",
-            num_swarms=1, 
+        num_swarms=1,
-            max_workers=None
+        max_workers=None
-        ):
+    ):
         self.openai_api_key = openai_api_key
         self.num_swarms = num_swarms
         self.swarms = [HierarchicalSwarm(openai_api_key) for _ in range(num_swarms)]
@@ -62,7 +63,7 @@ class HiveMind:
             logging.error(f"No swarm found at index {index}")
 
     def get_progress(self):
-        #this assumes that the swarms class has a get progress method
+        # this assumes that the swarms class has a get progress method
         pass
 
     def cancel_swarm(self, index):

swarms/memory/db.py

@@ -10,9 +10,11 @@ from swarms.memory.schemas import Task as APITask
 class Step(APIStep):
     additional_properties: Optional[Dict[str, str]] = None
 
+
 class Task(APITask):
     steps: List[Step] = []
 
+
 class NotFoundException(Exception):
     """
     Exception raised when a resource is not found.
@@ -23,6 +25,7 @@ class NotFoundException(Exception):
         self.item_id = item_id
         super().__init__(f"{item_name} with {item_id} not found.")
 
+
 class TaskDB(ABC):
     async def create_task(
         self,

swarms/memory/ocean.py

@@ -1,4 +1,4 @@
-#init ocean
+# init ocean
 # TODO upload ocean to pip and config it to the abstract class
 import logging
 from typing import Union, List
@@ -6,6 +6,7 @@ from typing import Union, List
 import oceandb
 from oceandb.utils.embedding_function import MultiModalEmbeddingFunction
 
+
 class OceanDB:
     def __init__(self):
         try:

swarms/models/__init__.py

@@ -1,4 +1,4 @@
-#prompts
+# prompts
 from swarms.models.anthropic import Anthropic
 # from swarms.models.palm import GooglePalm
 from swarms.models.petals import Petals

swarms/models/anthropic.py

@@ -1,19 +1,20 @@
 import requests
 import os
 
+
 class Anthropic:
     """Anthropic large language models."""
 
     def __init__(
-            self, 
+        self,
-            model="claude-2", 
+        model="claude-2",
-            max_tokens_to_sample=256, 
+        max_tokens_to_sample=256,
-            temperature=None, 
+        temperature=None,
-            top_k=None, 
+        top_k=None,
-            top_p=None, 
+        top_p=None,
-            streaming=False, 
+        streaming=False,
-            default_request_timeout=None
+        default_request_timeout=None
-        ):
+    ):
         self.model = model
         self.max_tokens_to_sample = max_tokens_to_sample
         self.temperature = temperature

swarms/models/base.py

@@ -1,15 +1,15 @@
 from abc import ABC, abstractmethod
 
+
 class AbstractModel(ABC):
-    #abstract base class for language models
+    # abstract base class for language models
     def __init__():
         pass
 
     @abstractmethod
     def run(self, prompt):
-        #generate text using language model
+        # generate text using language model
         pass
 
     def chat(self, prompt, history):
         pass
-    

swarms/models/chat_openai.py

@@ -458,7 +458,7 @@ class BaseOpenAI(BaseLLM):
                 )
             params["max_tokens"] = self.max_tokens_for_prompt(prompts[0])
         sub_prompts = [
-            prompts[i : i + self.batch_size]
+            prompts[i: i + self.batch_size]
             for i in range(0, len(prompts), self.batch_size)
         ]
         return sub_prompts
@@ -469,7 +469,7 @@ class BaseOpenAI(BaseLLM):
         """Create the LLMResult from the choices and prompts."""
         generations = []
         for i, _ in enumerate(prompts):
-            sub_choices = choices[i * self.n : (i + 1) * self.n]
+            sub_choices = choices[i * self.n: (i + 1) * self.n]
             generations.append(
                 [
                     Generation(

swarms/models/mistral.py

@@ -13,12 +13,13 @@ class Mistral:
     result = model.run(task)
     print(result)
     """
+
     def __init__(
         self,
         ai_name: str = "Node Model Agent",
         system_prompt: str = None,
-        model_name: str ="mistralai/Mistral-7B-v0.1", 
+        model_name: str = "mistralai/Mistral-7B-v0.1",
-        device: str ="cuda", 
+        device: str = "cuda",
         use_flash_attention: bool = False,
         temperature: float = 1.0,
         max_length: int = 100,
@@ -97,7 +98,7 @@ class Mistral:
 
         """
 
-        #add users message to the history
+        # add users message to the history
         self.history.append(
             Message(
                 "User",
@@ -105,11 +106,11 @@ class Mistral:
             )
         )
 
-        #process msg
+        # process msg
         try:
             response = self.agent.run(msg)
 
-            #add agent's response to the history
+            # add agent's response to the history
             self.history.append(
                 Message(
                     "Agent",
@@ -117,7 +118,7 @@ class Mistral:
                 )
             )
 
-            #if streaming is = True
+            # if streaming is = True
             if streaming:
                 return self._stream_response(response)
             else:
@@ -126,7 +127,7 @@ class Mistral:
         except Exception as error:
             error_message = f"Error processing message: {str(error)}"
 
-            #add error to history
+            # add error to history
             self.history.append(
                 Message(
                     "Agent",
@@ -151,4 +152,3 @@ class Mistral:
         """
         for token in response.split():
             yield token
-

swarms/models/petals.py

@@ -1,18 +1,19 @@
 from transformers import AutoTokenizer, AutoModelForCausalLM
 
+
 class Petals:
     """Petals Bloom models."""
 
     def __init__(
-            self, 
+        self,
-            model_name="bigscience/bloom-petals", 
+        model_name="bigscience/bloom-petals",
-            temperature=0.7, 
+        temperature=0.7,
-            max_new_tokens=256, 
+        max_new_tokens=256,
-            top_p=0.9, 
+        top_p=0.9,
-            top_k=None, 
+        top_k=None,
-            do_sample=True, 
+        do_sample=True,
-            max_length=None
+        max_length=None
-        ):
+    ):
         self.model_name = model_name
         self.temperature = temperature
         self.max_new_tokens = max_new_tokens

swarms/models/prompts/agent_output_parser.py

@@ -3,11 +3,13 @@ import re
 from abc import abstractmethod
 from typing import Dict, NamedTuple
 
+
 class AgentAction(NamedTuple):
     """Action returned by AgentOutputParser."""
     name: str
     args: Dict
 
+
 class BaseAgentOutputParser:
     """Base Output parser for Agent."""
 
@@ -15,6 +17,7 @@ class BaseAgentOutputParser:
     def parse(self, text: str) -> AgentAction:
         """Return AgentAction"""
 
+
 class AgentOutputParser(BaseAgentOutputParser):
     """Output parser for Agent."""
 

swarms/models/prompts/agent_prompt.py

@@ -1,6 +1,7 @@
 import json
 from typing import List
 
+
 class PromptGenerator:
     """A class for generating custom prompt strings."""
 
@@ -75,4 +76,3 @@ class PromptGenerator:
         )
 
         return prompt_string
-    

swarms/models/prompts/agent_prompt_auto.py

@@ -2,6 +2,7 @@ import time
 from typing import Any, List
 from swarms.models.prompts.agent_prompt_generator import get_prompt
 
+
 class TokenUtils:
     @staticmethod
     def count_tokens(text: str) -> int:

swarms/models/prompts/agent_prompts.py

@@ -25,7 +25,8 @@ def generate_report_prompt(question, research_summary):
            f' question or topic: "{question}" in a detailed report --'\
            " The report should focus on the answer to the question, should be well structured, informative," \
            " in depth, with facts and numbers if available, a minimum of 1,200 words and with markdown syntax and apa format. "\
-            "Write all source urls at the end of the report in apa format"
+        "Write all source urls at the end of the report in apa format"
+
 
 def generate_search_queries_prompt(question):
     """ Generates the search queries prompt for the given question.
@@ -69,6 +70,7 @@ def generate_outline_report_prompt(question, research_summary):
            ' The research report should be detailed, informative, in-depth, and a minimum of 1,200 words.' \
            ' Use appropriate Markdown syntax to format the outline and ensure readability.'
 
+
 def generate_concepts_prompt(question, research_summary):
     """ Generates the concepts prompt for the given question.
     Args: question (str): The question to generate the concepts prompt for
@@ -91,11 +93,12 @@ def generate_lesson_prompt(concept):
     """
 
     prompt = f'generate a comprehensive lesson about {concept} in Markdown syntax. This should include the definition'\
-    f'of {concept}, its historical background and development, its applications or uses in different'\
+        f'of {concept}, its historical background and development, its applications or uses in different'\
-    f'fields, and notable events or facts related to {concept}.'
+        f'fields, and notable events or facts related to {concept}.'
 
     return prompt
 
+
 def get_report_by_type(report_type):
     report_type_mapping = {
         'research_report': generate_report_prompt,

swarms/models/prompts/base.py

@@ -10,6 +10,7 @@ from swarms.utils.serializable import Serializable
 if TYPE_CHECKING:
     from langchain.prompts.chat import ChatPromptTemplate
 
+
 def get_buffer_string(
     messages: Sequence[BaseMessage], human_prefix: str = "Human", ai_prefix: str = "AI"
 ) -> str:
@@ -95,7 +96,7 @@ class BaseMessageChunk(BaseMessage):
         for k, v in right.items():
             if k not in merged:
                 merged[k] = v
-            elif type(merged[k]) != type(v):
+            elif not isinstance(merged[k], type(v)):
                 raise ValueError(
                     f'additional_kwargs["{k}"] already exists in this message,'
                     " but with a different type."

swarms/models/prompts/chat_prompt.py

@@ -11,6 +11,7 @@ class Message:
     The base abstract Message class.
     Messages are the inputs and outputs of ChatModels.
     """
+
     def __init__(self, content: str, role: str, additional_kwargs: Dict = None):
         self.content = content
         self.role = role
@@ -25,6 +26,7 @@ class HumanMessage(Message):
     """
     A Message from a human.
     """
+
     def __init__(self, content: str, role: str = "Human", additional_kwargs: Dict = None, example: bool = False):
         super().__init__(content, role, additional_kwargs)
         self.example = example
@@ -37,6 +39,7 @@ class AIMessage(Message):
     """
     A Message from an AI.
     """
+
     def __init__(self, content: str, role: str = "AI", additional_kwargs: Dict = None, example: bool = False):
         super().__init__(content, role, additional_kwargs)
         self.example = example
@@ -50,6 +53,7 @@ class SystemMessage(Message):
     A Message for priming AI behavior, usually passed in as the first of a sequence
     of input messages.
     """
+
     def __init__(self, content: str, role: str = "System", additional_kwargs: Dict = None):
         super().__init__(content, role, additional_kwargs)
 
@@ -61,6 +65,7 @@ class FunctionMessage(Message):
     """
     A Message for passing the result of executing a function back to a model.
     """
+
     def __init__(self, content: str, role: str = "Function", name: str, additional_kwargs: Dict = None):
         super().__init__(content, role, additional_kwargs)
         self.name = name
@@ -73,6 +78,7 @@ class ChatMessage(Message):
     """
     A Message that can be assigned an arbitrary speaker (i.e. role).
     """
+
     def __init__(self, content: str, role: str, additional_kwargs: Dict = None):
         super().__init__(content, role, additional_kwargs)
 

swarms/models/prompts/debate.py

@@ -21,6 +21,7 @@ def character(character_name, topic, word_limit):
     """
     return prompt
 
+
 def debate_monitor(game_description, word_limit, character_names):
     prompt = f"""
 

swarms/models/prompts/prebuild/sales_prompts.py

@@ -1,6 +1,5 @@
 
 
-
 SALES_ASSISTANT_PROMPT = """You are a sales assistant helping your sales agent to determine which stage of a sales conversation should the agent move to, or stay at.
 Following '===' is the conversation history.
 Use this conversation history to make your decision.
@@ -48,11 +47,10 @@ Conversation history:
 {salesperson_name}:
 """
 
-conversation_stages = {'1' : "Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional. Your greeting should be welcoming. Always clarify in your greeting the reason why you are contacting the prospect.",
+conversation_stages = {'1': "Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional. Your greeting should be welcoming. Always clarify in your greeting the reason why you are contacting the prospect.",
-'2': "Qualification: Qualify the prospect by confirming if they are the right person to talk to regarding your product/service. Ensure that they have the authority to make purchasing decisions.",
+                       '2': "Qualification: Qualify the prospect by confirming if they are the right person to talk to regarding your product/service. Ensure that they have the authority to make purchasing decisions.",
-'3': "Value proposition: Briefly explain how your product/service can benefit the prospect. Focus on the unique selling points and value proposition of your product/service that sets it apart from competitors.",
+                       '3': "Value proposition: Briefly explain how your product/service can benefit the prospect. Focus on the unique selling points and value proposition of your product/service that sets it apart from competitors.",
-'4': "Needs analysis: Ask open-ended questions to uncover the prospect's needs and pain points. Listen carefully to their responses and take notes.",
+                       '4': "Needs analysis: Ask open-ended questions to uncover the prospect's needs and pain points. Listen carefully to their responses and take notes.",
-'5': "Solution presentation: Based on the prospect's needs, present your product/service as the solution that can address their pain points.",
+                       '5': "Solution presentation: Based on the prospect's needs, present your product/service as the solution that can address their pain points.",
-'6': "Objection handling: Address any objections that the prospect may have regarding your product/service. Be prepared to provide evidence or testimonials to support your claims.",
+                       '6': "Objection handling: Address any objections that the prospect may have regarding your product/service. Be prepared to provide evidence or testimonials to support your claims.",
-'7': "Close: Ask for the sale by proposing a next step. This could be a demo, a trial or a meeting with decision-makers. Ensure to summarize what has been discussed and reiterate the benefits."}
+                       '7': "Close: Ask for the sale by proposing a next step. This could be a demo, a trial or a meeting with decision-makers. Ensure to summarize what has been discussed and reiterate the benefits."}
-

swarms/models/prompts/sales.py

@@ -9,7 +9,6 @@ conversation_stages = {
 }
 
 
-
 SALES_AGENT_TOOLS_PROMPT = """
 Never forget your name is {salesperson_name}. You work as a {salesperson_role}.
 You work at company named {company_name}. {company_name}'s business is the following: {company_business}.

swarms/structs/__init__.py

@@ -1,4 +1,4 @@
-#structs
+# structs
-#structs
+# structs
 from swarms.structs.workflow import Workflow
 from swarms.structs.task import Task

swarms/structs/nonlinear_workflow.py

@@ -2,6 +2,7 @@ from typing import List, Dict, Any, Union
 from concurrent.futures import Executor, ThreadPoolExecutor, as_completed
 from graphlib import TopologicalSorter
 
+
 class Task:
     def __init__(
         self,
@@ -19,3 +20,89 @@ class Task:
     def execute(self):
         raise NotImplementedError
 
+
+class NonLinearWorkflow:
+    """
+    NonLinearWorkflow constructs a non sequential DAG of tasks to be executed by agents
+
+
+    Architecture:
+    NonLinearWorkflow = Task + Agent + Executor
+
+    ASCII Diagram:
+    +-------------------+
+    | NonLinearWorkflow |
+    +-------------------+
+    |                   |
+    |                   |
+    |                   |
+    |                   |
+    |                   |
+    |                   |
+    |                   |
+    |                   |
+    |                   |
+    |                   |
+    +-------------------+
+
+
+    """
+
+    def __init__(
+        self,
+        agents,
+        iters_per_task
+    ):
+        """A workflow is a collection of tasks that can be executed in parallel or sequentially."""
+        super().__init__()
+        self.executor = ThreadPoolExecutor()
+        self.agents = agents
+        self.tasks = []
+
+    def add(self, task: Task):
+        """Add a task to the workflow"""
+        assert isinstance(
+            task,
+            Task
+        ), "Input must be an nstance of Task"
+        self.tasks.append(task)
+        return task
+
+    def run(self):
+        """Run the workflow"""
+        ordered_tasks = self.ordered_tasks
+        exit_loop = False
+
+        while not self.is_finished() and not exit_loop:
+            futures_list = {}
+
+            for task in ordered_tasks:
+                if task.can_execute:
+                    future = self.executor.submit(self.agents.run, task.task_string)
+                    futures_list[future] = task
+
+            for future in as_completed(futures_list):
+                if isinstance(future.result(), Exception):
+                    exit_loop = True
+                    break
+        return self.output_tasks()
+
+    def output_tasks(self) -> List[Task]:
+        """Output tasks from the workflow"""
+        return [task for task in self.tasks if not task.children]
+
+    def to_graph(self) -> Dict[str, set[str]]:
+        """Convert the workflow to a graph"""
+        graph = {
+            task.id: set(child.id for child in task.children) for task in self.tasks
+        }
+        return graph
+
+    def order_tasks(self) -> List[Task]:
+        """Order the tasks USING TOPOLOGICAL SORTING"""
+        task_order = TopologicalSorter(
+            self.to_graph()
+        ).static_order()
+        return [
+            self.find_task(task_id) for task_id in task_order
+        ]

swarms/structs/task.py

@@ -3,13 +3,12 @@ from __future__ import annotations
 import json
 import pprint
 import uuid
-from abc import ABC
+from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Any, Optional
+from typing import Any, List, Optional, Union
 
-from swarms.artifacts.main import Artifact
 from pydantic import BaseModel, Field, StrictStr, conlist
-
+from swarms.artifacts.main import Artifact
 from swarms.artifacts.error_artifact import ErrorArtifact
 
 
@@ -20,37 +19,37 @@ class BaseTask(ABC):
         FINISHED = 3
 
     def __init__(self):
-        self.id = uuid.uuid4().hex
+        self.id: str = uuid.uuid4().hex
-        self.state = self.State.PENDING
+        self.state: BaseTask.State = self.State.PENDING
-        self.parent_ids = []
+        self.parent_ids: List[str] = []
-        self.child_ids = []
+        self.child_ids: List[str] = []
-        self.output = None
+        self.output: Optional[Union[Artifact, ErrorArtifact]] = None
-        self.structure = None
+        self.structure: Optional['Structure'] = None
 
     @property
-    # @abstractmethod
+    @abstractmethod
-    def input(self):
+    def input(self) -> Any:
         pass
 
     @property
-    def parents(self):
+    def parents(self) -> List[BaseTask]:
         return [self.structure.find_task(parent_id) for parent_id in self.parent_ids]
 
     @property
-    def children(self):
+    def children(self) -> List[BaseTask]:
         return [self.structure.find_task(child_id) for child_id in self.child_ids]
 
-    def __rshift__(self, child):
+    def __rshift__(self, child: BaseTask) -> BaseTask:
         return self.add_child(child)
 
-    def __lshift__(self, child):
+    def __lshift__(self, child: BaseTask) -> BaseTask:
         return self.add_parent(child)
 
-    def preprocess(self, structure):
+    def preprocess(self, structure: 'Structure') -> BaseTask:
         self.structure = structure
         return self
 
-    def add_child(self, child):
+    def add_child(self, child: BaseTask) -> BaseTask:
         if self.structure:
             child.structure = self.structure
         elif child.structure:
@@ -70,7 +69,7 @@ class BaseTask(ABC):
 
         return child
 
-    def add_parent(self, parent):
+    def add_parent(self, parent: BaseTask) -> BaseTask:
         if self.structure:
             parent.structure = self.structure
         elif parent.structure:
@@ -90,22 +89,22 @@ class BaseTask(ABC):
 
         return parent
 
-    def is_pending(self):
+    def is_pending(self) -> bool:
         return self.state == self.State.PENDING
 
-    def is_finished(self):
+    def is_finished(self) -> bool:
         return self.state == self.State.FINISHED
 
-    def is_executing(self):
+    def is_executing(self) -> bool:
         return self.state == self.State.EXECUTING
 
-    def before_run(self):
+    def before_run(self) -> None:
         pass
 
-    def after_run(self):
+    def after_run(self) -> None:
         pass
 
-    def execute(self):
+    def execute(self) -> Optional[Union[Artifact, ErrorArtifact]]:
         try:
             self.state = self.State.EXECUTING
             self.before_run()
@@ -117,30 +116,19 @@ class BaseTask(ABC):
             self.state = self.State.FINISHED
             return self.output
 
-    def can_execute(self):
+    def can_execute(self) -> bool:
         return self.state == self.State.PENDING and all(parent.is_finished() for parent in self.parents)
 
-    def reset(self):
+    def reset(self) -> BaseTask:
         self.state = self.State.PENDING
         self.output = None
         return self
 
-    # @abstractmethod
+    @abstractmethod
-    def run(self):
+    def run(self) -> Optional[Union[Artifact, ErrorArtifact]]:
         pass
 
 
-
-
-
-
-
-
-
-
-
-
-
 class Task(BaseModel):
     input: Optional[StrictStr] = Field(
         None,
@@ -154,66 +142,37 @@ class Task(BaseModel):
         ...,
         description="ID of the task"
     )
-    artifacts: conlist(Artifact) = Field(
+    artifacts: conlist(Artifact, min_items=1) = Field(
         ...,
         description="A list of artifacts that the task has been produced"
     )
 
-    __properties = ["input", "additional_input", "task_id", "artifact"]
-
     class Config:
-        #pydantic config
-        
         allow_population_by_field_name = True
         validate_assignment = True
 
     def to_str(self) -> str:
-        """Returns the str representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))
 
     def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.dict(by_alias=True, exclude_none=True))
-        return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Task:
+    def from_json(cls, json_str: str) -> 'Task':
-        """Create an instance of Task from a json string"""
+        return cls.parse_raw(json_str)
-        return cls.from_dict(json.loads(json_str))
-    
-    def to_dict(self):
-        """Returns the dict representation of the model using alias"""
-        _dict = self.dict(by_alias=True, exclude={}, exclude_none=True)
-        _items =[]
-        if self.artifacts:
-            for _item in self.artifacts:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict["artifacts"] = _items
-        #set to None if additional input is None
-        # and __fields__set contains the field
-        if self.additional_input is None and "additional_input" in self.__fields__set__:
-            _dict["additional_input"] = None
 
+    def to_dict(self) -> dict:
+        _dict = self.dict(by_alias=True, exclude_none=True)
+        if self.artifacts:
+            _dict["artifacts"] = [artifact.dict(by_alias=True, exclude_none=True) for artifact in self.artifacts]
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> Task:
+    def from_dict(cls, obj: dict) -> 'Task':
-        """Create an instance of Task from dict"""
         if obj is None:
             return None
-        
         if not isinstance(obj, dict):
-            return Task.parse_obj(obj)
+            raise ValueError("Input must be a dictionary.")
-        
+        if 'artifacts' in obj:
-        _obj = Task.parse_obj(
+            obj['artifacts'] = [Artifact.parse_obj(artifact) for artifact in obj['artifacts']]
-            {
+        return cls.parse_obj(obj)
-                "input": obj.get("input"),
-                "additional_input": obj.get("additional_input"),
-                "task_id": obj.get("task_id"),
-                "artifacts": [
-                    Artifact.from_dict(_item) for _item in obj.get("artifacts")
-                ]
-                if obj.get("artifacts") is not None
-                else None,
-            }
-        )

swarms/structs/workflow.py

@@ -1,24 +1,8 @@
 from __future__ import annotations
 
-import concurrent.futures
+from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Dict, List, Optional
 
-from swarms.artifacts.error_artifact import ErrorArtifact
-from swarms.structs.task import BaseTask
-
-class StringTask(BaseTask):
-    def __init__(self, task):
-        super().__init__()
-        self.task = task
-
-    def execute(self) -> Any:
-        prompt = self.task.replace(
-            "{{ parent_input }}", self.parents[0].output if self.parents else ""
-        )
-
-        response = self.structure.llm(prompt)
-        self.output = response
-        return response
 
 class Workflow:
     """
@@ -41,21 +25,34 @@ class Workflow:
 
 
     """
-    def __init__(
+    class Task:
-        self,
+        def __init__(self, task: str):
-        llm,
+            self.task = task
-        parallel: bool = False
+            self.parents = []
-    ):
+            self.children = []
-        self.llm = llm
+            self.output = None
-        self.tasks: List[BaseTask] = []
+            self.structure = None
+
+        def add_child(self, child: 'Workflow.Task'):
+            self.children.append(child)
+            child.parents.append(self)
+            child.structure = self.structure
+
+        def execute(self) -> Any:
+            prompt = self.task.replace(
+                "{{ parent_input }}", self.parents[0].output if self.parents else ""
+            )
+            response = self.structure.agent.run(prompt)
+            self.output = response
+            return response
+
+    def __init__(self, agent, parallel: bool = False):
+        self.agent = agent
+        self.tasks: List[Workflow.Task] = []
         self.parallel = parallel
 
-    
+    def add(self, task: str) -> Task:
-    def add(
+        task = self.Task(task)
-        self,
-        task: BaseTask
-    ) -> BaseTask:
-        task = StringTask(task)
 
         if self.last_task():
             self.last_task().add_child(task)
@@ -64,48 +61,35 @@ class Workflow:
             self.tasks.append(task)
         return task
 
-    def first_task(self) -> Optional[BaseTask]:
+    def first_task(self) -> Optional[Task]:
         return self.tasks[0] if self.tasks else None
 
-    def last_task(self) -> Optional[BaseTask]:
+    def last_task(self) -> Optional[Task]:
         return self.tasks[-1] if self.tasks else None
 
-    def run(self, *args) -> BaseTask:
+    def run(self, *args) -> Task:
-        self._execution_args = args
-
         [task.reset() for task in self.tasks]
 
         if self.parallel:
-            with concurrent.futures.ThreadPoolExecutor() as executor:
+            with ThreadPoolExecutor() as executor:
                 list(executor.map(self.__run_from_task, [self.first_task]))
         else:
             self.__run_from_task(self.first_task())
 
-        self._execution_args = ()
-
         return self.last_task()
 
+    def context(self, task: Task) -> Dict[str, Any]:
+        return {
+            "parent_output": task.parents[0].output if task.parents and task.parents[0].output else None,
+            "parent": task.parents[0] if task.parents else None,
+            "child": task.children[0] if task.children else None
+        }
 
-    def context(self, task: BaseTask) -> Dict[str, Any]:
+    def __run_from_task(self, task: Optional[Task]) -> None:
-        context = super().context(task)
-
-        context.update(
-            {
-                "parent_output": task.parents[0].output.to_text() \
-                    if task.parents and task.parents[0].output else None,
-                "parent": task.parents[0] if task.parents else None,
-                "child": task.children[0] if task.children else None
-            }
-        )
-        return context
-
-    
-    def __run_from_task(self, task: Optional[BaseTask]) -> None:
         if task is None:
             return
         else:
-            if isinstance(task.execute(), ErrorArtifact):
+            if isinstance(task.execute(), Exception):
                 return
             else:
                 self.__run_from_task(next(iter(task.children), None))
-

swarms/swarms/autoscaler.py

@@ -5,6 +5,7 @@ from time import sleep
 from swarms.utils.decorators import error_decorator, log_decorator, timing_decorator
 from swarms.workers.worker import Worker
 
+
 class AutoScaler:
     """
     The AutoScaler is like a kubernetes pod, that autoscales an agent or worker or boss!
@@ -55,15 +56,15 @@ class AutoScaler:
 
     def scale_down(self):
         with self.lock:
-            if len(self.agents_pool) > 10: #ensure minmum of 10 agents
+            if len(self.agents_pool) > 10:  # ensure minmum of 10 agents
-                del self.agents_pool[-1] #remove last agent
+                del self.agents_pool[-1]  # remove last agent
 
     @log_decorator
     @error_decorator
     @timing_decorator
     def monitor_and_scale(self):
         while True:
-            sleep(60)#check minute
+            sleep(60)  # check minute
             pending_tasks = self.task_queue.qsize()
             active_agents = sum([1 for agent in self.agents_pool if agent.is_busy()])
 
@@ -91,4 +92,3 @@ class AutoScaler:
             if self.agents_pool:
                 agent_to_remove = self.agents_poo.pop()
                 del agent_to_remove
-

swarms/swarms/base.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 
+
 class AbstractSwarm(ABC):
     # TODO: Pass in abstract LLM class that can utilize Hf or Anthropic models, Move away from OPENAI
     # TODO: ADD Universal Communication Layer, a ocean vectorstore instance
@@ -19,5 +20,3 @@ class AbstractSwarm(ABC):
     @abstractmethod
     def run(self):
         pass
-
-    

swarms/swarms/dialogue_simulator.py

@@ -1,6 +1,7 @@
 from typing import List
 from swarms.workers.worker import Worker
 
+
 class DialogueSimulator:
     def __init__(self, agents: List[Worker]):
         self.agents = agents

swarms/swarms/god_mode.py

@@ -29,6 +29,7 @@ class GodMode:
 
 
     """
+
     def __init__(
         self,
         llms

swarms/swarms/groupchat.py

@@ -12,7 +12,7 @@ class GroupChat:
     workers: List[Worker]
     messages: List[Dict]
     max_rounds: int = 10
-    admin_name: str = "Admin" #admin worker
+    admin_name: str = "Admin"  # admin worker
 
     @property
     def worker_names(self) -> List[str]:
@@ -72,7 +72,6 @@ class GroupChat:
         )
 
 
-
 class GroupChatManager(Worker):
     def __init__(
         self,
@@ -85,9 +84,9 @@ class GroupChatManager(Worker):
     ):
         super().__init__(
             ai_name=ai_name,
-            max_consecutive_auto_reply=max_consecutive_auto_reply,
+            # max_consecutive_auto_reply=max_consecutive_auto_reply,
-            human_input_mode=human_input_mode,
+            # human_input_mode=human_input_mode,
-            system_message=system_message,
+            # system_message=system_message,
             **kwargs
         )
         self.register_reply(
@@ -103,7 +102,7 @@ class GroupChatManager(Worker):
         sender: Optional[Worker] = None,
         config: Optional[GroupChat] = None,
     ) -> Union[str, Dict, None]:
-        #run
+        # run
         if messages is None:
             messages = []
 
@@ -113,11 +112,11 @@ class GroupChatManager(Worker):
 
         for i in range(groupchat.max_rounds):
             if message["role"] != "function":
-                message["name"]= speaker.ai_name
+                message["name"] = speaker.ai_name
 
             groupchat.messages.append(message)
 
-            #broadcast the message to all workers except the speaker
+            # broadcast the message to all workers except the speaker
             for worker in groupchat.workers:
                 if worker != speaker:
                     self.send(
@@ -130,24 +129,24 @@ class GroupChatManager(Worker):
                 break
 
             try:
-                #select next speaker
+                # select next speaker
                 speaker = groupchat.select_speaker(speaker, self)
-                #let the speaker speak
+                # let the speaker speak
                 reply = speaker.generate_reply(sender=self)
 
             except KeyboardInterrupt:
-                #let the admin speak if interrupted
+                # let the admin speak if interrupted
                 if groupchat.admin_name in groupchat.worker_names:
-                    #admin worker is a particpant
+                    # admin worker is a particpant
                     speaker = groupchat.worker_by_name(groupchat.admin_name)
                     reply = speaker.generate_reply(sender=self)
                 else:
-                    #admin worker is not found in particpants
+                    # admin worker is not found in particpants
                     raise
             if reply is None:
                 break
 
-            #speaker sends message without requesting a reply
+            # speaker sends message without requesting a reply
             speaker.send(
                 reply,
                 self,

swarms/swarms/multi_agent_collab.py

@@ -2,22 +2,26 @@ import random
 import tenacity
 from langchain.output_parsers import RegexParser
 
-#utils
+# utils
+
+
 class BidOutputParser(RegexParser):
     def get_format_instructions(self) -> str:
         return "Your response should be an integrater delimited by angled brackets like this: <int>"
 
+
 bid_parser = BidOutputParser(
     regex=r"<(\d+)>", output_keys=["bid"], default_output_key="bid"
 )
 
+
 def select_next_speaker(
         step: int,
         agents,
         director
 ) -> int:
-    #if the step if even => director
+    # if the step if even => director
-    #=> director selects next speaker
+    # => director selects next speaker
     if step % 2 == 1:
         idx = 0
     else:
@@ -25,7 +29,7 @@ def select_next_speaker(
     return idx
 
 
-#main
+# main
 class MultiAgentCollaboration:
     def __init__(
         self,
@@ -63,7 +67,7 @@ class MultiAgentCollaboration:
         stop=tenacity.stop_after_attempt(10),
         wait=tenacity.wait_none(),
         retry=tenacity.retry_if_exception_type(ValueError),
-        before_sleep= lambda retry_state: print(
+        before_sleep=lambda retry_state: print(
             f"ValueError occured: {retry_state.outcome.exception()}, retying..."
         ),
         retry_error_callback=lambda retry_state: 0,

swarms/swarms/multi_agent_debate.py

@@ -7,6 +7,7 @@ def select_speaker(step: int, agents: List[Worker]) -> int:
     # This function selects the speaker in a round-robin fashion
     return step % len(agents)
 
+
 class MultiAgentDebate:
     """
     MultiAgentDebate
@@ -15,6 +16,7 @@ class MultiAgentDebate:
 
 
     """
+
     def __init__(
         self,
         agents: List[Worker],

swarms/swarms/orchestrate.py

@@ -15,6 +15,7 @@ class TaskStatus(Enum):
     COMPLETED = 3
     FAILED = 4
 
+
 class Orchestrator:
     """
     The Orchestrator takes in an agent, worker, or boss as input
@@ -88,6 +89,7 @@ class Orchestrator:
     print(orchestrator.retrieve_result(id(task)))
     ```
     """
+
     def __init__(
         self,
         agent,
@@ -96,8 +98,8 @@ class Orchestrator:
         collection_name: str = "swarm",
         api_key: str = None,
         model_name: str = None,
-        embed_func = None,
+        embed_func=None,
-        worker = None
+        worker=None
     ):
         self.agent = agent
         self.agents = queue.Queue()
@@ -110,7 +112,7 @@ class Orchestrator:
         self.chroma_client = chromadb.Client()
 
         self.collection = self.chroma_client.create_collection(
-            name = collection_name
+            name=collection_name
         )
 
         self.current_tasks = {}
@@ -121,8 +123,8 @@ class Orchestrator:
 
         self.embed_func = embed_func if embed_func else self.embed
 
-        
     # @abstractmethod
+
     def assign_task(
         self,
         agent_id: int,
@@ -140,7 +142,7 @@ class Orchestrator:
             try:
                 result = self.worker.run(task["content"])
 
-                #using the embed method to get the vector representation of the result
+                # using the embed method to get the vector representation of the result
                 vector_representation = self.embed(
                     result,
                     self.api_key,
@@ -170,13 +172,13 @@ class Orchestrator:
         embedding = openai(input)
         return embedding
 
-    
     # @abstractmethod
+
     def retrieve_results(self, agent_id: int) -> Any:
         """Retrieve results from a specific agent"""
 
         try:
-            #Query the vector database for documents created by the agents 
+            # Query the vector database for documents created by the agents
             results = self.collection.query(
                 query_texts=[str(agent_id)],
                 n_results=10
@@ -202,8 +204,8 @@ class Orchestrator:
             logging.error(f"Failed to update the vector database. Error: {e}")
             raise
 
-
     # @abstractmethod
+
     def get_vector_db(self):
         """Retrieve the vector database"""
         return self.collection
@@ -224,7 +226,7 @@ class Orchestrator:
             logging.error(f"Failed to append the agent output to database. Error: {e}")
             raise
 
-    def run(self, objective:str):
+    def run(self, objective: str):
         """Runs"""
         if not objective or not isinstance(objective, str):
             logging.error("Invalid objective")
@@ -280,7 +282,7 @@ class Orchestrator:
             self.model_name
         )
 
-        #store the mesage in the vector database
+        # store the mesage in the vector database
         self.collection.add(
             embeddings=[message_vector],
             documents=[message],
@@ -291,9 +293,6 @@ class Orchestrator:
             objective=f"chat with agent {receiver_id} about {message}"
         )
 
-        
-
-    
     def add_agents(
         self,
         num_agents: int
@@ -311,4 +310,3 @@ class Orchestrator:
         self.executor = ThreadPoolExecutor(
             max_workers=self.agents.qsize()
         )
-    

swarms/swarms/scable_groupchat.py

@@ -13,6 +13,7 @@ class TaskStatus(Enum):
     COMPLETED = 3
     FAILED = 4
 
+
 class ScalableGroupChat:
     """
     This is a class to enable scalable groupchat like a telegram, it takes an Worker as an input
@@ -26,6 +27,7 @@ class ScalableGroupChat:
     -> every worker can communicate without restrictions in parallel
 
     """
+
     def __init__(
         self,
         worker_count: int = 5,
@@ -61,7 +63,6 @@ class ScalableGroupChat:
 
         return embedding
 
-    
     def retrieve_results(
         self,
         agent_id: int
@@ -69,7 +70,7 @@ class ScalableGroupChat:
         """Retrieve results from a specific agent"""
 
         try:
-            #Query the vector database for documents created by the agents 
+            # Query the vector database for documents created by the agents
             results = self.collection.query(
                 query_texts=[str(agent_id)],
                 n_results=10
@@ -95,13 +96,12 @@ class ScalableGroupChat:
             logging.error(f"Failed to update the vector database. Error: {e}")
             raise
 
-
     # @abstractmethod
+
     def get_vector_db(self):
         """Retrieve the vector database"""
         return self.collection
 
-
     def append_to_db(
         self,
         result: str
@@ -118,8 +118,6 @@ class ScalableGroupChat:
             logging.error(f"Failed to append the agent output to database. Error: {e}")
             raise
 
-    
-    
     def chat(
         self,
         sender_id: int,
@@ -148,7 +146,7 @@ class ScalableGroupChat:
             message,
         )
 
-        #store the mesage in the vector database
+        # store the mesage in the vector database
         self.collection.add(
             embeddings=[message_vector],
             documents=[message],
@@ -158,5 +156,3 @@ class ScalableGroupChat:
         self.run(
             objective=f"chat with agent {receiver_id} about {message}"
         )
-
-

swarms/swarms/simple_swarm.py

@@ -1,12 +1,14 @@
 from swarms.workers.worker import Worker
 from queue import Queue, PriorityQueue
 
+
 class SimpleSwarm:
     def __init__(
-       self,
+        self,
-       num_workers,
+        num_workers: int = None,
-       openai_api_key,
+        openai_api_key: str = None,
-       ai_name
+        ai_name: str = None,
+        rounds: int = 1,
     ):
         """
 
@@ -37,14 +39,14 @@ class SimpleSwarm:
 
         """
         self.workers = [
-            Worker(openai_api_key, ai_name) for _ in range(num_workers)
+            Worker(ai_name, ai_name, openai_api_key) for _ in range(num_workers)
         ]
         self.task_queue = Queue()
         self.priority_queue = PriorityQueue()
 
     def distribute(
         self,
-        task,
+        task: str = None,
         priority=None
     ):
         """Distribute a task to the workers"""
@@ -54,7 +56,7 @@ class SimpleSwarm:
             self.task_queue.put(task)
 
     def _process_task(self, task):
-        #TODO, Implement load balancing, fallback mechanism
+        # TODO, Implement load balancing, fallback mechanism
         for worker in self.workers:
             response = worker.run(task)
             if response:
@@ -66,19 +68,18 @@ class SimpleSwarm:
 
         responses = []
 
-        #process high priority tasks first
+        # process high priority tasks first
         while not self.priority_queue.empty():
             _, task = self.priority_queue.get()
             responses.append(self._process_task(task))
 
-        #process normal tasks
+        # process normal tasks
         while not self.task_queue.empty():
             task = self.task_queue.get()
             responses.append(self._process_task(task))
 
         return responses
 
-
     def run_old(self, task):
         responses = []
 

swarms/tools/autogpt.py

@@ -1,3 +1,17 @@
+import interpreter
+from transformers import (
+    BlipForQuestionAnswering,
+    BlipProcessor,
+)
+from PIL import Image
+import torch
+from swarms.utils.logger import logger
+from pydantic import Field
+from langchain.tools.file_management.write import WriteFileTool
+from langchain.tools.file_management.read import ReadFileTool
+from langchain.tools import BaseTool
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.chains.qa_with_sources.loading import BaseCombineDocumentsChain
 import asyncio
 import os
 
@@ -13,16 +27,6 @@ from langchain.docstore.document import Document
 
 ROOT_DIR = "./data/"
 
-from langchain.chains.qa_with_sources.loading import BaseCombineDocumentsChain
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.tools import BaseTool
-from langchain.tools.file_management.read import ReadFileTool
-from langchain.tools.file_management.write import WriteFileTool
-from pydantic import Field
-
-from swarms.utils.logger import logger
-
-
 
 @contextmanager
 def pushd(new_dir):
@@ -34,6 +38,7 @@ def pushd(new_dir):
     finally:
         os.chdir(prev_dir)
 
+
 @tool
 def process_csv(
     llm, csv_file_path: str, instructions: str, output_path: Optional[str] = None
@@ -84,10 +89,12 @@ async def async_load_playwright(url: str) -> str:
         await browser.close()
     return results
 
+
 def run_async(coro):
     event_loop = asyncio.get_event_loop()
     return event_loop.run_until_complete(coro)
 
+
 @tool
 def browse_web_page(url: str) -> str:
     """Verbose way to scrape a whole webpage. Likely to cause issues parsing."""
@@ -97,9 +104,9 @@ def browse_web_page(url: str) -> str:
 def _get_text_splitter():
     return RecursiveCharacterTextSplitter(
         # Set a really small chunk size, just to show.
-        chunk_size = 500,
+        chunk_size=500,
-        chunk_overlap  = 20,
+        chunk_overlap=20,
-        length_function = len,
+        length_function=len,
     )
 
 
@@ -117,7 +124,7 @@ class WebpageQATool(BaseTool):
         results = []
         # TODO: Handle this with a MapReduceChain
         for i in range(0, len(web_docs), 4):
-            input_docs = web_docs[i:i+4]
+            input_docs = web_docs[i:i + 4]
             window_result = self.qa_chain({"input_documents": input_docs, "question": question}, return_only_outputs=True)
             results.append(f"Response from window {i} - {window_result}")
         results_docs = [Document(page_content="\n".join(results), metadata={"source": url})]
@@ -126,8 +133,6 @@ class WebpageQATool(BaseTool):
     async def _arun(self, url: str, question: str) -> str:
         raise NotImplementedError
 
-import interpreter
-
 
 @tool
 def compile(task: str):
@@ -153,16 +158,7 @@ def compile(task: str):
     os.environ["INTERPRETER_CLI_DEBUG"] = True
 
 
-
-
-
 # mm model workers
-import torch
-from PIL import Image
-from transformers import (
-    BlipForQuestionAnswering,
-    BlipProcessor,
-)
 
 
 @tool
@@ -195,5 +191,3 @@ def VQAinference(self, inputs):
     )
 
     return answer
-
-

swarms/tools/base.py

@@ -10,6 +10,7 @@ from langchain.llms.base import BaseLLM
 from langchain.agents.agent import AgentExecutor
 from langchain.agents import load_tools
 
+
 class ToolScope(Enum):
     GLOBAL = "global"
     SESSION = "session"

swarms/tools/code_intepretor.py

@@ -1,8 +1,9 @@
-#props to shroominic
+# props to shroominic
 from swarms.tools.base import Tool, ToolException
 from typing import Any, List
 from codeinterpreterapi import CodeInterpreterSession, File, ToolException
 
+
 class CodeInterpreter(Tool):
     def __init__(self, name: str, description: str):
         super().__init__(name, description, self.run)
@@ -51,6 +52,7 @@ class CodeInterpreter(Tool):
             # terminate the session
             await session.astop()
 
+
 """
 
 tool = CodeInterpreter("Code Interpreter", "A tool to interpret code and generate useful outputs.")

swarms/tools/developer.py

@@ -25,7 +25,7 @@ from swarms.tools.base import BaseToolSet, SessionGetter, ToolScope, tool
 from swarms.utils.logger import logger
 from swarms.utils.main import ANSI, Color, Style  # test
 
-#helpers
+# helpers
 PipeType = Union[Literal["stdout"], Literal["stderr"]]
 
 
@@ -42,7 +42,6 @@ def verify(func):
     return wrapper
 
 
-
 class SyscallTimeoutException(Exception):
     def __init__(self, pid: int, *args) -> None:
         super().__init__(f"deadline exceeded while waiting syscall for {pid}", *args)
@@ -132,8 +131,6 @@ class SyscallTracer:
         return exitcode, reason
 
 
-
-
 class StdoutTracer:
     def __init__(
         self,
@@ -196,7 +193,6 @@ class StdoutTracer:
         return (exitcode, output)
 
 
-
 class Terminal(BaseToolSet):
     def __init__(self):
         self.sessions: Dict[str, List[SyscallTracer]] = {}
@@ -242,7 +238,6 @@ class Terminal(BaseToolSet):
 #############
 
 
-
 @tool(
     name="Terminal",
     description="Executes commands in a terminal."
@@ -281,8 +276,6 @@ def terminal_execute(self, commands: str, get_session: SessionGetter) -> str:
     return output
 
 
-
-
 """
 write protocol:
 
@@ -291,7 +284,6 @@ write protocol:
 """
 
 
-
 class WriteCommand:
     separator = "\n"
 
@@ -316,7 +308,7 @@ class WriteCommand:
     @staticmethod
     def from_str(command: str) -> "WriteCommand":
         filepath = command.split(WriteCommand.separator)[0]
-        return WriteCommand(filepath, command[len(filepath) + 1 :])
+        return WriteCommand(filepath, command[len(filepath) + 1:])
 
 
 class CodeWriter:
@@ -329,15 +321,13 @@ class CodeWriter:
         return WriteCommand.from_str(command).with_mode("a").execute()
 
 
-
-
-
-
 """
 read protocol:
 
 <filepath>|<start line>-<end line>
 """
+
+
 class Line:
     def __init__(self, content: str, line_number: int, depth: int):
         self.__content: str = content
@@ -445,7 +435,7 @@ class ReadCommand:
         if self.start == self.end:
             code = code[self.start - 1]
         else:
-            code = "".join(code[self.start - 1 : self.end])
+            code = "".join(code[self.start - 1: self.end])
         return code
 
     @staticmethod
@@ -500,10 +490,6 @@ class CodeReader:
         return SummaryCommand.from_str(command).execute()
 
 
-
-
-
-
 """
 patch protocol:
 
@@ -563,7 +549,6 @@ test.py|11,16|11,16|_titles
 """
 
 
-
 class Position:
     separator = ","
 
@@ -607,9 +592,9 @@ class PatchCommand:
         lines[self.start.line] = (
             lines[self.start.line][: self.start.col]
             + self.content
-            + lines[self.end.line][self.end.col :]
+            + lines[self.end.line][self.end.col:]
         )
-        lines = lines[: self.start.line + 1] + lines[self.end.line + 1 :]
+        lines = lines[: self.start.line + 1] + lines[self.end.line + 1:]
 
         after = self.write_lines(lines)
 
@@ -664,11 +649,6 @@ class CodePatcher:
         return written, deleted
 
 
-
-
-
-
-
 class CodeEditor(BaseToolSet):
     @tool(
         name="CodeEditor.READ",
@@ -825,6 +805,7 @@ def code_editor_read(self, inputs: str) -> str:
     )
     return output
 
+
 @tool(
     name="CodeEditor.SUMMARY",
     description="Summary code. "
@@ -845,6 +826,7 @@ def code_editor_summary(self, inputs: str) -> str:
     )
     return output
 
+
 @tool(
     name="CodeEditor.APPEND",
     description="Append code to the existing file. "
@@ -867,6 +849,7 @@ def code_editor_append(self, inputs: str) -> str:
     )
     return output
 
+
 @tool(
     name="CodeEditor.WRITE",
     description="Write code to create a new tool. "
@@ -890,6 +873,7 @@ def code_editor_write(self, inputs: str) -> str:
     )
     return output
 
+
 @tool(
     name="CodeEditor.PATCH",
     description="Patch the code to correct the error if an error occurs or to improve it. "
@@ -920,6 +904,7 @@ def code_editor_patch(self, patches: str) -> str:
     )
     return output
 
+
 @tool(
     name="CodeEditor.DELETE",
     description="Delete code in file for a new start. "

swarms/tools/exit_conversation.py

@@ -20,6 +20,3 @@ class ExitConversation(BaseToolSet):
         logger.debug("\nProcessed ExitConversation.")
 
         return message
-    
-
-

swarms/tools/mm_models.py

@@ -223,7 +223,6 @@ class VisualQuestionAnswering(BaseToolSet):
         return answer
 
 
-
 class ImageCaptioning(BaseHandler):
     def __init__(self, device):
         print("Initializing ImageCaptioning to %s" % device)
@@ -256,8 +255,3 @@ class ImageCaptioning(BaseHandler):
         )
 
         return IMAGE_PROMPT.format(filename=filename, description=description)
-    
-
-
-
-

swarms/tools/requests.py

@@ -35,4 +35,3 @@ class RequestsGet(BaseToolSet):
         )
 
         return content
-

swarms/tools/stt.py

@@ -1,4 +1,4 @@
-#speech to text tool
+# speech to text tool
 
 import os
 import subprocess
@@ -10,14 +10,14 @@ from pytube import YouTube
 
 class SpeechToText:
     def __init__(
-            self, 
+        self,
-            video_url, 
+        video_url,
-            audio_format='mp3',
+        audio_format='mp3',
-            device='cuda',
+        device='cuda',
-            batch_size = 16,
+        batch_size=16,
-            compute_type = "float16",
+        compute_type="float16",
-            hf_api_key = None
+        hf_api_key=None
-        ):
+    ):
         """
         # Example usage
         video_url = "url"
@@ -38,7 +38,6 @@ class SpeechToText:
         subprocess.run(["pip", "install", "pytube"])
         subprocess.run(["pip", "install", "pydub"])
 
-
     def download_youtube_video(self):
         audio_file = f'video.{self.audio_format}'
 
@@ -121,5 +120,3 @@ class SpeechToText:
             return transcription
         except KeyError:
             print("The key 'segments' is not found in the result.")
-
-

swarms/utils/decorators.py

@@ -13,6 +13,7 @@ def log_decorator(func):
         return result
     return wrapper
 
+
 def error_decorator(func):
     def wrapper(*args, **kwargs):
         try:
@@ -22,6 +23,7 @@ def error_decorator(func):
             raise
     return wrapper
 
+
 def timing_decorator(func):
     def wrapper(*args, **kwargs):
         start_time = time.time()
@@ -31,6 +33,7 @@ def timing_decorator(func):
         return result
     return wrapper
 
+
 def retry_decorator(max_retries=5):
     def decorator(func):
         @functools.wraps(func)
@@ -44,16 +47,20 @@ def retry_decorator(max_retries=5):
         return wrapper
     return decorator
 
+
 def singleton_decorator(cls):
     instances = {}
+
     def wrapper(*args, **kwargs):
         if cls not in instances:
             instances[cls] = cls(*args, **kwargs)
         return instances[cls]
     return wrapper
 
+
 def synchronized_decorator(func):
     func.__lock__ = threading.Lock()
+
     def wrapper(*args, **kwargs):
         with func.__lock__:
             return func(*args, **kwargs)
@@ -67,6 +74,7 @@ def deprecated_decorator(func):
         return func(*args, **kwargs)
     return wrapper
 
+
 def validate_inputs_decorator(validator):
     def decorator(func):
         @functools.wraps(func)
@@ -76,4 +84,3 @@ def validate_inputs_decorator(validator):
             return func(*args, **kwargs)
         return wrapper
     return decorator
-

swarms/utils/main.py

@@ -1,3 +1,12 @@
+import pandas as pd
+from swarms.models.prompts.prebuild.multi_modal_prompts import DATAFRAME_PROMPT
+import requests
+from typing import Dict
+from enum import Enum
+from pathlib import Path
+import shutil
+import boto3
+from abc import ABC, abstractmethod, abstractstaticmethod
 import os
 import random
 import uuid
@@ -13,7 +22,7 @@ def seed_everything(seed):
 
         torch.manual_seed(seed)
         torch.cuda.manual_seed_all(seed)
-    except:
+    except BaseException:
         pass
     return seed
 
@@ -75,16 +84,10 @@ def get_new_dataframe_name(org_img_name, func_name="update"):
             this_new_uuid, func_name, recent_prev_file_name, most_org_file_name
         )
     return os.path.join(head, new_file_name)
-#########=======================> utils end
+# =======================> utils end
-
-
 
 
-
+# =======================> ANSI BEGINNING
-
-
-
-#########=======================> ANSI BEGINNING
 
 
 class Code:
@@ -200,13 +203,10 @@ def dim_multiline(message: str) -> str:
         return lines[0]
     return lines[0] + ANSI("\n... ".join([""] + lines[1:])).to(Color.black().bright())
 
-#+=============================> ANSI Ending
+# +=============================> ANSI Ending
-
 
-#================================> upload base
-
-from abc import ABC, abstractmethod, abstractstaticmethod
 
+# ================================> upload base
 
 
 STATIC_DIR = "static"
@@ -221,13 +221,10 @@ class AbstractUploader(ABC):
     def from_settings() -> "AbstractUploader":
         pass
 
-#================================> upload end
+# ================================> upload end
-
 
-#========================= upload s3
 
-
+# ========================= upload s3
-import boto3
 
 
 class S3Uploader(AbstractUploader):
@@ -259,11 +256,10 @@ class S3Uploader(AbstractUploader):
         self.client.upload_file(filepath, self.bucket, object_name)
         return self.get_url(object_name)
 
-#========================= upload s3
+# ========================= upload s3
 
-#========================> upload/static
+
-import shutil
+# ========================> upload/static
-from pathlib import Path
 
 
 class StaticUploader(AbstractUploader):
@@ -277,8 +273,6 @@ class StaticUploader(AbstractUploader):
         server = os.environ.get("SERVER", "http://localhost:8000")
         return StaticUploader(server, path, endpoint)
 
-
-
     def get_url(self, uploaded_path: str) -> str:
         return f"{self.server}/{uploaded_path}"
 
@@ -291,14 +285,8 @@ class StaticUploader(AbstractUploader):
         return f"{self.server}/{endpoint_path}"
 
 
+# ========================> handlers/base
 
-#========================> handlers/base
-
-import uuid
-from enum import Enum
-from typing import Dict
-
-import requests
 
 # from env import settings
 
@@ -371,7 +359,7 @@ class FileHandler:
     def handle(self, url: str) -> str:
         try:
             if url.startswith(os.environ.get("SERVER", "http://localhost:8000")):
-                local_filepath = url[len(os.environ.get("SERVER", "http://localhost:8000")) + 1 :]
+                local_filepath = url[len(os.environ.get("SERVER", "http://localhost:8000")) + 1:]
                 local_filename = Path("file") / local_filepath.split("/")[-1]
                 src = self.path / local_filepath
                 dst = self.path / os.environ.get("PLAYGROUND_DIR", "./playground") / local_filename
@@ -391,18 +379,12 @@ class FileHandler:
             return handler.handle(local_filename)
         except Exception as e:
             raise e
-########################### =>  base end
+# =>  base end
 
 
+# ===========================>
 
 
-
-
-#############===========================>
-
-from swarms.models.prompts.prebuild.multi_modal_prompts import DATAFRAME_PROMPT
-
-import pandas as pd
 class CsvToDataframe(BaseHandler):
     def handle(self, filename: str):
         df = pd.read_csv(filename)
@@ -417,7 +399,3 @@ class CsvToDataframe(BaseHandler):
         )
 
         return DATAFRAME_PROMPT.format(filename=filename, description=description)
-
-
-
-

swarms/utils/static.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 from swarms.utils.main import AbstractUploader
 
+
 class StaticUploader(AbstractUploader):
     def __init__(self, server: str, path: Path, endpoint: str):
         self.server = server

swarms/workers/__init__.py

@@ -1 +1,2 @@
 from swarms.workers.worker import Worker
+from swarms.workers.base import AbstractWorker

swarms/workers/base.py

@@ -0,0 +1,96 @@
+from typing import Dict, List, Optional, Union
+
+
+class AbstractWorker:
+    """(In preview) An abstract class for AI worker.
+
+    An worker can communicate with other workers and perform actions.
+    Different workers can differ in what actions they perform in the `receive` method.
+    """
+
+    def __init__(
+        self,
+        name: str,
+    ):
+        """
+        Args:
+            name (str): name of the worker.
+        """
+        # a dictionary of conversations, default value is list
+        self._name = name
+
+    @property
+    def name(self):
+        """Get the name of the worker."""
+        return self._name
+
+    def run(
+        self,
+        task: str
+    ):
+        """Run the worker agent once"""
+
+    def send(
+        self,
+        message: Union[Dict, str],
+        recipient,  # add AbstractWorker
+        request_reply: Optional[bool] = None
+    ):
+        """(Abstract method) Send a message to another worker."""
+
+    async def a_send(
+        self,
+        message: Union[Dict, str],
+        recipient,  # add AbstractWorker
+        request_reply: Optional[bool] = None
+    ):
+        """(Aabstract async method) Send a message to another worker."""
+
+    def receive(
+        self,
+        message: Union[Dict, str],
+        sender,  # add AbstractWorker
+        request_reply: Optional[bool] = None
+    ):
+        """(Abstract method) Receive a message from another worker."""
+
+    async def a_receive(
+        self,
+        message: Union[Dict, str],
+        sender,  # add AbstractWorker
+        request_reply: Optional[bool] = None
+    ):
+        """(Abstract async method) Receive a message from another worker."""
+
+    def reset(self):
+        """(Abstract method) Reset the worker."""
+
+    def generate_reply(
+        self,
+        messages: Optional[List[Dict]] = None,
+        sender=None,  # Optional["AbstractWorker"] = None,
+        **kwargs,
+    ) -> Union[str, Dict, None]:
+        """(Abstract method) Generate a reply based on the received messages.
+
+        Args:
+            messages (list[dict]): a list of messages received.
+            sender: sender of an Agent instance.
+        Returns:
+            str or dict or None: the generated reply. If None, no reply is generated.
+        """
+
+    async def a_generate_reply(
+        self,
+        messages: Optional[List[Dict]] = None,
+        sender=None,  # Optional["AbstractWorker"] = None,
+        **kwargs,
+    ) -> Union[str, Dict, None]:
+        """(Abstract async method) Generate a reply based on the received messages.
+
+        Args:
+            messages (list[dict]): a list of messages received.
+            sender: sender of an Agent instance.
+        Returns:
+            str or dict or None: the generated reply. If None, no reply is generated.
+        """