@sylix/coworker 2.0.11 → 2.0.14

package/dist/skills/defaults/backend-development/async-python.md

@@ -0,0 +1,237 @@
+---
+name: async-patterns
+description: Master async/await patterns in Python for building high-performance concurrent applications.
+---
+
+# Async Python Patterns — CoWorker Edition
+
+Build performant, concurrent Python applications.
+
+## When to Use This Skill
+
+- Building async APIs
+- Concurrent data processing
+- Background job systems
+- WebSocket servers
+
+## Core Concepts
+
+### 1. Async Basics
+
+```python
+import asyncio
+
+async def fetch_data(url: str) -> dict:
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            return await response.json()
+
+async def main():
+    # Sequential
+    result1 = await fetch_data("https://api1.example.com")
+    result2 = await fetch_data("https://api2.example.com")
+    
+    # Concurrent - gather
+    results = await asyncio.gather(
+        fetch_data("https://api1.example.com"),
+        fetch_data("https://api2.example.com"),
+        fetch_data("https://api3.example.com")
+    )
+```
+
+### 2. Async Context Managers
+
+```python
+class DatabaseConnection:
+    def __init__(self, dsn: str):
+        self.dsn = dsn
+        self.connection = None
+    
+    async def __aenter__(self):
+        self.connection = await asyncpg.connect(self.dsn)
+        return self.connection
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.connection:
+            await self.connection.close()
+
+# Usage
+async def query_data():
+    async with DatabaseConnection(DSN) as conn:
+        result = await conn.fetch("SELECT * FROM users")
+        return result
+```
+
+### 3. Semaphores for Rate Limiting
+
+```python
+import asyncio
+from aiohttp import ClientSession
+
+# Limit concurrent requests
+semaphore = asyncio.Semaphore(10)
+
+async def fetch_with_limit(session: ClientSession, url: str):
+    async with semaphore:
+        async with session.get(url) as response:
+            return await response.json()
+
+async def fetch_all(urls: list[str]):
+    async with ClientSession() as session:
+        tasks = [fetch_with_limit(session, url) for url in urls]
+        return await asyncio.gather(*tasks)
+```
+
+### 4. Background Tasks
+
+```python
+import asyncio
+from datetime import datetime
+
+class BackgroundTaskRunner:
+    def __init__(self):
+        self.tasks: set[asyncio.Task] = set()
+    
+    def schedule(self, coro):
+        task = asyncio.create_task(coro)
+        self.tasks.add(task)
+        task.add_done_callback(self.tasks.discard)
+        return task
+    
+    async def wait_all(self):
+        await asyncio.gather(*self.tasks)
+
+# Usage
+runner = BackgroundTaskRunner()
+
+def send_notification(user_id: str, message: str):
+    async def _send():
+        await asyncio.sleep(1)  # Simulate sending
+        print(f"Sent to {user_id}: {message}")
+    
+    return runner.schedule(_send())
+
+async def process_order(order_id: str):
+    # Process immediately
+    await update_order_status(order_id, "processing")
+    
+    # Schedule background task
+    send_notification(order_id, "Your order is being processed!")
+    
+    return {"status": "processing"}
+```
+
+### 5. Async Generators
+
+```python
+async def fetch_pages(url: str, page_size: int = 100):
+    """Stream paginated results."""
+    offset = 0
+    while True:
+        rows = await db.fetch(
+            "SELECT * FROM orders LIMIT $1 OFFSET $2",
+            page_size, offset
+        )
+        
+        if not rows:
+            break
+            
+        for row in rows:
+            yield row
+        
+        offset += page_size
+
+# Usage - process streaming
+async def process_all_orders():
+    async for order in fetch_pages("https://api.example.com/orders"):
+        await process_order(order)
+```
+
+### 6. Producer-Consumer Pattern
+
+```python
+import asyncio
+from collections import deque
+
+class AsyncQueue:
+    def __init__(self, maxsize: int = 100):
+        self.queue: asyncio.Queue = asyncio.Queue(maxsize=maxsize)
+    
+    async def produce(self, items: list):
+        for item in items:
+            await self.queue.put(item)
+        await self.queue.put(None)  # Sentinel
+    
+    async def consume(self, processor):
+        while True:
+            item = await self.queue.get()
+            if item is None:
+                self.queue.task_done()
+                break
+            await processor(item)
+            self.queue.task_done()
+    
+    async def run(self, items: list, processor):
+        await asyncio.gather(
+            self.produce(items),
+            self.consume(processor)
+        )
+
+# Usage
+queue = AsyncQueue(maxsize=50)
+
+async def process_item(item: dict):
+    await asyncio.sleep(0.1)  # Simulate work
+    return item["id"]
+
+await queue.run(large_dataset, process_item)
+```
+
+### 7. Async Context with Locks
+
+```python
+import asyncio
+
+class RateLimiter:
+    def __init__(self, max_concurrent: int = 5):
+        self.semaphore = asyncio.Semaphore(max_concurrent)
+        self.lock = asyncio.Lock()
+        self.active = 0
+    
+    async def __aenter__(self):
+        await self.semaphore.acquire()
+        async with self.lock:
+            self.active += 1
+        return self
+    
+    async def __aexit__(self, *args):
+        self.semaphore.release()
+        async with self.lock:
+            self.active -= 1
+
+# Usage - limit concurrent API calls
+async def call_api(url: str):
+    async with RateLimiter(max_concurrent=10):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as resp:
+                return await resp.json()
+```
+
+## Best Practices
+
+1. **Use asyncio.gather** - Concurrent execution
+2. **Avoid blocking calls** - Use async libraries
+3. **Semaphores** - Limit concurrency
+4. **Context managers** - Clean resources
+5. **Async generators** - Memory efficient
+6. **Proper cancellation** - Handle TaskGroup
+7. **Connection pooling** - Reuse connections
+
+## Common Mistakes
+
+- Blocking sync calls in async code
+- Not using connection pools
+- Too many concurrent tasks
+- Forgetting await
+- Race conditions with shared state
+- Not handling exceptions