Deploy: Conexión de pipeline BETO con esquema estrella de Supabase

Dockerfile

@@ -0,0 +1,40 @@
+# =============================================================================
+# DOCKERFILE OPTIMIZADO PARA API FASTAPI + TRANSFORMERS (BETO) EN ENTORNOS CPU
+# =============================================================================
+
+FROM python:3.12-slim
+
+# 1. Instalar compiladores necesarios para psycopg2 y rapidfuzz
+USER root
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libpq-dev \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# 2. Configurar el usuario exigido por Hugging Face (UID 1000)
+RUN useradd -m -u 1000 user
+ENV PATH="/home/user/.local/bin:$PATH" \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    HF_HOME=/tmp/huggingface_cache
+
+WORKDIR /app
+
+# 3. Copiar e instalar dependencias con los permisos correctos
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# 4. Descargar y almacenar los pesos de BETO en caché durante la construcción
+RUN python -c "from transformers import pipeline; pipeline('ner', model='mrm8488/bert-spanish-ner-cased', tokenizer='mrm8488/bert-spanish-ner-cased', aggregation_strategy='simple')"
+
+# 5. Copiar el resto del código asignando la propiedad al usuario final
+COPY --chown=user . /app
+
+USER user
+
+# 6. Escuchar obligatoriamente en el puerto 7860 exigido por Hugging Face
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

database.py

