API del inventario con FastAPI

"""Punto de entrada de la API. Une routers, traduce errores del dominio a HTTP."""

import os
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager

from fastapi import FastAPI

from inventario.db import init_db

VERSION = os.environ.get("INVENTARIO_VERSION", "dev")


@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
    init_db()  # antes de atender el primer request
    yield      # aquí la API atiende; lo de después de yield corre al apagarse


app = FastAPI(title="Inventario de laboratorio", version=VERSION, lifespan=lifespan)


@app.get("/health")
def health() -> dict:
    return {"status": "ok", "version": VERSION}

"""Esquemas de entrada y salida de la API. El contrato público, separado de las tablas."""

from datetime import date, datetime

from pydantic import BaseModel, Field


# --- entrada (lo que el cliente manda) ---


class ReactivoIn(BaseModel):
    nombre: str = Field(min_length=1)
    unidad: str = Field(min_length=1)
    cas: str | None = None


class LoteIn(BaseModel):
    reactivo_id: int
    ubicacion_id: int
    codigo: str = Field(min_length=1)
    cantidad: float = Field(gt=0)
    vencimiento: date


class MovimientoIn(BaseModel):
    codigo_lote: str = Field(min_length=1)
    cantidad: float = Field(gt=0)
    nota: str | None = None


# --- salida (lo que la API responde) ---


class ReactivoOut(BaseModel):
    id: int
    nombre: str
    unidad: str
    cas: str | None


class LoteOut(BaseModel):
    id: int
    codigo: str
    reactivo_id: int
    ubicacion_id: int
    cantidad: float
    vencimiento: date


class MovimientoOut(BaseModel):
    id: int
    lote_id: int
    cantidad: float
    fecha: datetime
    nota: str | None

"""Dependencias de FastAPI. Aquí vive el 'cómo consigo una sesión'."""

from collections.abc import Iterator
from typing import Annotated

from fastapi import Depends
from sqlmodel import Session

from inventario.db import engine


def get_session() -> Iterator[Session]:
    with Session(engine) as session:
        yield session


# Alias: "una Session que FastAPI inyecta llamando a get_session".
# Los routers lo usan como tipo y no repiten Depends(...) en cada función.
SessionDep = Annotated[Session, Depends(get_session)]

"""Rutas de reactivos. Traducen HTTP <-> services. Nada de SQL aquí."""

from fastapi import APIRouter, HTTPException, status

from inventario import services
from inventario.api.deps import SessionDep
from inventario.api.schemas import ReactivoIn, ReactivoOut
from inventario.models import Reactivo

router = APIRouter(prefix="/reactivos", tags=["reactivos"])


@router.get("", response_model=list[ReactivoOut])
def listar(session: SessionDep, q: str = "") -> list[Reactivo]:
    return services.buscar_reactivo(session, q)


@router.post("", response_model=ReactivoOut, status_code=status.HTTP_201_CREATED)
def crear(datos: ReactivoIn, session: SessionDep) -> Reactivo:
    return services.crear_reactivo(session, datos.nombre, datos.unidad, datos.cas)


@router.get("/{reactivo_id}", response_model=ReactivoOut)
def obtener(reactivo_id: int, session: SessionDep) -> Reactivo:
    reactivo = session.get(Reactivo, reactivo_id)
    if reactivo is None:
        raise HTTPException(status_code=404, detail=f"no existe el reactivo {reactivo_id}")
    return reactivo

from inventario.api.routers import reactivos

app.include_router(reactivos.router)

from fastapi import Request
from fastapi.responses import JSONResponse

from inventario.errors import LoteNoExiste, StockInsuficiente


@app.exception_handler(LoteNoExiste)
def _lote_no_existe(request: Request, exc: LoteNoExiste) -> JSONResponse:
    return JSONResponse(status_code=404, content={"detail": str(exc)})


@app.exception_handler(StockInsuficiente)
def _stock_insuficiente(request: Request, exc: StockInsuficiente) -> JSONResponse:
    return JSONResponse(status_code=409, content={"detail": str(exc)})

"""Rutas de movimientos (entradas y salidas de stock)."""

from fastapi import APIRouter, status

from inventario import services
from inventario.api.deps import SessionDep
from inventario.api.schemas import MovimientoIn, MovimientoOut

