from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"mensaje": "Hola mundo"}

@app.get("/productos/{producto_id}")
async def obtener_producto(producto_id: int):
    return {"producto_id": producto_id}

@app.get("/productos/{producto_id}")
async def obtener(producto_id: int):
    return {"producto_id": producto_id}

from enum import Enum

class Categoria(str, Enum):
    electronica = "electronica"
    ropa = "ropa"
    hogar = "hogar"

@app.get("/productos/categoria/{categoria}")
async def por_categoria(categoria: Categoria):
    return {"categoria": categoria}

@app.get("/productos")
async def listar_productos(skip: int = 0, limit: int = 10):
    return productos[skip : skip + limit]

from fastapi import Path, Query

@app.get("/productos")
async def listar(
    skip: int = Query(0, ge=0),
    limit: int = Query(10, ge=1, le=100),
    q: str | None = Query(None, min_length=2),
):
    ...

@app.get("/productos/{producto_id}")
async def obtener(producto_id: int = Path(gt=0)):
    ...

from pydantic import BaseModel, Field

class ProductoCreate(BaseModel):
    nombre: str
    descripcion: str | None = None
    precio: float = Field(gt=0)
    en_stock: bool = True

@app.post("/productos")
async def crear_producto(producto: ProductoCreate):
    return producto

@app.put("/productos/{producto_id}")
async def actualizar(
    producto_id: int,
    producto: ProductoCreate,
    notificar: bool = False,
):
    return {"id": producto_id, **producto.model_dump()}

class UsuarioIn(BaseModel):
    username: str
    password: str

class UsuarioOut(BaseModel):
    username: str

@app.post("/usuarios", response_model=UsuarioOut)
async def crear_usuario(usuario: UsuarioIn):
    return usuario  # la contraseña nunca se expone

from fastapi import status

@app.post("/productos", status_code=status.HTTP_201_CREATED)
async def crear_producto(producto: ProductoCreate):
    return producto

from fastapi import HTTPException

@app.get("/productos/{producto_id}", response_model=ProductoOut)
async def obtener(producto_id: int, db: AsyncSession = Depends(get_db)):
    producto = await db.get(Producto, producto_id)
    if producto is None:
        raise HTTPException(status_code=404, detail="Producto no encontrado")
    return producto

from fastapi import Depends

def paginacion(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/productos")
async def listar(pag: dict = Depends(paginacion)):
    return pag

from fastapi import BackgroundTasks

def enviar_correo(email: str, mensaje: str):
    ...

@app.post("/pedidos")
async def crear_pedido(email: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(enviar_correo, email, "Pedido confirmado")
    return {"estado": "creado"}

def auditar(background_tasks: BackgroundTasks, q: str | None = None):
    if q:
        background_tasks.add_task(registrar_busqueda, q)
    return q

@app.get("/productos")
async def listar(q: str = Depends(auditar)):
    return {"q": q}

from pydantic_settings import BaseSettings, SettingsConfigDict

class Settings(BaseSettings):
    database_url: str
    secret_key: str
    model_config = SettingsConfigDict(env_file=".env")

settings = Settings()

from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from sqlalchemy.orm import DeclarativeBase

DATABASE_URL = "postgresql+psycopg://tienda:tienda@localhost/tienda"

engine = create_async_engine(DATABASE_URL)
SessionLocal = async_sessionmaker(engine, expire_on_commit=False)

class Base(DeclarativeBase):
    pass

from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    await conectar_recursos()
    yield
    await liberar_recursos()

app = FastAPI(lifespan=lifespan)

from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

async def get_db():
    async with SessionLocal() as db:
        yield db

@app.get("/productos", response_model=list[ProductoOut])
async def listar(db: AsyncSession = Depends(get_db)):
    result = await db.scalars(select(Producto))
    return result.all()

from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

from fastapi import HTTPException

async def get_current_user(token: str = Depends(oauth2_scheme)):
    usuario = decodificar_token(token)  # verifica firma y expiración
    if usuario is None:
        raise HTTPException(
            status_code=401,
            detail="Token inválido",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return usuario

@app.get("/usuarios/me")
async def perfil(usuario: Usuario = Depends(get_current_user)):
    return usuario

from fastapi.security import OAuth2PasswordRequestForm

@app.post("/token")
async def login(form: OAuth2PasswordRequestForm = Depends()):
    # verificar form.username y form.password
    token = crear_token(form.username)
    return {"access_token": token, "token_type": "bearer"}

from fastapi import Security

@app.post(
    "/productos",
    dependencies=[Security(oauth2_scheme, scopes=["productos:escribir"])],
)
async def crear_producto(producto: ProductoCreate):
    ...

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://mitienda.com"],
    allow_methods=["*"],
    allow_headers=["*"],
)

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_root():
    r = client.get("/")
    assert r.status_code == 200
    assert r.json() == {"mensaje": "Hola mundo"}

import pytest
from httpx import AsyncClient, ASGITransport
from main import app

@pytest.fixture
def anyio_backend():
    return "asyncio"

@pytest.mark.anyio
async def test_root():
    transport = ASGITransport(app=app)
    async with AsyncClient(transport=transport, base_url="http://test") as ac:
        r = await ac.get("/")
    assert r.status_code == 200

from main import app, get_db
from fastapi.testclient import TestClient

async def db_falsa():
    yield FakeSession()

app.dependency_overrides[get_db] = db_falsa

def test_listar():
    client = TestClient(app)
    assert client.get("/productos").status_code == 200