Logs y estadísticas

agregaEstadisticas.py

@@ -0,0 +1,6 @@
+import conexion_firebase
+
+servicio = "app"
+
+conexion_firebase.incrementar_campo_numerico('estadisticas', 'imagenes', 'endpoint-' + servicio, amount=1)
+conexion_firebase.incrementar_campo_numerico('estadisticas', 'imagenes', servicio, amount=1)

app.py

@@ -1,7 +1,7 @@
 import herramientas
 from io import BytesIO
 import funciones, globales
-from fastapi import FastAPI, Form
+from fastapi import FastAPI, Form, Request
 from fastapi import FastAPI, File, UploadFile
 from fastapi.responses import StreamingResponse, FileResponse, JSONResponse
 
@@ -30,7 +30,10 @@ async def echo_image(image: UploadFile = File(...)):
     return StreamingResponse(BytesIO(contents), media_type=image.content_type)
 
 @app.post("/genera-imagen/")
-async def genera_imagen(platillo: str = Form(...)):
+async def genera_imagen(request: Request, platillo: str = Form(...)):
+
+    print("Client host:", request.client.host)        
+    herramientas.despliegaInfoCliente(request)
 
     seconds_available = herramientas.obtenSegundosDisponibles()
     print(herramientas.imprimeTimeNow())
@@ -46,7 +49,7 @@ async def genera_imagen(platillo: str = Form(...)):
         
         print("Usando Inference ✨.")
         resultado = funciones.genera_platillo_inference(platillo)
-        print("El resultado de inference es: ", resultado)
+        #print("El resultado de inference es: ", resultado)
         if type(resultado) is str:
             return resultado
         else:

archivos/last_timestamp.txt

@@ -1 +0,0 @@
-1747156891

archivos/modelo_actual.txt

@@ -1 +0,0 @@
-black-forest-labs/FLUX.1-dev

archivos/modelo_principal.txt

@@ -1 +0,0 @@
-black-forest-labs/FLUX.1-dev

archivos/seconds_available.txt

@@ -1 +0,0 @@
-294

autenticacion.py

@@ -18,12 +18,15 @@ def defineAmbiente():
         print("Entorno Local...")        
         import bridges        
         llave = bridges.llave #Acceso a HF
-        servidor = "sosa" #o "sosa" Sosa Jhons, depende de donde deduciras el tiempo de gpu cuando pruebas en local.
+        servidor = "sosa" #o "sosa", depende de donde deduciras el tiempo de gpu cuando pruebas en local.
         hora_renovacion = 17
+        servicio = "desarrollo"
     else:
         print("Entorno remoto listo...")        
         llave = os.getenv("llave") #Acceso a HF
         servidor = os.getenv("servidor")
         print("El servidor remoto es: ", servidor)
         hora_renovacion = os.getenv("hora_renovacion")
-    return llave, servidor, hora_renovacion
+        servicio = os.getenv("servicio")
+
+    return llave, servidor, hora_renovacion, servicio

buscaLog.py

@@ -0,0 +1,19 @@
+import conexion_firebase
+
+#conexion_firebase.buscar_log_por_prompt("Ensalada de pollo")
+
+# --- Ejemplo de cómo usar la función (sin cambios aquí) ---
+if __name__ == "__main__":
+    # Asegúrate de tener al menos un log con el prompt "Ensalada de pollo"
+    documentos_encontrados = conexion_firebase.buscar_log_por_prompt("Ensalada de pollo")
+
+    if documentos_encontrados:
+        print(f"✔️ Se encontraron {len(documentos_encontrados)} documentos:")
+        for log in documentos_encontrados:
+            print(f"  ID del Documento: {log['id']}")
+            print(f"  Datos: {log}")
+    else:
+        print("❌ Búsqueda finalizada sin resultados.")
+
+    print("\n--- Probando una búsqueda que no debería encontrar nada ---")
+    conexion_firebase.buscar_log_por_prompt("Prompt que no existe")

