Update app.py

app.py

@@ -1,4 +1,4 @@
-import speech_recognition as sr
+from streamlit_webrtc import webrtc_streamer, WebRtcMode
 from sentiment_analysis import analyze_sentiment
 from product_recommender import ProductRecommender
 from objection_handler import ObjectionHandler
@@ -10,66 +10,42 @@ import uuid
 import pandas as pd
 import plotly.express as px
 import streamlit as st
-import pyaudio
+import numpy as np
+from io import BytesIO
+import wave
 
 # Initialize components
 objection_handler = ObjectionHandler('objections.csv')
 product_recommender = ProductRecommender('recommendations.csv')
 model = SentenceTransformer('all-MiniLM-L6-v2')
 
-def list_audio_devices():
-    """List available audio input devices using pyaudio."""
-    p = pyaudio.PyAudio()
-    devices = []
-    for i in range(p.get_device_count()):
-        device_info = p.get_device_info_by_index(i)
-        if device_info["maxInputChannels"] > 0:  # Check if it's an input device
-            devices.append(device_info)
-    return devices
-
 def real_time_analysis():
     st.info("Listening... Say 'stop' to end the process.")
 
-    try:
-        # List available audio devices
-        devices = list_audio_devices()
-        st.write("Available audio devices:")
-        for device in devices:
-            st.write(f"Device {device['index']}: {device['name']} (Input Channels: {device['maxInputChannels']})")
-
-        if not devices:
-            st.error("No audio input devices found. Please check the virtual microphone setup.")
-            return
-
-        # Use the first available input device
-        device_index = devices[0]["index"]
-        st.write(f"Using device index {device_index}: {devices[0]['name']}")
-
-        recognizer = sr.Recognizer()
-        mic = sr.Microphone(device_index=device_index)
-
-        while True:
-            with mic as source:
-                st.write("Listening...")
-                recognizer.adjust_for_ambient_noise(source)
-                audio = recognizer.listen(source)
-
-            try:
-                st.write("Recognizing...")
-                text = recognizer.recognize_google(audio)
+    def audio_frame_callback(audio_frame):
+        # Convert audio frame to bytes
+        audio_bytes = audio_frame.to_ndarray().tobytes()
+
+        # Save audio bytes to a temporary WAV file
+        with BytesIO() as wav_buffer:
+            with wave.open(wav_buffer, 'wb') as wav_file:
+                wav_file.setnchannels(1)  # Mono audio
+                wav_file.setsampwidth(2)  # 2 bytes for int16
+                wav_file.setframerate(16000)  # Sample rate
+                wav_file.writeframes(audio_bytes)
+
+            # Transcribe the audio
+            text = transcribe_audio(wav_buffer.getvalue())
+            if text:
                 st.write(f"*Recognized Text:* {text}")
 
-                if 'stop' in text.lower():
-                    st.write("Stopping real-time analysis...")
-                    break
-
-                # Append to the total conversation
-                total_text += text + " "
+                # Analyze sentiment
                 sentiment, score = analyze_sentiment(text)
-                sentiment_scores.append(score)
+                st.write(f"*Sentiment:* {sentiment} (Score: {score})")
 
                 # Handle objection
                 objection_response = handle_objection(text)
+                st.write(f"*Objection Response:* {objection_response}")
 
                 # Get product recommendation
                 recommendations = []
@@ -80,96 +56,34 @@ def real_time_analysis():
                     if distances[0][0] < 1.5:  # Similarity threshold
                         recommendations = product_recommender.get_recommendations(text)
 
-                transcribed_chunks.append((text, sentiment, score))
-
-                st.write(f"*Sentiment:* {sentiment} (Score: {score})")
-                st.write(f"*Objection Response:* {objection_response}")
-
                 if recommendations:
                     st.write("*Product Recommendations:*")
                     for rec in recommendations:
                         st.write(rec)
 
