swarms 7.6.1__py3-none-any.whl → 7.6.4__py3-none-any.whl

swarms/structs/rearrange.py

@@ -2,20 +2,21 @@ import asyncio
 import json
 import uuid
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
-from pydantic import BaseModel, Field
 
-from swarms.schemas.agent_step_schemas import ManySteps
 from swarms.structs.agent import Agent
-from swarms.structs.agents_available import showcase_available_agents
 from swarms.structs.base_swarm import BaseSwarm
 
+from swarms.utils.any_to_str import any_to_str
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
 from swarms.utils.loguru_logger import initialize_logger
 from swarms.telemetry.main import log_agent_data
 from swarms.structs.conversation import Conversation
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
+from swarms.structs.multi_agent_exec import get_agents_info
 
 logger = initialize_logger(log_folder="rearrange")
 
@@ -24,35 +25,6 @@ def swarm_id():
     return uuid.uuid4().hex
 
 
-class AgentRearrangeInput(BaseModel):
-    swarm_id: Optional[str] = None
-    name: Optional[str] = None
-    description: Optional[str] = None
-    flow: Optional[str] = None
-    max_loops: Optional[int] = None
-    time: str = Field(
-        default_factory=lambda: datetime.now().strftime(
-            "%Y-%m-%d %H:%M:%S"
-        ),
-        description="The time the agent was created.",
-    )
-    output_type: OutputType = Field(default="final")
-
-
-class AgentRearrangeOutput(BaseModel):
-    output_id: str = Field(
-        default=swarm_id(), description="Output-UUID"
-    )
-    input: Optional[AgentRearrangeInput] = None
-    outputs: Optional[List[ManySteps]] = None
-    time: str = Field(
-        default_factory=lambda: datetime.now().strftime(
-            "%Y-%m-%d %H:%M:%S"
-        ),
-        description="The time the agent was created.",
-    )
-
-
 class AgentRearrange(BaseSwarm):
     """
     A class representing a swarm of agents for rearranging tasks.
@@ -117,6 +89,7 @@ class AgentRearrange(BaseSwarm):
         autosave: bool = True,
         return_entire_history: bool = False,
         rules: str = None,
+        team_awareness: bool = False,
         *args,
         **kwargs,
     ):
@@ -146,56 +119,18 @@ class AgentRearrange(BaseSwarm):
         self.no_use_clusterops = no_use_clusterops
         self.autosave = autosave
         self.return_entire_history = return_entire_history
-        self.output_schema = AgentRearrangeOutput(
-            input=AgentRearrangeInput(
-                swarm_id=id,
-                name=name,
-                description=description,
-                flow=flow,
-                max_loops=max_loops,
-            ),
-            outputs=[],
-        )
 
-        self.conversation = Conversation()
+        self.conversation = Conversation(
+            time_enabled=False, token_count=False
+        )
 
         if rules:
-            self.conversation.add("user", rules)
-
-    def showcase_agents(self):
-        # Get formatted agent info once
-        agents_available = showcase_available_agents(
-            name=self.name,
-            description=self.description,
-            agents=self.agents,
-            format="Table",
-        )
+            self.conversation.add("User", rules)
 
-        return agents_available
+        if team_awareness is True:
+            agents_info = get_agents_info(self.agents, self.name)
 
-    def rearrange_prompt_prep(self) -> str:
-        """Prepares a formatted prompt describing the swarm configuration.
-
-        Returns:
-            str: A formatted string containing the swarm's name, description,
-                 flow pattern, and participating agents.
-        """
-        agents_available = self.showcase_agents()
-        prompt = f"""
-        ===== Swarm Configuration =====
-        
-        Name: {self.name}
-        Description: {self.description}
-        
-        ===== Execution Flow =====
-        {self.flow}
-        
-        ===== Participating Agents =====
-        {agents_available}
-        
-        ===========================
-        """
-        return prompt
+            self.conversation.add("Your Swarm", agents_info)
 
     def set_custom_flow(self, flow: str):
         self.flow = flow
@@ -313,7 +248,7 @@ class AgentRearrange(BaseSwarm):
             Exception: For any other errors during execution
         """
         try:
-            self.conversation.add("user", task)
+            self.conversation.add("User", task)
 
             if not self.validate_flow():
                 logger.error("Flow validation failed")
@@ -321,15 +256,13 @@ class AgentRearrange(BaseSwarm):
 
             tasks = self.flow.split("->")
             current_task = task
