Update app.py

app.py

@@ -1,70 +1,64 @@
-import streamlit as st
 import os
 import io
+import streamlit as st
 from groq import Groq
 import soundfile as sf
-from tempfile import NamedTemporaryFile
-
-# API-Key aus Umgebungsvariable laden
-api_key = os.getenv('groqwhisper')
+from st_audiorec import st_audiorec
 
-if not api_key:
-    st.error("Bitte setzen Sie die Umgebungsvariable 'groqwhisper'")
+# Load environment variables
+api_key = os.getenv('groq_whisper')
+if api_key is None:
+    st.error("The 'groq_whisper' environment variable is not set. Please set it and restart the app.")
     st.stop()
 
-# Groq-Client initialisieren
+# Initialize Groq client
 client = Groq(api_key=api_key)
 
-def process_audio(audio_bytes):
-    """Verarbeitet Audio-Bytes und gibt Transkript zurück"""
-    tmpfile = None  # Initialisierung für finally-Block
+def process_audio(audio_data):
+    """Process audio data and return transcription."""
     try:
-        # Konvertiere Bytes in Audio-Daten
-        audio_io = io.BytesIO(audio_bytes)
-        samples, sample_rate = sf.read(audio_io)
+        sample_rate, samples = audio_data
         
-        with NamedTemporaryFile(suffix=".wav", delete=False) as tmpfile:
-            sf.write(tmpfile.name, samples, sample_rate)
+        # Create in-memory WAV file
+        with io.BytesIO() as wav_buffer:
+            sf.write(wav_buffer, samples, sample_rate, format='WAV')
+            wav_buffer.seek(0)
             
-            with open(tmpfile.name, "rb") as audio_file:
-                transcription = client.audio.transcriptions.create(
-                    file=(os.path.basename(tmpfile.name), audio_file),  # Korrigierte Parameter
-                    model="whisper-large-v3-turbo",
-                    language="de",
-                    response_format="text"
-                )
-        return transcription
-        
+            # Send to Groq for transcription
+            transcription = client.audio.transcriptions.create(
+                file=("recording.wav", wav_buffer.read(), "audio/wav"),
+                model="whisper-large-v3-turbo",
+                prompt="transcribe",
+                language="de",
+                response_format="json",
+                temperature=0.0
+            )
+        return transcription.text
     except Exception as e:
-        return f"Fehler: {str(e)}"
-    finally:
-        if tmpfile and os.path.exists(tmpfile.name):
-            os.unlink(tmpfile.name)
+        return f"An error occurred: {str(e)}"
 
 # Streamlit UI
-st.title("🎤 Audio Transkription")
-st.info("Funktioniert auf Hugging Face Spaces!")
+st.title("🎤 Live Audio Transcription")
+st.write("Record audio using your microphone and get real-time transcription")
 
-# Kombinierter Uploader für Datei und Mikrofon
-audio_bytes = st.audio_input(
-    "Aufnahme starten oder Datei hochladen", 
-)
+# Audio recorder component
+audio_bytes = st_audiorec()
 
 if audio_bytes:
-    with st.spinner("Verarbeite Audio..."):
-        try:
-            # Datei in Bytes lesen
-            #audio_bytes = audio_file.read()
-            with open(audio_bytes, "rb") as file:
-            # Transkription durchführen
-                result = process_audio(audio_bytes)
-            
-            # Ergebnis anzeigen
-            st.subheader("Transkription:")
-            st.text(result)
-            
-            # Audio-Player anzeigen
-            #st.audio(audio_bytes, format="audio/wav")
-            
-        except Exception as e:
-            st.error(f"Fehler: {str(e)}")
+    # Convert bytes to numpy array using soundfile
+    with io.BytesIO(audio_bytes) as wav_io:
+        samples, sample_rate = sf.read(wav_io)
+        
+        # Convert stereo to mono if necessary
+        if len(samples.shape) > 1 and samples.shape[1] == 2:
+            samples = samples.mean(axis=1)
+        
+        # Process the audio
+        with st.spinner("Transcribing..."):
+            transcription = process_audio((sample_rate, samples))
+        
+        # Display results
+        st.success("Transcription Complete!")
+        st.subheader("Result:")
+        st.write(transcription)
+        st.audio(audio_bytes, format='audio/wav')