router = APIRouter(prefix="/movimientos", tags=["movimientos"])


@router.post("", response_model=MovimientoOut, status_code=status.HTTP_201_CREATED)
def registrar_salida(datos: MovimientoIn, session: SessionDep) -> object:
    # Las excepciones del dominio (LoteNoExiste, StockInsuficiente) las
    # traducen a HTTP los exception handlers de main.py.
    return services.registrar_salida(session, datos.codigo_lote, datos.cantidad, datos.nota)

"""Rutas de lotes."""

from fastapi import APIRouter, HTTPException, status
from sqlalchemy.exc import IntegrityError

from inventario import services
from inventario.api.deps import SessionDep
from inventario.api.schemas import LoteIn, LoteOut
from inventario.models import Reactivo, Ubicacion

router = APIRouter(prefix="/lotes", tags=["lotes"])


@router.post("", response_model=LoteOut, status_code=status.HTTP_201_CREATED)
def crear(datos: LoteIn, session: SessionDep) -> object:
    if session.get(Reactivo, datos.reactivo_id) is None:
        raise HTTPException(status_code=404, detail=f"no existe el reactivo {datos.reactivo_id}")
    if session.get(Ubicacion, datos.ubicacion_id) is None:
        raise HTTPException(status_code=404, detail=f"no existe la ubicación {datos.ubicacion_id}")
    try:
        return services.agregar_lote(
            session,
            datos.reactivo_id,
            datos.ubicacion_id,
            datos.codigo,
            datos.cantidad,
            datos.vencimiento,
        )
    except IntegrityError:
        session.rollback()
        raise HTTPException(status_code=409, detail=f"ya existe un lote {datos.codigo!r}")


@router.get("/por-vencer", response_model=list[LoteOut])
def por_vencer(session: SessionDep, dias: int = 30) -> object:
    return services.lotes_por_vencer(session, dias)

"""Fixtures compartidas: una API contra una base en memoria, nueva en cada test."""

import pytest
from fastapi.testclient import TestClient
from sqlmodel import Session, SQLModel, StaticPool, create_engine

from inventario.api.deps import get_session
from inventario.api.main import app


@pytest.fixture()
def client():
    # Una DB sqlite en memoria por test: nace vacía, muere al terminar.
    engine = create_engine(
        "sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool
    )
    SQLModel.metadata.create_all(engine)

    def get_session_test():
        with Session(engine) as session:
            yield session

    # Le decimos a FastAPI: donde pedías get_session, usa esta otra.
    app.dependency_overrides[get_session] = get_session_test
    with TestClient(app) as c:
        yield c
    app.dependency_overrides.clear()

def test_crear_reactivo_devuelve_201_y_el_recurso(client):
    r = client.post("/reactivos", json={"nombre": "Etanol 96%", "unidad": "mL"})
    assert r.status_code == 201
    assert r.json()["nombre"] == "Etanol 96%"


def test_crear_reactivo_sin_nombre_devuelve_422(client):
    r = client.post("/reactivos", json={"unidad": "mL"})
    assert r.status_code == 422
    assert r.json()["detail"][0]["loc"] == ["body", "nombre"]


def test_salida_mayor_al_stock_devuelve_409_y_no_descuenta(datos_base):
    r = datos_base.post("/movimientos", json={"codigo_lote": "TAQ-2401", "cantidad": 9999})
    assert r.status_code == 409
    # y el stock sigue intacto:
    lotes = datos_base.get("/lotes/por-vencer", params={"dias": 60}).json()
    assert lotes[0]["cantidad"] == 500

FROM python:3.12-slim

COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv

WORKDIR /app

COPY pyproject.toml uv.lock ./
COPY src ./src

RUN uv sync --frozen --no-dev

# La API escucha en 0.0.0.0 para ser visible desde fuera del contenedor
CMD ["uv", "run", "uvicorn", "inventario.api.main:app", "--host", "0.0.0.0", "--port", "8000"]

services:
  api:
    build: .
    ports:
      - "8000:8000"          # puerto de tu máquina : puerto del contenedor
    environment:
      INVENTARIO_DB_URL: sqlite:////data/inventario.db
      INVENTARIO_VERSION: compose-dev
    volumes:
      - datos:/data          # la DB sobrevive a docker compose down

volumes:
  datos: