swarms 7.8.4__py3-none-any.whl → 7.8.7__py3-none-any.whl

swarms/structs/image_batch_processor.py

@@ -0,0 +1,261 @@
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from loguru import logger
+
+from swarms.structs import Agent
+
+
+class ImageProcessingError(Exception):
+    """Custom exception for image processing errors."""
+
+    pass
+
+
+class InvalidAgentError(Exception):
+    """Custom exception for invalid agent configurations."""
+
+    pass
+
+
+class ImageAgentBatchProcessor:
+    """
+    A class for processing multiple images in parallel using one or more agents.
+
+    This processor can:
+    - Handle multiple images from a directory
+    - Process images with single or multiple agents
+    - Execute tasks in parallel
+    - Provide detailed logging and error handling
+
+    Attributes:
+        agents (List[Agent]): List of agents to process images
+        max_workers (int): Maximum number of parallel workers
+        supported_formats (set): Set of supported image formats
+    """
+
+    def __init__(
+        self,
+        agents: Union[Agent, List[Agent], Callable, List[Callable]],
+        max_workers: int = None,
+        supported_formats: Optional[List[str]] = None,
+    ):
+        """
+        Initialize the ImageBatchProcessor.
+
+        Args:
+            agents: Single agent or list of agents to process images
+            max_workers: Maximum number of parallel workers (default: 4)
+            supported_formats: List of supported image formats (default: ['.jpg', '.jpeg', '.png'])
+
+        Raises:
+            InvalidAgentError: If agents parameter is invalid
+        """
+        self.agents = agents
+        self.max_workers = max_workers
+        self.supported_formats = supported_formats
+
+        self.agents = (
+            [agents] if isinstance(agents, Agent) else agents
+        )
+        if not self.agents:
+            raise InvalidAgentError(
+                "At least one agent must be provided"
+            )
+
+        # Get 95% of the total number of cores
+        self.max_workers = int(os.cpu_count() * 0.95)
+
+        self.supported_formats = set(
+            supported_formats or [".jpg", ".jpeg", ".png"]
+        )
+
+        # Setup logging
+        logger.add(
+            "image_processor.log",
+            rotation="100 MB",
+            retention="10 days",
+            level="INFO",
+        )
+
+    def _validate_image_path(
+        self, image_path: Union[str, Path]
+    ) -> Path:
+        """
+        Validate if the image path exists and has supported format.
+
+        Args:
+            image_path: Path to the image file
+
+        Returns:
+            Path: Validated Path object
+
+        Raises:
+            ImageProcessingError: If path is invalid or format not supported
+        """
+        path = Path(image_path)
+        if not path.exists():
+            raise ImageProcessingError(
+                f"Image path does not exist: {path}"
+            )
+        if path.suffix.lower() not in self.supported_formats:
+            raise ImageProcessingError(
+                f"Unsupported image format {path.suffix}. Supported formats: {self.supported_formats}"
+            )
+        return path
+
+    def _process_single_image(
+        self,
+        image_path: Path,
+        tasks: Union[str, List[str]],
+        agent: Agent,
+    ) -> Dict[str, Any]:
+        """
+        Process a single image with one agent and one or more tasks.
+
+        Args:
+            image_path: Path to the image
+            tasks: Single task or list of tasks to perform
+            agent: Agent to process the image
+
+        Returns:
+            Dict containing results for each task
+        """
+        try:
+            tasks_list = [tasks] if isinstance(tasks, str) else tasks
+            results = {}
+
+            logger.info(
+                f"Processing image {image_path} with agent {agent.__class__.__name__}"
+            )
+            start_time = time.time()
+
+            for task in tasks_list:
+                try:
+                    result = agent.run(task=task, img=str(image_path))
+                    results[task] = result
+                except Exception as e:
+                    logger.error(
+                        f"Error processing task '{task}' for image {image_path}: {str(e)}"
+                    )
+                    results[task] = f"Error: {str(e)}"
+
+            processing_time = time.time() - start_time
+            logger.info(
+                f"Completed processing {image_path} in {processing_time:.2f} seconds"
+            )
+
+            return {
+                "image_path": str(image_path),
+                "results": results,
+                "processing_time": processing_time,
+            }
+
+        except Exception as e:
+            logger.error(
+                f"Failed to process image {image_path}: {str(e)}"
+            )
+            raise ImageProcessingError(
+                f"Failed to process image {image_path}: {str(e)}"
+            )
+
+    def run(
+        self,
+        image_paths: Union[str, List[str], Path],
+        tasks: Union[str, List[str]],
+    ) -> List[Dict[str, Any]]:
+        """
+        Process multiple images in parallel with the configured agents.
+
+        Args:
+            image_paths: Single image path or list of image paths or directory path
+            tasks: Single task or list of tasks to perform on each image
+
+        Returns:
+            List of dictionaries containing results for each image
+
+        Raises:
+            ImageProcessingError: If any image processing fails
+        """
+        # Handle directory input
+        if (
+            isinstance(image_paths, (str, Path))
+            and Path(image_paths).is_dir()
+        ):
+            image_paths = [
+                os.path.join(image_paths, f)
+                for f in os.listdir(image_paths)
+                if Path(os.path.join(image_paths, f)).suffix.lower()
+                in self.supported_formats
+            ]
+        elif isinstance(image_paths, (str, Path)):
+            image_paths = [image_paths]
+
+        # Validate all paths
+        validated_paths = [
+            self._validate_image_path(path) for path in image_paths
+        ]
+
+        if not validated_paths:
+            logger.warning("No valid images found to process")
+            return []
+
+        logger.info(
+            f"Starting batch processing of {len(validated_paths)} images"
+        )
+        results = []
+
+        with ThreadPoolExecutor(
+            max_workers=self.max_workers
+        ) as executor:
+            future_to_path = {}
+
+            # Submit all tasks
+            for path in validated_paths:
+                for agent in self.agents:
+                    future = executor.submit(
+                        self._process_single_image, path, tasks, agent
+                    )
+                    future_to_path[future] = (path, agent)
+
+            # Collect results as they complete
+            for future in as_completed(future_to_path):
+                path, agent = future_to_path[future]
+                try:
+                    result = future.result()
+                    results.append(result)
+                except Exception as e:
+                    logger.error(
+                        f"Failed to process {path} with {agent.__class__.__name__}: {str(e)}"
+                    )
+                    results.append(
+                        {
+                            "image_path": str(path),
+                            "error": str(e),
+                            "agent": agent.__class__.__name__,
+                        }
+                    )
+
+        logger.info(
+            f"Completed batch processing of {len(validated_paths)} images"
+        )
+        return results
+
+    def __call__(self, *args, **kwargs):
+        """
+        Make the ImageAgentBatchProcessor callable like a function.
+
+        This allows the processor to be used directly as a function, which will
+        call the run() method with the provided arguments.
+
+        Args:
+            *args: Variable length argument list to pass to run()
+            **kwargs: Arbitrary keyword arguments to pass to run()
+
+        Returns:
+            The result of calling run() with the provided arguments
+        """
+        return self.run(*args, **kwargs)

