swarms 7.8.9__py3-none-any.whl → 7.9.1__py3-none-any.whl

swarms/structs/concurrent_workflow.py

@@ -1,13 +1,10 @@
+import concurrent.futures
 import os
-import time
-from concurrent.futures import ThreadPoolExecutor
-from functools import lru_cache
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Callable, List, Optional, Union
 
 from swarms.structs.agent import Agent
 from swarms.structs.base_swarm import BaseSwarm
 from swarms.structs.conversation import Conversation
-from swarms.utils.formatter import formatter
 from swarms.utils.history_output_formatter import (
     history_output_formatter,
 )
@@ -35,9 +32,7 @@ class ConcurrentWorkflow(BaseSwarm):
         return_str_on (bool): Flag indicating whether to return the output as a string. Defaults to False.
         auto_generate_prompts (bool): Flag indicating whether to auto-generate prompts for agents. Defaults to False.
         return_entire_history (bool): Flag indicating whether to return the entire conversation history. Defaults to False.
-        cache_size (int): The size of the cache. Defaults to 100.
-        max_retries (int): The maximum number of retry attempts. Defaults to 3.
-        retry_delay (float): The delay between retry attempts in seconds. Defaults to 1.0.
+
 
     Raises:
         ValueError: If the list of agents is empty or if the description is empty.
@@ -50,13 +45,7 @@ class ConcurrentWorkflow(BaseSwarm):
         auto_save (bool): Flag indicating whether to automatically save the metadata.
         output_type (str): The type of output format.
         max_loops (int): The maximum number of loops for each agent.
-        return_str_on (bool): Flag indicating whether to return the output as a string.
         auto_generate_prompts (bool): Flag indicating whether to auto-generate prompts for agents.
-        return_entire_history (bool): Flag indicating whether to return the entire conversation history.
-        cache_size (int): The size of the cache.
-        max_retries (int): The maximum number of retry attempts.
-        retry_delay (float): The delay between retry attempts in seconds.
-        _cache (dict): The cache for storing agent outputs.
     """
 
     def __init__(
@@ -68,12 +57,7 @@ class ConcurrentWorkflow(BaseSwarm):
         auto_save: bool = True,
         output_type: str = "dict-all-except-first",
         max_loops: int = 1,
-        return_str_on: bool = False,
         auto_generate_prompts: bool = False,
-        return_entire_history: bool = False,
-        cache_size: int = 100,
-        max_retries: int = 3,
-        retry_delay: float = 1.0,
         *args,
         **kwargs,
     ):
@@ -90,63 +74,31 @@ class ConcurrentWorkflow(BaseSwarm):
         self.metadata_output_path = metadata_output_path
         self.auto_save = auto_save
         self.max_loops = max_loops
-        self.return_str_on = return_str_on
         self.auto_generate_prompts = auto_generate_prompts
-        self.max_workers = os.cpu_count()
         self.output_type = output_type
-        self.return_entire_history = return_entire_history
-        self.tasks = []  # Initialize tasks list
-        self.cache_size = cache_size
-        self.max_retries = max_retries
-        self.retry_delay = retry_delay
-        self._cache = {}
 
         self.reliability_check()
         self.conversation = Conversation()
 
     def reliability_check(self):
         try:
-            formatter.print_panel(
-                content=f"\n 🏷️ Name: {self.name}\n 📝 Description: {self.description}\n 🤖 Agents: {len(self.agents)}\n 🔄 Max Loops: {self.max_loops}\n ",
-                title="⚙️ Concurrent Workflow Settings",
-                style="bold blue",
-            )
-            formatter.print_panel(
-                content="🔍 Starting reliability checks",
-                title="🔒 Reliability Checks",
-                style="bold blue",
-            )
-
-            if self.name is None:
-                logger.error("❌ A name is required for the swarm")
+            if self.agents is None:
                 raise ValueError(
-                    "❌ A name is required for the swarm"
+                    "ConcurrentWorkflow: No agents provided"
                 )
 
-            if not self.agents or len(self.agents) <= 1:
-                logger.error(
-                    "❌ The list of agents must not be empty."
-                )
+            if len(self.agents) == 0:
                 raise ValueError(
-                    "❌ The list of agents must not be empty."
+                    "ConcurrentWorkflow: No agents provided"
                 )
 
-            if not self.description:
-                logger.error("❌ A description is required.")
-                raise ValueError("❌ A description is required.")
-
-            formatter.print_panel(
-                content="✅ Reliability checks completed successfully",
-                title="🎉 Reliability Checks",
-                style="bold green",
-            )
-
-        except ValueError as e:
-            logger.error(f"❌ Reliability check failed: {e}")
-            raise
+            if len(self.agents) == 1:
+                logger.warning(
+                    "ConcurrentWorkflow: Only one agent provided. With ConcurrentWorkflow, you should use at least 2+ agents."
+                )
         except Exception as e:
             logger.error(
-                f"💥 An unexpected error occurred during reliability checks: {e}"
+                f"ConcurrentWorkflow: Reliability check failed: {e}"
             )
             raise
 
@@ -163,162 +115,84 @@ class ConcurrentWorkflow(BaseSwarm):
             for agent in self.agents:
                 agent.auto_generate_prompt = True
 
-    @lru_cache(maxsize=100)
-    def _cached_run(self, task: str, agent_id: int) -> Any:
-        """Cached version of agent execution to avoid redundant computations"""
-        return self.agents[agent_id].run(task=task)
-
-    def _validate_input(self, task: str) -> bool:
-        """Validate input task"""
-        if not isinstance(task, str):
-            raise ValueError("Task must be a string")
-        if not task.strip():
-            raise ValueError("Task cannot be empty")
-        return True
-
-    def _run_with_retry(
-        self, agent: Agent, task: str, img: str = None
-    ) -> Any:
-        """Run agent with retry mechanism"""
-        for attempt in range(self.max_retries):
-            try:
-                output = agent.run(task=task, img=img)
-                self.conversation.add(agent.agent_name, output)
-                return output
-            except Exception as e:
-                if attempt == self.max_retries - 1:
-                    logger.error(
-                        f"Error running agent {agent.agent_name} after {self.max_retries} attempts: {e}"
-                    )
-                    raise
-                logger.warning(
-                    f"Attempt {attempt + 1} failed for agent {agent.agent_name}: {e}"
-                )
-                time.sleep(
-                    self.retry_delay * (attempt + 1)
-                )  # Exponential backoff
-
-    def _process_agent(
-        self, agent: Agent, task: str, img: str = None
-    ) -> Any:
+    def run(
+        self,
+        task: str,
+        img: Optional[str] = None,
+        imgs: Optional[List[str]] = None,
+    ):
         """
