app_2.py

import os
import shutil
import tempfile
import threading
import gradio as gr
from google import genai
from google.genai import types

client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY"))
MODEL = "gemini-3.1-flash-lite-preview"

# Tools + Config (einmalig)
tools = [types.Tool(googleSearch=types.GoogleSearch())]
generate_content_config = types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(thinking_level="MINIMAL"),
    tools=tools,
)

def respond(message, history, state):
    if state is None:
        state = {
            "chat": client.chats.create(model=MODEL, config=generate_content_config),
            "lock": threading.Lock(),
        }
    
    history = history or []
    text = (message or {}).get("text", "")
    files = (message or {}).get("files", [])
    parts = []

   # 1. Dateien verarbeiten (Upload via API & UI-Vorbereitung)
    for file_path in files:
        # Reinen ASCII-Namen generieren (z.B. 'Lsungen-MP-4 1.pdf')
        base_name = os.path.basename(file_path)
        safe_name = base_name.encode('ascii', 'ignore').decode('ascii')
        
        # Fallback, falls der Name nach der Filterung komplett leer sein sollte
        if not safe_name.strip(". "): 
            safe_name = "upload_file.pdf"
            
        # Temporären, komplett sicheren Pfad generieren
        safe_temp_path = os.path.join(tempfile.gettempdir(), f"safe_{safe_name}")
        
        try:
            # Datei an den sicheren Ort kopieren
            shutil.copy2(file_path, safe_temp_path)
            
            # Upload mit dem sicheren Pfad durchführen
            uploaded_file = client.files.upload(
                file=safe_temp_path, 
                config=types.UploadFileConfig(display_name=safe_name)
            )
            parts.append(uploaded_file)
        finally:
            # Temporäre Kopie aufräumen, um Speicherplatz zu sparen
            if os.path.exists(safe_temp_path):
                os.remove(safe_temp_path)
        
        # Datei in der Gradio UI anzeigen (hier nutzen wir den Originalpfad für die korrekte Anzeige)
        history.append({"role": "user", "content": gr.FileData(path=file_path)})
        
    # 2. Text verarbeiten
    if text:
        parts.append(text)
        history.append({"role": "user", "content": text})

    if not parts:
        yield history, state
        return

    # 3. UI: Assistant Placeholder hinzufügen
    history.append({"role": "assistant", "content": ""})
    yield history, state

    # 4. Gemini: Senden + Streamen
    with state["lock"]:
        out = ""
        for chunk in state["chat"].send_message_stream(parts):
            if getattr(chunk, "text", None):
                out += chunk.text
                history[-1]["content"] = out
                yield history, state

def cleanup_gemini_files():
    deleted_count = 0
    # Holt alle Dateien, die mit deinem API-Key hochgeladen wurden
    for f in client.files.list():
        # Löscht die Datei über ihren eindeutigen Google-Ressourcennamen
        client.files.delete(name=f.name)
        deleted_count += 1
    
    # Zeigt ein kleines Popup in der Gradio UI an
    gr.Info(f"{deleted_count} Datei(en) erfolgreich gelöscht.")

def clear_msg():
    return {"text": "", "files": []}

with gr.Blocks() as demo:
    gr.Markdown("# Gemini AI Chat (Gradio 6.x & File API)")
    
    # Standard-Initialisierung für Gradio >= 6.0
    chatbot = gr.Chatbot(height=600)
    
    msg = gr.MultimodalTextbox(
        placeholder="Schreib was oder lade Dateien hoch…",
        file_count="multiple",
    )
    state = gr.State(None)
    
    msg.submit(respond, inputs=[msg, chatbot, state], outputs=[chatbot, state]) \
       .then(clear_msg, outputs=msg)

    with gr.Row():
        clear_btn = gr.Button("Clear Chat")
        cleanup_btn = gr.Button("🗑️ Server-Dateien bereinigen")
        
    clear_btn.click(
        lambda: ([], None, {"text": "", "files": []}),
        outputs=[chatbot, state, msg]
    )
    
    cleanup_btn.click(fn=cleanup_gemini_files)

if __name__ == "__main__":
    demo.launch()