aaa

app.py

@@ -1,28 +1,15 @@
 import os
 import asyncio
-import logging
-import httpx
 from google import genai
 from google.genai import types
 import gradio as gr
-import time
-from enum import Enum  # Si se requiere para enumeraciones
 
-# -----------------------------------------------------------------------------
-# Configuración del logging
-# -----------------------------------------------------------------------------
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# -----------------------------------------------------------------------------
-# Configuración de la clave de API de Gemini Developer
-# -----------------------------------------------------------------------------
+# Configuración de la clave de API
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
     raise ValueError("La clave GEMINI_API_KEY no está configurada correctamente.")
 
-# -----------------------------------------------------------------------------
-# Creación del cliente (Gemini Developer API)
-# -----------------------------------------------------------------------------
+# Se crea el cliente de la SDK para Gemini Developer API
 client = genai.Client(api_key=GEMINI_API_KEY)
 
 # -----------------------------------------------------------------------------
@@ -108,137 +95,68 @@ La salida debe contener *EXCLUSIVAMENTE* el texto revisado del borrador judicial
 Este rol es de suma importancia. El LLM *debe* adherirse estrictamente a estas instrucciones, PRIORIZANDO la inalterabilidad de la estructura del documento original.
 """
 
-# -----------------------------------------------------------------------------
-# Configuración de generación (se utiliza system_instruction en generation_config)
-# -----------------------------------------------------------------------------
+# Configuración común de generación para ambos modelos
 generation_config = types.GenerateContentConfig(
     system_instruction=instruction,
     temperature=0.3,
     top_p=0.9,
     top_k=40,
     max_output_tokens=8000,
+    response_mime_type="text/plain"
 )
 
-# -----------------------------------------------------------------------------
-# Nombres (o IDs) de los modelos a utilizar
-# -----------------------------------------------------------------------------
+# Definición de los nombres de modelo a utilizar
 model_flash_exp = "gemini-2.0-pro-exp-02-05"
 model_gemini_ex = "gemini-2.0-flash-thinking-exp-01-21"
 
-# -----------------------------------------------------------------------------
-# Auditoría
-# -----------------------------------------------------------------------------
-audit_log = []
-
-# -----------------------------------------------------------------------------
-# Función asíncrona para generación de contenido con Streaming
-# -----------------------------------------------------------------------------
-async def generate_content_streamed(model_name, borrador):
+# Función asíncrona para generar contenido usando el modelo indicado
+async def generate_content(model_name, borrador):
     try:
-        response_stream = await client.aio.models.generate_content_stream(
+        response = await client.aio.models.generate_content(
             model=model_name,
-            contents=borrador,  # Se envía solo el borrador; system_instruction está en generation_config
-            config=generation_config,
+            contents=borrador,
+            config=generation_config
         )
-
-        full_response = ""
-        async for chunk in response_stream:
-            full_response += chunk.text
-
-        audit_log.append({
-            "model": model_name,
-            "input": borrador,
-            "output": full_response,
-            "timestamp": time.time()
-        })
-        return full_response
-
-    except httpx.ReadTimeout as e:
-        error_message = f"Error de tiempo de espera (ReadTimeout) en {model_name}: {str(e)}"
-        logging.error(error_message)
-        audit_log.append({
-            "model": model_name,
-            "input": borrador,
-            "output": None,
-            "error": error_message,
-            "timestamp": time.time()
-        })
-        return error_message
-
+        return response.text
     except Exception as e:
-        error_message = f"Error inesperado en {model_name}: {str(e)}"
-        logging.exception(error_message)
-        audit_log.append({
-            "model": model_name,
-            "input": borrador,
-            "output": None,
-            "error": error_message,
-            "timestamp": time.time()
-        })
-        return error_message
+        return f"Error en {model_name}: {str(e)}"
 
-# -----------------------------------------------------------------------------
-# Combina las respuestas de dos modelos asíncronamente
-# -----------------------------------------------------------------------------
+# Función que combina las respuestas de ambos modelos
 async def combine_responses(borrador):
-    flash_task = asyncio.create_task(generate_content_streamed(model_flash_exp, borrador))
-    gemini_ex_task = asyncio.create_task(generate_content_streamed(model_gemini_ex, borrador))
-
+    flash_task = asyncio.create_task(generate_content(model_flash_exp, borrador))
+    gemini_ex_task = asyncio.create_task(generate_content(model_gemini_ex, borrador))
     flash_result = await flash_task
     gemini_ex_result = await gemini_ex_task
-
     combined_result = (
-        f"**Google Gemini flash-exp**:\n{flash_result}\n\n"
-        f"**Google gemini-exp-1206**:\n{gemini_ex_result}"
+        f"**Google Gemini flash-exp:**\n{flash_result}\n\n"
+        f"**Google gemini-exp-1206:**\n{gemini_ex_result}"
     )
     return combined_result
 
-# -----------------------------------------------------------------------------
-# Función de predicción final (asíncrona)
-# -----------------------------------------------------------------------------
+# Función asíncrona principal
 async def predict(borrador):
     return await combine_responses(borrador)
 
-# -----------------------------------------------------------------------------
-# Envoltorio síncrono (para Gradio)
-# -----------------------------------------------------------------------------
-def predict_sync(borrador, progress=gr.Progress()):
-    progress(0, desc="Iniciando...")
-    result = asyncio.run(predict(borrador))
-    progress(1, desc="Completado")
-    return result
+# Función sincrónica que envuelve la llamada asíncrona (para Gradio)
+def predict_sync(borrador):
+    return asyncio.run(predict(borrador))
 
-# -----------------------------------------------------------------------------
 # Interfaz Gradio
-# -----------------------------------------------------------------------------
 with gr.Blocks() as demo:
     gr.Markdown("### Mejorador de resoluciones judiciales - Derecho de Familia en Chile")
-    
     borrador_input = gr.Textbox(
         label="Borrador judicial",
         placeholder="Escribe o pega el texto aquí...",
         lines=10
     )
-    
     output = gr.Textbox(
         label="Resultado mejorado",
         placeholder="El resultado aparecerá aquí...",
         lines=10
     )
-    
     submit_btn = gr.Button("Enviar")
+    
     submit_btn.click(fn=predict_sync, inputs=borrador_input, outputs=output)
 
-    # Sección opcional para ver el log de auditoría
-    audit_log_output = gr.JSON(label="Log de Auditoría")
-    def show_audit_log():
-        return audit_log
-
-    show_log_button = gr.Button("Mostrar Log de Auditoría")
-    show_log_button.click(fn=show_audit_log, outputs=audit_log_output)
-
-# -----------------------------------------------------------------------------
-# Ejecución de la aplicación
-# -----------------------------------------------------------------------------
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()