-        Process a single agent with caching and error handling.
+        Executes all agents in the workflow concurrently on the given task.
 
         Args:
-            agent: The agent to process
-            task: Task to execute
-            img: Optional image input
+            task (str): The task to be executed by all agents.
+            img (Optional[str]): Optional image path for agents that support image input.
+            imgs (Optional[List[str]]): Optional list of image paths for agents that support multiple image inputs.
 
         Returns:
-            The agent's output
-        """
-        try:
-            # Fast path - check cache first
-            cache_key = f"{task}_{agent.agent_name}"
-            if cache_key in self._cache:
-                output = self._cache[cache_key]
-            else:
-                # Slow path - run agent and update cache
-                output = self._run_with_retry(agent, task, img)
-
-                if len(self._cache) >= self.cache_size:
-                    self._cache.pop(next(iter(self._cache)))
+            The formatted output based on the configured output_type.
 
-                self._cache[cache_key] = output
-
-            return output
-        except Exception as e:
-            logger.error(
-                f"Error running agent {agent.agent_name}: {e}"
-            )
-            raise
-
-    def _run(
-        self, task: str, img: str = None, *args, **kwargs
-    ) -> Union[Dict[str, Any], str]:
-        """
-        Enhanced run method with parallel execution.
+        Example:
+            >>> workflow = ConcurrentWorkflow(agents=[agent1, agent2])
+            >>> result = workflow.run("Analyze this financial data")
+            >>> print(result)
         """
-        # Fast validation
-        self._validate_input(task)
-        self.conversation.add("User", task)
-
-        try:
-            # Parallel execution with optimized thread pool
-            with ThreadPoolExecutor(
-                max_workers=self.max_workers
-            ) as executor:
-                futures = [
-                    executor.submit(
-                        self._process_agent, agent, task, img
-                    )
-                    for agent in self.agents
-                ]
-                # Wait for all futures to complete
-                for future in futures:
-                    future.result()
-
-        except Exception as e:
-            logger.error(f"An error occurred during execution: {e}")
-            raise e
+        self.conversation.add(role="User", content=task)
+
+        # Use 95% of available CPU cores for optimal performance
+        max_workers = int(os.cpu_count() * 0.95)
+
+        # Run agents concurrently using ThreadPoolExecutor
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=max_workers
+        ) as executor:
+            # Submit all agent tasks and store with their index
+            future_to_agent = {
+                executor.submit(
+                    agent.run, task=task, img=img, imgs=imgs
+                ): agent
+                for agent in self.agents
+            }
+
+            # Collect results and add to conversation in completion order
+            for future in concurrent.futures.as_completed(
+                future_to_agent
+            ):
+                agent = future_to_agent[future]
+                output = future.result()
+                self.conversation.add(role=agent.name, content=output)
 
         return history_output_formatter(
-            self.conversation,
-            type=self.output_type,
+            conversation=self.conversation,
+            output_type=self.output_type,
         )
 
-    def run(
+    def batch_run(
         self,
-        task: Optional[str] = None,
+        tasks: List[str],
         img: Optional[str] = None,
-        *args,
-        **kwargs,
-    ) -> Any:
+        imgs: Optional[List[str]] = None,
+    ):
         """
