@martinffx/atelier 1.4.0 → 3.0.0

package/skills/python-build-tools/references/uv.md

@@ -1,257 +0,0 @@
-# uv - Fast Python Package Manager
-
-Rust-based Python package manager that replaces pip, pip-tools, and virtualenv. 10-100x faster than pip with full pip and setuptools compatibility.
-
-## Installation
-
-```bash
-curl -LsSf https://astral.sh/uv/install.sh | sh
-```
-
-## Project Setup
-
-```bash
-# Create new project with uv template
-uv init my-project
-cd my-project
-
-# Initialize uv in existing project
-uv init
-
-# Install Python version
-uv python install 3.12
-
-# Install dependencies
-uv sync
-
-# Add dependencies
-uv add fastapi pydantic
-
-# Add dev dependencies
-uv add --dev pytest ruff basedpyright
-
-# Remove dependency
-uv remove fastapi
-```
-
-## Running Commands
-
-```bash
-# Run Python script
-uv run python script.py
-
-# Run module
-uv run python -m my_module
-
-# Run installed tool (no venv activation needed)
-uv run pytest
-uv run ruff check .
-uv run basedpyright
-
-# Run with specific Python version
-uv run --python 3.12 python script.py
-
-# Run script in context with venv
-uv run python -c "import fastapi; print(fastapi.__version__)"
-```
-
-## Dependency Management
-
-```bash
-# Update all dependencies
-uv lock --upgrade
-
-# Update specific package
-uv lock --upgrade-package fastapi
-
-# Show dependency tree
-uv tree
-
-# Export requirements.txt
-uv pip compile pyproject.toml -o requirements.txt
-
-# Sync after manual pyproject.toml edits
-uv sync
-
-# Sync and skip lock file update
-uv sync --frozen
-
-# Reinstall all
-uv sync --reinstall
-```
-
-## Workspace Configuration
-
-For monorepos with multiple packages:
-
-```toml
-[workspace]
-members = ["packages/core", "packages/api", "packages/cli"]
-
-[project]
-name = "monorepo"
-version = "0.1.0"
-
-[tool.uv.workspace]
-exclude = ["docs"]
-```
-
-Then within each member:
-
-```toml
-[project]
-name = "core"
-version = "0.1.0"
-dependencies = []
-
-[project.optional-dependencies]
-dev = ["pytest>=8.0.0"]
-```
-
-## Scripts in pyproject.toml
-
-```toml
-[tool.uv.scripts]
-dev = "uvicorn my_app.main:app --reload"
-migrate = "alembic upgrade head"
-test = "pytest tests/"
-lint = "ruff check ."
-format = "ruff format ."
-typecheck = "basedpyright"
-check = { chain = ["lint", "format", "typecheck", "test"] }
-```
-
-Run scripts:
-
-```bash
-uv run dev
-uv run migrate
-uv run test
-uv run check  # Runs all checks in sequence
-```
-
-## Version Pinning
-
-Specify exact versions in pyproject.toml:
-
-```toml
-dependencies = [
-    "fastapi>=0.100.0,<1.0.0",
-    "pydantic==2.0.0",
-    "sqlalchemy>=2.0.0",
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-cov>=5.0.0",
-    "ruff>=0.8.0",
-    "basedpyright>=1.0.0",
-]
-```
-
-The lock file (`uv.lock`) records exact versions used.
-
-## Environment Variables
-
-Create `.env` file in project root:
-
-```bash
-DATABASE_URL="postgresql://user:pass@localhost/mydb"
-PYTHONPATH="src"
-LOG_LEVEL="INFO"
-```
-
-Load in Python:
-
-```python
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-db_url = os.getenv("DATABASE_URL")
-```
-
-Or use `python-dotenv`:
-
-```bash
-uv add python-dotenv
-```
-
-## Advanced Options
-
-### Custom Index
-
-```toml
-[tool.uv]
-index-url = "https://pypi.org/simple"
-extra-index-urls = ["https://test.pypi.org/simple"]
-```
-
-### Dev Dependencies Separation
-
-```toml
-[project]
-dependencies = ["fastapi>=0.100.0"]
-
-[project.optional-dependencies]
-dev = ["pytest>=8.0.0", "ruff>=0.8.0"]
-test = ["pytest>=8.0.0"]
-docs = ["sphinx>=6.0.0"]
-
-[tool.uv]
-dev-dependencies = [
-    "pytest>=8.0.0",
-    "ruff>=0.8.0",
-    "basedpyright>=1.0.0",
-]
-```
-
-### Constraints File
-
-Use constraints.txt to pin versions without changing dependencies:
-
-```bash
-# constraints.txt
-sqlalchemy==2.0.0
-pydantic==2.5.0
-```
-
-Apply constraints:
-
-```bash
-uv pip compile pyproject.toml --constraint constraints.txt -o requirements.txt
-```
-
-## Performance
-
-uv is 10-100x faster because it:
-- Written in Rust (native performance)
-- Parallel dependency resolution
-- Intelligent caching
-- Compiled wheels by default
-- Local disk cache
-
-Typical project:
-- pip: 30-60 seconds
-- uv: 1-5 seconds
-
-## Troubleshooting
-
-```bash
-# Clear cache
-uv cache clean
-
-# Verbose output
-uv sync -v
-
-# Check Python installation
-uv python list
-
-# Update uv itself
-uv self update
-
-# Check project structure
-uv tree
-uv tree --depth 2
-```

