Update app.py

app.py

@@ -1,136 +1,119 @@
+import os
 import streamlit as st
+import tempfile
 import requests
 import json
-from PIL import Image
-import io
-import base64
-import pandas as pd
-import zipfile
-import PyPDF2
-import os # Wird für die zukünftige Umgebungsvariablen-Nutzung bereitgehalten
+# Entfernte Imports: PIL.Image, io, base64, pandas, zipfile, PyPDF2
+# Da kein File Manager mehr benötigt wird.
+
+# ----------------------------------------------------
+# 🚨 KRITISCHE FIXES FÜR DEN PERMISSION ERROR
+# Zwingt Streamlit, seine temporären/Konfigurationsdateien
+# in den beschreibbaren /tmp-Bereich zu schreiben.
+# ----------------------------------------------------
+
+# 1. Temporären, beschreibbaren Pfad erstellen
+TEMP_STREAMLIT_HOME = os.path.join(tempfile.gettempdir(), "st_config_workaround")
+os.makedirs(TEMP_STREAMLIT_HOME, exist_ok=True)
+
+# 2. Umgebungsvariablen setzen
+os.environ["STREAMLIT_HOME"] = TEMP_STREAMLIT_HOME
+os.environ["STREAMLIT_GATHER_USAGE_STATS"] = "false"
+
+# 3. Minimale config.toml erstellen, um Schreibversuche zu unterbinden
+CONFIG_PATH = os.path.join(TEMP_STREAMLIT_HOME, "config.toml")
+CONFIG_CONTENT = """
+[browser]
+gatherUsageStats = false
+"""
+
+if not os.path.exists(CONFIG_PATH):
+    try:
+        with open(CONFIG_PATH, "w") as f:
+            f.write(CONFIG_CONTENT)
+    except Exception as e:
+        print(f"WARNUNG: Konnte config.toml nicht schreiben: {e}")
+
+# ----------------------------------------------------
+# Ende der Workarounds
+# ----------------------------------------------------
 
 # --- Konfiguration ---
-st.set_page_config(page_title="OpenRouter Free Interface", layout="wide")
+# Hinweis: Layout-Einstellung 'wide' bleibt erhalten
+st.set_page_config(page_title="OpenRouter Minimal Chat UI", layout="wide")
 OPENROUTER_API_BASE = "https://openrouter.ai/api/v1"
 
 # --- Page Title ---
-st.title("💸 OpenRouter Free-Tier Interface")
+st.title("💸 OpenRouter Minimal Chat Interface")
 st.markdown("""
-**Willkommen im All-OpenRouter-Free-Interface Deluxe!**
-Chatte mit **kostenlosen (Free-Tier)** Modellen über die OpenRouter API.
-Alle Modelle unterliegen den OpenRouter-Ratenbegrenzungen.
+**Willkommen im OpenRouter Minimal Chat Interface!**
+Chatte mit **kostenlosen (Free-Tier)** Modellen über die OpenRouter API. Nur Text-Chat.
 """)
 
 # --- Session State Management ---
-# Verwenden des einheitlichen Schlüssels 'messages'
 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
+# st.session_state.uploaded_content wurde entfernt.
 
+# --- Context-Length Fetch (Wird beibehalten, da für den Slider wichtig) ---
+def fetch_model_contexts(api_key):
+    """Lädt alle Modelle + deren context_length."""
+    if not api_key:
+        return {}
+    headers = {"Authorization": f"Bearer {api_key}"}
+    try:
+        res = requests.get(f"{OPENROUTER_API_BASE}/models", headers=headers, timeout=10)
+        contexts = {}
+        if res.status_code == 200:
+            for m in res.json().get("data", []):
+                mid = m.get("id")
+                ctx = m.get("context_length", 4096)
+                contexts[mid] = ctx
+        return contexts
+    except Exception as e:
+        return {}
 
-# --- Datei-Verarbeitung (Multimodal, basierend auf Gemini-UI) ---
-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):
-    """Verarbeitet die hochgeladene Datei (Text, Bild, PDF, ZIP) und extrahiert den Inhalt."""
-    file_type = uploaded_file.name.split('.')[-1].lower()
-    text_exts = ('.txt', '.csv', '.py', '.html', '.js', '.css', '.json', '.xml', '.sql', '.xlsx')
-    
-    if file_type in ["jpg", "jpeg", "png"]:
-        return {"type": "image", "content": Image.open(uploaded_file).convert('RGB')}
-    
-    if file_type in ["txt"] + [ext.strip('.') for ext in text_exts if ext not in ('.csv', '.xlsx')]:
-        return {"type": "text", "content": uploaded_file.read().decode("utf-8", errors="ignore")}
-    
-    if file_type in ["csv", "xlsx"]:
-        try:
-            if file_type == "csv":
-                df = pd.read_csv(uploaded_file)
-            else: # xlsx
-                df = pd.read_excel(uploaded_file)
-            return {"type": "text", "content": df.to_string()}
-        except Exception as e:
-            return {"type": "error", "content": f"Fehler beim Lesen der Tabelle: {e}"}
-            
-    if file_type == "pdf":
-        try:
-            reader = PyPDF2.PdfReader(uploaded_file)
-            # Extrahieren des Textes und Zusammenführen aller Seiten
-            return {"type": "text", "content": "".join(page.extract_text() or "" for page in reader.pages)}
-        except Exception as e:
-            return {"type": "error", "content": f"PDF Fehler: {e}"}
-            
-    if file_type == "zip":
-        try:
-            with zipfile.ZipFile(uploaded_file) as z:
-                content = "ZIP Contents:\n"
-                for f in z.infolist():
-                    if not f.is_dir() and f.filename.lower().endswith(text_exts):
-                        content += f"\n📄 {f.filename}:\n"
-                        # Sicherstellen, dass das Lesen und Dekodieren robust ist
-                        content += z.read(f.filename).decode("utf-8", errors="ignore")
-                return {"type": "text", "content": content or "ZIP enthält keine lesbaren Textdateien."}
-        except Exception as e:
-            return {"type": "error", "content": f"ZIP Fehler: {e}"}
-            
-    return {"type": "error", "content": "Nicht unterstütztes Dateiformat."}
 
 # --- Sidebar ---
 with st.sidebar:
     st.header("⚙️ API Settings")
     api_key = st.text_input("OpenRouter API Key", type="password")
 
