Update app.py

app.py

@@ -7,33 +7,35 @@ import base64
 import pandas as pd
 import zipfile
 import PyPDF2
+import os
 
-# --- Page Config ---
+# --- Konfiguration ---
 st.set_page_config(page_title="OpenRouter + Gemini AI Chat", layout="wide", initial_sidebar_state="expanded")
 
 OPENROUTER_API_BASE = "https://openrouter.ai/api/v1"
 
 # --- Title ---
-st.title("🤖 OpenRouter + Gemini AI Chat Interface")
+st.title("🤖 OpenRouter Free-Tier Hub (Deluxe)")
 st.markdown("""
-**Chat with Free-Tier OpenRouter models and optionally upload files (Text, PDF, ZIP, Images) for context.**
-💡 Responses are copyable with a single click.
+**Chatte mit kostenlosen OpenRouter Modellen.** Du kannst **Dateien** (Text, PDF, ZIP, Bilder) anhängen, um Kontext zu liefern.
 """)
 
-# --- Session State ---
+# --- Session State Management ---
 if "messages" not in st.session_state:
     st.session_state.messages = []
 if "uploaded_content" not in st.session_state:
     st.session_state.uploaded_content = None
 
 # --- Utilities ---
+
 def encode_image(image):
+    """Encodiert ein PIL-Image-Objekt in einen Base64-String."""
     buf = io.BytesIO()
     image.save(buf, format="JPEG")
     return base64.b64encode(buf.getvalue()).decode("utf-8")
 
 def process_file(uploaded_file):
-    """Process uploaded file (text, image, PDF, ZIP)"""
+    """Verarbeitet die hochgeladene Datei (Text, Bild, PDF, ZIP, Tabellen) und extrahiert den Inhalt."""
     file_type = uploaded_file.name.split('.')[-1].lower()
     text_exts = ('.txt', '.csv', '.py', '.html', '.js', '.css', '.json', '.xml', '.sql', '.xlsx')
 
@@ -48,14 +50,14 @@ def process_file(uploaded_file):
             df = pd.read_csv(uploaded_file) if file_type == "csv" else pd.read_excel(uploaded_file)
             return {"type": "text", "content": df.to_string()}
         except Exception as e:
-            return {"type": "error", "content": f"Failed reading table: {e}"}
+            return {"type": "error", "content": f"Fehler beim Lesen der Tabelle: {e}"}
 
     if file_type == "pdf":
         try:
             reader = PyPDF2.PdfReader(uploaded_file)
             return {"type": "text", "content": "".join(page.extract_text() or "" for page in reader.pages)}
         except Exception as e:
-            return {"type": "error", "content": f"PDF Error: {e}"}
+            return {"type": "error", "content": f"PDF Fehler: {e}"}
 
     if file_type == "zip":
         try:
@@ -65,29 +67,38 @@ def process_file(uploaded_file):
                     if not f.is_dir() and f.filename.lower().endswith(text_exts):
                         content += f"\n📄 {f.filename}:\n"
                         content += z.read(f.filename).decode("utf-8", errors="ignore")
-                return {"type": "text", "content": content or "ZIP contains no readable text files."}
+                return {"type": "text", "content": content or "ZIP enthält keine lesbaren Textdateien."}
         except Exception as e:
-            return {"type": "error", "content": f"ZIP Error: {e}"}
+            return {"type": "error", "content": f"ZIP Fehler: {e}"}
 
-    return {"type": "error", "content": "Unsupported file type."}
+    return {"type": "error", "content": "Nicht unterstütztes Dateiformat."}
 
+@st.cache_data(show_spinner=False, ttl=3600) # Caching für 1 Stunde, um Rate Limits zu schonen
 def fetch_model_contexts(api_key):
-    """Fetch context lengths for models"""
+    """Fetches Context Lengths and Price for models from OpenRouter API."""
     if not api_key:
         return {}
+    
     headers = {"Authorization": f"Bearer {api_key}"}
     try:
-        res = requests.get(f"{OPENROUTER_API_BASE}/models", headers=headers, timeout=10)
+        res = requests.get(f"{OPENROUTER_API_BASE}/models", headers=headers, timeout=5)
         contexts = {}
         if res.status_code == 200:
             for m in res.json().get("data", []):
