@martinffx/atelier 2.0.0 → 3.0.1

package/skills/python-modern-python/references/async.md

@@ -1,76 +0,0 @@
-# Async/Await Patterns
-
-## Basic Async
-
-```python
-import asyncio
-
-async def fetch_user(user_id: int) -> User:
-    """Async function"""
-    await asyncio.sleep(1)  # Simulate IO
-    return User(id=user_id)
-
-# Run async function
-user = await fetch_user(1)
-
-# Or from sync code
-user = asyncio.run(fetch_user(1))
-```
-
-## Concurrent Execution
-
-```python
-async def process_all(user_ids: list[int]):
-    """Process multiple users concurrently"""
-    tasks = [fetch_user(id) for id in user_ids]
-    users = await asyncio.gather(*tasks)
-    return users
-```
-
-## Async Context Managers
-
-```python
-class AsyncDB:
-    async def __aenter__(self):
-        await self.connect()
-        return self
-
-    async def __aexit__(self, *args):
-        await self.disconnect()
-
-async with AsyncDB() as db:
-    result = await db.query(...)
-```
-
-## Async Iterators
-
-```python
-class AsyncRange:
-    def __init__(self, n: int):
-        self.n = n
-        self.i = 0
-
-    def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        if self.i >= self.n:
-            raise StopAsyncIteration
-        self.i += 1
-        await asyncio.sleep(0.1)
-        return self.i
-
-async for i in AsyncRange(10):
-    print(i)
-```
-
-## Error Handling
-
-```python
-async def safe_fetch(url: str):
-    try:
-        return await fetch_data(url)
-    except httpx.HTTPError as e:
-        logger.error(f"Failed to fetch {url}: {e}")
-        return None
-```

package/skills/python-modern-python/references/pattern-matching.md

@@ -1,89 +0,0 @@
-# Pattern Matching (Python 3.10+)
-
-## Basic Patterns
-
-```python
-def handle_status(code: int):
-    match code:
-        case 200:
-            return "OK"
-        case 404:
-            return "Not Found"
-        case 500:
-            return "Server Error"
-        case _:
-            return "Unknown"
-```
-
-## Or Patterns
-
-```python
-match status:
-    case 200 | 201 | 204:
-        return "Success"
-    case 400 | 404:
-        return "Client Error"
-    case 500 | 502 | 503:
-        return "Server Error"
-```
-
-## Structural Patterns
-
-```python
-def process_point(point):
-    match point:
-        case (0, 0):
-            return "Origin"
-        case (x, 0):
-            return f"X-axis at {x}"
-        case (0, y):
-            return f"Y-axis at {y}"
-        case (x, y):
-            return f"Point at ({x}, {y})"
-```
-
-## Class Patterns
-
-```python
-from dataclasses import dataclass
-
-@dataclass
-class Circle:
-    radius: float
-
-@dataclass
-class Rectangle:
-    width: float
-    height: float
-
-def area(shape):
-    match shape:
-        case Circle(radius=r):
-            return 3.14 * r * r
-        case Rectangle(width=w, height=h):
-            return w * h
-        case _:
-            raise ValueError("Unknown shape")
-```
-
-## Guards
-
-```python
-match point:
-    case (x, y) if x == y:
-        return "On diagonal"
-    case (x, y) if x > y:
-        return "Above diagonal"
-    case (x, y):
-        return "Below diagonal"
-```
-
-## Nested Patterns
-
-```python
-match event:
-    case {"type": "click", "position": (x, y)}:
-        handle_click(x, y)
-    case {"type": "key", "key": key_code}:
-        handle_key(key_code)
-```

package/skills/python-modern-python/references/typing.md

@@ -1,96 +0,0 @@
-# Advanced Type Hints
-
-## Generics
-
-```python
-from typing import TypeVar, Generic
-
-T = TypeVar("T")
-
-class Stack(Generic[T]):
-    def __init__(self):
-        self.items: list[T] = []
-
-    def push(self, item: T) -> None:
-        self.items.append(item)
-
-    def pop(self) -> T:
-        return self.items.pop()
-
-stack: Stack[int] = Stack()
-stack.push(1)
-```
-
-## Protocol
-
-```python
-from typing import Protocol
-
-class Comparable(Protocol):
-    def __lt__(self, other: object) -> bool:
-        ...
-
-def sort_items(items: list[Comparable]) -> list[Comparable]:
-    return sorted(items)
-```
-
-## TypedDict
-
-```python
-from typing import TypedDict
-
-class UserDict(TypedDict):
-    id: int
-    name: str
-    email: str
-
-def create_user(data: UserDict) -> User:
-    return User(
-        id=data["id"],
-        name=data["name"],
-        email=data["email"],
-    )
-```
-
-## Literal
-
-```python
-from typing import Literal
-
-Status = Literal["pending", "active", "inactive"]
-
-def set_status(status: Status) -> None:
-    ...
-
-set_status("pending")  # OK
-set_status("invalid")  # Type error
-```
-
-## ParamSpec
-
-```python
-from typing import Callable, ParamSpec, TypeVar
-
-P = ParamSpec("P")
-R = TypeVar("R")
-
-def with_logging(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
-```
-
-## Self (Python 3.11+)
-
-```python
-from typing import Self
-
-class Builder:
-    def with_name(self, name: str) -> Self:
-        self.name = name
-        return self
-
-    def build(self) -> Product:
-        return Product(self.name)
-```

