swarms 7.9.8__py3-none-any.whl → 8.0.0__py3-none-any.whl

swarms/utils/concurrent_wrapper.py

@@ -0,0 +1,520 @@
+import asyncio
+import concurrent.futures
+import functools
+import inspect
+import time
+import pickle
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
+from functools import wraps
+from typing import Any, Callable, Dict, List, Optional, Union, TypeVar, Generic
+from dataclasses import dataclass
+from enum import Enum
+
+from swarms.utils.loguru_logger import initialize_logger
+
+logger = initialize_logger("concurrent_wrapper")
+
+T = TypeVar('T')
+R = TypeVar('R')
+
+
+# Global function for process pool execution (must be picklable)
+def _execute_task_in_process(task_data):
+    """
+    Execute a task in a separate process.
+    This function must be at module level to be picklable.
+    """
+    func, task_args, task_kwargs, task_id, max_retries, retry_on_failure, retry_delay, return_exceptions = task_data
+    
+    start_time = time.time()
+    
+    for attempt in range(max_retries + 1):
+        try:
+            result = func(*task_args, **task_kwargs)
+            execution_time = time.time() - start_time
+            return ConcurrentResult(
+                value=result,
+                execution_time=execution_time,
+                worker_id=task_id
+            )
+        except Exception as e:
+            if attempt == max_retries or not retry_on_failure:
+                execution_time = time.time() - start_time
+                if return_exceptions:
+                    return ConcurrentResult(
+                        exception=e,
+                        execution_time=execution_time,
+                        worker_id=task_id
+                    )
+                else:
+                    raise
+            else:
+                time.sleep(retry_delay * (2 ** attempt))
+    
+    # This should never be reached, but just in case
+    return ConcurrentResult(exception=Exception("Max retries exceeded"))
+
+
+class ExecutorType(Enum):
+    """Enum for different types of executors."""
+    THREAD = "thread"
+    PROCESS = "process"
+    ASYNC = "async"
+
+
+@dataclass
+class ConcurrentConfig:
+    """Configuration for concurrent execution."""
+    name: Optional[str] = None
+    description: Optional[str] = None
+    max_workers: int = 4
+    timeout: Optional[float] = None
+    executor_type: ExecutorType = ExecutorType.THREAD
+    return_exceptions: bool = False
+    chunk_size: Optional[int] = None
+    ordered: bool = True
+    retry_on_failure: bool = False
+    max_retries: int = 3
+    retry_delay: float = 1.0
+
+
+class ConcurrentResult(Generic[T]):
+    """Result wrapper for concurrent execution."""
+    
+    def __init__(self, value: T = None, exception: Exception = None, 
+                 execution_time: float = 0.0, worker_id: Optional[int] = None):
+        self.value = value
+        self.exception = exception
+        self.execution_time = execution_time
+        self.worker_id = worker_id
+        self.success = exception is None
+    
+    def __repr__(self):
+        if self.success:
+            return f"ConcurrentResult(value={self.value}, time={self.execution_time:.3f}s)"
+        else:
+            return f"ConcurrentResult(exception={type(self.exception).__name__}: {self.exception})"
+
+
+def concurrent(
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    max_workers: int = 4,
+    timeout: Optional[float] = None,
+    executor_type: ExecutorType = ExecutorType.THREAD,
+    return_exceptions: bool = False,
+    chunk_size: Optional[int] = None,
+    ordered: bool = True,
+    retry_on_failure: bool = False,
+    max_retries: int = 3,
+    retry_delay: float = 1.0,
+):
+    """
+    A decorator that enables concurrent execution of functions.
+    
+    Args:
+        name (Optional[str]): Name for the concurrent operation
+        description (Optional[str]): Description of the operation
+        max_workers (int): Maximum number of worker threads/processes
+        timeout (Optional[float]): Timeout in seconds for each task
+        executor_type (ExecutorType): Type of executor (thread, process, async)
+        return_exceptions (bool): Whether to return exceptions instead of raising
+        chunk_size (Optional[int]): Size of chunks for batch processing
+        ordered (bool): Whether to maintain order of results
+        retry_on_failure (bool): Whether to retry failed tasks
+        max_retries (int): Maximum number of retries per task
+        retry_delay (float): Delay between retries in seconds
+    
+    Returns:
+        Callable: Decorated function that can execute concurrently
+    """
+    
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        config = ConcurrentConfig(
+            name=name or func.__name__,
+            description=description or f"Concurrent execution of {func.__name__}",
+            max_workers=max_workers,
+            timeout=timeout,
+            executor_type=executor_type,
+            return_exceptions=return_exceptions,
+            chunk_size=chunk_size,
+            ordered=ordered,
+            retry_on_failure=retry_on_failure,
+            max_retries=max_retries,
+            retry_delay=retry_delay
+        )
+        
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        
+        def _execute_single_task(task_args, task_kwargs, task_id=None):
+            """Execute a single task with retry logic."""
+            start_time = time.time()
+            
+            for attempt in range(config.max_retries + 1):
+                try:
+                    result = func(*task_args, **task_kwargs)
+                    execution_time = time.time() - start_time
+                    return ConcurrentResult(
+                        value=result,
+                        execution_time=execution_time,
+                        worker_id=task_id
+                    )
+                except Exception as e:
+                    if attempt == config.max_retries or not config.retry_on_failure:
+                        execution_time = time.time() - start_time
+                        if config.return_exceptions:
+                            return ConcurrentResult(
+                                exception=e,
+                                execution_time=execution_time,
+                                worker_id=task_id
+                            )
+                        else:
+                            raise
+                    else:
+                        logger.warning(
+                            f"Task {task_id} failed (attempt {attempt + 1}/{config.max_retries + 1}): {e}"
+                        )
+                        time.sleep(config.retry_delay * (2 ** attempt))
+        
+        def concurrent_execute(*args_list, **kwargs_list):
+            """Execute the function concurrently with multiple argument sets."""
+            if not args_list and not kwargs_list:
+                raise ValueError("At least one set of arguments must be provided")
+            
+            # Prepare tasks
+            tasks = []
+            if args_list:
+                for args in args_list:
+                    if isinstance(args, (list, tuple)):
+                        tasks.append((args, {}))
+                    else:
+                        tasks.append(([args], {}))
+            
+            if kwargs_list:
+                for kwargs in kwargs_list:
+                    if isinstance(kwargs, dict):
+                        tasks.append(((), kwargs))
+                    else:
+                        raise ValueError("kwargs_list must contain dictionaries")
+            
+            logger.info(f"Starting concurrent execution of {len(tasks)} tasks with {config.max_workers} workers")
+            start_time = time.time()
+            
+            try:
+                if config.executor_type == ExecutorType.THREAD:
+                    results = _execute_with_thread_pool(tasks)
+                elif config.executor_type == ExecutorType.PROCESS:
+                    results = _execute_with_process_pool(tasks)
+                elif config.executor_type == ExecutorType.ASYNC:
+                    results = _execute_with_async(tasks)
+                else:
+                    raise ValueError(f"Unsupported executor type: {config.executor_type}")
+                
+                total_time = time.time() - start_time
+                successful_tasks = sum(1 for r in results if r.success)
+                
+                logger.info(
+                    f"Completed {len(tasks)} tasks in {total_time:.3f}s "
+                    f"({successful_tasks}/{len(tasks)} successful)"
+                )
+                
+                return results
+                
+            except Exception as e:
+                logger.error(f"Concurrent execution failed: {e}")
+                raise
+        
+        def _execute_with_thread_pool(tasks):
+            """Execute tasks using ThreadPoolExecutor."""
+            results = []
+            
+            with ThreadPoolExecutor(max_workers=config.max_workers) as executor:
+                if config.ordered:
+                    future_to_task = {
+                        executor.submit(_execute_single_task, task[0], task[1], i): i 
+                        for i, task in enumerate(tasks)
+                    }
+                    
+                    for future in as_completed(future_to_task, timeout=config.timeout):
+                        try:
+                            result = future.result(timeout=config.timeout)
+                            results.append(result)
+                        except Exception as e:
+                            if config.return_exceptions:
+                                results.append(ConcurrentResult(exception=e))
+                            else:
+                                raise
+                else:
+                    futures = [
+                        executor.submit(_execute_single_task, task[0], task[1], i)
+                        for i, task in enumerate(tasks)
+                    ]
+                    
+                    for future in as_completed(futures, timeout=config.timeout):
+                        try:
+                            result = future.result(timeout=config.timeout)
+                            results.append(result)
+                        except Exception as e:
+                            if config.return_exceptions:
+                                results.append(ConcurrentResult(exception=e))
+                            else:
+                                raise
+            
+            return results
+        
+        def _execute_with_process_pool(tasks):
+            """Execute tasks using ProcessPoolExecutor."""
+            results = []
+            
+            # Prepare task data for process execution
+            task_data_list = []
+            for i, task in enumerate(tasks):
+                task_data = (
+                    func,  # The function to execute
+                    task[0],  # args
+                    task[1],  # kwargs
+                    i,  # task_id
+                    config.max_retries,
+                    config.retry_on_failure,
+                    config.retry_delay,
+                    config.return_exceptions
+                )
+                task_data_list.append(task_data)
+            
+            with ProcessPoolExecutor(max_workers=config.max_workers) as executor:
+                if config.ordered:
+                    future_to_task = {
+                        executor.submit(_execute_task_in_process, task_data): i 
+                        for i, task_data in enumerate(task_data_list)
+                    }
+                    
+                    for future in as_completed(future_to_task, timeout=config.timeout):
+                        try:
+                            result = future.result(timeout=config.timeout)
+                            results.append(result)
+                        except Exception as e:
+                            if config.return_exceptions:
+                                results.append(ConcurrentResult(exception=e))
+                            else:
+                                raise
+                else:
+                    futures = [
+                        executor.submit(_execute_task_in_process, task_data)
+                        for task_data in task_data_list
+                    ]
+                    
+                    for future in as_completed(futures, timeout=config.timeout):
+                        try:
+                            result = future.result(timeout=config.timeout)
+                            results.append(result)
+                        except Exception as e:
+                            if config.return_exceptions:
+                                results.append(ConcurrentResult(exception=e))
+                            else:
+                                raise
+            
+            return results
+        
+        async def _execute_with_async(tasks):
+            """Execute tasks using asyncio."""
+            async def _async_task(task_args, task_kwargs, task_id=None):
+                start_time = time.time()
+                
+                for attempt in range(config.max_retries + 1):
+                    try:
+                        loop = asyncio.get_event_loop()
+                        result = await loop.run_in_executor(
+                            None, 
+                            lambda: func(*task_args, **task_kwargs)
+                        )
+                        execution_time = time.time() - start_time
+                        return ConcurrentResult(
+                            value=result,
+                            execution_time=execution_time,
+                            worker_id=task_id
+                        )
+                    except Exception as e:
+                        if attempt == config.max_retries or not config.retry_on_failure:
+                            execution_time = time.time() - start_time
+                            if config.return_exceptions:
+                                return ConcurrentResult(
+                                    exception=e,
+                                    execution_time=execution_time,
+                                    worker_id=task_id
+                                )
+                            else:
+                                raise
+                        else:
+                            logger.warning(
+                                f"Async task {task_id} failed (attempt {attempt + 1}/{config.max_retries + 1}): {e}"
+                            )
+                            await asyncio.sleep(config.retry_delay * (2 ** attempt))
+            
+            semaphore = asyncio.Semaphore(config.max_workers)
+            
+            async def _limited_task(task_args, task_kwargs, task_id):
+                async with semaphore:
+                    return await _async_task(task_args, task_kwargs, task_id)
+            
+            tasks_coros = [
+                _limited_task(task[0], task[1], i) 
+                for i, task in enumerate(tasks)
+            ]
+            
+            if config.ordered:
+                results = []
+                for coro in asyncio.as_completed(tasks_coros):
+                    try:
+                        result = await coro
+                        results.append(result)
+                    except Exception as e:
+                        if config.return_exceptions:
+                            results.append(ConcurrentResult(exception=e))
+                        else:
+                            raise
+                return results
+            else:
+                return await asyncio.gather(*tasks_coros, return_exceptions=config.return_exceptions)
+        
+        def concurrent_batch(items: List[Any], batch_size: Optional[int] = None, 
+                           **kwargs) -> List[ConcurrentResult]:
+            """Execute the function concurrently on a batch of items."""
+            batch_size = batch_size or config.chunk_size or len(items)
+            
+            tasks = []
+            for item in items:
+                if isinstance(item, (list, tuple)):
+                    tasks.append((item, kwargs))
+                else:
+                    tasks.append(([item], kwargs))
+            
+            return concurrent_execute(*[task[0] for task in tasks], 
+                                    **[task[1] for task in tasks])
+        
+        def concurrent_map(items: List[Any], **kwargs) -> List[ConcurrentResult]:
+            """Map the function over a list of items concurrently."""
+            return concurrent_batch(items, **kwargs)
+        
+        # Attach methods to the wrapper
+        wrapper.concurrent_execute = concurrent_execute
+        wrapper.concurrent_batch = concurrent_batch
+        wrapper.concurrent_map = concurrent_map
+        wrapper.config = config
+        
+        # Add metadata
+        wrapper.__concurrent_config__ = config
+        wrapper.__concurrent_enabled__ = True
+        
+        return wrapper
+    
+    return decorator
+
+
+def concurrent_class_executor(
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    max_workers: int = 4,
+    timeout: Optional[float] = None,
+    executor_type: ExecutorType = ExecutorType.THREAD,
+    return_exceptions: bool = False,
+    chunk_size: Optional[int] = None,
+    ordered: bool = True,
+    retry_on_failure: bool = False,
+    max_retries: int = 3,
+    retry_delay: float = 1.0,
+    methods: Optional[List[str]] = None,
+):
+    """
+    A decorator that enables concurrent execution for class methods.
+    
+    Args:
+        name (Optional[str]): Name for the concurrent operation
+        description (Optional[str]): Description of the operation
+        max_workers (int): Maximum number of worker threads/processes
+        timeout (Optional[float]): Timeout in seconds for each task
+        executor_type (ExecutorType): Type of executor (thread, process, async)
+        return_exceptions (bool): Whether to return exceptions instead of raising
+        chunk_size (Optional[int]): Size of chunks for batch processing
+        ordered (bool): Whether to maintain order of results
+        retry_on_failure (bool): Whether to retry failed tasks
+        max_retries (int): Maximum number of retries per task
+        retry_delay (float): Delay between retries in seconds
+        methods (Optional[List[str]]): List of method names to make concurrent
+    
+    Returns:
+        Class: Class with concurrent execution capabilities
+    """
+    
+    def decorator(cls):
+        config = ConcurrentConfig(
+            name=name or f"{cls.__name__}_concurrent",
+            description=description or f"Concurrent execution for {cls.__name__}",
+            max_workers=max_workers,
+            timeout=timeout,
+            executor_type=executor_type,
+            return_exceptions=return_exceptions,
+            chunk_size=chunk_size,
+            ordered=ordered,
+            retry_on_failure=retry_on_failure,
+            max_retries=max_retries,
+            retry_delay=retry_delay
+        )
+        
+        # Get methods to make concurrent
+        target_methods = methods or [
+            name for name, method in inspect.getmembers(cls, inspect.isfunction)
+            if not name.startswith('_')
+        ]
+        
+        for method_name in target_methods:
+            if hasattr(cls, method_name):
+                original_method = getattr(cls, method_name)
+                
+                # Create concurrent version of the method
+                concurrent_decorator = concurrent(
+                    name=f"{cls.__name__}.{method_name}",
+                    description=f"Concurrent execution of {cls.__name__}.{method_name}",
+                    max_workers=config.max_workers,
+                    timeout=config.timeout,
+                    executor_type=config.executor_type,
+                    return_exceptions=config.return_exceptions,
+                    chunk_size=config.chunk_size,
+                    ordered=config.ordered,
+                    retry_on_failure=config.retry_on_failure,
+                    max_retries=config.max_retries,
+                    retry_delay=config.retry_delay,
+                )
+                
+                # Apply the concurrent decorator to the method
+                setattr(cls, method_name, concurrent_decorator(original_method))
+        
+        # Add class-level concurrent configuration
+        cls.__concurrent_config__ = config
+        cls.__concurrent_enabled__ = True
+        
+        return cls
+    
+    return decorator
+
+
+# Convenience functions for common use cases
+def thread_executor(**kwargs):
+    """Convenience decorator for thread-based concurrent execution."""
+    return concurrent(executor_type=ExecutorType.THREAD, **kwargs)
+
+
+def process_executor(**kwargs):
+    """Convenience decorator for process-based concurrent execution."""
+    return concurrent(executor_type=ExecutorType.PROCESS, **kwargs)
+
+
+def async_executor(**kwargs):
+    """Convenience decorator for async-based concurrent execution."""
+    return concurrent(executor_type=ExecutorType.ASYNC, **kwargs)
+
+
+def batch_executor(batch_size: int = 10, **kwargs):
+    """Convenience decorator for batch processing."""
+    return concurrent(chunk_size=batch_size, **kwargs) 