package/skills/python-fastapi/SKILL.md

@@ -1,184 +0,0 @@
----
-name: python-fastapi
-description: Building REST APIs with FastAPI, Pydantic validation, and OpenAPI. Use when creating routes, handling requests, designing endpoints, implementing validation, error responses, pagination, or generating API documentation.
-user-invocable: false
----
-
-# FastAPI - Modern Python Web APIs
-
-FastAPI is a modern, fast web framework for building APIs with Python, using standard Python type hints. FastAPI automatically validates requests, generates OpenAPI documentation, and provides excellent developer experience.
-
-## Quick Start
-
-### Basic Application
-
-```python
-from fastapi import FastAPI
-from pydantic import BaseModel
-
-app = FastAPI(
-    title="My API",
-    description="API for my application",
-    version="1.0.0",
-)
-
-class Item(BaseModel):
-    name: str
-    price: float
-
-@app.get("/")
-def read_root():
-    return {"message": "Hello World"}
-
-@app.post("/items", response_model=Item)
-def create_item(item: Item):
-    return item
-```
-
-**Run with:**
-```bash
-uvicorn main:app --reload
-```
-
-## Core Concepts
-
-### Request & Response Models
-
-Use Pydantic models for automatic validation and serialization:
-
-```python
-from pydantic import BaseModel, EmailStr, Field
-
-class CreateUserRequest(BaseModel):
-    email: EmailStr
-    name: str = Field(min_length=1, max_length=100)
-    age: int = Field(ge=18, le=120)
-
-class UserResponse(BaseModel):
-    id: int
-    email: str
-    name: str
-    model_config = {"from_attributes": True}  # Enable ORM mode
-
-@app.post("/users", response_model=UserResponse)
-def create_user(user: CreateUserRequest):
-    """Request validated, response serialized automatically"""
-    return user
-```
-
-See `references/validation.md` for detailed validation patterns including custom validators and field constraints.
-
-### Routers for Organization
-
-Split routes across routers for clean organization:
-
-```python
-# routers/users.py
-from fastapi import APIRouter
-
-router = APIRouter(prefix="/users", tags=["users"])
-
-@router.get("/")
-def list_users():
-    ...
-
-@router.post("/")
-def create_user(user: CreateUserRequest):
-    ...
-
-# main.py
-app.include_router(users.router)
-```
-
-### Dependency Injection
-
-FastAPI's core feature for managing dependencies like database sessions and authentication:
-
-```python
-from fastapi import Depends
-from sqlalchemy.orm import Session
-
-def get_db() -> Session:
-    """Database session dependency"""
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-@app.get("/users")
-def list_users(db: Session = Depends(get_db)):
-    """db automatically injected"""
-    return db.query(User).all()
-```
-
-See `references/dependencies.md` for advanced patterns including auth services, scoped dependencies, and dependency classes.
-
-## Error Handling
-
-### HTTP Exceptions
-
-```python
-from fastapi import HTTPException
-
-@app.get("/users/{user_id}")
-def get_user(user_id: int):
-    user = db.get(user_id)
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found")
-    return user
-```
-
-### Custom Exception Handlers
-
-```python
-from fastapi import Request
-from fastapi.responses import JSONResponse
-
-class BusinessError(Exception):
-    def __init__(self, message: str):
-        self.message = message
-
-@app.exception_handler(BusinessError)
-async def business_error_handler(request: Request, exc: BusinessError):
-    return JSONResponse(
-        status_code=400,
-        content={"error": exc.message},
-    )
-```
-
-## Project Structure
-
-```
-my-api/
-├── main.py                   # FastAPI app
-├── routers/                  # Route handlers
-│   ├── users.py
-│   └── products.py
-├── schemas/                  # Pydantic models
-│   ├── users.py
-│   └── products.py
-├── services/                 # Business logic
-│   └── users.py
-├── repositories/             # Data access
-│   └── users.py
-└── dependencies.py           # Dependency injection
-```
-
-## Reference Materials
-
-Detailed patterns for common scenarios:
-
-- **Validation**: `references/validation.md` - Field constraints, custom validators, model validation
-- **Dependencies**: `references/dependencies.md` - Auth services, scoped dependencies, advanced injection patterns
-- **Middleware**: `references/middleware.md` - CORS, custom middleware, request/response processing
-- **API Design**: `references/api-design.md` - REST naming, pagination, OpenAPI customization, status codes
-
-## Best Practices
-
-1. **Use response_model** - Always define explicit response schemas
-2. **Validate inputs** - Use Pydantic models with constraints
-3. **Dependency injection** - Manage sessions, auth, and cross-cutting concerns
-4. **Router organization** - Split routes by resource/domain
-5. **Error handling** - Use HTTP exceptions and custom handlers appropriately
-6. **Type hints** - FastAPI uses them for both validation and documentation