-    # --- Manuelle Modelle (Austauschbar mit Auto-Discovery) ---
+    # --- Manuelle Modelle ---
     FREE_MODEL_LIST = [
         "cognitivecomputations/dolphin-mistral-24b-venice-edition:free",
         "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", # Ein Beispiel für ein großes Free-Modell
+        "nousresearch/nous-hermes-2-mixtral-8x7b-dpo",
     ]
     model = st.selectbox("Wähle ein Modell", FREE_MODEL_LIST, index=0)
+
+    # Kontextlänge holen (mit Fallback)
+    model_contexts = fetch_model_contexts(api_key)
+    default_ctx = model_contexts.get(model, 4096) 
+
     temperature = st.slider("Temperature", 0.0, 1.0, 0.7)
-    max_tokens = st.slider("Max Tokens", 1, 4096, 512)
+    max_tokens = st.slider(
+        f"Max Output Tokens (max {default_ctx})", 
+        1, 
+        min(default_ctx, 32000), 
+        min(512, default_ctx)
+    )
+    st.caption(f"🔢 Model Context Length (Fallback 4096): {default_ctx}")
 
     if st.button("🔄 Chat Reset"):
         st.session_state.messages = []
-        st.session_state.uploaded_content = None # Auch den Anhang löschen
-        st.success("Chat-Verlauf und Anhang gelöscht.")
+        st.success("Chat-Verlauf gelöscht.")
+        st.experimental_rerun()
 
     st.markdown("""
     ---
-    🧠 **Hinweis:** Diese Modelle sind **kostenlos**, aber ggf. durch Rate-Limits beschränkt.  
-    Dein API-Key wird nur **lokal** verwendet.
+    **Minimal UI:** Nur Text-Chat.
     """)
 
-# --- Datei Upload ---
-uploaded_file = st.file_uploader("Upload File (optional)", 
-                                 type=["jpg", "jpeg", "png", "txt", "pdf", "zip", "csv", "xlsx", "html", "css", "js", "py"])
-
-# Logik zur Dateiverarbeitung und Vorschau
-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:")
-    
-    if processed["type"] == "image":
-        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"):
-        st.session_state.uploaded_content = None
-        st.experimental_rerun() # Nötig, um den file_uploader optisch zu resetten
+# --- Datei Upload Sektion komplett entfernt ---
 
 
 # --- Chat Verlauf anzeigen ---
@@ -139,15 +122,13 @@ for msg in st.session_state.messages:
         st.markdown(msg["content"])
 
 
-# --- API Request Funktion ---
+# --- API Request Funktion (Unverändert) ---
 def call_openrouter(model, messages, temp, max_tok, key):
-    """Führt den API-Aufruf an OpenRouter (OpenAI-Schema) durch."""
     headers = {
         "Authorization": f"Bearer {key}",
         "Content-Type": "application/json",
-        # KORRIGIERT: "Referer" statt "HTTP-Referer"
-        "Referer": "https://aicodecraft.io", 
-        "X-Title": "OpenRouter-Free-Interface",
+        "Referer": "https://aicodecraft.io",
+        "X-Title": "OpenRouter-Minimal-Interface",
     }
     payload = {
         "model": model,
@@ -160,14 +141,12 @@ def call_openrouter(model, messages, temp, max_tok, key):
     
     if res.status_code == 200:
         try:
-            # KORRIGIERT: Stabile Extraktion der Antwort
             return res.json()["choices"][0]["message"]["content"]
         except (KeyError, IndexError):
             raise Exception("Fehlerhafte API-Antwort: Konnte Antworttext nicht extrahieren.")
     else:
         try:
             err = res.json()
-            # Versuch, die spezifische Fehlermeldung zu finden
             msg = err.get("error", {}).get("message", res.text)
         except:
             msg = res.text
@@ -188,24 +167,6 @@ if prompt := st.chat_input("Deine Nachricht..."):
     # API Nachrichten vorbereiten (für Chatverlauf)
     messages = [{"role": m["role"], "content": m["content"]} for m in st.session_state.messages]
 
-    # Datei anhängen, falls vorhanden (Multimodalitäts-Handling)
-    if st.session_state.uploaded_content:
-        content = st.session_state.uploaded_content
-        
-        # OpenRouter/OpenAI Multimodalität: Bilder als 'url' mit Base64
-        if content["type"] == "image":
-            base64_img = encode_image(content["content"])
-            
-            # Aufbau des Multimodal-Contents für die API
-            messages[-1]["content"] = [
-                {"type": "text", "text": prompt},
-                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}"}}
-            ]
-            
-        # Text-Dateien einfach dem letzten Prompt anhängen
-        elif content["type"] == "text":
-            messages[-1]["content"] += f"\n\n[Attached File Content]\n{content['content']}"
-
     # Antwort generieren
     with st.chat_message("assistant"):
         with st.spinner(f"Fragend {model}..."):