Download scripts/seed_datos_reales.py from Modulo-6/api: direct link, hf CLI and curl.
- Browser
- Download file 11.6 kB
-
https://huggingface.co/spaces/Modulo-6/api/resolve/main/scripts/seed_datos_reales.py
- Command line
-
hf download hf://spaces/Modulo-6/api/scripts/seed_datos_reales.py
-
curl -L -o seed_datos_reales.py https://huggingface.co/spaces/Modulo-6/api/resolve/main/scripts/seed_datos_reales.py
11.6 kB
| """ | |
| Normalización de datos reales en Supabase — 3 fases (ver plan aprobado en | |
| `docs/superpowers` o el historial de conversación del 2026-07-14). | |
| Fase 1: corrige los campos de las 17 camas ya cargadas (piso/sector/tipo/hospital_id/ | |
| specialty_id/contraindicaciones) para que tengan sentido semántico y médico, deja | |
| el piso 5 exclusivo para quirófanos, y vacía TODAS las camas dejándolas DISPONIBLE. | |
| Fase 2: trunca `solicitudes`/`reservas_quirofano` (datos de prueba viejos, confirmado con | |
| el usuario) y siembra 6 internaciones + 3 traslados + 4 reservas de quirófano | |
| usando los 7 pacientes reales de M1 (vía el service layer real de la app, no SQL | |
| a mano) y episodios reales abiertos en M1. | |
| Fase 3: sobre las camas que quedan sin paciente tras la fase 2, marca variedad de estados | |
| (FUERA_DE_SERVICIO, BAJA_PERMANENTE) — sin tocar los quirófanos, que tienen | |
| reservas activas dependientes de que sigan DISPONIBLE. | |
| Uso: | |
| .venv/bin/python scripts/seed_datos_reales.py | |
| Requiere el `.env` real del proyecto (Supabase + cuenta de servicio de M6 en el Core). | |
| `mock_external_services` se fuerza a `True` en este proceso: no hace falta generar | |
| tráfico real hacia M1/M9/M7 por una carga de datos, solo hacia M1 (pacientes/episodios, | |
| por `httpx` directo) y M10 (login de la cuenta de servicio). | |
| """ | |
| from __future__ import annotations | |
| import sys | |
| from datetime import datetime, timedelta, timezone | |
| import httpx | |
| from app.config import settings | |
| # Fuerza mock para las notificaciones salientes del service layer (HCE/M9/M7) — no | |
| # quiere decir que no consultemos M1 real: las consultas de este script (pacientes, | |
| # episodios) van directo por httpx, no pasan por `app.integrations.hce`. | |
| settings.mock_external_services = True | |
| from app.dependencies import get_db # noqa: E402 | |
| from app.integrations import core_auth # noqa: E402 | |
| from app.schemas.solicitud import SolicitudHceWebhook, SolicitudResolucionRequest # noqa: E402 | |
| from app.schemas.reserva import ReservaQuirofanoCreateRequest # noqa: E402 | |
| from app.services import solicitud_service, cama_service # noqa: E402 | |
| # `settings.m1_hce_url` apunta al hostname interno de docker (`http://modulo1:8001`), | |
| # solo resoluble dentro del cluster donde corre M6 desplegado. Este script corre standalone | |
| # (fuera del cluster), así que necesita el host público real de M1. | |
| M1_PUBLIC_URL = "https://healthgrid-hce-backend.onrender.com" | |
| RESUELTO_POR = 1 # id de usuario ADMINISTRATIVO, mismo criterio que datos previos | |
| def _m1_headers() -> dict: | |
| token = core_auth.get_service_token() | |
| if not token: | |
| print("ERROR: no se pudo obtener token de la cuenta de servicio (CORE_SERVICE_EMAIL/PASSWORD).", file=sys.stderr) | |
| sys.exit(1) | |
| return {"Authorization": f"Bearer {token}"} | |
| def _abrir_episodio_m1(paciente_id: int, tipo: str, diagnostico: str) -> int: | |
| """POST /api/v1/patients/{id}/episodes en M1 real — devuelve id_episodio real.""" | |
| r = httpx.post( | |
| f"{M1_PUBLIC_URL}/api/v1/patients/{paciente_id}/episodes", | |
| json={"tipo": tipo, "estado": "open", "diagnostico_principal": diagnostico}, | |
| headers=_m1_headers(), | |
| timeout=15, | |
| ) | |
| r.raise_for_status() | |
| return r.json()["id_episodio"] | |
| # ─── Fase 1: normalizar camas ─────────────────────────────────────────────── | |
| # id de cama -> (numero, piso, sector, tipo, specialty_id, contraindicaciones) | |
| CAMAS_FASE1 = { | |
| 9: ("101", 1, "GUARDIA", "ESTANDAR", None, []), | |
| 10: ("102", 1, "GUARDIA", "CRITICA", None, []), | |
| 18: ("103", 1, "GUARDIA", "PEDIATRICA", None, []), | |
| 11: ("201", 2, "SALA_COMUN", "ESTANDAR", None, []), | |
| 12: ("202", 2, "SALA_COMUN", "ESTANDAR", None, []), | |
| 13: ("203", 2, "SALA_COMUN", "AISLAMIENTO", None, ["COVID"]), | |
| 15: ("204", 2, "SALA_COMUN", "ESTANDAR", None, []), | |
| 16: ("205", 2, "SALA_COMUN", "ESTANDAR", None, []), | |
| 20: ("206", 2, "SALA_COMUN", "ESTANDAR", None, []), | |
| 5: ("301", 3, "UTI", "CRITICA", None, []), | |
| 6: ("302", 3, "UTI", "AISLAMIENTO", None, ["INMUNOSUPRIMIDO"]), | |
| 8: ("303", 3, "UTI", "CRITICA", None, []), | |
| 14: ("401", 4, "NEONATOLOGIA", "PEDIATRICA", None, []), | |
| 21: ("402", 4, "NEONATOLOGIA", "PEDIATRICA", None, ["ALERGIA_LATEX"]), | |
| 7: ("501", 5, "QUIROFANO", "CIRUGIA", 1, []), | |
| 17: ("502", 5, "QUIROFANO", "CIRUGIA", 22, []), | |
| 19: ("503", 5, "QUIROFANO", "CIRUGIA", 43, []), | |
| } | |
| # numero (nuevo) -> id de cama, para referenciar por número "de piso" en las fases 2/3 | |
| CAMA_ID_POR_NUMERO = {v[0]: k for k, v in CAMAS_FASE1.items()} | |
| def fase1_normalizar_camas(db) -> None: | |
| print("\n=== FASE 1: normalizar camas ===") | |
| now = datetime.now(timezone.utc).isoformat() | |
| for cama_id, (numero, piso, sector, tipo, specialty_id, contraindicaciones) in CAMAS_FASE1.items(): | |
| updates = { | |
| "numero": numero, | |
| "piso": piso, | |
| "sector": sector, | |
| "tipo": tipo, | |
| "specialty_id": specialty_id, | |
| "hospital_id": "1", | |
| "contraindicaciones_incompatibles": contraindicaciones, | |
| "estado": "DISPONIBLE", | |
| "paciente_id": None, | |
| "ultimo_movimiento_tipo": None, | |
| "solicitud_hce_id": None, | |
| "fecha_ingreso": None, | |
| "alta_tipo": None, | |
| "alta_timestamp": None, | |
| "episodio_id": None, | |
| "ultima_actualizacion": now, | |
| } | |
| db.table("camas").update(updates).eq("id", cama_id).execute() | |
| print(f" cama id={cama_id} -> numero={numero} piso={piso} sector={sector} tipo={tipo}") | |
| print(f"Fase 1 OK — {len(CAMAS_FASE1)} camas normalizadas, todas DISPONIBLE.") | |
| # ─── Fase 2: poblar con pacientes reales de M1 ────────────────────────────── | |
| INTERNACIONES = [ | |
| # (paciente_id, cama_numero_destino, medico_solicitante_id, diagnostico, prioridad) | |
| (3001, "101", 10, "Dolor torácico agudo a estudio", "ALTA"), | |
| (3002, "201", 10, "Neumonía adquirida en la comunidad", "MEDIA"), | |
| (3003, "301", 14, "Sepsis de foco urinario", "MUY_ALTA"), | |
| (3004, "202", 10, "Pielonefritis aguda", "MEDIA"), | |
| (3005, "102", 14, "Apendicitis aguda, prequirúrgico", "ALTA"), | |
| (22, "302", 14, "Politraumatismo, aislamiento por sospecha infecciosa", "MUY_ALTA"), | |
| ] | |
| TRASLADOS = [ | |
| # (paciente_id, cama_origen_numero, cama_destino_numero, motivo) | |
| (3001, "101", "205", "Estabilizado en guardia, pasa a sala común"), | |
| (3003, "301", "204", "Sale de terapia intensiva, mejoría clínica"), | |
| (22, "302", "203", "Continúa aislamiento fuera de UTI"), | |
| ] | |
| RESERVAS = [ | |
| # (paciente_id, quirofano_numero, medico_cirujano_id, procedimiento, inicio, fin) | |
| (3005, "501", 30, "Apendicectomía laparoscópica", | |
| datetime(2026, 7, 20, 9, 0, tzinfo=timezone.utc), timedelta(hours=2)), | |
| (3003, "502", 30, "Drenaje programado", | |
| datetime(2026, 7, 21, 9, 0, tzinfo=timezone.utc), timedelta(hours=1, minutes=30)), | |
| (216, "503", 22, "Hernia inguinal (cirugía ambulatoria)", | |
| datetime(2026, 7, 22, 10, 0, tzinfo=timezone.utc), timedelta(hours=1)), | |
| (3004, "501", 30, "Colecistectomía programada", | |
| datetime(2026, 7, 20, 14, 0, tzinfo=timezone.utc), timedelta(hours=2)), | |
| ] | |
| def _truncar_datos_viejos(db) -> None: | |
| print("Truncando solicitudes/reservas_quirofano viejas...") | |
| db.table("solicitudes").delete().gte("id", 0).execute() | |
| db.table("reservas_quirofano").delete().gte("id", 0).execute() | |
| def fase2_poblar_pacientes_reales(db) -> None: | |
| print("\n=== FASE 2: poblar con pacientes reales de M1 ===") | |
| _truncar_datos_viejos(db) | |
| # --- Internaciones --- | |
| for i, (paciente_id, cama_num, medico_id, diagnostico, prioridad) in enumerate(INTERNACIONES, start=1): | |
| cama_id = CAMA_ID_POR_NUMERO[cama_num] | |
| episodio_id = _abrir_episodio_m1(paciente_id, "internacion", diagnostico) | |
| webhook = SolicitudHceWebhook( | |
| tipo="INTERNACION", | |
| solicitud_hce_id=f"HCE-INT-{paciente_id}", | |
| paciente_id=paciente_id, | |
| medico_solicitante_id=medico_id, | |
| cama_solicitada_id=cama_id, | |
| origen="GUARDIA", | |
| diagnostico_ingreso=diagnostico, | |
| prioridad=prioridad, | |
| hospital_id="1", | |
| episodio_id=episodio_id, | |
| timestamp=datetime.now(timezone.utc), | |
| ) | |
| sol = solicitud_service.recibir_solicitud(db, webhook) | |
| solicitud_service.resolver_solicitud( | |
| db, sol.solicitud_id, SolicitudResolucionRequest(accion="APROBAR"), resuelto_por=RESUELTO_POR, | |
| ) | |
| print(f" [{i}/6] INTERNACION paciente={paciente_id} -> cama {cama_num} (episodio_id={episodio_id}) OK") | |
| # --- Traslados --- | |
| for i, (paciente_id, origen_num, destino_num, motivo) in enumerate(TRASLADOS, start=1): | |
| origen_id = CAMA_ID_POR_NUMERO[origen_num] | |
| destino_id = CAMA_ID_POR_NUMERO[destino_num] | |
| webhook = SolicitudHceWebhook( | |
| tipo="TRASLADO", | |
| solicitud_hce_id=f"HCE-TRA-{paciente_id}", | |
| paciente_id=paciente_id, | |
| medico_solicitante_id=10, | |
| cama_origen_id=origen_id, | |
| cama_destino_solicitada_id=destino_id, | |
| motivo_traslado=motivo, | |
| hospital_id="1", | |
| timestamp=datetime.now(timezone.utc), | |
| ) | |
| sol = solicitud_service.recibir_solicitud(db, webhook) | |
| solicitud_service.resolver_solicitud( | |
| db, sol.solicitud_id, SolicitudResolucionRequest(accion="APROBAR"), resuelto_por=RESUELTO_POR, | |
| ) | |
| print(f" [{i}/3] TRASLADO paciente={paciente_id} -> {origen_num} => {destino_num} OK") | |
| # --- Reservas de quirófano --- | |
| for i, (paciente_id, quir_num, medico_id, procedimiento, inicio, duracion) in enumerate(RESERVAS, start=1): | |
| quir_id = CAMA_ID_POR_NUMERO[quir_num] | |
| data = ReservaQuirofanoCreateRequest( | |
| turno_id=9000 + i, | |
| paciente_id=paciente_id, | |
| medico_cirujano_id=medico_id, | |
| fecha_hora_inicio=inicio, | |
| fecha_hora_fin_estimada=inicio + duracion, | |
| prioridad="MEDIA", | |
| observaciones=procedimiento, | |
| ) | |
| cama_service.create_reserva(db, quir_id, data) | |
| print(f" [{i}/4] RESERVA paciente={paciente_id} -> quirófano {quir_num} ({procedimiento}) OK") | |
| print("Fase 2 OK.") | |
| # ─── Fase 3: variedad de estados en camas sin paciente ────────────────────── | |
| CAMAS_FASE3 = { | |
| "303": ("FUERA_DE_SERVICIO", "Mantenimiento preventivo de monitor"), | |
| "103": ("BAJA_PERMANENTE", "Cama retirada de servicio"), | |
| "206": ("FUERA_DE_SERVICIO", "Mantenimiento"), | |
| } | |
| def fase3_variedad_estados(db) -> None: | |
| print("\n=== FASE 3: variedad de estados en camas sin paciente ===") | |
| now = datetime.now(timezone.utc).isoformat() | |
| for numero, (estado, motivo) in CAMAS_FASE3.items(): | |
| cama_id = CAMA_ID_POR_NUMERO[numero] | |
| db.table("camas").update({"estado": estado, "ultima_actualizacion": now}).eq("id", cama_id).execute() | |
| print(f" cama numero={numero} (id={cama_id}) -> {estado} ({motivo})") | |
| print("Fase 3 OK — quirófanos (501/502/503) y neonatología (401/402) sin tocar.") | |
| def main() -> int: | |
| db = get_db() | |
| fase1_normalizar_camas(db) | |
| fase2_poblar_pacientes_reales(db) | |
| fase3_variedad_estados(db) | |
| print("\n✔ Seed completo.") | |
| return 0 | |
| if __name__ == "__main__": | |
| raise SystemExit(main()) | |