-        Executes the agent's run method with parallel execution.
+        Executes the workflow on multiple tasks sequentially.
 
         Args:
-            task (Optional[str], optional): The task to be executed. Defaults to None.
-            img (Optional[str], optional): The image to be processed. Defaults to None.
-            *args: Additional positional arguments to be passed to the execution method.
-            **kwargs: Additional keyword arguments to be passed to the execution method.
+            tasks (List[str]): List of tasks to be executed by all agents.
+            img (Optional[str]): Optional image path for agents that support image input.
+            imgs (Optional[List[str]]): Optional list of image paths for agents that support multiple image inputs.
 
         Returns:
-            Any: The result of the execution.
-
-        Raises:
-            ValueError: If task validation fails.
-            Exception: If any other error occurs during execution.
-        """
-        if task is not None:
-            self.tasks.append(task)
-
-        try:
-            outputs = self._run(task, img, *args, **kwargs)
-            return outputs
-        except Exception as e:
-            logger.error(f"An error occurred during execution: {e}")
-            raise e
+            List of results, one for each task.
 
-    def run_batched(self, tasks: List[str]) -> Any:
-        """
-        Enhanced batched execution
+        Example:
+            >>> workflow = ConcurrentWorkflow(agents=[agent1, agent2])
+            >>> tasks = ["Task 1", "Task 2", "Task 3"]
+            >>> results = workflow.batch_run(tasks)
+            >>> print(len(results))  # 3
         """
-        if not tasks:
-            raise ValueError("Tasks list cannot be empty")
-
-        return [self.run(task) for task in tasks]
-
-    def clear_cache(self):
-        """Clear the task cache"""
-        self._cache.clear()
-
-    def get_cache_stats(self) -> Dict[str, int]:
-        """Get cache statistics"""
-        return {
-            "cache_size": len(self._cache),
-            "max_cache_size": self.cache_size,
-        }
+        return [
+            self.run(task=task, img=img, imgs=imgs) for task in tasks
+        ]
 
 
 # if __name__ == "__main__":

swarms/structs/conversation.py

@@ -221,27 +221,6 @@ class Conversation(BaseStructure):
     ):
         super().__init__()
 
-        # Support both 'provider' and 'backend' parameters for backwards compatibility
-        # 'backend' takes precedence if both are provided
-        self.backend = backend or provider
-        self.backend_instance = None
-
-        # Validate backend
-        valid_backends = [
-            "in-memory",
-            "mem0",
-            "supabase",
-            "redis",
-            "sqlite",
-            "duckdb",
-            "pulsar",
-        ]
-        if self.backend not in valid_backends:
-            raise ValueError(
-                f"Invalid backend: '{self.backend}'. "
-                f"Valid backends are: {', '.join(valid_backends)}"
-            )
-
         # Initialize all attributes first
         self.id = id
         self.name = name or id
@@ -275,6 +254,27 @@ class Conversation(BaseStructure):
         self.provider = provider  # Keep for backwards compatibility
         self.conversations_dir = conversations_dir
 
+        #  Support both 'provider' and 'backend' parameters for backwards compatibility
+        # 'backend' takes precedence if both are provided
+        self.backend = backend or provider
+        self.backend_instance = None
+
+        # Validate backend
+        valid_backends = [
+            "in-memory",
+            "mem0",
+            "supabase",
+            "redis",
+            "sqlite",
+            "duckdb",
+            "pulsar",
+        ]
+        if self.backend not in valid_backends:
+            raise ValueError(
+                f"Invalid backend: '{self.backend}'. "
+                f"Valid backends are: {', '.join(valid_backends)}"
+            )
+
         # Initialize backend if using persistent storage
         if self.backend in [
             "supabase",
@@ -484,8 +484,7 @@ class Conversation(BaseStructure):
         self,
         role: str,
         content: Union[str, dict, list, Any],
-        *args,
-        **kwargs,
+        category: Optional[str] = None,
     ):
         """Add a message to the conversation history.
 