swarms/structs/interactive_groupchat.py

@@ -0,0 +1,356 @@
+import re
+from typing import Callable, List, Union
+
+from loguru import logger
+
+from swarms.structs.agent import Agent
+from swarms.structs.conversation import Conversation
+from swarms.utils.generate_keys import generate_api_key
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+
+
+class InteractiveGroupChatError(Exception):
+    """Base exception class for InteractiveGroupChat errors"""
+
+    pass
+
+
+class AgentNotFoundError(InteractiveGroupChatError):
+    """Raised when a mentioned agent is not found in the group"""
+
+    pass
+
+
+class NoMentionedAgentsError(InteractiveGroupChatError):
+    """Raised when no agents are mentioned in the task"""
+
+    pass
+
+
+class InvalidTaskFormatError(InteractiveGroupChatError):
+    """Raised when the task format is invalid"""
+
+    pass
+
+
+class InteractiveGroupChat:
+    """
+    An interactive group chat system that enables conversations with multiple agents using @mentions.
+
+    This class allows users to interact with multiple agents by mentioning them using @agent_name syntax.
+    When multiple agents are mentioned, they can see and respond to each other's tasks.
+
+    Attributes:
+        name (str): Name of the group chat
+        description (str): Description of the group chat's purpose
+        agents (List[Union[Agent, Callable]]): List of Agent instances or callable functions
+        max_loops (int): Maximum number of conversation turns
+        conversation (Conversation): Stores the chat history
+        agent_map (Dict[str, Union[Agent, Callable]]): Mapping of agent names to their instances
+
+    Args:
+        name (str, optional): Name of the group chat. Defaults to "InteractiveGroupChat".
+        description (str, optional): Description of the chat. Defaults to "An interactive group chat for multiple agents".
+        agents (List[Union[Agent, Callable]], optional): List of participating agents or callables. Defaults to empty list.
+        max_loops (int, optional): Maximum conversation turns. Defaults to 1.
+        output_type (str, optional): Type of output format. Defaults to "string".
+        interactive (bool, optional): Whether to enable interactive terminal mode. Defaults to False.
+
+    Raises:
+        ValueError: If invalid initialization parameters are provided
+    """
+
+    def __init__(
+        self,
+        id: str = generate_api_key(prefix="swarms-"),
+        name: str = "InteractiveGroupChat",
+        description: str = "An interactive group chat for multiple agents",
+        agents: List[Union[Agent, Callable]] = [],
+        max_loops: int = 1,
+        output_type: str = "string",
+        interactive: bool = False,
+    ):
+        self.id = id
+        self.name = name
+        self.description = description
+        self.agents = agents
+        self.max_loops = max_loops
+        self.output_type = output_type
+        self.interactive = interactive
+
+        # Initialize conversation history
+        self.conversation = Conversation(time_enabled=True)
+
+        # Create a mapping of agent names to agents for easy lookup
+        self.agent_map = {}
+        for agent in agents:
+            if isinstance(agent, Agent):
+                self.agent_map[agent.agent_name] = agent
+            elif callable(agent):
+                # For callable functions, use the function name as the agent name
+                self.agent_map[agent.__name__] = agent
+
+        self._validate_initialization()
+        self._setup_conversation_context()
+        self._update_agent_prompts()
+
+    def _validate_initialization(self) -> None:
+        """
+        Validates the group chat configuration.
+
+        Raises:
+            ValueError: If any required components are missing or invalid
+        """
+        if len(self.agents) < 1:
+            raise ValueError(
+                "At least one agent is required for the group chat"
+            )
+
+        if self.max_loops <= 0:
+            raise ValueError("Max loops must be greater than 0")
+
+    def _setup_conversation_context(self) -> None:
+        """Sets up the initial conversation context with group chat information."""
+        agent_info = []
+        for agent in self.agents:
+            if isinstance(agent, Agent):
+                agent_info.append(
+                    f"- {agent.agent_name}: {agent.system_prompt}"
+                )
+            elif callable(agent):
+                agent_info.append(
+                    f"- {agent.__name__}: Custom callable function"
+                )
+
+        context = (
+            f"Group Chat Name: {self.name}\n"
+            f"Description: {self.description}\n"
+            f"Available Agents:\n" + "\n".join(agent_info)
+        )
+        self.conversation.add(role="System", content=context)
+
+    def _update_agent_prompts(self) -> None:
+        """Updates each agent's system prompt with information about other agents and the group chat."""
+        agent_info = []
+        for agent in self.agents:
+            if isinstance(agent, Agent):
+                agent_info.append(
+                    {
+                        "name": agent.agent_name,
+                        "description": agent.system_prompt,
+                    }
+                )
+            elif callable(agent):
+                agent_info.append(
+                    {
+                        "name": agent.__name__,
+                        "description": "Custom callable function",
+                    }
+                )
+
+        group_context = (
+            f"\n\nYou are part of a group chat named '{self.name}' with the following description: {self.description}\n"
+            f"Other participants in this chat:\n"
+        )
+
+        for agent in self.agents:
+            if isinstance(agent, Agent):
+                # Create context excluding the current agent
+                other_agents = [
+                    info
+                    for info in agent_info
+                    if info["name"] != agent.agent_name
+                ]
+                agent_context = group_context
+                for other in other_agents:
+                    agent_context += (
+                        f"- {other['name']}: {other['description']}\n"
+                    )
+
+                # Update the agent's system prompt
+                agent.system_prompt = (
+                    agent.system_prompt + agent_context
+                )
+                logger.info(
+                    f"Updated system prompt for agent: {agent.agent_name}"
+                )
+
+    def _extract_mentions(self, task: str) -> List[str]:
+        """
+        Extracts @mentions from the task.
+
+        Args:
+            task (str): The input task
+
+        Returns:
+            List[str]: List of mentioned agent names
+
+        Raises:
+            InvalidtaskFormatError: If the task format is invalid
+        """
+        try:
+            # Find all @mentions using regex
+            mentions = re.findall(r"@(\w+)", task)
+            return [
+                mention
+                for mention in mentions
+                if mention in self.agent_map
+            ]
+        except Exception as e:
+            logger.error(f"Error extracting mentions: {e}")
+            raise InvalidTaskFormatError(f"Invalid task format: {e}")
+
+    def start_interactive_session(self):
+        """
+        Start an interactive terminal session for chatting with agents.
+
+        This method creates a REPL (Read-Eval-Print Loop) that allows users to:
+        - Chat with agents using @mentions
+        - See available agents and their descriptions
+        - Exit the session using 'exit' or 'quit'
+        - Get help using 'help' or '?'
+        """
+        if not self.interactive:
+            raise InteractiveGroupChatError(
+                "Interactive mode is not enabled. Initialize with interactive=True"
+            )
+
+        print(f"\nWelcome to {self.name}!")
+        print(f"Description: {self.description}")
+        print("\nAvailable agents:")
+        for name, agent in self.agent_map.items():
+            if isinstance(agent, Agent):
+                print(
+                    f"- @{name}: {agent.system_prompt.splitlines()[0]}"
+                )
+            else:
+                print(f"- @{name}: Custom callable function")
+
+        print("\nCommands:")
+        print("- Type 'help' or '?' for help")
+        print("- Type 'exit' or 'quit' to end the session")
+        print("- Use @agent_name to mention agents")
+        print("\nStart chatting:")
+
+        while True:
+            try:
+                # Get user input
+                user_input = input("\nYou: ").strip()
+
+                # Handle special commands
+                if user_input.lower() in ["exit", "quit"]:
+                    print("Goodbye!")
+                    break
+
+                if user_input.lower() in ["help", "?"]:
+                    print("\nHelp:")
+                    print("1. Mention agents using @agent_name")
+                    print(
+                        "2. You can mention multiple agents in one task"
+                    )
+                    print("3. Available agents:")
+                    for name in self.agent_map:
+                        print(f"   - @{name}")
+                    print(
+                        "4. Type 'exit' or 'quit' to end the session"
+                    )
+                    continue
+
+                if not user_input:
+                    continue
+
+                # Process the task and get responses
+                try:
+                    response = self.run(user_input)
+                    print("\nChat:")
+                    print(response)
+
+                except NoMentionedAgentsError:
+                    print(
+                        "\nError: Please mention at least one agent using @agent_name"
+                    )
+                except AgentNotFoundError as e:
+                    print(f"\nError: {str(e)}")
+                except Exception as e:
+                    print(f"\nAn error occurred: {str(e)}")
+
+            except KeyboardInterrupt:
+                print("\nSession terminated by user. Goodbye!")
+                break
+            except Exception as e:
+                print(f"\nAn unexpected error occurred: {str(e)}")
+                print(
+                    "The session will continue. You can type 'exit' to end it."
+                )
+
+    def run(self, task: str) -> str:
+        """
+        Process a task and get responses from mentioned agents.
+        If interactive mode is enabled, this will be called by start_interactive_session().
+        Otherwise, it can be called directly for single task processing.
+        """
+        try:
+            # Extract mentioned agents
+            mentioned_agents = self._extract_mentions(task)
+
+            if not mentioned_agents:
+                raise NoMentionedAgentsError(
+                    "No valid agents mentioned in the task"
+                )
+
+            # Add user task to conversation
+            self.conversation.add(role="User", content=task)
+
+            # Get responses from mentioned agents
+            for agent_name in mentioned_agents:
+                agent = self.agent_map.get(agent_name)
+                if not agent:
+                    raise AgentNotFoundError(
+                        f"Agent '{agent_name}' not found"
+                    )
+
+                try:
+                    # Get the complete conversation history
+                    context = (
+                        self.conversation.return_history_as_string()
+                    )
+
+                    # Get response from agent
+                    if isinstance(agent, Agent):
+                        response = agent.run(
+                            task=f"{context}\nPlease respond to the latest task as {agent_name}."
+                        )
+                    else:
+                        # For callable functions
+                        response = agent(context)
+
+                    # Add response to conversation
+                    if response and not response.isspace():
+                        self.conversation.add(
+                            role=agent_name, content=response
+                        )
+                        logger.info(f"Agent {agent_name} responded")
+
+                except Exception as e:
+                    logger.error(
+                        f"Error getting response from {agent_name}: {e}"
+                    )
+                    self.conversation.add(
+                        role=agent_name,
+                        content=f"Error: Unable to generate response - {str(e)}",
+                    )
+
+            return history_output_formatter(
+                self.conversation, self.output_type
+            )
+
+        except InteractiveGroupChatError as e:
+            logger.error(f"GroupChat error: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error: {e}")
+            raise InteractiveGroupChatError(
+                f"Unexpected error occurred: {str(e)}"
+            )