-            all_responses = []
             response_dict = {}
-            previous_agent = None
 
             logger.info(
                 f"Starting task execution with {len(tasks)} steps"
             )
 
-            # Handle custom tasks
+            # # Handle custom tasks
             if custom_tasks is not None:
                 logger.info("Processing custom tasks")
                 c_agent_name, c_task = next(
@@ -354,150 +287,65 @@ class AgentRearrange(BaseSwarm):
                         name.strip() for name in task.split(",")
                     ]
 
-                    # Prepare prompt with previous agent info
-                    prompt_prefix = ""
-                    if previous_agent and task_idx > 0:
-                        prompt_prefix = f"Previous agent {previous_agent} output: {current_task}\n"
-                    elif task_idx == 0:
-                        prompt_prefix = "Initial task: "
-
                     if len(agent_names) > 1:
                         # Parallel processing
                         logger.info(
                             f"Running agents in parallel: {agent_names}"
                         )
-                        results = []
 
                         for agent_name in agent_names:
-                            if agent_name == "H":
-                                if (
-                                    self.human_in_the_loop
-                                    and self.custom_human_in_the_loop
-                                ):
-                                    current_task = (
-                                        self.custom_human_in_the_loop(
-                                            prompt_prefix
-                                            + str(current_task)
-                                        )
-                                    )
-                                else:
-                                    current_task = input(
-                                        prompt_prefix
-                                        + "Enter your response: "
-                                    )
-                                results.append(current_task)
-                                response_dict[agent_name] = (
-                                    current_task
-                                )
-                            else:
-                                agent = self.agents[agent_name]
-                                task_with_context = (
-                                    prompt_prefix + str(current_task)
-                                    if current_task
-                                    else prompt_prefix
-                                )
-                                result = agent.run(
-                                    task=task_with_context,
-                                    img=img,
-                                    is_last=is_last,
-                                    *args,
-                                    **kwargs,
-                                )
-                                result = str(result)
-                                self.conversation.add(
-                                    agent.agent_name, result
-                                )
-                                results.append(result)
-                                response_dict[agent_name] = result
-                                self.output_schema.outputs.append(
-                                    agent.agent_output
-                                )
-                                logger.debug(
-                                    f"Agent {agent_name} output: {result}"
-                                )
-
-                        current_task = "; ".join(results)
-                        all_responses.extend(results)
-                        previous_agent = ",".join(agent_names)
-
-                    else:
-                        # Sequential processing
-                        logger.info(
-                            f"Running agent sequentially: {agent_names[0]}"
-                        )
-                        agent_name = agent_names[0]
-
-                        if agent_name == "H":
-                            if (
-                                self.human_in_the_loop
-                                and self.custom_human_in_the_loop
-                            ):
-                                current_task = (
-                                    self.custom_human_in_the_loop(
-                                        prompt_prefix
-                                        + str(current_task)
-                                    )
-                                )
-                            else:
-                                current_task = input(
-                                    prompt_prefix
-                                    + "Enter the next task: "
-                                )
-                            response_dict[agent_name] = current_task
-                        else:
                             agent = self.agents[agent_name]