package/skills/python-monorepo/SKILL.md

@@ -1,146 +0,0 @@
----
-name: python-monorepo
-description: Python monorepo architecture with uv workspaces, mise, and apps/packages pattern. Use when setting up project structure, configuring workspaces, managing dependencies across packages, or designing multi-app Python repositories.
-user-invocable: false
----
-
-# Python Monorepo with uv Workspaces
-
-Modern Python monorepo architecture using `uv` for workspace management and `mise` for Python version and task orchestration.
-
-## Core Concepts
-
-**Monorepo**: Single repository containing multiple related packages and applications
-
-**uv workspace**: Python's answer to npm/pnpm workspaces
-- Single lock file for entire repo
-- Shared virtual environment
-- Cross-package dependency resolution
-
-## Directory Structure
-
-```
-my-monorepo/
-├── .mise.toml           # Python version + task runner
-├── pyproject.toml       # Root workspace config
-├── uv.lock              # Unified lock file
-├── apps/                # Deployable applications
-│   ├── api/
-│   └── worker/
-└── packages/            # Shared libraries
-    ├── core/
-    └── utils/
-```
-
-## Workspace Configuration
-
-**Root pyproject.toml:**
-
-```toml
-[project]
-name = "my-monorepo"
-version = "0.1.0"
-requires-python = ">=3.12"
-
-[tool.uv.workspace]
-members = ["apps/*", "packages/*"]
-
-[tool.uv]
-dev-dependencies = [
-    "pytest>=8.0.0",
-    "ruff>=0.8.0",
-    "basedpyright>=1.0.0",
-]
-```
-
-See `references/workspace-config.md` for detailed configurations.
-
-## Package Linking
-
-Workspace packages reference each other by distribution name:
-
-**packages/utils/pyproject.toml:**
-```toml
-[project]
-name = "my-utils"
-dependencies = ["my-core"]
-```
-
-**apps/api/pyproject.toml:**
-```toml
-[project]
-name = "my-api"
-dependencies = ["my-core", "my-utils", "fastapi>=0.100.0"]
-```
-
-## Cross-Package Import
-
-**packages/core/src/my_core/entities.py:**
-```python
-class User:
-    def __init__(self, email: str):
-        self.email = email
-```
-
-**apps/api/src/my_api/main.py:**
-```python
-from my_core.entities import User  # Import from workspace package
-
-def run():
-    # App code...
-```
-
-## Dependency Direction (Critical)
-
-```
-apps/ → packages/  (Apps depend on packages)
-packages/ ⇏ apps/  (Never the reverse)
-```
-
-**Rules:**
-- Apps can depend on packages
-- Packages can depend on other packages
-- Packages NEVER depend on apps
-- Avoid circular dependencies
-
-## mise Task Runner
-
-**.mise.toml:**
-
-```toml
-[tools]
-python = "3.12"
-
-[tasks.check]
-depends = ["lint", "typecheck", "test"]
-
-[tasks.lint]
-run = "uv run ruff check ."
-```
-
-**Usage:** `mise run check`
-
-## Core uv Commands
-
-```bash
-uv sync                           # Install all packages
-uv add fastapi --package my-api   # Add to specific package
-uv add my-core --package my-api   # Add workspace package
-uv run pytest                      # Run tests
-uv lock --upgrade                 # Update dependencies
-```
-
-## Best Practices
-
-1. Single lock file at root
-2. Shared dev tools (ruff, pytest) in root dev-dependencies
-3. Pin Python version with mise
-4. Apps depend on packages only
-5. Use namespace packages for logical grouping (optional)
-
-## References
-
-For detailed patterns:
-- `references/workspace-config.md` - pyproject.toml patterns, dependencies, versions
-- `references/docker.md` - Multi-stage Docker builds
-- `references/namespace-packages.md` - PEP 420 namespace packages