Despliegue HF

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+protection-environment-robot-holding-lightbulb-with-recycle-icon-sustainable-and-nature_10461459.jpg!sw800 filter=lfs diff=lfs merge=lfs -text

.github/workflows/sync_to_hf_yml

@@ -0,0 +1,19 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+  force_push:
+    branches: [main]
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push --force https://YellowAlberto:$HF_TOKEN@huggingface.co/spaces/YellowAlberto/ReciclA main

.gitignore

@@ -0,0 +1,14 @@
+.env
+
+test.db
+sql_app.db
+
+__pycache__/
+*.py[cod]
+*$py.class
+venv/
+.venv/
+
+imagenes_subidas/
+
+*.png

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.10-slim
+
+# Instalamos las dependencias actualizadas para OpenCV y ONNX
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    libpq-dev \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+RUN mkdir -p imagenes_subidas && chmod 777 imagenes_subidas
+RUN chmod +x run.sh
+EXPOSE 7860
+CMD ["./run.sh"]

ProyectoBasura.py

@@ -0,0 +1,366 @@
+from fastapi import Depends, FastAPI, HTTPException, status, Request, File, UploadFile
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from pydantic import BaseModel
+import jwt
+from datetime import datetime, timedelta, timezone
+import uvicorn
+import modelsProyecto
+from databaseProyecto import SessionLocal, engine
+from sqlalchemy.orm import Session
+import SeguridadProyecto
+from SeguridadProyecto import generar_hash 
+from typing import Annotated
+import os
+import shutil
+import io
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+from ultralytics import YOLO
+from fastapi.responses import StreamingResponse
+from dotenv import load_dotenv
+from groq import Groq
+from fastapi.middleware.cors import CORSMiddleware
+load_dotenv()
+
+
+model = YOLO("best.onnx", task="detect")
+
+client_groq = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+SECRET_KEY = os.getenv("SECRET_KEY")
+ALGORITHM = os.getenv("ALGORITHM")
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+modelsProyecto.Base.metadata.create_all(bind=engine)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+registros_mensajes= {}
+
+@app.post("/login",summary="Login de usuario", description="Comprueba las credenciales y genera un token JWT de acceso", response_model=Token)
+async def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
+
+
+    verificar_frecuencia(form_data.username, segundos=10)
+
+    usuario_db = db.query(modelsProyecto.Usuario).filter(modelsProyecto.Usuario.username == form_data.username).first()
+
+    if not usuario_db or not SeguridadProyecto.verificar_password(form_data.password, usuario_db.password_hash):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="ID de usuario o contraseña incorrectos",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    expire = datetime.now(timezone.utc) + timedelta(minutes=30)
+    to_encode = {
+        "sub": usuario_db.username,
+        "exp": expire,
+        "rol": usuario_db.es_admin
+    }
+    
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return {"access_token": encoded_jwt, "token_type": "bearer"}
+
+async def verificar_admin(token: str = Depends(oauth2_scheme)):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        es_admin: bool = payload.get("rol") 
+        
+    except jwt.PyJWTError:
+        raise HTTPException(status_code=401, detail="Token inválido o expirado")
+
+    if es_admin is not True:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, 
+            detail="No tienes permisos de administrador"
+        )
+    return {"username": username, "rol": es_admin}
+
+
+
+@app.get("/revisarUsuarios", 
+    summary="Listar usuarios (Solo Admin)",
+    description="Retorna una lista de todos los usuarios registrados. Requiere privilegios de administrador.")
+async def revisar_Usuarios(admin_info: dict = Depends(verificar_admin), db: Session = Depends(get_db)):
+    usuarios = db.query(modelsProyecto.Usuario).all()
+    return usuarios
+
+def verificar_frecuencia(usuario_actual: str, segundos: int = 5):
+    ahora = datetime.now()
+    if usuario_actual in registros_mensajes:
+        ultima_solicitud = registros_mensajes[usuario_actual]
+        tiempo_transcurrido = ahora - ultima_solicitud
+
+        if tiempo_transcurrido < timedelta(seconds=segundos):
+            segundos_restantes = segundos - int(tiempo_transcurrido.total_seconds())
+            raise HTTPException(
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                detail=f"Demasiado rápido. Espera {segundos_restantes}s."
+            )
+    registros_mensajes[usuario_actual] = ahora
+
+def agente_inteligente_llm(deteccion: str, confianza: float):
+
+    saludo = "¡Bienvenido! Soy ReciclIA. Estoy aquí para ayudarte a transformar tus hábitos y cuidar el planeta de forma experta. Vamos a hacer que cada residuo cuente."
+    
+    prompt = f"""
+    Eres un ReciclIA, un Agente experto en sostenibilidad y reciclaje. 
+    Se ha detectado un objeto mediante visión artificial:
+    - Objeto: {deteccion}
+    - Confianza: {confianza:.2f}
+
+    INSTRUCCIÓN DE SALUDO:
+    Comienza SIEMPRE tu respuesta con esta frase exacta: "{saludo}"
+
+
+    BASE DE CONOCIMIENTO (ESTRICTA):
+    1. CONTENEDOR MARRÓN (Orgánico): Restos de comida, cáscaras de fruta, posos de café, tapones de corcho, servilletas sucias y cualquier residuo de origen BIOLÓGICO.
+    2. CONTENEDOR VERDE (Vidrio): Botellas de vidrio, frascos de conservas, tarros de perfume. (¡NUNCA para orgánicos!).
+    3. CONTENEDOR AMARILLO (Envases): Plásticos, latas, briks y envases metálicos.
+    4. CONTENEDOR AZUL (Papel/Cartón): Cajas de cartón, periódicos, folletos.
+    5. CONTENEDOR GRIS (Resto): Pañales, colillas, objetos rotos que no se reciclan.
+    6. PUNTO LIMPIO: Pilas, electrónica, muebles, ropa, aceite usado.
+
+    
+    Explica al usuario de forma breve y amable:
+    1. En qué contenedor debe tirarlo, añade el color especifico del contenedor utilizando la base de conocimientos.
+    2. Un dato curioso sobre el reciclaje de ese material.
+    
+    REGLA CRÍTICA PARA EL PUNTO 3:
+    - SI la confianza es menor a 0.5: Añade una advertencia breve diciendo que podrías estar equivocado debido a la baja precisión.
+    - SI la confianza es 0.5 o mayor: NO menciones nada sobre la confianza, ni sobre umbrales, ni des explicaciones de por qué estás seguro. Omite este punto totalmente.
+
+    Termina la explicación siempre con esta frase:
+    -Recuerda, cada pequeño gesto cuenta, y reciclar correctamente es un paso importante hacia un futuro más sostenible. ¡Gracias por tu contribución!
+    """
+
+    chat_completion = client_groq.chat.completions.create(
+        messages=[{"role": "user", "content": prompt}],
+        model="llama-3.3-70b-versatile", # Un modelo rápido y capaz
+    )
+    return chat_completion.choices[0].message.content
+
+
+
+#CRUD Usuarios
+
+@app.post("/registrar", 
+    summary="Registrar nuevo usuario",
+    description="Crea la cuenta de un usuario y lo guarda en la base de datos.",
+    status_code=status.HTTP_201_CREATED)
+async def registrar_usuario(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
+    existe = db.query(modelsProyecto.Usuario).filter(modelsProyecto.Usuario.username == form_data.username).first()
+    if existe:
+        raise HTTPException(status_code=400, detail="El nombre de usuario ya existe")
+
+    password_con_hash = generar_hash(form_data.password)
+
+    nuevo_usuario = modelsProyecto.Usuario(
+        username=form_data.username,
+        password_hash=password_con_hash,
+        es_admin=True
+    )
+    db.add(nuevo_usuario)
+    db.commit()
+    return {"mensaje": "Usuario creado con éxito usando HASH"}
+
+
+@app.put("/usuarios/actualizarUsuario", 
+    summary="Actualizar nombre de usuario",
+    description="Actualiza el nombre de usuario del perfil activo.",
+    responses={400: {"description": "Nombre en uso"}, 404: {"description": "No encontrado"}})
+async def actualizar_username(
+    nuevo_username: str,
+    token: str = Depends(oauth2_scheme), 
+    db: Session = Depends(get_db)
+):
+    payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+    username_actual = payload.get("sub")
+    
+    usuario = db.query(modelsProyecto.Usuario).filter(modelsProyecto.Usuario.username == username_actual).first()
+    
+    if not usuario:
+        raise HTTPException(status_code=404, detail="Usuario no encontrado")
+
+    # 3. Verificar si el nuevo nombre ya está pillado por OTRO usuario
+    existe = db.query(modelsProyecto.Usuario).filter(modelsProyecto.Usuario.username == nuevo_username).first()
+    if existe and existe.username != username_actual:
+        raise HTTPException(status_code=400, detail="Ese nombre de usuario ya está en uso")
+
+    usuario.username = nuevo_username
+    db.commit()
+    db.refresh(usuario)
+    
+    return {"message": "Nombre actualizado", "nuevo_username": nuevo_username}
+
+@app.delete("/usuarios/{user}", 
+    summary="Eliminar cuenta",
+    description="Borra un usuario. Los administradores pueden borrar cualquier cuenta; usuarios normales solo la suya.",
+    status_code=status.HTTP_204_NO_CONTENT)
+async def eliminar_usuario(
+    user: str, 
+    token: str = Depends(oauth2_scheme), 
+    db: Session = Depends(get_db),
+):
+
+    payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+    username_token = payload.get("sub")
+    es_admin: bool = payload.get("rol") 
+
+    usuario = db.query(modelsProyecto.Usuario).filter(modelsProyecto.Usuario.username == user).first()
+    
+    if not usuario:
+        raise HTTPException(status_code=404, detail="Usuario no encontrado")
+
+    if usuario.username != username_token and not es_admin:
+        raise HTTPException(status_code=403, detail="No tienes permiso para eliminar esta cuenta")
+
+    db.delete(usuario)
+    db.commit()
+    
+    return None 
+
+@app.post("/detectar-visual", 
+    summary="Detección de objetos y Reciclaje",
+    description="Analiza una imagen, devuelve la predicción + respuesta del agente y guarda en historial.",
+    responses={
+        200: {"content": {"image/jpeg": {}}, "description": "Imagen procesada con cajas de detección."},
+        429: {"description": "Límite de velocidad excedido"}
+    })
+async def detectar_visual(file: UploadFile = File(...), token: str = Depends(oauth2_scheme),db: Session = Depends(get_db)):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        usuario = db.query(modelsProyecto.Usuario).filter(modelsProyecto.Usuario.username == username).first()
+        if not usuario:
+            raise HTTPException(status_code=404, detail="Usuario no encontrado")
+    except jwt.PyJWTError:
+        raise HTTPException(status_code=401, detail="Token inválido")
+    
+
+    verificar_frecuencia(username, segundos=30)
+
+    contents = await file.read()
+    image = Image.open(io.BytesIO(contents)).convert("RGB")
+    
+    results = model.predict(image, imgsz=640, conf=0.25)[0]
+
+    prediccion_nombre = "Sin detecciones"
+    confianza_valor = 0.0
+
+    if len(results.boxes) > 0:
+        box = results.boxes[0]
+        prediccion_nombre = results.names[int(box.cls)]
+        confianza_valor = float(box.conf)
+        respuesta_agente = agente_inteligente_llm(prediccion_nombre, confianza_valor)
+    else:
+        respuesta_agente = "No veo nada claro aquí. ¿Puedes acercar más la cámara?"
+
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    ext = file.filename.split(".")[-1]
+    nombre_unico = f"img_{timestamp}.{ext}"
+
+    
+    if not os.path.exists("imagenes_subidas"):
+        os.makedirs("imagenes_subidas")
+    
+    ruta_archivo = f"imagenes_subidas/{nombre_unico}"
+    with open(ruta_archivo, "wb") as buffer:
+        buffer.write(contents)
+
+    nueva_imagen = modelsProyecto.Imagen(
+        name=nombre_unico,
+        ruta=ruta_archivo,
+        usuario_id=usuario.id,
+        prediccion=prediccion_nombre,
+        confianza=confianza_valor
+    )
+    db.add(nueva_imagen)
+    
+    nuevo_historial = modelsProyecto.HistorialChat(
+        usuario_id=usuario.id,
+        mensaje_usuario=f"Detección de {prediccion_nombre}",
+        respuesta_agente=respuesta_agente
+    )
+    db.add(nuevo_historial)
+    db.commit()
+    
+    im_array = results.plot() 
+    im_rgb = Image.fromarray(im_array[..., ::-1])
+    
+    img_io = io.BytesIO()
+    im_rgb.save(img_io, 'JPEG', quality=70)
+    img_io.seek(0)
+    return StreamingResponse(
+        img_io, 
+        media_type="image/jpeg",
+        headers={
+            "X-Agent-Reply": respuesta_agente.replace("\n", " | "), 
+            "X-Detection": prediccion_nombre
+        }
+    )
+
+@app.get("/historial", 
+    summary="Obtener historial de chat",
+    description="Recupera las últimas 10 consultas del usuario autenticado.")
+async def obtener_mi_historial(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+    username = payload.get("sub")
+    usuario = db.query(modelsProyecto.Usuario).filter(modelsProyecto.Usuario.username == username).first()
+    
+    # Trae los últimos 10 mensajes
+    return db.query(modelsProyecto.HistorialChat).filter(
+        modelsProyecto.HistorialChat.usuario_id == usuario.id
+    ).order_by(modelsProyecto.HistorialChat.fecha.desc()).limit(10).all()
+
+
+@app.delete("/historial", 
+    summary="Vaciar historial",
+    description="Borra permanentemente todo el historial del usuari.")
+async def vaciar_todo_el_historial(
+    token: str = Depends(oauth2_scheme), 
+    db: Session = Depends(get_db)
+):
+    
+    payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+    username = payload.get("sub")
+    usuario = db.query(modelsProyecto.Usuario).filter(modelsProyecto.Usuario.username == username).first()
+
+    registros = db.query(modelsProyecto.HistorialChat).filter(
+        modelsProyecto.HistorialChat.usuario_id == usuario.id
+    )
+    
+    cantidad = registros.count()
+    registros.delete(synchronize_session=False)
+    db.commit()
+    
+    return {"mensaje": f"Se han eliminado {cantidad} registros de tu historial"}
+
+
+if __name__ == "__main__":
+    uvicorn.run("ProyectoBasura:app", host="127.0.0.1", port=8000, reload=True)

README.md

@@ -0,0 +1,75 @@
+---
+title: Agente Inteligente Reciclaje
+emoji: ♻️
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# ReciclA: Asistente Inteligente de Reciclaje
+
+![Sync to Hugging Face](https://github.com/YellowAlberto/ReciclA---Proyecto-Agente/actions/workflows/sync_to_hf.yml/badge.svg)
+
+**ReciclA** es un ecosistema inteligente diseñado para facilitar el reciclaje mediante el uso de Inteligencia Artificial avanzada. El sistema integra visión artificial para la detección de residuos y un agente conversacional que asesora al usuario sobre la gestión de desechos.
+
+### Componentes Clave:
+
+*   **Agente Inteligente:** Implementado con **Groq** para ofrecer respuestas expertas y personalizadas en lenguaje natural.
+*   **Visión Artificial:** Utiliza modelos **YOLOv8** optimizados para identificar objetos en imágenes subidas por el usuario.
+*   **Base de Datos Híbrida:** Configurada para trabajar con **PostgreSQL (Supabase)** en producción o **SQLite** de forma local y automática si no se detectan credenciales.
+*   **Contenedorización:** Sistema orquestado con **Docker Compose** para garantizar la portabilidad sin dependencias manuales.
+* **CI/CD Automático:** Sincronización automatizada mediante **GitHub Actions** que despliega cada actualización directamente en **Hugging Face Spaces**.
+
+---
+
+# Instrucciones de Instalación
+
+### Requisitos previos:
+*   **Docker Desktop:** Instalado y en funcionamiento.
+*   **Groq API Key:** Necesaria para el funcionamiento del agente conversacional.
+
+### Pasos para el despliegue:
+
+1.  **Configuración de entorno:** Crea un archivo `.env` en la raíz del proyecto con el siguiente contenido:
+    ```env
+    GROQ_API_KEY=tu_api_key_aqui
+    SECRET_KEY=un_secreto_aleatorio_para_jwt
+    # Opcional: Si se omite DATABASE_URL, el sistema iniciará en modo SQLite local
+    DATABASE_URL=postgresql://tu_url_de_supabase
+    ```
+
+2.  **Lanzamiento:** Abre una terminal en la carpeta del proyecto y ejecuta el siguiente comando:
+    ```bash
+    docker-compose up --build
+    ```
+
+3.  **Acceso a las interfaces:**
+    *   **Despliegue Online (Hugging Face):** [https://huggingface.co/spaces/YellowAlberto/ReciclA]
+    *   **Frontend (Gradio):** [http://localhost:7860](http://localhost:7860)
+    *   **API Docs (Swagger):** [http://localhost:8000/docs](http://localhost:8000/docs)
+
+> **Nota sobre el despliegue:** Este repositorio está configurado con **GitHub Actions**. Cualquier commit en la rama `main` dispara automáticamente una actualización del contenedor en Hugging Face.
+
+---
+
+# Uso de la API
+
+La API sigue los principios **RESTful**, utilizando los verbos HTTP para definir las acciones sobre cada recurso.
+
+| Método | Endpoint | Descripción |
+| :--- | :--- | :--- |
+| **POST** | `/registrar` | Crea la cuenta de un usuario y lo guarda en la base de datos. |
+| **POST** | `/login` | Comprueba las credenciales y genera un token JWT de acceso. |
+| **POST** | `/detectar-visual` | Analiza una imagen, devuelve la predicción + respuesta del agente y guarda en historial. |
+| **GET** | `/historial` | Recupera las últimas 10 consultas del usuario autenticado. |
+| **PUT** | `/usuarios/actualizarUsuario` | Actualiza el nombre de usuario del perfil activo. |
+| **DELETE** | `/historial` | Borra permanentemente todo el historial del usuario. |
+
+---
+
+### Persistencia de Datos
+El proyecto utiliza **volúmenes de Docker** para asegurar que la persistencia sea efectiva:
+*   **SQLite:** Si se usa el modo local, se creará un archivo `test.db` en tu carpeta raíz que no se borrará al apagar el contenedor.
+*   **Interfaz:** El logo e iconos se cargan mediante codificación **Base64** para garantizar su visualización correcta sin errores de rutas locales o bloqueos de seguridad del navegador.

SeguridadProyecto.py

@@ -0,0 +1,9 @@
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def generar_hash(password: str):
+    return pwd_context.hash(password)
+
+def verificar_password(password_plano, password_hasheado):
+    return pwd_context.verify(password_plano, password_hasheado)

app_front.py

@@ -0,0 +1,227 @@
+import gradio as gr
+import requests
+import io
+from PIL import Image
+import re
+import base64
+
+# URL interna de la API
+API_URL = "http://127.0.0.1:8000"
+
+# --- Imagenes --- 
+def get_base64_image(image_path):
+    try:
+        with open(image_path, "rb") as img_file:
+            return base64.b64encode(img_file.read()).decode('utf-8')
+    except Exception:
+        return ""
+
+nombre_archivo = "protection-environment-robot-holding-lightbulb-with-recycle-icon-sustainable-and-nature_10461459.jpg!sw800"
+img_base64 = get_base64_image(nombre_archivo)
+
+robot_html = f"<img src='data:image/jpeg;base64,{img_base64}' width='40' style='display:inline-block; vertical-align:middle; border-radius:50%; margin-right:10px;'>"
+# --- Estilos ---
+custom_css = """
+#titulo-proyecto h1, #respuesta-agente h2 {
+    font-family: 'Charter', 'Bitstream Charter', 'Cambria', 'Georgia', serif !important;
+    font-weight: 700 !important;
+    letter-spacing: -0.5px !important;
+    color: #F3F4F6 !important; /* El color blanco hueso que elegiste */
+}
+#respuesta-agente p {
+    font-family: 'Charter', 'Georgia', serif !important;
+    font-size: 1.1em;
+}
+#btn-actualizar {
+    background: #2D5A27 !important;
+    color: white !important;
+    border: none !important;
+}
+#btn-actualizar:hover {
+    background: #3e7a36 !important;
+}
+"""
+
+# --- FUNCIONES ---
+
+def registrar_usuario(new_user, new_pass):
+    if not new_user or not new_pass:
+        return " Por favor, rellena ambos campos.", gr.update()
+    try:
+        data = {"username": new_user, "password": new_pass}
+        response = requests.post(f"{API_URL}/registrar", data=data)
+        
+        if response.ok: 
+            return f" Usuario '{new_user}' registrado. ¡Inicia sesión!", gr.Tabs(selected=1)
+        
+        error_msg = response.json().get('detail', 'No se pudo registrar')
+        return f" Error: {error_msg}", gr.update()
+        
+    except Exception as e:
+        return f" Error de conexión: {str(e)}", gr.update()
+
+def login_usuario(username, password):
+    if not username or not password:
+        return None, " Introduce tus credenciales.", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+    try:
+        login_data = {"username": username, "password": password}
+        res = requests.post(f"{API_URL}/login", data=login_data)
+        if res.ok:
+            token = res.json().get("access_token")
+            user_txt = f" **Usuario:** {username}"
+            return token, f" Hola {username}", gr.Tabs(selected=2), user_txt, user_txt, user_txt, user_txt, gr.update(visible=False), gr.update(visible=True), " Preparado para analizar imágenes"
+        return None, " Error", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+    except Exception as e:
+        return None, f" Error: {str(e)}", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+
+def analizar_foto(token, imagen):
+    if not token: return " Debes iniciar sesión primero.", None, gr.Tabs(selected=1)
+    if imagen is None: return " Por favor, sube una foto.", None, gr.update()
+    try:
+        buf = io.BytesIO()
+        imagen.save(buf, format="JPEG")
+        buf.seek(0)
+        headers = {"Authorization": f"Bearer {token}"}
+        files = {"file": ("image.jpg", buf, "image/jpeg")}
+        res = requests.post(f"{API_URL}/detectar-visual", headers=headers, files=files)
+        if res.ok:
+            msg_crudo = res.headers.get("X-Agent-Reply", "Sin respuesta")
+            det = res.headers.get("X-Detection", "Desconocido")
+            msg_formateado = msg_crudo.replace("|", "\n\n")
+            msg_formateado = re.sub(r' +', ' ', msg_formateado).strip()
+            img_res = Image.open(io.BytesIO(res.content))
+            return f"## {robot_html} ReciclA Dice:\n\n{msg_formateado}\n\n**Objeto:** {det}", img_res, gr.update()
+        return f" Error: {res.text}", None, gr.update()
+    except Exception as e: return f" Error: {str(e)}", None, gr.update()
+
+def ver_historial(token):
+    if not token: return " Inicia sesión primero.", gr.Tabs(selected=1)
+    try:
+        headers = {"Authorization": f"Bearer {token}"}
+        res = requests.get(f"{API_URL}/historial", headers=headers)
+        if res.ok:
+            h = res.json()
+            if not h: return "Aún no tienes historial.", gr.update()
+            texto = "### Tu historial de reciclaje:\n"
+            for item in h:
+                fecha = item.get('fecha', 'Sin fecha')[:10]
+                resp = item.get('respuesta_agente', 'Sin respuesta')
+                texto += f"**{fecha}**:\n> {robot_html} {resp}\n\n--- \n"
+            return texto, gr.update()
+        return f" Error: {res.text}", gr.update()
+    except Exception as e: return f" Error: {str(e)}", gr.update()
+
+def logout_usuario():
+    no_user = " **Usuario:** No identificado"
+    return None, "Sesión cerrada.", gr.Tabs(selected=1), no_user, no_user, no_user, no_user, gr.update(visible=True), gr.update(visible=False)
+
+def update_usuario(token, nuevo_nombre):
+    no_user = " **Usuario:** No identificado"
+    if not token or not nuevo_nombre:
+        return token, " Error: Datos incompletos", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+    try:
+        headers = {"Authorization": f"Bearer {token}"}
+        nuevo_nombre = nuevo_nombre.strip()
+        res = requests.put(f"{API_URL}/usuarios/actualizarUsuario?nuevo_username={nuevo_nombre}", headers=headers)
+        if res.ok:
+            mensaje_exito = f" Nombre cambiado a '{nuevo_nombre}'. Reinicia sesión por seguridad."
+            return None, mensaje_exito, gr.Tabs(selected=1), no_user, no_user, no_user, no_user, gr.update(visible=True), gr.update(visible=False)
+        error_api = res.json().get('detail', 'Error desconocido')
+        return token, f" Error: {error_api}", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+    except Exception as e:
+        return token, f" Error de conexion: {str(e)}", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+
+def vaciar_historial_usuario(token):
+    if not token: return " Inicia sesión primero."
+    headers = {"Authorization": f"Bearer {token}"}
+    res = requests.delete(f"{API_URL}/historial", headers=headers)
+    return " Historial vaciado correctamente." if res.ok else f" Error: {res.text}"
+
+# --- INTERFAZ ---
+
+with gr.Blocks(title="ReciclA", css=custom_css) as demo: 
+    token_state = gr.State()
+    gr.Markdown(f"# {robot_html} ReciclA : Tu Asistente Inteligente de Reciclaje", elem_id="titulo-proyecto")
+    
+    with gr.Tabs() as main_tabs:
+        
+        # PESTAÑA 0: REGISTRO
+        with gr.TabItem("📝 Registro", id=0) as tab_registro:
+            user_info_0 = gr.Markdown(" **Usuario:** No identificado")
+            gr.Markdown("---")
+            reg_user = gr.Textbox(label="Usuario")
+            reg_pass = gr.Textbox(label="Contraseña", type="password")
+            reg_btn = gr.Button("Registrarme")
+            reg_out = gr.Markdown()
+
+        # PESTAÑA 4: PERFIL 
+        with gr.TabItem("👤 Mi Perfil", id=4, visible=False) as tab_perfil:
+            user_info_p = gr.Markdown(" **Usuario:** No identificado")
+            with gr.Group():
+                gr.Markdown("### Configuración de Perfil")
+                nuevo_nombre_input = gr.Textbox(label="Nuevo nombre de usuario", placeholder="Escribe tu nuevo nombre aquí...")
+                btn_cambiar_nombre = gr.Button("Actualizar Nombre", variant="primary", elem_id="btn-actualizar")
+                gr.Markdown("<center><small> Por seguridad, se cerrará la sesión tras el cambio.</small></center>")
+            logout_btn = gr.Button("Cerrar Sesión", variant="stop")
+
+        # PESTAÑA 1: LOGIN
+        with gr.TabItem("🔐 Login", id=1):
+            user_info_1 = gr.Markdown(" **Usuario:** No identificado")
+            gr.Markdown("---")
+            l_user = gr.Textbox(label="Usuario")
+            l_pass = gr.Textbox(label="Contraseña", type="password")
+            with gr.Row():
+                l_btn = gr.Button("Iniciar Sesión", variant="primary")
+            l_status = gr.Markdown(visible=False)
+
+        # PESTAÑA 2: ANALISIS
+        with gr.TabItem("🔍 Análisis", id=2):
+            user_info_2 = gr.Markdown(" **Usuario:** No identificado")
+            gr.Markdown("---")
+            img_input = gr.Image(type="pil", show_label=False)
+            btn_scan = gr.Button("Analizar", variant="primary")
+            txt_output = gr.Markdown("Inicia sesión para poder analizar tus imagenes", elem_id="respuesta-agente")
+            img_output = gr.Image(show_label=False)
+
+        # PESTAÑA 3: HISTORIAL
+        with gr.TabItem("📜 Historial", id=3):
+            user_info_3 = gr.Markdown(" **Usuario:** No identificado")
+            gr.Markdown("---")
+            with gr.Row():
+                btn_hist = gr.Button(" Cargar mi Historial", variant="primary")
+                btn_vaciar = gr.Button(" Vaciar Historial", variant="stop")
+            out_hist = gr.Markdown("Dale a 'Cargar' para ver tus movimientos.")
+    
+    # --- Botones ---
+    reg_btn.click(registrar_usuario, [reg_user, reg_pass], [reg_out, main_tabs])
+    
+    l_btn.click(
+        login_usuario, 
+        [l_user, l_pass], 
+        [token_state, l_status, main_tabs, user_info_0, user_info_1, user_info_2, user_info_3, tab_registro, tab_perfil]
+    )
+    
+    logout_btn.click(
+        logout_usuario,
+        None,
+        [token_state, l_status, main_tabs, user_info_0, user_info_1, user_info_2, user_info_3, tab_registro, tab_perfil]
+    )
+
+    btn_scan.click(analizar_foto, [token_state, img_input], [txt_output, img_output, main_tabs])
+    btn_hist.click(ver_historial, [token_state], [out_hist, main_tabs])
+    btn_vaciar.click(vaciar_historial_usuario, [token_state], [out_hist])
+
+    btn_cambiar_nombre.click(
+        fn=update_usuario,
+        inputs=[token_state, nuevo_nombre_input],
+        outputs=[token_state, l_status, main_tabs, user_info_0, user_info_1, user_info_2, user_info_3, tab_registro, tab_perfil]
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        theme=gr.themes.Soft(),
+        favicon_path="favicon.png",
+        allowed_paths=["/app"]
+    )

best.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:464baadf8248ab7e76647ab35256326eb81bbba197450ebaeb353649ccc4758f
+size 10611218

csc

@@ -0,0 +1,26 @@
+diff --git a/.github/workflows/sync_to_hf_yml b/.github/workflows/sync_to_hf_yml
+new file mode 100644
+index 0000000..61eb009
+--- /dev/null
++++ b/.github/workflows/sync_to_hf_yml
+@@ -0,0 +1,19 @@
++name: Sync to Hugging Face hub
++on:
++  push:
++    branches: [main]
++  force_push:
++    branches: [main]
++
++jobs:
++  sync-to-hub:
++    runs-on: ubuntu-latest
++    steps:
++      - uses: actions/checkout@v3
++        with:
++          fetch-depth: 0
++          lfs: true
++      - name: Push to hub
++        env:
++          HF_TOKEN: ${{ secrets.HF_TOKEN }}
++        run: git push --force https://YellowAlberto:$HF_TOKEN@huggingface.co/spaces/YellowAlberto/ReciclA main
+

databaseProyecto.py

@@ -0,0 +1,16 @@
+import os
+from dotenv import load_dotenv
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+load_dotenv()
+SQLALCHEMY_DATABASE_URL = os.getenv("DATABASE_URL")
+
+# Si no hay URL (local), usamos SQLite por si acaso
+if not SQLALCHEMY_DATABASE_URL:
+    SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()

docker-compose.yaml

@@ -0,0 +1,13 @@
+services:
+  app:
+    build: .
+    ports:
+      - "7860:7860"
+      - "8000:8000"
+    env_file:
+      - .env
+    environment:
+      - DATABASE_URL=${DATABASE_URL}
+      - GROQ_API_KEY=${GROQ_API_KEY}
+    volumes:
+      - .:/app

modelsProyecto.py

@@ -0,0 +1,44 @@
+from sqlalchemy import Column, Integer, String, ForeignKey, Boolean, DateTime, Float, Text
+from sqlalchemy.orm import relationship
+from databaseProyecto import Base
+from datetime import datetime 
+from pydantic import BaseModel
+
+class Usuario(Base):
+    __tablename__ = "usuarios"
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    password_hash = Column(String)
+    es_admin = Column(Boolean, default=False)
+    
+    imagenes = relationship("Imagen", back_populates="usuario", cascade="all, delete-orphan") 
+    historial = relationship("HistorialChat", back_populates="usuario")
+
+class UsuarioSchema(BaseModel):
+    username: str
+    es_admin: bool = False
+
+class Imagen(Base):
+    __tablename__ = "imagenes"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, unique=True, index=True)
+    ruta = Column(String, unique=True)
+    
+    fecha_subida = Column(DateTime, default=datetime.utcnow) 
+
+    prediccion = Column(String, nullable=True)
+    confianza = Column(Float, nullable=True)
+
+    usuario_id = Column(Integer, ForeignKey("usuarios.id"), nullable=False)
+
+    usuario = relationship("Usuario", back_populates="imagenes")
+
+class HistorialChat(Base):
+    __tablename__ = "historial_chat"
+    id = Column(Integer, primary_key=True, index=True)
+    usuario_id = Column(Integer, ForeignKey("usuarios.id"))
+    mensaje_usuario = Column(Text)
+    respuesta_agente = Column(Text) 
+    fecha = Column(DateTime, default=datetime.utcnow)
+
+    usuario = relationship("Usuario", back_populates="historial")

protection-environment-robot-holding-lightbulb-with-recycle-icon-sustainable-and-nature_10461459.jpg!sw800

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53a7cb9ff6536d515c9378d61ee25f8709ba7080a63d5abe381000a304f41a10
+size 294919

requirements.txt

@@ -0,0 +1,16 @@
+fastapi
+uvicorn
+sqlalchemy
+psycopg2-binary
+PyJWT[crypto]
+passlib[bcrypt]==1.7.4
+bcrypt==4.0.1
+ultralytics
+onnxruntime
+groq
+python-multipart
+python-dotenv
+requests
+gradio
+pillow
+numpy

run.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# Iniciar FastAPI 
+uvicorn ProyectoBasura:app --host 0.0.0.0 --port 8000 &
+
+sleep 5
+
+# Iniciar frontend
+python app_front.py