agent-python-expert

Files (1)

• SKILL.md

SKILL.md (first lines)

You are a Python expert with deep ecosystem knowledge.

## Modern Python (3.10+)

### Type Hints

```python
from typing import TypeVar, Generic, Protocol, Callable
from collections.abc import Sequence, Mapping

# Basic types
def greet(name: str) -> str:
    return f"Hello, {name}"

# Union types (3.10+)
def process(value: int | str | None) -> str:
    ...

# Generics
T = TypeVar('T')
def first(items: Sequence[T]) -> T | None:
    return items[0] if items else None

# Protocols (structural subtyping)
class Printable(Protocol):
    def __str__(self) -> str: ...

# TypedDict for structured dicts
from typing import TypedDict

class UserDict(TypedDict):
    name: str
    age: int
    email: str | None
```

### Async Patterns

```python
import asyncio
from typing import AsyncIterator

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 generator
async def paginate(url: str) -> AsyncIterator[dict]:
    page = 1
    while True:
        data = await fetch_data(f"{url}?page={page}")
        if not data["items"]:
            break
        for item in data["items"]:
            yield item
        page += 1

# Gather for parallelism
async def fetch_all(urls: list[str]) -> list[dict]:
    return await asyncio.gather(*[fetch_data(url) for url in urls])
```

### Data Classes

```python
from dataclasses import dataclass, field
from datetime import datetime

@dataclass(frozen=True)  # Immutable
class User:
    id: int
    name: str
    email: str
    created_at: datetime = field(default_factory=datetime.now)
    tags: list[str] = field(default_factory=list)

# Pydantic for validation
from pydantic import BaseModel, EmailStr, validator

class UserInput(BaseModel):
    name: str
    email: EmailStr
    age: int

    @validator('age')
    def age_must_be_positive(cls, v):
        if v < 0:
            raise ValueError('Age must be positive')
        return v
```

### Context Managers

```python
from contextlib import contextmanager, asynccontextmanager

@contextmanager
def timer(name: str):
    start = time.time()
    try:
        yield
    finally:
        print(f"{name}: {time.time() - start:.2f}s")

@asynccontextmanager
async def db_transaction():
    conn = await get_connection()
    try:
        yield conn
        await conn.commit()
    except Exception:
        await conn.rollback()
        raise
    finally:
        await conn.close()
```

## Project Structure

From travisjneuman/.claude, MIT.

More from travisjneuman/.claude