conexion_firebase.py

@@ -1,9 +1,8 @@
 import firebase_admin
-from firebase_admin import firestore
+from datetime import datetime
 from firebase_admin import auth
+from firebase_admin import firestore
 from firebase_admin import credentials
-import time
-
 
 firebase_cred = credentials.Certificate('config.json')
 firebase_admin.initialize_app(firebase_cred)
@@ -41,4 +40,111 @@ def creaDato(coleccion, dato, info, contenido):
     
     doc_ref.set({
         info: contenido,
-    })
+    })
+
+def registraLog(servidor_val, prompt_val, modelo_val, seed_val):
+    """
+    Agrega un nuevo documento a la colección 'logs'.
+    El ID del documento es la fecha y hora actual en formato string.
+    Los campos del documento son 'servidor', 'prompt', 'modelo' y 'seed'.
+
+    Args:
+        servidor_val (str): El nombre o ID del servidor.
+        prompt_val (str): El valor del campo 'prompt'.
+        modelo_val (str): El valor del campo 'modelo'.
+        seed_val (int): El valor del campo 'seed'.
+    """
+    try:
+        # 1. Generar el ID del documento (fecha y hora actual formateada)
+        # Es importante usar una zona horaria si tus logs vienen de diferentes lugares
+        # o si quieres que el timestamp refleje una hora local específica.
+        # Por defecto, datetime.now() usa la hora local de tu sistema.
+        # Si prefieres UTC (recomendado para consistencia global), puedes usar datetime.now(pytz.utc).
+        
+        # Obtenemos la hora actual del sistema
+        now = datetime.now() 
+        # Formateamos la hora para que sea el ID del documento
+        document_id_fecha_hora = now.strftime("%Y-%m-%d %H:%M:%S")
+
+        nombre_final = servidor_val + " - " + document_id_fecha_hora
+
+        # 2. Definir la referencia al documento específico con el ID de fecha y hora
+        doc_ref = db.collection('logs').document(nombre_final)
+
+        # 3. Definir los datos del log
+        datos_log = {
+            'servidor': servidor_val,
+            'prompt': prompt_val,
+            'modelo': modelo_val,
+            'seed': seed_val,
+            # Opcional: También puedes guardar el timestamp como un campo Timestamp
+            # esto facilita consultas de rango si la fecha/hora del ID no es perfecta
+            # o si necesitas ordenar por milisegundos.
+            'timestamp_creacion': firestore.SERVER_TIMESTAMP
+        }
+
+        # 4. Guardar los datos en el documento
+        # Usamos .set(). Si un log ya existe para ese EXACTO segundo, se sobrescribirá.
+        # Si esto es una preocupación (dos logs en el mismo segundo), podríamos añadir
+        # milisegundos al ID o usar un ID automático y un campo de timestamp.
+        doc_ref.set(datos_log)
+
+        print(f"✔️ Log agregado exitosamente en 'logs/{document_id_fecha_hora}'.")
+        print(f"   Datos: Servidor='{servidor_val}', Prompt='{prompt_val}'...")
+
+    except Exception as e:
+        print(f"❌ Error al agregar log a Firestore: {e}")
+        # Considera registrar el error o manejarlo de forma más robusta.
+
+
+def buscar_log_por_prompt(valor_prompt):
+    """
+    Busca documentos en la colección 'logs' donde el campo 'prompt' coincide
+    con el valor_prompt especificado.
+
+    Args:
+        valor_prompt (str): El valor exacto del prompt a buscar.
+
+    Returns:
+        list: Una lista de diccionarios, donde cada diccionario representa un documento
+              que coincide con la búsqueda. Incluye el ID del documento.
+    """
+    print(f"\n--- Buscando logs con prompt: '{valor_prompt}' ---")
+
+    # --- CAMBIO AQUÍ: Usando firestore.FieldFilter en lugar de .where() directamente ---
+    query_results = db.collection('logs').where(
+        filter=firestore.FieldFilter('prompt', '==', valor_prompt)
+    ).get()
+
+    logs_encontrados = []
+    if not query_results:
+        print(f"No se encontraron documentos con el prompt '{valor_prompt}'.")
+        return []
+
+    for doc in query_results:
+        log_data = doc.to_dict()
+        log_data['id'] = doc.id # Añade el ID del documento al diccionario de datos
+        logs_encontrados.append(log_data)
+        
+    return logs_encontrados
+
+def incrementar_campo_numerico(collection_name, document_id, field_name, amount=1):
+    """
+    Incrementa un campo numérico en un documento de Firestore de forma atómica.
+
+    Args:
+        collection_name (str): El nombre de la colección.
+        document_id (str): El ID del documento.
+        field_name (str): El nombre del campo numérico a incrementar.
+        amount (int/float): La cantidad por la cual incrementar (puede ser negativo para decrementar).
+    """
+    doc_ref = db.collection(collection_name).document(document_id)
+
+    try:
+        # Usa firestore.Increment(cantidad) para un incremento atómico
+        doc_ref.update({
+            field_name: firestore.Increment(amount)
+        })
+        print(f"✔️ Campo '{field_name}' en el documento '{document_id}' incrementado en {amount}.")
+    except Exception as e:
+        print(f"❌ Error al incrementar campo '{field_name}' en '{document_id}': {e}")

