autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/pytest.md

@@ -0,0 +1,313 @@
+# Pytest Skill
+
+## Project Structure
+\`\`\`
+tests/
+├── conftest.py           # Shared fixtures
+├── unit/
+│   ├── test_models.py
+│   └── test_services.py
+├── integration/
+│   └── test_api.py
+└── e2e/
+    └── test_flows.py
+\`\`\`
+
+## Fixtures
+\`\`\`python
+# conftest.py
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+@pytest.fixture(scope="session")
+def engine():
+    """Create test database engine once per test session."""
+    engine = create_engine("sqlite:///:memory:")
+    Base.metadata.create_all(engine)
+    yield engine
+    engine.dispose()
+
+@pytest.fixture(scope="function")
+def db_session(engine):
+    """Create a new session for each test."""
+    Session = sessionmaker(bind=engine)
+    session = Session()
+    yield session
+    session.rollback()
+    session.close()
+
+@pytest.fixture
+def user(db_session):
+    """Create a test user."""
+    user = User(email="test@example.com", name="Test User")
+    db_session.add(user)
+    db_session.commit()
+    return user
+
+@pytest.fixture
+def client(app):
+    """Flask test client."""
+    return app.test_client()
+
+@pytest.fixture
+def auth_headers(client, user):
+    """Get auth headers for authenticated requests."""
+    response = client.post('/auth/login', json={
+        'email': user.email,
+        'password': 'password',
+    })
+    token = response.json['access_token']
+    return {'Authorization': f'Bearer {token}'}
+\`\`\`
+
+## Parametrize
+\`\`\`python
+import pytest
+
+# Multiple test cases
+@pytest.mark.parametrize("email,expected", [
+    ("valid@example.com", True),
+    ("invalid-email", False),
+    ("", False),
+    ("a@b.c", True),
+])
+def test_validate_email(email, expected):
+    assert validate_email(email) == expected
+
+# Multiple parameters
+@pytest.mark.parametrize("a,b,expected", [
+    (1, 2, 3),
+    (0, 0, 0),
+    (-1, 1, 0),
+])
+def test_add(a, b, expected):
+    assert add(a, b) == expected
+
+# Combining parametrize decorators (cartesian product)
+@pytest.mark.parametrize("x", [1, 2])
+@pytest.mark.parametrize("y", [10, 20])
+def test_multiply(x, y):
+    assert multiply(x, y) == x * y
+
+# With IDs for better test names
+@pytest.mark.parametrize(
+    "status_code,expected_error",
+    [
+        pytest.param(400, "Bad Request", id="bad_request"),
+        pytest.param(401, "Unauthorized", id="unauthorized"),
+        pytest.param(404, "Not Found", id="not_found"),
+    ]
+)
+def test_error_messages(status_code, expected_error):
+    assert get_error_message(status_code) == expected_error
+\`\`\`
+
+## Mocking
+\`\`\`python
+from unittest.mock import Mock, patch, MagicMock, AsyncMock
+
+# Patch a module function
+@patch('app.services.user.send_email')
+def test_create_user_sends_email(mock_send_email, db_session):
+    user = create_user(db_session, "test@example.com", "Test")
+    mock_send_email.assert_called_once_with("test@example.com", "Welcome!")
+
+# Patch a method
+@patch.object(UserService, 'get_user')
+def test_get_user_not_found(mock_get_user):
+    mock_get_user.return_value = None
+    result = UserService().get_user(999)
+    assert result is None
+
+# Mock with return values
+def test_external_api(mocker):
+    mock_response = Mock()
+    mock_response.json.return_value = {'data': 'value'}
+    mock_response.status_code = 200
+
+    mocker.patch('requests.get', return_value=mock_response)
+
+    result = fetch_data()
+    assert result == {'data': 'value'}
+
+# Mock async functions
+@pytest.mark.asyncio
+async def test_async_function(mocker):
+    mock_fetch = AsyncMock(return_value={'id': 1})
+    mocker.patch('app.services.fetch_user', mock_fetch)
+
+    result = await get_user_data(1)
+    assert result['id'] == 1
+
+# Using pytest-mock's mocker fixture
+def test_with_mocker(mocker):
+    mocker.patch('time.sleep')  # Speed up tests
+    mocker.patch('os.environ.get', return_value='test_value')
+\`\`\`
+
+## Async Testing
+\`\`\`python
+import pytest
+import asyncio
+
+# Mark async tests
+@pytest.mark.asyncio
+async def test_async_function():
+    result = await async_fetch_data()
+    assert result is not None
+
+# Async fixture
+@pytest.fixture
+async def async_client():
+    async with AsyncClient(app, base_url="http://test") as client:
+        yield client
+
+@pytest.mark.asyncio
+async def test_async_api(async_client):
+    response = await async_client.get("/api/users")
+    assert response.status_code == 200
+
+# Test async generators
+@pytest.mark.asyncio
+async def test_async_generator():
+    results = []
+    async for item in async_stream():
+        results.append(item)
+    assert len(results) == 10
+\`\`\`
+
+## Testing Exceptions
+\`\`\`python
+import pytest
+
+def test_raises_exception():
+    with pytest.raises(ValueError) as exc_info:
+        validate_age(-1)
+    assert "Age must be positive" in str(exc_info.value)
+
+def test_raises_specific_exception():
+    with pytest.raises(ValidationError, match="Invalid email"):
+        validate_email("not-an-email")
+
+# Test exception attributes
+def test_custom_exception():
+    with pytest.raises(AppError) as exc_info:
+        do_something_risky()
+
+    assert exc_info.value.code == "RISK_ERROR"
+    assert exc_info.value.status_code == 400
+\`\`\`
+
+## Markers
+\`\`\`python
+# Custom markers in pytest.ini or pyproject.toml
+# [tool.pytest.ini_options]
+# markers = [
+#     "slow: marks tests as slow",
+#     "integration: marks integration tests",
+# ]
+
+@pytest.mark.slow
+def test_slow_operation():
+    result = process_large_dataset()
+    assert result is not None
+
+@pytest.mark.integration
+def test_database_connection(db_session):
+    assert db_session.execute("SELECT 1").scalar() == 1
+
+@pytest.mark.skip(reason="Not implemented yet")
+def test_future_feature():
+    pass
+
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix only")
+def test_unix_specific():
+    pass
+
+@pytest.mark.xfail(reason="Known bug #123")
+def test_known_bug():
+    assert broken_function() == "expected"
+
+# Run specific markers
+# pytest -m slow
+# pytest -m "not slow"
+# pytest -m "integration and not slow"
+\`\`\`
+
+## Coverage Configuration
+\`\`\`toml
+# pyproject.toml
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+asyncio_mode = "auto"
+addopts = [
+    "-v",
+    "--tb=short",
+    "--cov=app",
+    "--cov-report=term-missing",
+    "--cov-report=html",
+    "--cov-fail-under=80",
+]
+
+[tool.coverage.run]
+source = ["app"]
+omit = ["*/tests/*", "*/__init__.py"]
+branch = true
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+]
+\`\`\`
+
+## Test Utilities
+\`\`\`python
+# Freeze time
+from freezegun import freeze_time
+
+@freeze_time("2024-01-15 12:00:00")
+def test_timestamp():
+    assert get_current_time() == datetime(2024, 1, 15, 12, 0, 0)
+
+# Factory Boy for test data
+from factory import Factory, Faker, SubFactory
+
+class UserFactory(Factory):
+    class Meta:
+        model = User
+
+    email = Faker('email')
+    name = Faker('name')
+
+class PostFactory(Factory):
+    class Meta:
+        model = Post
+
+    title = Faker('sentence')
+    author = SubFactory(UserFactory)
+
+def test_with_factory():
+    user = UserFactory()
+    posts = PostFactory.create_batch(5, author=user)
+    assert len(posts) == 5
+\`\`\`
+
+## ❌ DON'T
+- Use global state between tests
+- Skip cleanup in fixtures
+- Write tests that depend on order
+- Mock too much (test real behavior)
+
+## ✅ DO
+- Use fixtures for setup/teardown
+- Use parametrize for multiple inputs
+- Use markers to categorize tests
+- Mock external dependencies only
+- Test edge cases and errors
+- Run with coverage reports
+- Use factory patterns for test data

package/.claude/skills/python.md

@@ -0,0 +1,272 @@
+# Python Skill
+
+## Project Structure
+\`\`\`
+my_project/
+├── pyproject.toml         # Project config (Poetry/PDM)
+├── .python-version        # Python version
+├── .env                   # Environment variables
+├── src/
+│   └── my_project/
+│       ├── __init__.py
+│       ├── main.py
+│       ├── config.py
+│       ├── models/
+│       ├── services/
+│       └── utils/
+└── tests/
+    ├── conftest.py
+    └── test_*.py
+\`\`\`
+
+## Type Hints
+\`\`\`python
+from typing import Optional, List, Dict, TypeVar, Generic
+from collections.abc import Callable, Awaitable
+
+# Basic types
+def get_user(user_id: str) -> User | None:
+    return db.query(User).filter(User.id == user_id).first()
+
+# Collections
+def get_users(ids: list[str]) -> list[User]:
+    return db.query(User).filter(User.id.in_(ids)).all()
+
+# Dictionaries
+def process_data(data: dict[str, int]) -> dict[str, str]:
+    return {k: str(v) for k, v in data.items()}
+
+# Callable types
+Handler = Callable[[Request], Awaitable[Response]]
+
+# Generics
+T = TypeVar('T')
+
+class Repository(Generic[T]):
+    def find(self, id: str) -> T | None: ...
+    def save(self, entity: T) -> T: ...
+\`\`\`
+
+## Dataclasses & Pydantic
+\`\`\`python
+from dataclasses import dataclass, field
+from pydantic import BaseModel, EmailStr, Field
+
+# Dataclasses for simple data containers
+@dataclass
+class User:
+    id: str
+    email: str
+    name: str | None = None
+    tags: list[str] = field(default_factory=list)
+
+# Pydantic for validation
+class UserCreate(BaseModel):
+    email: EmailStr
+    name: str = Field(min_length=1, max_length=100)
+    password: str = Field(min_length=8)
+
+    class Config:
+        str_strip_whitespace = True
+
+# Usage
+user = UserCreate(email="test@example.com", name="John", password="secret123")
+user_dict = user.model_dump()
+\`\`\`
+
+## Async/Await
+\`\`\`python
+import asyncio
+from typing import AsyncIterator
+
+# Async function
+async def fetch_user(user_id: str) -> User:
+    async with httpx.AsyncClient() as client:
+        response = await client.get(f"/users/{user_id}")
+        return User(**response.json())
+
+# Concurrent execution
+async def fetch_all_users(ids: list[str]) -> list[User]:
+    tasks = [fetch_user(id) for id in ids]
+    return await asyncio.gather(*tasks)
+
+# Async context manager
+class DatabaseConnection:
+    async def __aenter__(self) -> "DatabaseConnection":
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        await self.disconnect()
+
+# Async generator
+async def stream_users() -> AsyncIterator[User]:
+    async for row in db.stream_query("SELECT * FROM users"):
+        yield User(**row)
+
+# Usage
+async for user in stream_users():
+    print(user.name)
+\`\`\`
+
+## Error Handling
+\`\`\`python
+from typing import NoReturn
+
+# Custom exceptions
+class UserNotFoundError(Exception):
+    def __init__(self, user_id: str):
+        self.user_id = user_id
+        super().__init__(f"User {user_id} not found")
+
+class ValidationError(Exception):
+    def __init__(self, errors: list[str]):
+        self.errors = errors
+        super().__init__(f"Validation failed: {errors}")
+
+# Try/except patterns
+def get_user_or_raise(user_id: str) -> User:
+    try:
+        user = db.get_user(user_id)
+        if not user:
+            raise UserNotFoundError(user_id)
+        return user
+    except DatabaseError as e:
+        logger.error(f"Database error: {e}")
+        raise
+    finally:
+        db.close()
+
+# Result pattern (no exceptions)
+from dataclasses import dataclass
+
+@dataclass
+class Result[T]:
+    value: T | None = None
+    error: str | None = None
+
+    @property
+    def is_ok(self) -> bool:
+        return self.error is None
+
+def safe_get_user(user_id: str) -> Result[User]:
+    try:
+        user = db.get_user(user_id)
+        return Result(value=user)
+    except Exception as e:
+        return Result(error=str(e))
+\`\`\`
+
+## Logging
+\`\`\`python
+import logging
+from logging.handlers import RotatingFileHandler
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+
+# Module logger
+logger = logging.getLogger(__name__)
+
+# Structured logging
+logger.info("User created", extra={"user_id": user.id, "email": user.email})
+
+# Production setup
+def setup_logging():
+    handler = RotatingFileHandler(
+        "app.log",
+        maxBytes=10_000_000,  # 10MB
+        backupCount=5,
+    )
+    handler.setFormatter(logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    ))
+    logging.getLogger().addHandler(handler)
+\`\`\`
+
+## Context Managers
+\`\`\`python
+from contextlib import contextmanager, asynccontextmanager
+
+# Sync context manager
+@contextmanager
+def transaction():
+    db.begin()
+    try:
+        yield db
+        db.commit()
+    except Exception:
+        db.rollback()
+        raise
+
+# Async context manager
+@asynccontextmanager
+async def get_connection():
+    conn = await pool.acquire()
+    try:
+        yield conn
+    finally:
+        await pool.release(conn)
+
+# Usage
+async with get_connection() as conn:
+    await conn.execute("SELECT * FROM users")
+\`\`\`
+
+## Environment & Config
+\`\`\`python
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+class Settings(BaseSettings):
+    database_url: str
+    redis_url: str
+    jwt_secret: str
+    debug: bool = False
+
+    class Config:
+        env_file = ".env"
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
+
+# Usage
+settings = get_settings()
+print(settings.database_url)
+\`\`\`
+
+## Virtual Environments
+\`\`\`bash
+# Create venv
+python -m venv .venv
+
+# Activate
+source .venv/bin/activate  # Unix
+.venv\\Scripts\\activate     # Windows
+
+# Modern: use Poetry or PDM
+poetry init
+poetry add fastapi uvicorn
+poetry install
+\`\`\`
+
+## ❌ DON'T
+- Use mutable default arguments (use None or field())
+- Catch bare Exception without re-raising
+- Use global state without proper management
+- Mix sync and async code incorrectly
+- Ignore type hints
+
+## ✅ DO
+- Follow PEP 8 (use ruff/black for formatting)
+- Use type hints everywhere
+- Prefer f-strings over .format()
+- Use context managers for resources
+- Use dataclasses/pydantic for data
+- Use async for I/O-bound operations
+- Use logging instead of print
+- Use virtual environments