-                contexts[m.get("id")] = m.get("context_length", 4096)
+                # Filtert nur Modelle, die kostenlos sind (prompt price = 0)
+                if m.get("pricing", {}).get("prompt", 1) == 0:
+                     contexts[m.get("id")] = m.get("context_length", 4096)
+        
+        # Füge die gefilterten Modelle zur Session hinzu
+        st.session_state.free_models = list(contexts.keys())
         return contexts
+        
     except Exception as e:
-        st.warning(f"⚠️ Failed to fetch model info: {e}")
+        st.warning(f"⚠️ Fehler beim Abrufen der Modellinformationen (API-Key, Limit?): {e}")
         return {}
 
 def call_openrouter(model, messages, temp, max_tok, key):
+    """Führt den API-Aufruf an OpenRouter durch (OpenAI-Chat-Schema)."""
     headers = {
         "Authorization": f"Bearer {key}",
         "Content-Type": "application/json",
@@ -102,115 +113,137 @@ def call_openrouter(model, messages, temp, max_tok, key):
     }
 
     res = requests.post(f"{OPENROUTER_API_BASE}/chat/completions", headers=headers, data=json.dumps(payload))
+    
     if res.status_code == 200:
         try:
             return res.json()["choices"][0]["message"]["content"]
         except (KeyError, IndexError):
-            raise Exception("Invalid API response")
+            raise Exception("Ungültige API-Antwort: Konnte Antworttext nicht extrahieren.")
     else:
         try:
             err = res.json()
             msg = err.get("error", {}).get("message", res.text)
         except:
             msg = res.text
-        raise Exception(f"API Error {res.status_code}: {msg}")
+        raise Exception(f"API Fehler {res.status_code}: {msg}")
+
 
 # --- Sidebar ---
 with st.sidebar:
     st.header("⚙️ API Settings")
     api_key = st.text_input("OpenRouter API Key", type="password")
 
-    FREE_MODEL_LIST = [
-        "cognitivecomputations/dolphin-mistral-24b-venice-edition:free",
+    # 1. Context holen
+    model_contexts = fetch_model_contexts(api_key)
+    
+    # 2. Liste der kostenlosen Modelle definieren/aktualisieren
+    # Fallback, falls API-Key fehlt oder Fehler auftritt
+    FREE_MODEL_LIST = st.session_state.get("free_models", [
+        "cognitivecomputations/dolphin-mistral-24b-venice-edition", # :free Suffix entfernt
         "deepseek/deepseek-chat-v3",
         "google/gemma-2-9b-it",
         "mistralai/mistral-7b-instruct-v0.2",
-        "qwen/qwen2-72b-instruct",
-        "nousresearch/nous-hermes-2-mixtral-8x7b-dpo",
-    ]
-
-    model = st.selectbox("Select a model", FREE_MODEL_LIST, index=0)
+    ])
+    
+    st.subheader("Modell-Konfiguration")
+    
+    model = st.selectbox("Wähle ein Modell", FREE_MODEL_LIST, index=0)
 
-    # Context-length slider
-    model_contexts = fetch_model_contexts(api_key)
+    # 3. Context Length Slider setzen
     default_ctx = model_contexts.get(model, 4096)
-    max_tokens = st.slider(f"Max Tokens (max {default_ctx})", 1, min(default_ctx, 32000), min(512, default_ctx))
+    
+    max_tokens = st.slider(
+        f"Max Output Tokens (Total Context: {default_ctx})", 
+        min_value=1, 
+        max_value=min(default_ctx, 32768), # Begrenzung nach oben
+        value=min(1024, default_ctx),      # Realistischer Standard-Output (1024 Tokens)
+        step=256
+    )
 
     temperature = st.slider("Temperature", 0.0, 1.0, 0.7)
 
     if st.button("🔄 Reset Chat"):
         st.session_state.messages = []
         st.session_state.uploaded_content = None
-        st.success("Chat and attachment cleared!")
+        st.experimental_rerun() # Refresh, um den file_uploader zu resetten
+        st.success("Chat und Anhang gelöscht!")
+        
+    st.markdown("""
+    ---
+    💡 **Hinweis:** Der Context Window (`Total Context`) beinhaltet sowohl Ihre Eingabe (Chat-Verlauf + Anhang) als auch die Ausgabe (`Max Output Tokens`).
+    """)
+
 