@@ -0,0 +1,61 @@
+import os
+from dotenv import load_dotenv
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+# Load environment variables from .env file
+load_dotenv()
+
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+if not DATABASE_URL:
+    # Fallback to local postgres if not set for safety, or raise a warning
+    DATABASE_URL = "postgresql://postgres:postgres@localhost:5432/postgres"
+
+# For Supabase, pool_pre_ping=True is highly recommended to handle stale connections
+engine = create_engine(
+    DATABASE_URL,
+    pool_pre_ping=True,
+    pool_recycle=3600
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+from sqlalchemy import Column, Integer, String, Numeric, Boolean, DateTime, ForeignKey
+import datetime
+
+Base = declarative_base()
+
+class DimEstudiante(Base):
+    __tablename__ = "dim_estudiante"
+    id_estudiante = Column(Integer, primary_key=True, index=True)
+    nombre_completo = Column(String(200), nullable=False)
+    codigo_estudiante = Column(String(50))
+
+class FactRendimientoAcademico(Base):
+    __tablename__ = "fact_rendimiento_academico"
+    id_hecho_aca = Column(Integer, primary_key=True, index=True)
+    id_estudiante = Column(Integer, ForeignKey("dim_estudiante.id_estudiante"))
+    id_docente = Column(Integer)
+    id_modulo = Column(Integer)
+    id_tiempo = Column(Integer)
+    id_documento = Column(Integer)
+    id_usuario_carga = Column(Integer)
+    nota_final = Column(Numeric(5,2))
+    asistencia_pct = Column(Numeric(5,2))
+    incumplimiento_actividades_pct = Column(Numeric(5,2))
+    nivel_confianza_ia = Column(Numeric(5,4))
+    requiere_revision = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=datetime.datetime.utcnow)
+
+
+def get_db():
+    """
+    Dependency injection helper to yield a database session.
+    Guarantees that the session is closed after the request completes.
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

main.py

@@ -0,0 +1,89 @@
+import datetime
+import logging
+from typing import List
+from fastapi import FastAPI, Depends, HTTPException, status
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from database import get_db, DimEstudiante, FactRendimientoAcademico, engine
+from ner_engine import ner_engine
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="GiraGroup BI Backend Cloud",
+    description="API para Tecnologías Emergentes II con BETO y Supabase",
+    version="1.0.0"
+)
+
+class ProcessSheetPayload(BaseModel):
+    texto_celda: str
+    nota_detectada: float
+    asistencia: float
+    incumplimiento_tareas: float
+    id_docente: int
+    id_modulo: int
+    id_tiempo: int
+    id_documento: int
+    id_usuario: int
+
+@app.get("/")
+def read_root():
+    return {
+        "status": "healthy",
+        "service": "GiraGroup BI Backend API Cloud",
+        "ner_initialized": ner_engine._initialized or ner_engine.pipeline is not None
+    }
+
+@app.post("/api/v1/ingesta/tabular", status_code=status.HTTP_201_CREATED)
+def procesar_registro_tabular(payload: ProcessSheetPayload, db: Session = Depends(get_db)):
+    entidades = ner_engine.extract_entities(payload.texto_celda)
+    confianza_ia = sum([e["score"] for e in entidades]) / len(entidades) if entidades else 1.0
+
+    forzar_revision = False
+    if confianza_ia < 0.60:
+        forzar_revision = True
+
+    nombre_resuelto = payload.texto_celda.strip()
+    estudiante = db.query(DimEstudiante).filter(DimEstudiante.nombre_completo == nombre_resuelto).first()
+    
+    if not estudiante:
+        estudiante = DimEstudiante(nombre_completo=nombre_resuelto)
+        db.add(estudiante)
+        db.commit()
+        db.refresh(estudiante)
+
+    alertas_disparadas = []
+    if payload.nota_detectada <= 70.0:
+        alertas_disparadas.append("RIESGO_ACADEMICO_CRITICO")
+    if payload.asistencia < 70.0 or payload.incumplimiento_tareas > 30.0:
+        alertas_disparadas.append("RIESGO_DESERCION_ALTA")
+
+    try:
+        nuevo_hecho = FactRendimientoAcademico(
+            id_estudiante=estudiante.id_estudiante,
+            id_docente=payload.id_docente,
+            id_modulo=payload.id_modulo,
+            id_tiempo=payload.id_tiempo,
+            id_documento=payload.id_documento,
+            id_usuario_carga=payload.id_usuario,
+            nota_final=payload.nota_detectada,
+            asistencia_pct=payload.asistencia,
+            incumplimiento_actividades_pct=payload.incumplimiento_tareas,
+            nivel_confianza_ia=confianza_ia,
+            requiere_revision=forzar_revision
+        )
+        db.add(nuevo_hecho)
+        db.commit()
+        
+        return {
+            "status": "processed",
+            "id_estudiante_asignado": estudiante.id_estudiante,
+            "confianza_modelo_beto": round(confianza_ia, 4),
+            "requiere_auditoria_humana": forzar_revision,
+            "alertas_estrategicas": alertas_disparadas
+        }
+    except Exception as err:
+        db.rollback()
+        logger.error(f"Fallo en persistencia: {err}")
+        raise HTTPException(status_code=500, detail="Error al escribir en Supabase.")

ner_engine.py

@@ -0,0 +1,101 @@
+import logging
+import re
+from typing import List, Dict, Any
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class NEREngine:
+    def __init__(self, model_name: str = "mrm8488/bert-spanish-ner-cased"):
+        self.model_name = model_name
+        self.pipeline = None
+        self._initialized = False
+
+    def initialize(self):
+        """
+        Lazily initialize the Hugging Face pipeline.
+        This prevents startup failure if transformers/torch is missing
+        and speeds up unit tests.
+        """
+        if self._initialized:
+            return
+
+        logger.info(f"Initializing NER model: {self.model_name}...")
+        try:
+            from transformers import pipeline
+            self.pipeline = pipeline(
+                "ner",
+                model=self.model_name,
+                tokenizer=self.model_name,
+                aggregation_strategy="simple"
+            )
+            self._initialized = True
+            logger.info("NER model loaded successfully.")
+        except Exception as e:
+            logger.error(f"Error loading NER model: {e}")
+            logger.warning("Falling back to a mock regex entity extractor for development/testing.")
+            self.pipeline = None
+            self._initialized = True
+
+    def extract_entities(self, text: str) -> List[Dict[str, Any]]:
+        """
+        Extract named entities from Spanish text.
+        Returns a list of dictionaries with word, entity_group, score, start, and end.
+        """
+        self.initialize()
+        
+        if not text or not text.strip():
+            return []
+
+        if self.pipeline:
+            try:
+                raw_entities = self.pipeline(text)
+                entities = []
+                for ent in raw_entities:
+                    entities.append({
+                        "word": ent.get("word"),
+                        "entity_group": ent.get("entity_group"),
+                        "score": float(ent.get("score")),
+                        "start": int(ent.get("start")),
+                        "end": int(ent.get("end"))
+                    })
+                return entities
+            except Exception as e:
+                logger.error(f"Error executing NER pipeline: {e}")
+                return self._mock_extraction(text)
+        else:
+            return self._mock_extraction(text)
+
+    def _mock_extraction(self, text: str) -> List[Dict[str, Any]]:
+        """
+        Basic regex-based entity extractor fallback for development/testing environments
+        when PyTorch or Transformers are not fully installed.
+        """
+        entities = []
+        # Find capitalized words
+        for match in re.finditer(r'\b[A-Z][a-zA-Z0-9_]+\b', text):
+            word = match.group()
+            start, end = match.span()
+            
+            # Simple rule-based classification for mock entities
+            if word in ["Madrid", "Barcelona", "Bogota", "Santiago", "Lima", "Mexico"]:
+                entity_group = "LOC"
+            elif word in ["GiraGroup", "Supabase", "Google", "Microsoft", "SQLAlchemy"]:
+                entity_group = "ORG"
+            elif word in ["Juan", "Maria", "Carlos", "Jose", "Pedro", "Ana"]:
+                entity_group = "PER"
+            else:
+                entity_group = "MISC"
+
+            entities.append({
+                "word": word,
+                "entity_group": entity_group,
+                "score": 1.0,
+                "start": start,
+                "end": end
+            })
+        return entities
+
+# Global instance of the engine
+ner_engine = NEREngine()

requirements.txt

@@ -0,0 +1,12 @@
+fastapi>=0.100.0
+uvicorn[standard]>=0.22.0
+sqlalchemy>=2.0.0
+psycopg2-binary>=2.9.0
+python-dotenv>=1.0.0
+transformers>=4.30.0
+torch>=2.0.0 --extra-index-url https://download.pytorch.org/whl/cpu
+pandas>=2.2.1
+openpyxl==3.1.2
+gspread==6.1.0
+rapidfuzz==3.6.1
+pydantic>=2.0.0