-            except sr.UnknownValueError:
-                st.error("Speech Recognition could not understand the audio.")
-            except sr.RequestError as e:
-                st.error(f"Error with the Speech Recognition service: {e}")
-            except Exception as e:
-                st.error(f"Error during processing: {e}")
-
-        # After conversation ends, calculate and display overall sentiment and summary
-        overall_sentiment = calculate_overall_sentiment(sentiment_scores)
-        call_summary = generate_comprehensive_summary(transcribed_chunks)
-
-        st.subheader("Conversation Summary:")
-        st.write(total_text.strip())
-        st.subheader("Overall Sentiment:")
-        st.write(overall_sentiment)
-
-        # Store data in Google Sheets
-        store_data_in_sheet(
-            config["google_sheet_id"],
-            transcribed_chunks,
-            call_summary,
-            overall_sentiment
-        )
-        st.success("Conversation data stored successfully in Google Sheets!")
-
-    except Exception as e:
-        st.error(f"Error in real-time analysis: {e}")
-
-
-def generate_comprehensive_summary(chunks):
-    """Generate a comprehensive summary from conversation chunks."""
-    full_text = " ".join([chunk[0] for chunk in chunks])
-    total_chunks = len(chunks)
-    sentiments = [chunk[1] for chunk in chunks]
-
-    context_keywords = {
-        'product_inquiry': ['dress', 'product', 'price', 'stock'],
-        'pricing': ['cost', 'price', 'budget'],
-        'negotiation': ['installment', 'payment', 'manage']
-    }
-
-    themes = []
-    for keyword_type, keywords in context_keywords.items():
-        if any(keyword.lower() in full_text.lower() for keyword in keywords):
-            themes.append(keyword_type)
-
-    positive_count = sentiments.count('POSITIVE')
-    negative_count = sentiments.count('NEGATIVE')
-    neutral_count = sentiments.count('NEUTRAL')
-
-    key_interactions = []
-    for chunk in chunks:
-        if any(keyword.lower() in chunk[0].lower() for keyword in ['price', 'dress', 'stock', 'installment']):
-            key_interactions.append(chunk[0])
-
-    summary = f"Conversation Summary:\n"
-    if 'product_inquiry' in themes:
-        summary += "• Customer initiated a product inquiry about items.\n"
-    if 'pricing' in themes:
-        summary += "• Price and budget considerations were discussed.\n"
-    if 'negotiation' in themes:
-        summary += "• Customer and seller explored flexible payment options.\n"
-
-    summary += f"\nConversation Sentiment:\n"
-    summary += f"• Positive Interactions: {positive_count}\n"
-    summary += f"• Negative Interactions: {negative_count}\n"
-    summary += f"• Neutral Interactions: {neutral_count}\n"
-
-    summary += "\nKey Conversation Points:\n"
-    for interaction in key_interactions[:3]:
-        summary += f"• {interaction}\n"
-
-    if positive_count > negative_count:
-        summary += "\nOutcome: Constructive and potentially successful interaction."
-    elif negative_count > positive_count:
-        summary += "\nOutcome: Interaction may require further follow-up."
-    else:
-        summary += "\nOutcome: Neutral interaction with potential for future engagement."
-
-    return summary
+        return audio_frame
+
+    # Start WebRTC audio stream
+    webrtc_ctx = webrtc_streamer(
+        key="real-time-audio",
+        mode=WebRtcMode.SENDONLY,
+        audio_frame_callback=audio_frame_callback,
+        media_stream_constraints={"audio": True, "video": False},
+    )
+
+def transcribe_audio(audio_bytes):
+    """Transcribe audio using a speech-to-text model or API."""
+    # Replace this with your actual speech-to-text implementation
+    # For now, we'll just return a dummy text
+    return "This is a placeholder transcription."
+
+def handle_objection(text):
+    query_embedding = model.encode([text])
+    distances, indices = objection_handler.index.search(query_embedding, 1)
+    if distances[0][0] < 1.5:  # Adjust similarity threshold as needed
+        responses = objection_handler.handle_objection(text)
+        return "\n".join(responses) if responses else "No objection response found."
+    return "No objection response found."
 
 def is_valid_input(text):
     text = text.strip().lower()