-                            task_with_context = (
-                                prompt_prefix + str(current_task)
-                                if current_task
-                                else prompt_prefix
-                            )
-                            current_task = agent.run(
-                                task=task_with_context,
+                            result = agent.run(
+                                task=self.conversation.get_str(),
                                 img=img,
                                 is_last=is_last,
                                 *args,
                                 **kwargs,
                             )
-                            current_task = str(current_task)
+                            result = any_to_str(result)
+
                             self.conversation.add(
-                                agent.agent_name, current_task
-                            )
-                            response_dict[agent_name] = current_task
-                            self.output_schema.outputs.append(
-                                agent.agent_output
+                                agent.agent_name, result
                             )
+
+                            response_dict[agent_name] = result
                             logger.debug(
-                                f"Agent {agent_name} output: {current_task}"
+                                f"Agent {agent_name} output: {result}"
                             )
 
-                        all_responses.append(
-                            f"Agent Name: {agent.agent_name} \n Output: {current_task} "
+                        ",".join(agent_names)
+
+                    else:
+                        # Sequential processing
+                        logger.info(
+                            f"Running agent sequentially: {agent_names[0]}"
                         )
-                        previous_agent = agent_name
+                        agent_name = agent_names[0]
 
-                loop_count += 1
+                        agent = self.agents[agent_name]
 
-            logger.info("Task execution completed")
+                        current_task = agent.run(
+                            task=self.conversation.get_str(),
+                            img=img,
+                            is_last=is_last,
+                            *args,
+                            **kwargs,
+                        )
+                        current_task = any_to_str(current_task)
 
-            if self.return_json:
-                return self.output_schema.model_dump_json(indent=4)
+                        self.conversation.add(
+                            agent.agent_name, current_task
+                        )
 
-            if self.return_entire_history:
-                return self.output_schema.model_dump_json(indent=4)
+                        response_dict[agent_name] = current_task
 
-            # Handle different output types
-            if self.output_type == "all":
-                output = " ".join(all_responses)
-            elif self.output_type == "list":
-                output = all_responses
-            elif self.output_type == "dict":
-                output = (
-                    self.conversation.return_messages_as_dictionary()
-                )
-            else:  # "final"
-                output = current_task
+                loop_count += 1
+
+            logger.info("Task execution completed")
 
-            return output
+            return history_output_formatter(
+                self.conversation, self.output_type
+            )
 
         except Exception as e:
             self._catch_error(e)
@@ -542,13 +390,19 @@ class AgentRearrange(BaseSwarm):
             The result from executing the task through the cluster operations wrapper.
         """
         try:
-            return self._run(
+            log_agent_data(self.to_dict())
+
+            out = self._run(
                 task=task,
                 img=img,
                 *args,
                 **kwargs,
             )
 
+            log_agent_data(self.to_dict())
+
+            return out
+
         except Exception as e:
             self._catch_error(e)
 
@@ -780,6 +634,8 @@ class AgentRearrange(BaseSwarm):
 
 
 def rearrange(
+    name: str = None,
+    description: str = None,
     agents: List[Agent] = None,
     flow: str = None,
     task: str = None,
@@ -807,6 +663,11 @@ def rearrange(
         rearrange(agents, flow, task)
     """
     agent_system = AgentRearrange(
-        agents=agents, flow=flow, *args, **kwargs
+        name=name,
+        description=description,
+        agents=agents,
+        flow=flow,
+        *args,
+        **kwargs,
     )
-    return agent_system.run(task, img=img, *args, **kwargs)
+    return agent_system.run(task=task, img=img)

swarms/structs/sequential_workflow.py

@@ -1,8 +1,9 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import List, Optional
+
 from swarms.structs.agent import Agent
+from swarms.structs.output_types import OutputType
 from swarms.structs.rearrange import AgentRearrange
-from swarms.structs.output_type import OutputType
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from swarms.utils.loguru_logger import initialize_logger
 
 logger = initialize_logger(log_folder="sequential_workflow")
@@ -10,18 +11,20 @@ logger = initialize_logger(log_folder="sequential_workflow")
 
 class SequentialWorkflow:
     """
-    Initializes a SequentialWorkflow object, which orchestrates the execution of a sequence of agents.
+    A class that orchestrates the execution of a sequence of agents in a defined workflow.
 
     Args:
         name (str, optional): The name of the workflow. Defaults to "SequentialWorkflow".
         description (str, optional): A description of the workflow. Defaults to "Sequential Workflow, where agents are executed in a sequence."
-        agents (List[Agent], optional): The list of agents in the workflow. Defaults to None.
-        max_loops (int, optional): The maximum number of loops to execute the workflow. Defaults to 1.
-        *args: Variable length argument list.
-        **kwargs: Arbitrary keyword arguments.
+        agents (List[Agent], optional): A list of agents that will be part of the workflow. Defaults to an empty list.
+        max_loops (int, optional): The maximum number of times to execute the workflow. Defaults to 1.
+        output_type (OutputType, optional): The format of the output from the workflow. Defaults to "dict".
+        shared_memory_system (callable, optional): A callable for managing shared memory between agents. Defaults to None.
+        *args: Additional positional arguments.
+        **kwargs: Additional keyword arguments.
 
     Raises:
-        ValueError: If agents list is None or empty, or if max_loops is 0
+        ValueError: If the agents list is None or empty, or if max_loops is set to 0.
     """
 
     def __init__(
@@ -31,9 +34,7 @@ class SequentialWorkflow:
         agents: List[Agent] = [],
         max_loops: int = 1,
         output_type: OutputType = "dict",
-        return_json: bool = False,
         shared_memory_system: callable = None,
-        return_entire_history: bool = False,
         *args,
         **kwargs,
     ):
@@ -42,9 +43,7 @@ class SequentialWorkflow:
         self.agents = agents
         self.max_loops = max_loops
         self.output_type = output_type
-        self.return_json = return_json
         self.shared_memory_system = shared_memory_system
-        self.return_entire_history = return_entire_history
 
         self.reliability_check()
         self.flow = self.sequential_flow()
@@ -56,7 +55,6 @@ class SequentialWorkflow:
             flow=self.flow,
             max_loops=max_loops,
             output_type=output_type,
-            return_json=return_json,
             shared_memory_system=shared_memory_system,
             *args,
             **kwargs,
@@ -101,7 +99,7 @@ class SequentialWorkflow:
         if self.max_loops == 0:
             raise ValueError("max_loops cannot be 0")
 
-        logger.info("Checks completed your swarm is ready.")
+        logger.info("Checks completed; your swarm is ready.")
 
     def run(
         self,
@@ -114,25 +112,25 @@ class SequentialWorkflow:
         no_use_clusterops: bool = True,
         *args,
         **kwargs,
-    ) -> str:
+    ):
         """
-        Executes a task through the agents in the dynamically constructed flow.
+        Executes a specified task through the agents in the dynamically constructed flow.
 
         Args:
             task (str): The task for the agents to execute.
-            device (str): The device to use for the agents to execute.
-            all_cores (bool): Whether to use all cores.
-            all_gpus (bool): Whether to use all gpus.
-            device_id (int): The device id to use for the agents to execute.
-            no_use_clusterops (bool): Whether to use clusterops.
-
+            img (Optional[str]): An optional image input for the agents.
+            device (str): The device to use for the agents to execute. Defaults to "cpu".
+            all_cores (bool): Whether to utilize all CPU cores. Defaults to False.
+            all_gpus (bool): Whether to utilize all available GPUs. Defaults to False.
+            device_id (int): The specific device ID to use for execution. Defaults to 0.
+            no_use_clusterops (bool): Whether to avoid using cluster operations. Defaults to True.
 
         Returns:
             str: The final result after processing through all agents.
 
         Raises:
-            ValueError: If task is None or empty
-            Exception: If any error occurs during task execution
+            ValueError: If the task is None or empty.
+            Exception: If any error occurs during task execution.
         """
 
         try:
@@ -143,17 +141,6 @@ class SequentialWorkflow:
                 **kwargs,
             )
 
