aigroup-workflow 2.1.1 → 2.2.0

package/skills/python-pro/references/testing.md

@@ -1,404 +0,0 @@
-# Testing with Pytest
-
-## Basic Pytest Structure
-
-```python
-# test_user.py
-import pytest
-from myapp.user import User, UserService
-
-# Simple test function
-def test_user_creation() -> None:
-    user = User(id=1, name="Alice", email="alice@example.com")
-    assert user.name == "Alice"
-    assert user.is_active is True
-
-# Test with multiple assertions
-def test_user_validation() -> None:
-    with pytest.raises(ValueError, match="Invalid email"):
-        User(id=1, name="Alice", email="invalid")
-
-# Test class for grouping
-class TestUserService:
-    def test_find_user(self) -> None:
-        service = UserService()
-        user = service.find(1)
-        assert user is not None
-
-    def test_create_user(self) -> None:
-        service = UserService()
-        user = service.create(name="Bob", email="bob@example.com")
-        assert user.id > 0
-```
-
-## Fixtures for Setup/Teardown
-
-```python
-# conftest.py - shared fixtures
-import pytest
-from typing import Iterator
-from myapp.database import Database, Session
-
-@pytest.fixture
-def db() -> Iterator[Database]:
-    """Provide database instance with cleanup."""
-    database = Database("test.db")
-    database.create_tables()
-    yield database
-    database.drop_tables()
-    database.close()
-
-@pytest.fixture
-def db_session(db: Database) -> Iterator[Session]:
-    """Provide database session with rollback."""
-    session = db.create_session()
-    yield session
-    session.rollback()
-    session.close()
-
-@pytest.fixture
-def sample_user() -> User:
-    """Provide test user."""
-    return User(id=1, name="Test User", email="test@example.com")
-
-# Using fixtures in tests
-def test_user_creation(db_session: Session, sample_user: User) -> None:
-    db_session.add(sample_user)
-    db_session.commit()
-
-    retrieved = db_session.query(User).filter_by(id=1).first()
-    assert retrieved.name == "Test User"
-
-# Fixture with parameters
-@pytest.fixture(params=["sqlite", "postgresql", "mysql"])
-def db_engine(request: pytest.FixtureRequest) -> str:
-    return request.param
-
-def test_connection(db_engine: str) -> None:
-    # Test runs 3 times with different engines
-    assert create_connection(db_engine)
-
-# Autouse fixture (runs automatically)
-@pytest.fixture(autouse=True)
-def reset_state() -> Iterator[None]:
-    """Reset global state before each test."""
-    clear_caches()
-    yield
-    cleanup_temp_files()
-```
-
-## Parametrize for Multiple Cases
-
-```python
-import pytest
-
-# Parametrize test function
-@pytest.mark.parametrize(
-    "input,expected",
-    [
-        (2, 4),
-        (3, 9),
-        (4, 16),
-        (-2, 4),
-    ]
-)
-def test_square(input: int, expected: int) -> None:
-    assert square(input) == expected
-
-# Multiple parameters
-@pytest.mark.parametrize("base", [2, 10])
-@pytest.mark.parametrize("exponent", [0, 1, 2])
-def test_power(base: int, exponent: int) -> None:
-    result = base ** exponent
-    assert result >= 0
-
-# Parametrize with IDs
-@pytest.mark.parametrize(
-    "email,valid",
-    [
-        ("user@example.com", True),
-        ("invalid", False),
-        ("@example.com", False),
-        ("user@", False),
-    ],
-    ids=["valid", "no_at", "no_user", "no_domain"]
-)
-def test_email_validation(email: str, valid: bool) -> None:
-    assert is_valid_email(email) == valid
-
-# Parametrize with fixtures
-@pytest.fixture
-def user_factory():
-    def _make_user(name: str, active: bool = True) -> User:
-        return User(name=name, active=active)
-    return _make_user
-
-@pytest.mark.parametrize("name", ["Alice", "Bob", "Charlie"])
-def test_user_names(user_factory, name: str) -> None:
-    user = user_factory(name)
-    assert user.name == name
-```
-
-## Mocking and Patching
-
-```python
-from unittest.mock import Mock, MagicMock, patch, AsyncMock, call
-import pytest
-
-# Mock object
-def test_api_call_with_mock() -> None:
-    mock_client = Mock()
-    mock_client.get.return_value = {"status": "ok"}
-
-    service = ApiService(mock_client)
-    result = service.fetch_data()
-
-    mock_client.get.assert_called_once_with("/api/data")
-    assert result["status"] == "ok"
-
-# Patch function/method
-def test_database_call() -> None:
-    with patch("myapp.database.connect") as mock_connect:
-        mock_connect.return_value = Mock()
-
-        db = Database()
-        db.connect()
-
-        mock_connect.assert_called_once()
-
-# Patch as decorator
-@patch("myapp.user.send_email")
-def test_user_registration(mock_send_email: Mock) -> None:
-    service = UserService()
-    service.register("user@example.com")
-
-    mock_send_email.assert_called_with(
-        to="user@example.com",
-        subject="Welcome"
-    )
-
-# Multiple patches
-@patch("myapp.api.requests.get")
-@patch("myapp.api.cache.get")
-def test_cached_api(mock_cache: Mock, mock_requests: Mock) -> None:
-    mock_cache.return_value = None
-    mock_requests.return_value.json.return_value = {"data": "value"}
-
-    result = fetch_with_cache("key")
-
-    mock_cache.assert_called_once_with("key")
-    mock_requests.assert_called_once()
-
-# Mock side effects
-def test_retry_logic() -> None:
-    mock_api = Mock()
-    mock_api.call.side_effect = [
-        ConnectionError("Failed"),
-        ConnectionError("Failed"),
-        {"status": "ok"}
-    ]
-
-    result = retry_api_call(mock_api)
-    assert result["status"] == "ok"
-    assert mock_api.call.call_count == 3
-
-# Async mock
-@pytest.mark.asyncio
-async def test_async_function() -> None:
-    mock_db = AsyncMock()
-    mock_db.fetch_user.return_value = User(id=1, name="Alice")
-
-    service = AsyncUserService(mock_db)
-    user = await service.get_user(1)
-
-    mock_db.fetch_user.assert_awaited_once_with(1)
-    assert user.name == "Alice"
-```
-
-## Async Testing
-
-```python
-import pytest
-import asyncio
-
-# Mark async test
-@pytest.mark.asyncio
-async def test_async_fetch() -> None:
-    result = await fetch_data("https://api.example.com")
-    assert result["status"] == "ok"
-
-# Async fixture
-@pytest.fixture
-async def async_db() -> AsyncIterator[AsyncDatabase]:
-    db = AsyncDatabase()
-    await db.connect()
-    yield db
-    await db.disconnect()
-
-@pytest.mark.asyncio
-async def test_async_query(async_db: AsyncDatabase) -> None:
-    result = await async_db.query("SELECT * FROM users")
-    assert len(result) > 0
-
-# Test concurrent operations
-@pytest.mark.asyncio
-async def test_concurrent_requests() -> None:
-    urls = ["http://example.com/1", "http://example.com/2"]
-    results = await asyncio.gather(*[fetch(url) for url in urls])
-    assert len(results) == 2
-```
-
-## Pytest Markers
-
-```python
-import pytest
-
-# Skip test
-@pytest.mark.skip(reason="Not implemented yet")
-def test_future_feature() -> None:
-    pass
-
-# Conditional skip
-@pytest.mark.skipif(sys.version_info < (3, 11), reason="Requires Python 3.11+")
-def test_new_feature() -> None:
-    pass
-
-# Expected failure
-@pytest.mark.xfail(reason="Known bug #123")
-def test_known_bug() -> None:
-    assert buggy_function() == expected_value
-
-# Custom markers
-@pytest.mark.slow
-def test_slow_operation() -> None:
-    time.sleep(5)
-    assert True
-
-@pytest.mark.integration
-def test_integration() -> None:
-    assert external_service.ping()
-
-# Run with: pytest -m "not slow"
-```
-
-## Test Coverage
-
-```python
-# Run with coverage
-# pytest --cov=myapp --cov-report=html --cov-report=term
-
-# conftest.py - coverage configuration
-def pytest_configure(config):
-    config.addinivalue_line(
-        "markers", "unit: mark test as unit test"
-    )
-
-# pytest.ini or pyproject.toml
-"""
-[tool.pytest.ini_options]
-minversion = "7.0"
-addopts = [
-    "--cov=myapp",
-    "--cov-report=term-missing",
-    "--cov-fail-under=90",
-    "-ra",
-    "--strict-markers",
-]
-testpaths = ["tests"]
-"""
-```
-
-## Property-Based Testing
-
-```python
-from hypothesis import given, strategies as st
-
-# Property-based test
-@given(st.integers(), st.integers())
-def test_addition_commutative(a: int, b: int) -> None:
-    assert a + b == b + a
-
-@given(st.lists(st.integers()))
-def test_sorted_is_ordered(lst: list[int]) -> None:
-    sorted_lst = sorted(lst)
-    for i in range(len(sorted_lst) - 1):
-        assert sorted_lst[i] <= sorted_lst[i + 1]
-
-# Custom strategies
-@given(st.emails())
-def test_email_validation(email: str) -> None:
-    assert "@" in email
-    assert validate_email(email)
-
-# Composite strategies
-from hypothesis import strategies as st
-from hypothesis.strategies import composite
-
-@composite
-def users(draw) -> User:
-    return User(
-        id=draw(st.integers(min_value=1)),
-        name=draw(st.text(min_size=1, max_size=50)),
-        email=draw(st.emails()),
-        age=draw(st.integers(min_value=18, max_value=120))
-    )
-
-@given(users())
-def test_user_creation(user: User) -> None:
-    assert user.age >= 18
-    assert len(user.name) > 0
-```
-
-## Test Organization
-
-```python
-# tests/
-#   conftest.py          - Shared fixtures
-#   test_user.py         - User tests
-#   test_api.py          - API tests
-#   integration/
-#     test_workflow.py   - Integration tests
-#   unit/
-#     test_models.py     - Unit tests
-
-# Fixture factory pattern
-@pytest.fixture
-def user_factory(db_session: Session):
-    created_users: list[User] = []
-
-    def _create_user(
-        name: str = "Test User",
-        email: str | None = None,
-        **kwargs
-    ) -> User:
-        if email is None:
-            email = f"{name.lower().replace(' ', '.')}@example.com"
-
-        user = User(name=name, email=email, **kwargs)
-        db_session.add(user)
-        db_session.commit()
-        created_users.append(user)
-        return user
-
-    yield _create_user
-
-    # Cleanup
-    for user in created_users:
-        db_session.delete(user)
-    db_session.commit()
-```
-
-## Snapshot Testing
-
-```python
-import pytest
-from syrupy.assertion import SnapshotAssertion
-
-def test_api_response(snapshot: SnapshotAssertion) -> None:
-    response = api.get_user(1)
-    assert response == snapshot
-
-def test_rendered_template(snapshot: SnapshotAssertion) -> None:
-    html = render_template("user.html", user=get_user(1))
-    assert html == snapshot
-```