@@ -180,17 +94,167 @@ def is_valid_input(text):
 def is_relevant_sentiment(sentiment_score):
     return sentiment_score > 0.4
 
-def calculate_overall_sentiment(sentiment_scores):
-    if sentiment_scores:
-        average_sentiment = sum(sentiment_scores) / len(sentiment_scores)
-        overall_sentiment = (
-            "POSITIVE" if average_sentiment > 0 else
-            "NEGATIVE" if average_sentiment < 0 else
-            "NEUTRAL"
-        )
-    else:
-        overall_sentiment = "NEUTRAL"
-    return overall_sentiment
+def run_app():
+    st.set_page_config(page_title="Sales Call Assistant", layout="wide")
+    st.title("AI Sales Call Assistant")
+
+    st.sidebar.title("Navigation")
+    app_mode = st.sidebar.radio("Choose a mode:", ["Real-Time Call Analysis", "Dashboard"])
+
+    if app_mode == "Real-Time Call Analysis":
+        st.header("Real-Time Sales Call Analysis")
+        real_time_analysis()
+
+    elif app_mode == "Dashboard":
+        st.header("Call Summaries and Sentiment Analysis")
+        try:
+            data = fetch_call_data(config["google_sheet_id"])
+            if data.empty:
+                st.warning("No data available in the Google Sheet.")
+            else:
+                sentiment_counts = data['Sentiment'].value_counts()
+
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.subheader("Sentiment Distribution")
+                    fig_pie = px.pie(
+                        values=sentiment_counts.values,
+                        names=sentiment_counts.index,
+                        title='Call Sentiment Breakdown',
+                        color_discrete_map={
+                            'POSITIVE': 'green',
+                            'NEGATIVE': 'red',
+                            'NEUTRAL': 'blue'
+                        }
+                    )
+                    st.plotly_chart(fig_pie)
+
+                with col2:
+                    st.subheader("Sentiment Counts")
+                    fig_bar = px.bar(
+                        x=sentiment_counts.index,
+                        y=sentiment_counts.values,
+                        title='Number of Calls by Sentiment',
+                        labels={'x': 'Sentiment', 'y': 'Number of Calls'},
+                        color=sentiment_counts.index,
+                        color_discrete_map={
+                            'POSITIVE': 'green',
+                            'NEGATIVE': 'red',
+                            'NEUTRAL': 'blue'
+                        }
+                    )
+                    st.plotly_chart(fig_bar)
+
+                st.subheader("All Calls")
+                display_data = data.copy()
+                display_data['Summary Preview'] = display_data['Summary'].str[:100] + '...'
+                st.dataframe(display_data[['Call ID', 'Chunk', 'Sentiment', 'Summary Preview', 'Overall Sentiment']])
+
+                unique_call_ids = data[data['Call ID'] != '']['Call ID'].unique()
+                call_id = st.selectbox("Select a Call ID to view details:", unique_call_ids)
+
+                call_details = data[data['Call ID'] == call_id]
+                if not call_details.empty:
+                    st.subheader("Detailed Call Information")
+                    st.write(f"**Call ID:** {call_id}")
+                    st.write(f"**Overall Sentiment:** {call_details.iloc[0]['Overall Sentiment']}")
+
+                    st.subheader("Full Call Summary")
+                    st.text_area("Summary:",
+                                 value=call_details.iloc[0]['Summary'],
+                                 height=200,
+                                 disabled=True)
+
+                    st.subheader("Conversation Chunks")
+                    for _, row in call_details.iterrows():
+                        if pd.notna(row['Chunk']):
+                            st.write(f"**Chunk:** {row['Chunk']}")
+                            st.write(f"**Sentiment:** {row['Sentiment']}")
+                            st.write("---")
+                else:
+                    st.error("No details available for the selected Call ID.")
+        except Exception as e:
+            st.error(f"Error loading dashboard: {e}")
+
+if __name__ == "__main__":
+    run_app()from streamlit_webrtc import webrtc_streamer, WebRtcMode
+from sentiment_analysis import analyze_sentiment
+from product_recommender import ProductRecommender
+from objection_handler import ObjectionHandler
+from google_sheets import fetch_call_data, store_data_in_sheet
+from sentence_transformers import SentenceTransformer
+from env_setup import config
+import re
+import uuid
+import pandas as pd
+import plotly.express as px
+import streamlit as st
+import numpy as np
+from io import BytesIO
+import wave
+
+# Initialize components
+objection_handler = ObjectionHandler('objections.csv')
+product_recommender = ProductRecommender('recommendations.csv')
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+def real_time_analysis():
+    st.info("Listening... Say 'stop' to end the process.")
+
+    def audio_frame_callback(audio_frame):
+        # Convert audio frame to bytes
+        audio_bytes = audio_frame.to_ndarray().tobytes()
+
+        # Save audio bytes to a temporary WAV file
+        with BytesIO() as wav_buffer:
+            with wave.open(wav_buffer, 'wb') as wav_file:
+                wav_file.setnchannels(1)  # Mono audio
+                wav_file.setsampwidth(2)  # 2 bytes for int16
+                wav_file.setframerate(16000)  # Sample rate
+                wav_file.writeframes(audio_bytes)
+
+            # Transcribe the audio
+            text = transcribe_audio(wav_buffer.getvalue())
+            if text:
+                st.write(f"*Recognized Text:* {text}")
+
+                # Analyze sentiment
+                sentiment, score = analyze_sentiment(text)
+                st.write(f"*Sentiment:* {sentiment} (Score: {score})")
+
+                # Handle objection
+                objection_response = handle_objection(text)
+                st.write(f"*Objection Response:* {objection_response}")
+
+                # Get product recommendation
+                recommendations = []
+                if is_valid_input(text) and is_relevant_sentiment(score):
+                    query_embedding = model.encode([text])
+                    distances, indices = product_recommender.index.search(query_embedding, 1)
+
+                    if distances[0][0] < 1.5:  # Similarity threshold
+                        recommendations = product_recommender.get_recommendations(text)
+
+                if recommendations:
+                    st.write("*Product Recommendations:*")
+                    for rec in recommendations:
+                        st.write(rec)
+
+        return audio_frame
+
+    # Start WebRTC audio stream
+    webrtc_ctx = webrtc_streamer(
+        key="real-time-audio",
+        mode=WebRtcMode.SENDONLY,
+        audio_frame_callback=audio_frame_callback,
+        media_stream_constraints={"audio": True, "video": False},
+    )
+
+def transcribe_audio(audio_bytes):
+    """Transcribe audio using a speech-to-text model or API."""
+    # Replace this with your actual speech-to-text implementation
+    # For now, we'll just return a dummy text
+    return "This is a placeholder transcription."
 
 def handle_objection(text):
     query_embedding = model.encode([text])
@@ -200,6 +264,15 @@ def handle_objection(text):
         return "\n".join(responses) if responses else "No objection response found."
     return "No objection response found."
 
+def is_valid_input(text):
+    text = text.strip().lower()
+    if len(text) < 3 or re.match(r'^[a-zA-Z\s]*$', text) is None:
+        return False
+    return True
+
+def is_relevant_sentiment(sentiment_score):
+    return sentiment_score > 0.4
+
 def run_app():
     st.set_page_config(page_title="Sales Call Assistant", layout="wide")
     st.title("AI Sales Call Assistant")
@@ -209,8 +282,7 @@ def run_app():
 
     if app_mode == "Real-Time Call Analysis":
         st.header("Real-Time Sales Call Analysis")
-        if st.button("Start Listening"):
-            real_time_analysis()
+        real_time_analysis()
 
     elif app_mode == "Dashboard":
         st.header("Call Summaries and Sentiment Analysis")