@@ -505,6 +504,9 @@ class Conversation(BaseStructure):
         if self.message_id_on:
             message["message_id"] = str(uuid.uuid4())
 
+        if category:
+            message["category"] = category
+
         # Add message to conversation history
         self.conversation_history.append(message)
 
@@ -520,6 +522,79 @@ class Conversation(BaseStructure):
                     f"Failed to autosave conversation: {str(e)}"
                 )
 
+    def export_and_count_categories(
+        self, tokenizer_model_name: Optional[str] = "gpt-4.1-mini"
+    ) -> Dict[str, int]:
+        """Export all messages with category 'input' and 'output' and count their tokens.
+
+        This method searches through the conversation history and:
+        1. Extracts all messages marked with category 'input' or 'output'
+        2. Concatenates the content of each category
+        3. Counts tokens for each category using the specified tokenizer model
+
+        Args:
+            tokenizer_model_name (str): Name of the model to use for tokenization
+
+        Returns:
+            Dict[str, int]: A dictionary containing:
+                - input_tokens: Number of tokens in input messages
+                - output_tokens: Number of tokens in output messages
+                - total_tokens: Total tokens across both categories
+        """
+        try:
+            # Extract input and output messages
+            input_messages = []
+            output_messages = []
+
+            for message in self.conversation_history:
+                # Get message content and ensure it's a string
+                content = message.get("content", "")
+                if not isinstance(content, str):
+                    content = str(content)
+
+                # Sort messages by category
+                category = message.get("category", "")
+                if category == "input":
+                    input_messages.append(content)
+                elif category == "output":
+                    output_messages.append(content)
+
+            # Join messages with spaces
+            all_input_text = " ".join(input_messages)
+            all_output_text = " ".join(output_messages)
+
+            print(all_input_text)
+            print(all_output_text)
+
+            # Count tokens only if there is text
+            input_tokens = (
+                count_tokens(all_input_text, tokenizer_model_name)
+                if all_input_text.strip()
+                else 0
+            )
+            output_tokens = (
+                count_tokens(all_output_text, tokenizer_model_name)
+                if all_output_text.strip()
+                else 0
+            )
+            total_tokens = input_tokens + output_tokens
+
+            return {
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "total_tokens": total_tokens,
+            }
+
+        except Exception as e:
+            logger.error(
+                f"Error in export_and_count_categories: {str(e)}"
+            )
+            return {
+                "input_tokens": 0,
+                "output_tokens": 0,
+                "total_tokens": 0,
+            }
+
     def add_mem0(
         self,
         role: str,
@@ -546,8 +621,9 @@ class Conversation(BaseStructure):
     def add(
         self,
         role: str,
-        content: Union[str, dict, list],
+        content: Union[str, dict, list, Any],
         metadata: Optional[dict] = None,
+        category: Optional[str] = None,
     ):
         """Add a message to the conversation history."""
         # If using a persistent backend, delegate to it
@@ -562,7 +638,9 @@ class Conversation(BaseStructure):
                 )
                 return self.add_in_memory(role, content)
         elif self.provider == "in-memory":
-            return self.add_in_memory(role, content)
+            return self.add_in_memory(
+                role=role, content=content, category=category
+            )
         elif self.provider == "mem0":
             return self.add_mem0(
                 role=role, content=content, metadata=metadata