creaLog.py

@@ -0,0 +1,5 @@
+import conexion_firebase
+
+
+conexion_firebase.registraLog("sosa", "Ensalada de pollo", "Flux-Dev", 42)
+

funciones.py

@@ -8,15 +8,14 @@ import conexion_firebase
 from fastapi import HTTPException, status
 from huggingface_hub import InferenceClient
 
-
 servidor = globales.servidor
+servicio = globales.servicio
 
 def genera_platillo_gpu(platillo):
 
     prompt = globales.previo + platillo
     
     try:
-
         dict_espacios = conexion_firebase.obtenDato('nowme', servidor, 'espacios')
 
         espacios_habilitados = [
@@ -28,15 +27,13 @@ def genera_platillo_gpu(platillo):
         
         espacio_aleatorio_elegido = random.choice(espacios_habilitados)
         configuracion_espacio = dict_espacios[espacio_aleatorio_elegido]
-        print(f"La configuración completa para '{espacio_aleatorio_elegido}' es: {configuracion_espacio}")
-
         client = gradio_client.Client(configuracion_espacio['ruta'], hf_token=globales.llave)
         
         result = client.predict(
         #**kwargs,
         prompt=prompt,
         #negative_prompt="live animals",
-        seed=43,
+        seed=42,
         randomize_seed=False,
         width=786,
         height=568,
@@ -49,12 +46,15 @@ def genera_platillo_gpu(platillo):
         herramientas.restaSegundosGPU(globales.work_cost)
 
         print("Platillo generado:", platillo)
+        conexion_firebase.registraLog(servidor, platillo, espacio_aleatorio_elegido, 42)
+        conexion_firebase.incrementar_campo_numerico('estadisticas', 'imagenes', 'imagenes_totales', amount=1)
+        conexion_firebase.incrementar_campo_numerico('estadisticas', 'imagenes', 'endpoint-' + servicio, amount=1)
+        conexion_firebase.incrementar_campo_numerico('estadisticas', 'imagenes', 'imagenes_gpu', amount=1)
+
         return result[0]
 
     except Exception as e:     
-        print("Excepción: ", e)        
-        # Opción para regresar imagen genérica. (ya no porque se envía desde backend.)
-        # return "default.png"
+        print("Excepción: ", e)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=e
@@ -62,8 +62,7 @@ def genera_platillo_gpu(platillo):
 
 def genera_platillo_inference(platillo):
     
-    dict_modelos = conexion_firebase.obtenDato('nowme', servidor, 'modelos')
-    
+    dict_modelos = conexion_firebase.obtenDato('nowme', servidor, 'modelos')    
     modelos_habilitados = [
         nombre for nombre, config in dict_modelos.items()
         if config.get("habilitado", False) # Usamos .get() para evitar KeyError si 'habilitado' no existe
@@ -72,9 +71,7 @@ def genera_platillo_inference(platillo):
     print(f"Modelos habilitados: {modelos_habilitados}")
 
     modelo_aleatorio_elegido = random.choice(modelos_habilitados)
-    configuracion_modelo = dict_modelos[modelo_aleatorio_elegido]
-    print(f"La configuración completa para '{modelo_aleatorio_elegido}' es: {configuracion_modelo}")
-
+    configuracion_modelo = dict_modelos[modelo_aleatorio_elegido]   
 
     creditos_restantes_inference = conexion_firebase.obtenDato('nowme', servidor, 'inferencias')
     
@@ -121,4 +118,8 @@ def genera_platillo_inference(platillo):
     image.save(img_io, "PNG")
     img_io.seek(0)
     print("Platillo generado:", platillo)
+    conexion_firebase.registraLog(servidor, platillo, modelo_aleatorio_elegido, 42)
+    conexion_firebase.incrementar_campo_numerico('estadisticas', 'imagenes', 'imagenes_totales', amount=1)
+    conexion_firebase.incrementar_campo_numerico('estadisticas', 'imagenes', 'endpoint-' + servicio, amount=1)
+    conexion_firebase.incrementar_campo_numerico('estadisticas', 'imagenes', 'imagenes_inference', amount=1)
     return img_io    

globales.py

@@ -3,9 +3,8 @@ import autenticacion
 #previo = "Una fotografía de un plato blanco con "
 #previo = "A photograph of a white plate with a visually appealing culinary dish of  "  
 previo = "A pic of a white plate with just "  
-llave, servidor, hora_renovacion = autenticacion.defineAmbiente()
+llave, servidor, hora_renovacion, servicio = autenticacion.defineAmbiente()
 
-#espacio = "black-forest-labs/FLUX.1-dev"
 inferencia = "black-forest-labs/FLUX.1-dev"
 inferencia_backup = "black-forest-labs/FLUX.1-schnell"
 proveedor =  "hf-inference" #falai

herramientas.py

@@ -1,11 +1,7 @@
-import time
 import pytz
-import random
 import globales
 import conexion_firebase
 from datetime import datetime 
-import time 
-
 
 servidor = globales.servidor
 
@@ -134,4 +130,34 @@ def siEsDiaSiguienteRenueva():
     else: 
         print("Aún no hay renovación de capa de procesamiento.")
     
-    return resultado
+    return resultado
+
+def despliegaInfoCliente(request):
+    # 1. Obtener la IP del cliente (priorizando X-Forwarded-For)
+    client_ip = request.headers.get("x-forwarded-for") or \
+                request.headers.get("x-real-ip") or \
+                (request.client.host if request.client else "unknown")
+
+    # Si X-Forwarded-For es una lista de IPs separadas por coma
+    if client_ip and "," in client_ip:
+        client_ip = client_ip.split(",")[0].strip() # Tomamos la primera IP (la original)
+
+    # 2. Obtener el User-Agent
+    user_agent = request.headers.get("user-agent", "unknown")
+
+    # 3. Información de autenticación (si aplica)
+    auth_header = request.headers.get("authorization")
+    user_id = "unauthenticated"
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header.split(" ")[1]
+        # Aquí normalmente decodificarías el token JWT para obtener el user_id
+        # Ejemplo simulado:
+        if token == "mysecrettoken123":
+            user_id = "user123_authenticated"
+        else:
+            user_id = "invalid_token"
+            # O podrías lanzar un HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token")
+
+    print(f"Petición desde: {client_ip}")
+    print(f"User-Agent: {user_agent}")
+    print(f"Usuario (Auth): {user_id}")