-            if self.output_type == "dict":
-                result = (
-                    self.agent_rearrange.conversation.return_messages_as_dictionary()
-                )
-            elif self.output_type == "list":
-                result = (
-                    self.agent_rearrange.conversation.return_messages_as_list()
-                )
-            elif self.output_type == "str" or self.return_json:
-                result = self.agent_rearrange.conversation.get_str()
-
             return result
         except Exception as e:
             logger.error(
@@ -161,7 +148,7 @@ class SequentialWorkflow:
             )
             raise e
 
-    def __call__(self, task: str, *args, **kwargs) -> str:
+    def __call__(self, task: str, *args, **kwargs):
         return self.run(task, *args, **kwargs)
 
     def run_batched(self, tasks: List[str]) -> List[str]:
@@ -169,14 +156,14 @@ class SequentialWorkflow:
         Executes a batch of tasks through the agents in the dynamically constructed flow.
 
         Args:
-            tasks (List[str]): The tasks for the agents to execute.
+            tasks (List[str]): A list of tasks for the agents to execute.
 
         Returns:
-            List[str]: The final results after processing through all agents.
+            List[str]: A list of final results after processing through all agents.
 
         Raises:
-            ValueError: If tasks is None or empty
-            Exception: If any error occurs during task execution
+            ValueError: If tasks is None or empty.
+            Exception: If any error occurs during task execution.
         """
         if not tasks or not all(
             isinstance(task, str) for task in tasks
@@ -195,7 +182,7 @@ class SequentialWorkflow:
 
     async def run_async(self, task: str) -> str:
         """
-        Executes the task through the agents in the dynamically constructed flow asynchronously.
+        Executes the specified task through the agents in the dynamically constructed flow asynchronously.
 
         Args:
             task (str): The task for the agents to execute.