{swarms-7.9.8.dist-info → swarms-8.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: swarms
-Version: 7.9.8
+Version: 8.0.0
 Summary: Swarms - TGSC
 License: MIT
 Keywords: artificial intelligence,deep learning,optimizers,Prompt Engineering,swarms,agents,llms,transformers,multi-agent,swarms of agents,Enterprise-Grade Agents,Production-Grade Agents,Agents,Multi-Grade-Agents,Swarms,Transformers,LLMs,Prompt Engineering,Agents,Generative Agents,Generative AI,Agent Marketplace,Agent Store,quant,finance,algorithmic trading,portfolio optimization,risk management,financial modeling,machine learning for finance,natural language processing for finance
@@ -280,20 +280,26 @@ A `SequentialWorkflow` executes tasks in a strict order, forming a pipeline wher
 ```python
 from swarms import Agent, SequentialWorkflow
 
-# Initialize agents for a 3-step process
-# 1. Generate an idea
-idea_generator = Agent(agent_name="IdeaGenerator", system_prompt="Generate a unique startup idea.", model_name="gpt-4o-mini")
-# 2. Validate the idea
-validator = Agent(agent_name="Validator", system_prompt="Take this startup idea and analyze its market viability.", model_name="gpt-4o-mini")
-# 3. Create a pitch
-pitch_creator = Agent(agent_name="PitchCreator", system_prompt="Write a 3-sentence elevator pitch for this validated startup idea.", model_name="gpt-4o-mini")
+# Agent 1: The Researcher
+researcher = Agent(
+    agent_name="Researcher",
+    system_prompt="Your job is to research the provided topic and provide a detailed summary.",
+    model_name="gpt-4o-mini",
+)
 
-# Create the sequential workflow
-workflow = SequentialWorkflow(agents=[idea_generator, validator, pitch_creator])
+# Agent 2: The Writer
+writer = Agent(
+    agent_name="Writer",
+    system_prompt="Your job is to take the research summary and write a beautiful, engaging blog post about it.",
+    model_name="gpt-4o-mini",
+)
+
+# Create a sequential workflow where the researcher's output feeds into the writer's input
+workflow = SequentialWorkflow(agents=[researcher, writer])
 
-# Run the workflow
-elevator_pitch = workflow.run()
-print(elevator_pitch)
+# Run the workflow on a task
+final_post = workflow.run("The history and future of artificial intelligence")
+print(final_post)
 ```
 
 -----
@@ -356,9 +362,7 @@ rearrange_system = AgentRearrange(
     flow=flow,
 )
 
-# Run the system
-# The researcher will generate content, and then both the writer and editor
-# will process that content in parallel.
+# Run the swarm
 outputs = rearrange_system.run("Analyze the impact of AI on modern cinema.")
 print(outputs)
 ```

{swarms-7.9.8.dist-info → swarms-8.0.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 swarms/__init__.py,sha256=0tc5msh0Sfk6V_KIwen_4p2kwkHBLjLxZVoAsFE-b80,513
 swarms/agents/__init__.py,sha256=hEp16SuPhlcLX84HAlaK_9RNf6JB0JQ27YTrTnvak04,1171
-swarms/agents/agent_judge.py,sha256=xT242CX5mV64cq2B-3RGkuEHiV5aD04P_Zq8_s64iMQ,3967
+swarms/agents/agent_judge.py,sha256=FshQXqpcqEVsfeGiuXCIhmVa2o1dO9CuZN8UxXMAjLk,15924
 swarms/agents/agent_print.py,sha256=SXqWA2ZzXwRFdv8hkuYwOPMTasvaGTG6U29413qRCAA,918
 swarms/agents/ape_agent.py,sha256=Ws7PmfCL5ctxIdLjQ-lkTWoYMGMjnqqDuo4chPpsF0w,1046
 swarms/agents/auto_generate_swarm_config.py,sha256=7eJ873xS7PJmyreMaa5Uub8qFu-qIinuyMuogB2Ehjc,8474
@@ -12,8 +12,8 @@ swarms/agents/gkp_agent.py,sha256=5Jms3zHQ2qwJ6-PHDh9X-cFtAlH4dSUoDgRqN-xZzog,21
 swarms/agents/i_agent.py,sha256=_kqGt3a4SGB21_GP-KcV8A5p_9wneShs6eJUJYFdluw,12274
 swarms/agents/openai_assistant.py,sha256=mTSEtj26J0mc5pCeWrmMY0EXzTRYQfyfw_BtOqtcCHc,11044
 swarms/agents/react_agent.py,sha256=yM8lQoRsqJZicqtmgBrC7RHv0aKEb5oZHh4q5aAA_xs,5804
-swarms/agents/reasoning_agents.py,sha256=En3H6NeeLRTQfhdvn_5TdxPya3xXD4AZpDKWJ_btVVk,12672
-swarms/agents/reasoning_duo.py,sha256=4qw9RtwmWkWnDWjEtJqYFVLh--EV9YQd24-fQa0lMfM,3873
+swarms/agents/reasoning_agents.py,sha256=TpYqtQ-Ogyg4zvqXU1qDj3M8UQL8EWS_nEzl58OIxiw,13100
+swarms/agents/reasoning_duo.py,sha256=SwL1urMPvbeiLgbvOOd2xe6YNRUo9qIQ_cOghSyL_nk,5767
 swarms/agents/self_agent_builder.py,sha256=bX7xSwak6HiyK901VdeE8OlT4yqE0n7jyHcWJrkMeew,1104
 swarms/agents/tool_agent.py,sha256=G7rhBACsHsGUMT4H9eF5aY7e3Gx-5jOmJkhCF1jm9mU,5087
 swarms/artifacts/__init__.py,sha256=M111xTw7IVVt8gLDwW7Kau5n1YdwkL3vbCJPVeEWktI,83
@@ -106,8 +106,8 @@ swarms/schemas/llm_agent_schema.py,sha256=S5ZIF21q-I9EUtQpgKYZc361o5FGFOnrW_6YTK
 swarms/schemas/mcp_schemas.py,sha256=XZJ4HyiY_cv8Gvj-53ddjzXuqT9hBU2f0cHbhIKs_jY,1330
 swarms/schemas/swarms_api_schemas.py,sha256=uKqleW_7hNpqHi06yoba9jS2i9yzZp-SBV944MnkN68,6233
 swarms/schemas/tool_schema_base_model.py,sha256=0biTGIoibsPPP3fOrkC6WvNU5vXaalyccVKC1fpO_eg,1409
-swarms/structs/__init__.py,sha256=EvJy-Dt6BacI5VJik7AJdmGHn9Rav98eZthuJ5dIOIQ,4641
-swarms/structs/agent.py,sha256=YH19a3clZWOQWa57tfWGgytzJO3qJvUCRHgYIy2jP5g,119744
+swarms/structs/__init__.py,sha256=lmcKJ5z4JAsbHhFHlX5Fi78pfd10AFX6kzlnum0d_FI,4709
+swarms/structs/agent.py,sha256=kVc88kSWCuTy4JiSH1vqoe_1XH6VL84edFyjARt_d6c,120164
 swarms/structs/agent_builder.py,sha256=tYNpfO4_8cgfMHfgA5DAOWffHnt70p6CLt59esqfVCY,12133
 swarms/structs/agent_rag_handler.py,sha256=g17YRrNmf16TLvyFCCcsitVk3d-QNZmck_XYmjSN_YM,21372
 swarms/structs/agent_registry.py,sha256=il507cO1NF-d4ChyANVLuWrN8bXsEAi8_7bLJ_sTU6A,12112
@@ -127,8 +127,10 @@ swarms/structs/csv_to_agent.py,sha256=Zv41sjeWA50msq-paGHESzlxZyMU78DYDLNNKZtNfo
 swarms/structs/de_hallucination_swarm.py,sha256=9cC0rSSXGwYu6SRDwpeMbCcQ40C1WI1RE9SNapKRLOQ,10309
 swarms/structs/deep_research_swarm.py,sha256=cNLDI7_lT47q4bCRlMJO4IAO3Fu_iF3nPi3jgtg6CJQ,17026
 swarms/structs/dynamic_conversational_swarm.py,sha256=xm8x_0OCI4ijatgVt8dzHhLNUyMzqG2U_XQL14kcIS8,8354
+swarms/structs/election_swarm.py,sha256=zPKoH1xKN9RLfM5TG53zE_856hb8jeYC-kbi5NdoDmU,10062
 swarms/structs/graph_workflow.py,sha256=TAaUG_J3898hhghPOp0WEAV3Zf0in6s48ZSVbSTX-vQ,8629
 swarms/structs/groupchat.py,sha256=jjH0BqU9Nrd_3jl9QzrcvbSce527SFpUaepawaRiw2o,15391
+swarms/structs/heavy_swarm.py,sha256=p0i7wjRUtndH2Opoq5sZl6JwJ3n5jEx3clI9Dyf1gaE,66264
 swarms/structs/hiearchical_swarm.py,sha256=7yLnheE34bAk9pdjloXBQo-LvM_e7pxNzkMV7YsonOI,28942
 swarms/structs/hybrid_hiearchical_peer_swarm.py,sha256=0BrmzSVit-I_04DFfrs7onLblLA6PSPa0JE3-4j05FA,9316
 swarms/structs/image_batch_processor.py,sha256=31Z8vTVL4dw18QxGwb0Jg1nvp0YzX8lwVgGj_-KrkhY,8207
@@ -146,6 +148,7 @@ swarms/structs/multi_agent_exec.py,sha256=3hIGgwJ_mQwgD16N096jN48-DEIZWFPoetR2nC
 swarms/structs/multi_agent_router.py,sha256=A4MDd4_QAoarrLaxClnCxnEP62bSMFvyq77ttqeq3u8,11049
 swarms/structs/multi_model_gpu_manager.py,sha256=gHC6MmVia4etMD6RlpEdbqZtV7ng4f-6jVMH0Zrt8y4,47356
 swarms/structs/omni_agent_types.py,sha256=RdKLfZ-lXDJrEa0aJT_Rfx9TypJQo8SISqKz4fnLkAk,230
+swarms/structs/qa_swarm.py,sha256=z4o5ycwbGnJIO5fol0FlFoziuQr5JPrL-vLD_XgjdEQ,8720
 swarms/structs/rearrange.py,sha256=V_CiIIMknZVmTwvr3a4zyimGtbAGaPPmna49nn2k88g,20661
 swarms/structs/round_robin.py,sha256=MGk623KiN9uSxTMG6MY_BIAkvEDh1RPwyl5Min7GLOU,7573
 swarms/structs/safe_loading.py,sha256=gmYX8G9TsvAIp6OCvREBZt5mwSFc-p-t1rSnDBfhEmE,7124
@@ -157,14 +160,14 @@ swarms/structs/swarm_eval.py,sha256=148E2R2zaCmt_LZYx15nmdFjybXHiQ2CZbl6pk77jNs,
 swarms/structs/swarm_id_generator.py,sha256=Wly7AtGM9e6VgzhYmfg8_gSOdxAdsOvWHJFK81cpQNQ,68
 swarms/structs/swarm_matcher.py,sha256=HUCxTWRnxT5Rix3CMKEuJCqNleqPA9xGrWFGw6rjcTw,26821
 swarms/structs/swarm_registry.py,sha256=P0XRrqp1qBNyt0BycqPQljUzKv9jClaQMhtaBMinhYg,5578
-swarms/structs/swarm_router.py,sha256=XO_KSsEKMpEpTzTvyUpqa06QFutIFlRds7aGNuhUeSI,26748
+swarms/structs/swarm_router.py,sha256=zey-KopVKLRaIDn_KBSLWOpiJwJWffsh2u5VuZjwpRI,28488
 swarms/structs/swarming_architectures.py,sha256=guNQU2N7Ofuk01fZbU3tmBJymnZ9zdGULpPZAdaqCeA,28276
 swarms/structs/tree_swarm.py,sha256=AnIxrt0KhWxAQN8uGjfCcOq-XCmsuTJiH8Ex4mXy8V8,12500
 swarms/structs/utils.py,sha256=Mo6wHQYOB8baWZUKnAJN5Dsgubpo81umNwJIEDitb2A,1873
 swarms/structs/various_alt_swarms.py,sha256=qdBuOF31UjatlKRu-9bxwyRQzIjohRhTv_63YoUeYEY,27866
 swarms/telemetry/__init__.py,sha256=-DIOcGcgSKISGhMarT5_LsqcM9xU7AVhKt2l3iIslvo,255
 swarms/telemetry/bootup.py,sha256=0leCNCy5rhzL19EsOsqHWSDI85KVcWO6_5hLDS0h4sY,1155
-swarms/telemetry/log_executions.py,sha256=kC8vy0f55f4-DQPOMQIhREmYcnVaJPZOnnW5p50PnNM,1433
+swarms/telemetry/log_executions.py,sha256=aOZPSICkvyat9sgI9oRmhtR-US_mqgqo0ANfzDP_GtI,9998
 swarms/telemetry/main.py,sha256=SZyuXVHJdOutCLcMrIZLEjss4i8l4jxjzrMwvhtp5pM,3489
 swarms/tools/__init__.py,sha256=6j4tc28dxLrlHG88Yot90PHuNZxhJFb27xqJ8GjwN-0,2268
 swarms/tools/base_tool.py,sha256=PBA4QAP9nN3DrNc5YgzdpkGWkbaxPlhYLcQUYHxq2xQ,107434
@@ -185,11 +188,13 @@ swarms/tools/tool_parse_exec.py,sha256=FW5XzkuNEs2YrroybjKChbCzDvaCs7ypknSDpYhfk
 swarms/tools/tool_registry.py,sha256=ULZmIKBTx9XRCJRD9hwXfY3iQw9v94arw-VV6jcuftY,7992
 swarms/tools/tool_utils.py,sha256=yXzzqG7Ytd8ybB8bsjNUNLaXIuIp9JbbpUKCiHxQqo8,2816
 swarms/utils/__init__.py,sha256=tpbhE-BTISDMXemSRSRJz-Rz7m_C05Q5Pre3d9H9SN4,1195
+swarms/utils/agent_cache.py,sha256=GOzX7NVHYIEAtdFCa1a73KvWvESl43A9jcpkL6FLEs0,21794
 swarms/utils/any_to_str.py,sha256=Qi4N9ed6LYnCs2AeFYo1zwEfYhOKUesGVFUmVUz54KI,2936
 swarms/utils/audio_processing.py,sha256=Y3KaWG9WJrgquWCeaty20HWPIXfeuPAhcJFzoSBIQjE,9893
 swarms/utils/auto_download_check_packages.py,sha256=nnEPfUr2zy_Y6vPZF56zyWLamz0e2gskS4ecKSw30ww,4594
 swarms/utils/calculate_func_metrics.py,sha256=Nb5r7rWf809m5F7mWIYXZ0H_WeyGr78A2UZD2GHtJkM,5007
 swarms/utils/check_all_model_max_tokens.py,sha256=ZHIKlrU-L-OM2IJAbYkCoVyBKe2d0JrGhDC9QNppGIs,1519
+swarms/utils/concurrent_wrapper.py,sha256=ElenyEdYzMiDbvRBqKbLc9xvMhB6NmS4ZPA7UtMynkw,21138
 swarms/utils/data_to_text.py,sha256=1PUoWokylp7MOrGNk1cmO3cJlfskdAIiImGk9ECwsKU,3427
 swarms/utils/disable_logging.py,sha256=KKPKQVfQqLPFgj03uveOoyeHOTlfEJt-yfLc3SA53Rk,2470
 swarms/utils/file_processing.py,sha256=QjQCIPTcwicQlfy656BXBYpIzMR0s2343E7ftnok5Uo,4865
@@ -210,8 +215,8 @@ swarms/utils/str_to_dict.py,sha256=T3Jsdjz87WIlkSo7jAW6BB80sv0Ns49WT1qXlOrdEoE,8
 swarms/utils/try_except_wrapper.py,sha256=uvDZDZJcH986EF0Ej6zZBLcqHJ58NHizPsAH5olrE7Q,3919
 swarms/utils/vllm_wrapper.py,sha256=sNkm4EbeMrqqmHidnvq5zTnofQAaARy3HIrNBu11lKs,5072
 swarms/utils/xml_utils.py,sha256=D4nEdo1nkHqSoTKrWylXBXjcHFhGaOYvvfGNQQoYV5o,2514
-swarms-7.9.8.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
-swarms-7.9.8.dist-info/METADATA,sha256=kFHDWgpAamZitdueXYE4QEfRVPcA2J5nbLVULHCpuKo,38991
-swarms-7.9.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-swarms-7.9.8.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
-swarms-7.9.8.dist-info/RECORD,,
+swarms-8.0.0.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
+swarms-8.0.0.dist-info/METADATA,sha256=IKf7l5_rtuibcObU_cfdd28c0doN3BchbHi8iFqyv2I,38842
+swarms-8.0.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+swarms-8.0.0.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
+swarms-8.0.0.dist-info/RECORD,,