swarms/structs/ma_blocks.py

@@ -1,3 +1,4 @@
+from typing import Union
 from swarms.structs.agent import Agent
 from typing import List, Callable
 from swarms.structs.conversation import Conversation
@@ -82,3 +83,77 @@ def aggregate(
     return history_output_formatter(
         conversation=conversation, type=type
     )
+
+
+def run_agent(
+    agent: Agent,
+    task: str,
+    type: HistoryOutputType = "all",
+    *args,
+    **kwargs,
+):
+    """
+    Run an agent on a task.
+
+    Args:
+        agent (Agent): The agent to run
+        task (str): The task to run the agent on
+        type (HistoryOutputType, optional): The type of history output. Defaults to "all".
+        *args: Variable length argument list
+        **kwargs: Arbitrary keyword arguments
+
+    Returns:
+        Any: The result of running the agent
+
+    Raises:
+        ValueError: If agent or task is None
+        TypeError: If agent is not an instance of Agent
+    """
+    if agent is None:
+        raise ValueError("Agent cannot be None")
+
+    if task is None:
+        raise ValueError("Task cannot be None")
+
+    if not isinstance(agent, Agent):
+        raise TypeError("Agent must be an instance of Agent")
+
+    try:
+        return agent.run(task=task, *args, **kwargs)
+    except Exception as e:
+        raise RuntimeError(f"Error running agent: {str(e)}")
+
+
+def find_agent_by_name(
+    agents: List[Union[Agent, Callable]], agent_name: str
+) -> Agent:
+    """
+    Find an agent by its name in a list of agents.
+
+    Args:
+        agents (List[Union[Agent, Callable]]): List of agents to search through
+        agent_name (str): Name of the agent to find
+
+    Returns:
+        Agent: The found agent
+
+    Raises:
+        ValueError: If agents list is empty or agent not found
+        TypeError: If agent_name is not a string
+    """
+    if not agents:
+        raise ValueError("Agents list cannot be empty")
+
+    if not isinstance(agent_name, str):
+        raise TypeError("Agent name must be a string")
+
+    if not agent_name.strip():
+        raise ValueError("Agent name cannot be empty or whitespace")
+
+    try:
+        for agent in agents:
+            if hasattr(agent, "name") and agent.name == agent_name:
+                return agent
+        raise ValueError(f"Agent with name '{agent_name}' not found")
+    except Exception as e:
+        raise RuntimeError(f"Error finding agent: {str(e)}")

swarms/structs/majority_voting.py

@@ -9,7 +9,7 @@ from typing import Any, Callable, List, Optional
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
 from swarms.structs.multi_agent_exec import run_agents_concurrently
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.utils.formatter import formatter
 from swarms.utils.loguru_logger import initialize_logger