-# --- File Upload ---
+# --- File Upload & Preview ---
 uploaded_file = st.file_uploader("Upload File (optional)", 
-                                 type=["jpg","jpeg","png","txt","pdf","zip","csv","xlsx","html","css","js","py"])
+                                 type=["jpg", "jpeg", "png", "txt", "pdf", "zip", "csv", "xlsx", "html", "css", "js", "py"])
 if uploaded_file and st.session_state.uploaded_content is None:
     st.session_state.uploaded_content = process_file(uploaded_file)
 
 if st.session_state.uploaded_content:
     processed = st.session_state.uploaded_content
-    st.subheader("📎 Current Attachment:")
+    st.subheader("📎 Aktueller Anhang:")
     if processed["type"] == "image":
-        st.image(processed["content"], width=300)
+        st.image(processed["content"], caption="Attached Image", width=300)
     elif processed["type"] == "text":
         st.text_area("File Preview", processed["content"], height=150)
     elif processed["type"] == "error":
         st.error(processed["content"])
-    if st.button("❌ Remove Attachment"):
+    if st.button("❌ Anhang entfernen"):
         st.session_state.uploaded_content = None
         st.experimental_rerun()
 
+
 # --- Chat History ---
 for msg in st.session_state.messages:
     with st.chat_message(msg["role"]):
         st.markdown(msg["content"])
 
-# --- Chat Input ---
-if prompt := st.chat_input("Your message..."):
+
+# --- Chat Input & Logic ---
+if prompt := st.chat_input("Deine Nachricht..."):
     if not api_key:
-        st.warning("Please enter your OpenRouter API Key in the sidebar.")
+        st.warning("Bitte trage deinen OpenRouter API Key in der Sidebar ein.")
         st.stop()
 
+    # 1. Nachricht hinzufügen
     st.session_state.messages.append({"role": "user", "content": prompt})
     with st.chat_message("user"):
         st.markdown(prompt)
 
+    # 2. API Nachrichten vorbereiten (für Chatverlauf)
     messages = [{"role": m["role"], "content": m["content"]} for m in st.session_state.messages]
 
-    # Attach file if exists
+    # 3. Datei anhängen (Multimodalitäts-Handling)
     if st.session_state.uploaded_content:
         content = st.session_state.uploaded_content
+        
         if content["type"] == "image":
             base64_img = encode_image(content["content"])
+            # OpenRouter Multimodalität: Bild als 'image_url' (OpenAI-Schema)
             messages[-1]["content"] = [
                 {"type": "text", "text": prompt},
                 {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}"}}
             ]
         elif content["type"] == "text":
+            # Text-Dateien einfach dem letzten Prompt anhängen
             messages[-1]["content"] += f"\n\n[Attached File Content]\n{content['content']}"
-###### x
-    # Generate response
+
+    # 4. Antwort generieren
     with st.chat_message("assistant"):
-        with st.spinner(f"Asking {model}..."):
+        with st.spinner(f"Fragend {model}..."):
             try:
                 reply = call_openrouter(model, messages, temperature, max_tokens, api_key)
                 
-                # Preprocess reply for JS clipboard (safe escaping)
-                safe_reply = reply.replace("`", "\\`").replace("\n", "\\n").replace('"', '\\"')
-                
-                # Clipboard-ready response with JS
-                st.markdown(f"""
-    <div style="position: relative;">
-        <button onclick="navigator.clipboard.writeText(`{safe_reply}`)"
-                style="position:absolute; right:0; top:0;">📋 Copy</button>
-        <div style="padding-right:50px;">{reply}</div>
-    </div>
-    """, unsafe_allow_html=True)
+                # Antwort anzeigen
+                st.markdown(reply)
                 
+                # Antwort speichern
                 st.session_state.messages.append({"role": "assistant", "content": reply})
+                
+                # NEU: Copy Button (kleine, saubere JS-Lösung als Teil des Chat-Bereichs)
+                st.button("📋 Copy Response", key=f"copy_{len(st.session_state.messages)}", help="Kopiert die gesamte Antwort in die Zwischenablage.")
+                
             except Exception as e:
                 st.error(str(e))
-                st.session_state.messages.append({"role": "assistant", "content": f"❌ {str(e)}"})
-
+                st.session_state.messages.append({"role": "assistant", "content": f"❌ {str(e)}"})