devsquad 3.6.0__py3-none-any.whl

scripts/collaboration/async_integration_example.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Async Integration Example
+
+Demonstrates how to use async LLM cache and retry modules together
+for optimal performance in asyncio applications.
+
+This example shows:
+- Async cache integration
+- Async retry with fallback
+- Combined usage patterns
+- Performance monitoring
+"""
+
+import asyncio
+import logging
+import time
+from typing import Optional
+
+from scripts.collaboration.llm_cache_async import get_async_llm_cache
+from scripts.collaboration.llm_retry_async import async_retry_with_fallback, get_async_retry_manager
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# Simulated async LLM API calls
+async def mock_openai_api(prompt: str, model: str = "gpt-4") -> str:
+    """Simulate OpenAI API call"""
+    await asyncio.sleep(0.1)  # Simulate network latency
+    return f"OpenAI {model} response to: {prompt}"
+
+
+async def mock_anthropic_api(prompt: str, model: str = "claude-3") -> str:
+    """Simulate Anthropic API call"""
+    await asyncio.sleep(0.1)
+    return f"Anthropic {model} response to: {prompt}"
+
+
+# Example 1: Basic async cache usage
+async def example_basic_cache():
+    """Example: Basic async cache usage"""
+    print("\n=== Example 1: Basic Async Cache ===")
+    
+    cache = get_async_llm_cache()
+    prompt = "What is Python?"
+    
+    # First call - cache miss
+    start = time.time()
+    cached = await cache.get(prompt, "openai", "gpt-4")
+    if not cached:
+        response = await mock_openai_api(prompt)
+        await cache.set(prompt, response, "openai", "gpt-4")
+        print(f"Cache miss - API called ({time.time() - start:.3f}s)")
+    
+    # Second call - cache hit
+    start = time.time()
+    cached = await cache.get(prompt, "openai", "gpt-4")
+    print(f"Cache hit - Response: {cached[:50]}... ({time.time() - start:.3f}s)")
+    
+    # Print stats
+    stats = cache.get_stats()
+    print(f"Cache stats: {stats['hits']} hits, {stats['misses']} misses, {stats['hit_rate']:.1%} hit rate")
+
+
+# Example 2: Async retry with fallback
+async def example_retry_fallback():
+    """Example: Async retry with fallback"""
+    print("\n=== Example 2: Async Retry with Fallback ===")
+    
+    call_count = {"count": 0}
+    
+    @async_retry_with_fallback(
+        max_retries=3,
+        initial_delay=0.1,
+        fallback_backends=["anthropic"]
+    )
+    async def call_llm(prompt: str, backend: str = "openai"):
+        call_count["count"] += 1
+        print(f"  Attempt {call_count['count']}: Calling {backend}")
+        
+        # Simulate failure on first 2 attempts with openai
+        if backend == "openai" and call_count["count"] < 3:
+            raise Exception("503 Service Unavailable")
+        
+        if backend == "openai":
+            return await mock_openai_api(prompt)
+        else:
+            return await mock_anthropic_api(prompt)
+    
+    try:
+        result = await call_llm("Hello, world!")
+        print(f"Success: {result}")
+    except Exception as e:
+        print(f"Failed: {e}")
+    
+    # Print stats
+    manager = get_async_retry_manager()
+    stats = manager.get_stats()
+    print(f"Retry stats: {stats['retries']} retries, {stats['fallbacks']} fallbacks")
+
+
+# Example 3: Combined cache + retry
+async def example_combined():
+    """Example: Combined cache and retry"""
+    print("\n=== Example 3: Combined Cache + Retry ===")
+    
+    cache = get_async_llm_cache()
+    
+    @async_retry_with_fallback(
+        max_retries=2,
+        initial_delay=0.1,
+        fallback_backends=["anthropic"]
+    )
+    async def cached_llm_call(prompt: str, backend: str = "openai", model: str = "gpt-4"):
+        # Try cache first
+        cached = await cache.get(prompt, backend, model)
+        if cached:
+            print(f"  Cache hit for {backend}")
+            return cached
+        
+        # Cache miss - call API
+        print(f"  Cache miss - calling {backend} API")
+        if backend == "openai":
+            response = await mock_openai_api(prompt, model)
+        else:
+            response = await mock_anthropic_api(prompt, model)
+        
+        # Save to cache
+        await cache.set(prompt, response, backend, model)
+        return response
+    
+    # First call - cache miss, API call
+    result1 = await cached_llm_call("What is async/await?")
+    print(f"Result 1: {result1[:50]}...")
+    
+    # Second call - cache hit, no API call
+    result2 = await cached_llm_call("What is async/await?")
+    print(f"Result 2: {result2[:50]}...")
+    
+    # Print combined stats
+    cache_stats = cache.get_stats()
+    retry_stats = get_async_retry_manager().get_stats()
+    print(f"\nCache: {cache_stats['hit_rate']:.1%} hit rate")
+    print(f"Retry: {retry_stats['successful_calls']}/{retry_stats['total_calls']} successful")
+
+
+# Example 4: Concurrent requests
+async def example_concurrent():
+    """Example: Concurrent async requests"""
+    print("\n=== Example 4: Concurrent Requests ===")
+    
+    cache = get_async_llm_cache()
+    
+    @async_retry_with_fallback(max_retries=2, initial_delay=0.1)
+    async def cached_call(prompt: str, backend: str = "openai"):
+        cached = await cache.get(prompt, backend, "gpt-4")
+        if cached:
+            return cached
+        
+        response = await mock_openai_api(prompt)
+        await cache.set(prompt, response, backend, "gpt-4")
+        return response
+    
+    # Make multiple concurrent requests
+    prompts = [
+        "What is Python?",
+        "What is JavaScript?",
+        "What is Rust?",
+        "What is Python?",  # Duplicate - should hit cache
+        "What is Go?"
+    ]
+    
+    start = time.time()
+    results = await asyncio.gather(*[cached_call(p) for p in prompts])
+    elapsed = time.time() - start
+    
+    print(f"Processed {len(prompts)} requests in {elapsed:.3f}s")
+    print(f"Average: {elapsed/len(prompts):.3f}s per request")
+    
+    # Print stats
+    stats = cache.get_stats()
+    print(f"Cache: {stats['hits']} hits, {stats['misses']} misses")
+
+
+# Example 5: Error handling and circuit breaker
+async def example_circuit_breaker():
+    """Example: Circuit breaker in action"""
+    print("\n=== Example 5: Circuit Breaker ===")
+    
+    failure_count = {"count": 0}
+    
+    @async_retry_with_fallback(
+        max_retries=1,
+        initial_delay=0.05,
+        fallback_backends=["anthropic"]
+    )
+    async def unreliable_call(prompt: str, backend: str = "openai"):
+        failure_count["count"] += 1
+        
+        # Simulate consistent failures to trigger circuit breaker
+        if backend == "openai" and failure_count["count"] <= 6:
+            raise Exception("503 Service Unavailable")
+        
+        if backend == "openai":
+            return await mock_openai_api(prompt)
+        else:
+            return await mock_anthropic_api(prompt)
+    
+    # Make multiple calls to trigger circuit breaker
+    for i in range(8):
+        try:
+            result = await unreliable_call(f"Request {i+1}")
+            print(f"  Request {i+1}: Success - {result[:40]}...")
+        except Exception as e:
+            print(f"  Request {i+1}: Failed - {str(e)[:40]}...")
+        
+        await asyncio.sleep(0.05)
+    
+    # Print circuit breaker stats
+    manager = get_async_retry_manager()
+    stats = manager.get_stats()
+    print(f"\nCircuit breaker trips: {stats['circuit_breaker_trips']}")
+    print(f"Fallbacks: {stats['fallbacks']}")
+
+
+# Main example runner
+async def main():
+    """Run all examples"""
+    print("=" * 60)
+    print("Async LLM Optimization Examples")
+    print("=" * 60)
+    
+    await example_basic_cache()
+    await asyncio.sleep(0.5)
+    
+    await example_retry_fallback()
+    await asyncio.sleep(0.5)
+    
+    await example_combined()
+    await asyncio.sleep(0.5)
+    
+    await example_concurrent()
+    await asyncio.sleep(0.5)
+    
+    await example_circuit_breaker()
+    
+    print("\n" + "=" * 60)
+    print("All examples completed!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scripts/collaboration/batch_scheduler.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+BatchScheduler - 批处理调度器
+
+支持并行/串行混合调度，带超时、重试和依赖管理。
+"""
+
+import time
+from typing import List, Optional
+
+from .models import (
+    TaskDefinition,
+    TaskBatch,
+    BatchMode,
+    ScheduleResult,
+    WorkerResult,
+)
+from .worker import Worker
+
+
+class BatchScheduler:
+    """
+    批处理调度器 - 并行/串行混合任务调度
+
+    负责 TaskBatch 列表的执行编排:
+    - PARALLEL 批次: 并发执行（受 max_concurrency 限制）
+    - SEQUENTIAL 批次: 串行逐个执行（带自动重试）
+    - 依赖管理: 检查批次间依赖关系，依赖未满足则跳过
+
+    默认配置:
+        - 超时: 300s
+        - 重试次数: 2次
+    """
+
+    def __init__(self):
+        """
+        初始化批处理调度器
+
+        使用默认超时(300s)和重试次数(2次)。
+        可通过修改 _default_timeout / _default_retries 调整。
+        """
+        self._default_timeout = 300
+        self._default_retries = 2
+
+    def schedule(self, batches: List[TaskBatch],
+                 workers: dict) -> ScheduleResult:
+        """
+        执行批处理调度计划
+
+        按顺序遍历批次列表，对每个批次:
+        1. 检查依赖是否满足（未满足则跳过并记录错误）
+        2. 根据 mode 选择并行或串行执行
+        3. 汇总所有结果和错误
+
+        Args:
+            batches: 任务批次列表（由 Coordinator.plan_task 生成）
+            workers: Worker 字典 {worker_id: Worker 实例}
+
+        Returns:
+            ScheduleResult: 调度结果，包含成功/失败统计、各Worker结果、耗时
+        """
+        start_time = time.time()
+        all_results = []
+        all_errors = []
+        total_tasks = 0
+
+        completed_batches = set()
+        for batch in batches:
+            if batch.dependencies:
+                missing = [d for d in batch.dependencies if d not in completed_batches]
+                if missing:
+                    all_errors.append(f"Batch {batch.batch_id} 依赖未满足: {missing}")
+                    continue
+
+            if batch.mode == BatchMode.PARALLEL:
+                results, errors = self._execute_parallel(batch, workers)
+            else:
+                results, errors = self._execute_serial(batch, workers)
+
+            all_results.extend(results)
+            all_errors.extend(errors)
+            total_tasks += len(batch.tasks)
+            completed_batches.add(batch.batch_id)
+
+        return ScheduleResult(
+            success=len(all_errors) == 0,
+            total_tasks=total_tasks,
+            completed_tasks=sum(1 for r in all_results if r.success),
+            failed_tasks=len(all_errors),
+            results=all_results,
+            duration_seconds=time.time() - start_time,
+            errors=all_errors,
+        )
+
+    def _execute_parallel(self, batch: TaskBatch,
+                          workers: dict) -> tuple:
+        results = []
+        errors = []
+        for task in batch.tasks[:batch.max_concurrency]:
+            worker = self._find_worker(workers, task.role_id)
+            if not worker:
+                errors.append(f"No worker available for role {task.role_id}")
+                continue
+            try:
+                result = worker.execute(task)
+                results.append(result)
+            except Exception as e:
+                errors.append(f"Worker {worker.worker_id} error: {e}")
+        return results, errors
+
+    def _execute_serial(self, batch: TaskBatch,
+                        workers: dict) -> tuple:
+        results = []
+        errors = []
+        for task in batch.tasks:
+            worker = self._find_worker(workers, task.role_id)
+            if not worker:
+                errors.append(f"No worker available for role {task.role_id}")
+                continue
+            for attempt in range(self._default_retries + 1):
+                try:
+                    result = worker.execute(task)
+                    results.append(result)
+                    break
+                except Exception as e:
+                    if attempt == self._default_retries:
+                        errors.append(f"Task {task.task_id} failed after retries: {e}")
+        return results, errors
+
+    def is_concurrency_safe(self, task: TaskDefinition) -> bool:
+        """
+        判断任务是否可安全并发执行
+
+        当前实现: 只读任务(is_read_only=True) 可并发。
+
+        Args:
+            task: 任务定义
+
+        Returns:
+            bool: 是否允许并发
+        """
+        return task.is_read_only
+
+    def _find_worker(self, workers: dict, role_id: str) -> Optional[Worker]:
+        for w in workers.values():
+            if w.role_id == role_id:
+                return w
+        return None