Have the agent scaffold tinylink

Build a small URL shortener I'll deploy to Render.

Requirements:
- FastAPI in Python 3.12, single main.py
- Postgres for persistence (SQLAlchemy is fine), one `links` table
- Use Render Key Value to rate-limit POST /links to 5/min per IP
- Endpoints: POST /links {url}, GET /{slug} (redirect), GET /healthz
- Read DATABASE_URL and REDIS_URL from env
- A requirements.txt
- A README.md with the local dev steps and the env vars I'll need on Render

Don't write a Blueprint yet - you'll do that next. Just write the app.

I'll use the Render-aware skills to make sure this deploys cleanly:
  - render-web-services for port binding and health checks
  - render-postgres for the connection string format
  - render-keyvalue for Render Key Value client and URL conventions

Plan:
  1. main.py with FastAPI, SQLAlchemy, redis-py
  2. requirements.txt pinning known-good versions
  3. .gitignore for Python + venv
  4. README.md with setup + env vars

Writing now...

import os
import secrets
from contextlib import asynccontextmanager
from datetime import datetime, timedelta, timezone

import redis
from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import RedirectResponse
from pydantic import BaseModel, HttpUrl
from sqlalchemy import Column, DateTime, String, create_engine
from sqlalchemy.orm import declarative_base, sessionmaker

Base = declarative_base()

DATABASE_URL = os.environ["DATABASE_URL"]
REDIS_URL = os.environ["REDIS_URL"]

engine = create_engine(DATABASE_URL, pool_pre_ping=True)
SessionLocal = sessionmaker(bind=engine, autoflush=False)
rds = redis.from_url(REDIS_URL, decode_responses=True)


class Link(Base):
    __tablename__ = "links"
    slug = Column(String, primary_key=True)
    target_url = Column(String, nullable=False)
    expires_at = Column(DateTime(timezone=True), nullable=False)


@asynccontextmanager
async def lifespan(app: FastAPI):
    Base.metadata.create_all(bind=engine)
    yield


app = FastAPI(lifespan=lifespan)


class CreateLink(BaseModel):
    url: HttpUrl


def _rate_limit(ip: str) -> None:
    key = f"rl:{ip}"
    n = rds.incr(key)
    if n == 1:
        rds.expire(key, 60)
    if n > 5:
        raise HTTPException(status_code=429, detail="Slow down")


@app.get("/healthz")
def healthz():
    return {"status": "ok"}


@app.post("/links", status_code=201)
def create_link(payload: CreateLink, request: Request):
    _rate_limit(request.client.host)
    slug = secrets.token_urlsafe(6)
    with SessionLocal() as s:
        s.add(Link(slug=slug, target_url=str(payload.url),
                   expires_at=datetime.now(timezone.utc) + timedelta(days=30)))
        s.commit()
    return {"slug": slug}


@app.get("/{slug}")
def follow(slug: str):
    with SessionLocal() as s:
        link = s.get(Link, slug)
    if not link or link.expires_at < datetime.now(timezone.utc):
        raise HTTPException(status_code=404, detail="Not found")
    return RedirectResponse(link.target_url, status_code=307)

fastapi==0.118.0
uvicorn[standard]==0.34.0
sqlalchemy==2.0.36
psycopg[binary]==3.2.3
redis==5.2.1
pydantic==2.10.4

# tinylink

A tiny URL shortener for the [Render plugin tutorial](#).

## Local dev

\`\`\`bash
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
export DATABASE_URL=postgresql+psycopg://localhost/tinylink
export REDIS_URL=redis://localhost:6379/0
uvicorn main:app --reload --host 0.0.0.0 --port 8000
\`\`\`

## Env vars on Render

| Name           | Source                          |
| -------------- | ------------------------------- |
| `DATABASE_URL` | `fromDatabase` on `tinylink-db` |
| `REDIS_URL`    | `fromService` on `tinylink-kv`  |