Update app.py

app.py

@@ -248,135 +248,58 @@ if st.button("Stopo Listening"):
         st.write(f"- {recommendation}")
 
 # HTML/JavaScript for Audio Recording in the Browser
-html_code = """
-<script>
-  let mediaRecorder;
-  let audioChunks = [];
-
-  async function startRecording() {
-    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-    mediaRecorder = new MediaRecorder(stream);
-
-    mediaRecorder.ondataavailable = (event) => {
-      audioChunks.push(event.data);
-    };
-
-    mediaRecorder.onstop = () => {
-      const audioBlob = new Blob(audioChunks, { type: "audio/webm" });
-      audioChunks = [];
-      sendAudioToBackend(audioBlob);
-    };
-
-    mediaRecorder.start(100); // Record audio in small chunks (100ms)
-  }
-
-  function sendAudioToBackend(audioBlob) {
-    const formData = new FormData();
-    formData.append("audio", audioBlob);
-    fetch("/process_audio", {
-      method: "POST",
-      body: formData,
-    })
-      .then((response) => response.json())
-      .then((data) => {
-        console.log("Transcription:", data.transcription);
-        document.getElementById("transcription").innerText = data.transcription;
-      })
-      .catch((error) => console.error("Error:", error));
-  }
-
-  function stopRecording() {
-    mediaRecorder.stop();
-  }
-</script>
-
-<button onclick="startRecording()">Start Recording</button>
-<button onclick="stopRecording()">Stop Recording</button>
-<p id="transcription"></p>
-"""
-recognizer = sr.Recognizer()
-microphone = sr.Microphone()
-
-# Display the HTML interface for recording
-st.markdown(html_code, unsafe_allow_html=True)
-
-def process_audio(audio_file):
-    # Convert the audio to WAV if necessary, and use speech recognition
-    recognizer = sr.Recognizer()
-    audio_path = "temp_audio.webm"
-    with open(audio_path, "wb") as f:
-        f.write(audio_file.getbuffer())
 
-    # Transcription with SpeechRecognition library (Google API)
-    with sr.AudioFile(audio_path) as source:
-        audio_data = recognizer.record(source)
-        transcription = recognizer.recognize_google(audio_data)
-    
-    return transcription
+import gradio as gr
+import speech_recognition as sr
+from datetime import datetime
 
-# Streamlit Server to handle POST requests (this will work in FastAPI or directly in your Streamlit app)
-import os
-from fastapi import FastAPI, File, UploadFile
-from starlette.responses import JSONResponse
+# Initialize recognizer
+recognizer = sr.Recognizer()
 
-app = FastAPI()
+# Add some simple session management
+import gradio as gr
+import speech_recognition as sr
+import json
+from datetime import datetime
 
-@app.post("/process_audio")
-async def process_audio_endpoint(file: UploadFile = File(...)):
-    transcription = process_audio(file)
-    return JSONResponse({"transcription": transcription})
+# Initialize recognizer and microphone
+recognizer = sr.Recognizer()
 
-def transcribe_audio():
-    with microphone as source:
-        recognizer.adjust_for_ambient_noise(source)  # Adjust for ambient noise
-        audio = recognizer.listen(source)  # Listen to the source (microphone)
+# Sample product recommendation function (replace with your own logic)
+def recommend_products(transcription):
+    products = {
+        "phone": [("Smartphone", "Latest model with 5G support"), ("Phone Case", "Durable and stylish")],
+        "laptop": [("Laptop", "High performance for gaming and work"), ("Laptop Stand", "Ergonomic and adjustable")],
+    }
+    recommendations = []
+    for keyword, product_list in products.items():
+        if keyword.lower() in transcription.lower():
+            recommendations.extend(product_list)
+    return recommendations
+
+def transcribe_audio(audio):
+    """Transcribe audio captured from Gradio."""
+    audio_data = sr.AudioData(audio, 16000, 2)
     try:
-        # Recognize speech using Google Web Speech API or other recognizers
-        transcription = recognizer.recognize_google(audio)
+        transcription = recognizer.recognize_google(audio_data)
         return transcription
     except sr.UnknownValueError:
-        # Could not understand the speech
         return "Could not understand audio."
     except sr.RequestError as e:
-        # API error
         return f"Error with the speech recognition service: {e}"
 
-# Add some simple session management
-session_data = {"interactions": [], "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
-if st.button("Startass Listening"):
-    st.write("Listening... Speak into the microphone.")
-
-    # Process real-time audio and show results
-    while True:
-        transcription = transcribe_audio()
-        if transcription:
-            st.write(f"User: {transcription}")
-
-            # Product Recommendations
-            recommendations = recommend_products(transcription)
-            st.subheader("Product Recommendations")
-            for title, description in recommendations:
-                st.write(f"- **{title}**: {description}")
-
-            # Objection Handling
-            objection, response = handle_objection(transcription)
-            st.subheader("Objection Handling")
-            st.write(f"**Objection:** {objection}")
-            st.write(f"**Response:** {response}")
-
-            # Sentiment Analysis
-            sentiment = analyze_sentiment(transcription)
-            st.subheader("Sentiment Analysis")
-            st.write(f"**Sentiment:** {sentiment['label']}")
-            st.write(f"**Score:** {sentiment['score']}")
-
-            # Add interaction to session data and update JSON file
-            interaction = {
-                "transcription": transcription,
-                "sentiment": sentiment,
-                "product_recommendations": recommendations,
-                "objection_handling": {"objection": objection, "response": response},
-            }
-            session_data["interactions"].append(interaction)
-            with open("session_data.json", "w") as f:
-                json.dump(session_data, f, indent=4)
+def gradio_interface(audio):
+    """Gradio interface for capturing audio."""
+    transcription = transcribe_audio(audio)
+    
+    # Product recommendations based on transcription
+    recommendations = recommend_products(transcription)
+    
+    recommendation_text = ""
+    for title, description in recommendations:
+        recommendation_text += f"- **{title}**: {description}\n"
+    
+    return transcription, recommendation_text
+
+# Gradio UI for capturing audio and displaying transcription + recommendations
+gr.Interface(fn=gradio_interface, inputs="microphone", outputs=["text", "text"]).launch(share=True)