@@ -204,8 +191,8 @@ class SequentialWorkflow:
             str: The final result after processing through all agents.
 
         Raises:
-            ValueError: If task is None or empty
-            Exception: If any error occurs during task execution
+            ValueError: If task is None or empty.
+            Exception: If any error occurs during task execution.
         """
         if not task or not isinstance(task, str):
             raise ValueError("Task must be a non-empty string")
@@ -223,14 +210,14 @@ class SequentialWorkflow:
         Executes a batch of tasks through the agents in the dynamically constructed flow concurrently.
 
         Args:
-            tasks (List[str]): The tasks for the agents to execute.
+            tasks (List[str]): A list of tasks for the agents to execute.
 
         Returns:
-            List[str]: The final results after processing through all agents.
+            List[str]: A list of final results after processing through all agents.
 
         Raises:
-            ValueError: If tasks is None or empty
-            Exception: If any error occurs during task execution
+            ValueError: If tasks is None or empty.
+            Exception: If any error occurs during task execution.
         """
         if not tasks or not all(
             isinstance(task, str) for task in tasks

swarms/structs/swarm_router.py

@@ -18,7 +18,7 @@ from swarms.structs.rearrange import AgentRearrange
 from swarms.structs.sequential_workflow import SequentialWorkflow
 from swarms.structs.spreadsheet_swarm import SpreadSheetSwarm
 from swarms.structs.swarm_matcher import swarm_matcher
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 from swarms.utils.loguru_logger import initialize_logger
 from swarms.structs.malt import MALT
 from swarms.structs.deep_research_swarm import DeepResearchSwarm
@@ -193,7 +193,8 @@ class SwarmRouter:
         )
 
         # Handle Automated Prompt Engineering
-        self.activate_ape()
+        if self.auto_generate_prompts is True:
+            self.activate_ape()
 
         # Handle shared memory
         if self.shared_memory_system is not None:

swarms/telemetry/bootup.py

@@ -1,59 +1,40 @@
 import os
-import logging
 import warnings
-import concurrent.futures
-from dotenv import load_dotenv
-from loguru import logger
+from pathlib import Path
 from swarms.utils.disable_logging import disable_logging
+from loguru import logger
 
 
 def bootup():
-    """Initialize swarms environment and configuration
-
-    Handles environment setup, logging configuration, telemetry,
-    and workspace initialization.
-    """
+    """Super-fast initialization of swarms environment"""
     try:
-        # Load environment variables
-        load_dotenv()
-
-        # Configure logging
-        if (
-            os.getenv("SWARMS_VERBOSE_GLOBAL", "False").lower()
-            == "false"
-        ):
-            logger.disable("")
-            logging.disable(logging.CRITICAL)
+        # Cache env vars
+        verbose = os.getenv("SWARMS_VERBOSE_GLOBAL", "False").lower()
+        workspace_path = Path.cwd() / "agent_workspace"
 
+        # Configure logging early
+        if verbose == "false":
+            logger.disable("CRITICAL")
         else:
             logger.enable("")
 
-        # Silent wandb
+        # Silence wandb
         os.environ["WANDB_SILENT"] = "true"
 
-        # Configure workspace
-        workspace_dir = os.path.join(os.getcwd(), "agent_workspace")
-        os.makedirs(workspace_dir, exist_ok=True)
-        os.environ["WORKSPACE_DIR"] = workspace_dir
+        # Setup workspace dir only if needed
+        if not workspace_path.exists():
+            workspace_path.mkdir(parents=True, exist_ok=True)
+        os.environ["WORKSPACE_DIR"] = str(workspace_path)
 
-        # Suppress warnings
+        # Suppress deprecation warnings
         warnings.filterwarnings("ignore", category=DeprecationWarning)
 
-        # Run telemetry functions concurrently
+        # Run lightweight telemetry
         try:
-            with concurrent.futures.ThreadPoolExecutor(
-                max_workers=2
-            ) as executor:
-
-                future_disable_logging = executor.submit(
-                    disable_logging
-                )
-
-                # Wait for completion and check for exceptions
-                future_disable_logging.result()
+            disable_logging()
         except Exception as e:
-            logger.error(f"Error running telemetry functions: {e}")
+            logger.error(f"Telemetry error: {e}")
 
     except Exception as e:
-        logger.error(f"Error during bootup: {str(e)}")
+        logger.error(f"Bootup error: {str(e)}")
         raise