package/skills/python-pro/references/type-system.md

@@ -1,290 +0,0 @@
-# Type System Mastery
-
-## Basic Type Annotations
-
-```python
-from typing import Any
-from collections.abc import Sequence, Mapping
-
-# Function signatures
-def process_user(name: str, age: int, active: bool = True) -> dict[str, Any]:
-    return {"name": name, "age": age, "active": active}
-
-# Use | for unions (Python 3.10+)
-def find_user(user_id: int | str) -> dict[str, Any] | None:
-    if isinstance(user_id, int):
-        return {"id": user_id}
-    return None
-
-# Collections - prefer collections.abc
-def process_items(items: Sequence[str]) -> list[str]:
-    """Accepts list, tuple, or any sequence."""
-    return [item.upper() for item in items]
-
-def merge_configs(base: Mapping[str, int], override: dict[str, int]) -> dict[str, int]:
-    """Mapping for read-only, dict for mutable."""
-    return {**base, **override}
-```
-
-## Generic Types
-
-```python
-from typing import TypeVar, Generic, Protocol
-from collections.abc import Callable
-
-T = TypeVar('T')
-K = TypeVar('K')
-V = TypeVar('V')
-
-# Generic function
-def first_element(items: Sequence[T]) -> T | None:
-    return items[0] if items else None
-
-# Generic class
-class Cache(Generic[K, V]):
-    def __init__(self) -> None:
-        self._data: dict[K, V] = {}
-
-    def get(self, key: K) -> V | None:
-        return self._data.get(key)
-
-    def set(self, key: K, value: V) -> None:
-        self._data[key] = value
-
-# Usage
-user_cache: Cache[int, str] = Cache()
-user_cache.set(1, "Alice")
-
-# Constrained TypeVar
-from numbers import Number
-NumT = TypeVar('NumT', bound=Number)
-
-def add_numbers(a: NumT, b: NumT) -> NumT:
-    return a + b  # type: ignore[return-value]
-```
-
-## Protocol for Structural Typing
-
-```python
-from typing import Protocol, runtime_checkable
-
-# Define interface without inheritance
-class Drawable(Protocol):
-    def draw(self) -> str:
-        ...
-
-    @property
-    def color(self) -> str:
-        ...
-
-class Circle:
-    def __init__(self, radius: float, color: str) -> None:
-        self.radius = radius
-        self._color = color
-
-    def draw(self) -> str:
-        return f"Drawing {self._color} circle"
-
-    @property
-    def color(self) -> str:
-        return self._color
-
-# Circle implements Drawable without inheriting
-def render(shape: Drawable) -> str:
-    return shape.draw()
-
-# Runtime checkable protocol
-@runtime_checkable
-class Closeable(Protocol):
-    def close(self) -> None:
-        ...
-
-def cleanup(resource: Closeable) -> None:
-    if isinstance(resource, Closeable):
-        resource.close()
-```
-
-## Advanced Type Features
-
-```python
-from typing import Literal, TypeAlias, TypedDict, NotRequired, Self, overload
-
-# Literal types for constants
-Mode = Literal["read", "write", "append"]
-
-def open_file(path: str, mode: Mode) -> None:
-    ...
-
-# Type aliases for complex types
-JsonDict: TypeAlias = dict[str, Any]
-UserId: TypeAlias = int | str
-
-# TypedDict for structured dictionaries
-class UserDict(TypedDict):
-    id: int
-    name: str
-    email: str
-    age: NotRequired[int]  # Optional field
-
-def create_user(data: UserDict) -> None:
-    print(data["name"])  # Type-safe access
-
-# Self type for method chaining
-class Builder:
-    def __init__(self) -> None:
-        self._value = 0
-
-    def add(self, n: int) -> Self:
-        self._value += n
-        return self
-
-    def multiply(self, n: int) -> Self:
-        self._value *= n
-        return self
-
-# Overload for different signatures
-@overload
-def process(data: str) -> str: ...
-
-@overload
-def process(data: int) -> int: ...
-
-def process(data: str | int) -> str | int:
-    if isinstance(data, str):
-        return data.upper()
-    return data * 2
-```
-
-## Callable Types
-
-```python
-from collections.abc import Callable
-from typing import ParamSpec, Concatenate
-
-# Basic callable
-def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
-    return func(a, b)
-
-# ParamSpec for preserving signatures
-P = ParamSpec('P')
-R = TypeVar('R')
-
-def logging_decorator(func: Callable[P, R]) -> Callable[P, R]:
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        print(f"Calling {func.__name__}")
-        return func(*args, **kwargs)
-    return wrapper
-
-# Concatenate for dependency injection
-def with_connection(
-    func: Callable[Concatenate[Connection, P], R]
-) -> Callable[P, R]:
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        conn = get_connection()
-        return func(conn, *args, **kwargs)
-    return wrapper
-
-# Usage
-@with_connection
-def query_user(conn: Connection, user_id: int) -> User:
-    return conn.execute(f"SELECT * FROM users WHERE id = {user_id}")
-```
-
-## Mypy Configuration
-
-```toml
-# pyproject.toml
-[tool.mypy]
-python_version = "3.11"
-strict = true
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = true
-disallow_any_generics = true
-disallow_subclassing_any = true
-disallow_untyped_calls = true
-disallow_incomplete_defs = true
-check_untyped_defs = true
-no_implicit_optional = true
-warn_redundant_casts = true
-warn_unused_ignores = true
-warn_no_return = true
-warn_unreachable = true
-strict_equality = true
-
-[[tool.mypy.overrides]]
-module = "third_party.*"
-ignore_missing_imports = true
-```
-
-## Common Type Patterns
-
-```python
-# Result type pattern
-from dataclasses import dataclass
-
-@dataclass
-class Success(Generic[T]):
-    value: T
-
-@dataclass
-class Error:
-    message: str
-
-Result = Success[T] | Error
-
-def divide(a: int, b: int) -> Result[float]:
-    if b == 0:
-        return Error("Division by zero")
-    return Success(a / b)
-
-# Option/Maybe type
-def safe_get(items: Sequence[T], index: int) -> T | None:
-    try:
-        return items[index]
-    except IndexError:
-        return None
-
-# Sentinel value with typing
-from typing import Final
-
-MISSING: Final = object()
-
-def get_value(key: str, default: T | type[MISSING] = MISSING) -> T:
-    if default is MISSING:
-        raise KeyError(key)
-    return default  # type: ignore[return-value]
-```
-
-## Type Narrowing
-
-```python
-from typing import assert_type, assert_never
-
-def process_value(value: int | str | None) -> str:
-    # Type guards
-    if value is None:
-        return "null"
-
-    if isinstance(value, int):
-        # Type narrowed to int
-        return str(value * 2)
-
-    # Type narrowed to str
-    return value.upper()
-
-# Exhaustiveness checking
-def handle_mode(mode: Literal["read", "write"]) -> str:
-    if mode == "read":
-        return "Reading"
-    elif mode == "write":
-        return "Writing"
-    else:
-        # Mypy will error if mode can be anything else
-        assert_never(mode)
-
-# Custom type guard
-def is_string_list(val: list[Any]) -> bool:
-    """Runtime check for list of strings."""
-    return all(isinstance(x, str) for x in val)
-```