Update app.py

app.py

@@ -1,66 +1,86 @@
 import streamlit as st
 import os
+import io
 from groq import Groq
 import soundfile as sf
 from tempfile import NamedTemporaryFile
-import io  # Für Bytes-IO hinzugefügt
 
-# Load the API key from the environment variable
+# API-Key aus Umgebungsvariable laden
 api_key = os.getenv('groqwhisper')
 
-if api_key is None:
-    raise ValueError("groq_whisper environment variable is not set")
+if not api_key:
+    st.error("Bitte setzen Sie die Umgebungsvariable 'groqwhisper'")
+    st.stop()
 
-# Initialize the Groq client
+# Groq-Client initialisieren
 client = Groq(api_key=api_key)
 
-def processaudio(audio_data):
+def process_audio(audio_data):
+    """Verarbeitet Audiodaten und gibt Transkript zurück"""
     try:
-        # Entpacken der Audiodaten (Sample-Rate und Numpy-Array)
-        sample_rate, samples = audio_data
+        samples, sample_rate = audio_data  # Korrigierte Reihenfolge
         
-        # Temporäre Audiodatei erstellen
-        with NamedTemporaryFile(suffix=".wav", delete=True) as tmpfile:
-            # Audio als WAV-Datei speichern
+        with NamedTemporaryFile(suffix=".wav", delete=False) as tmpfile:
             sf.write(tmpfile.name, samples, sample_rate)
             
-            # Datei erneut öffnen und an Groq senden
-            with open(tmpfile.name, "rb") as file:
+            with open(tmpfile.name, "rb") as audio_file:
                 transcription = client.audio.transcriptions.create(
-                    file=(os.path.basename(tmpfile.name), file.read()),
+                    file=(tmpfile.name, audio_file, "audio/wav"),
                     model="whisper-large-v3-turbo",
-                    prompt="transcribe",
                     language="de",
-                    response_format="json",
-                    temperature=0.0
+                    response_format="text"
                 )
-            return transcription.text
-            
+        return transcription
+        
     except Exception as e:
-        return f"Ein Fehler ist aufgetreten: {str(e)}"
+        return f"Fehler: {str(e)}"
+    finally:
+        if tmpfile:
+            os.unlink(tmpfile.name)
 
-# Streamlit Interface
-st.title("Audio Transkription")
-sr_outputs = st.empty()
+# Streamlit UI
+st.title("🎤 Live Audio Transkription")
+st.info("Erlaube Mikrofonzugriff im Browser wenn gefragt!")
 
-# Dateiupload und Mikrofonaufnahme als getrennte Eingaben
-uploaded_file = st.file_uploader("Laden Sie eine Audiodatei hoch", type=["wav", "mp3"])
-audio_bytes = st.audio_input("Oder sprechen Sie jetzt:", type="wav")
+col1, col2 = st.columns(2)
 
-if uploaded_file:
-    # Verarbeitung hochgeladener Datei
-    audio_data = sf.read(uploaded_file)
-    transcription = processaudio(audio_data)
-    sr_outputs.text(transcription)
+with col1:
+    st.subheader("Option 1: Mikrofonaufnahme")
+    audio_bytes = st.audio_input(
+        "Sprich jetzt:",
+        type="wav",
+        key="mic_input"
+    )
 
-elif audio_bytes is not None:
-    # Verarbeitung Mikrofonaufnahme
-    try:
-        # Konvertiere Bytes in Audio-Daten
-        audio_io = io.BytesIO(audio_bytes)
-        audio_data = sf.read(audio_io)
-        transcription = processaudio(audio_data)
-        sr_outputs.text(transcription)
-    except Exception as e:
-        sr_outputs.text(f"Fehler bei der Aufnahmeverarbeitung: {str(e)}")
+with col2:
+    st.subheader("Option 2: Datei-Upload")
+    uploaded_file = st.file_uploader(
+        "Oder Datei hochladen:", 
+        type=["wav", "mp3"],
+        key="file_upload"
+    )
 
+# Verarbeitung
+if audio_bytes or uploaded_file:
+    with st.spinner("Verarbeite Audio..."):
+        try:
+            if audio_bytes:
+                # Mikrofonaufnahme verarbeiten
+                audio_io = io.BytesIO(audio_bytes)
+                audio_data = sf.read(audio_io)
+            else:
+                # Hochgeladene Datei verarbeiten
+                audio_data = sf.read(uploaded_file)
+            
+            # Transkription durchführen
+            result = process_audio(audio_data)
+            
+            # Ergebnis anzeigen
+            st.subheader("Transkription:")
+            st.success(result)
+            
+            # Audio-Player anzeigen
+            st.audio(audio_bytes or uploaded_file)
+            
+        except Exception as e:
+            st.error(f"Verarbeitungsfehler: {str(e)}")