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, transcribe_with_chunks
 from product_recommender import ProductRecommender
 from objection_handler import ObjectionHandler
@@ -15,43 +15,54 @@ from io import BytesIO
 import wave
 import threading
 import queue
-from streamlit_webrtc import webrtc_streamer, WebRtcMode, AudioProcessorBase
 
 # Initialize components
-objection_handler = ObjectionHandler("objections.csv")
-product_recommender = ProductRecommender("recommendations.csv")
+objection_handler = ObjectionHandler("objections.csv")  # Use relative path
+product_recommender = ProductRecommender("recommendations.csv")  # Use relative path
 model = SentenceTransformer('all-MiniLM-L6-v2')
 
 # Queue to hold transcribed text
 transcription_queue = queue.Queue()
 
 def generate_comprehensive_summary(chunks):
+    """
+    Generate a comprehensive summary from conversation chunks
+    """
+    # Extract full text from chunks
     full_text = " ".join([chunk[0] for chunk in chunks])
+    
+    # Perform basic analysis
     total_chunks = len(chunks)
     sentiments = [chunk[1] for chunk in chunks]
     
+    # Determine overall conversation context
     context_keywords = {
         'product_inquiry': ['dress', 'product', 'price', 'stock'],
         'pricing': ['cost', 'price', 'budget'],
         'negotiation': ['installment', 'payment', 'manage']
     }
     
+    # Detect conversation themes
     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)
     
+    # Basic sentiment analysis
     positive_count = sentiments.count('POSITIVE')
     negative_count = sentiments.count('NEGATIVE')
     neutral_count = sentiments.count('NEUTRAL')
     
+    # Key interaction highlights
     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])
     
+    # Construct summary
     summary = f"Conversation Summary:\n"
     
+    # Context and themes
     if 'product_inquiry' in themes:
         summary += "• Customer initiated a product inquiry about items.\n"
     
@@ -61,15 +72,18 @@ def generate_comprehensive_summary(chunks):
     if 'negotiation' in themes:
         summary += "• Customer and seller explored flexible payment options.\n"
     
+    # Sentiment insights
     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"
     
+    # Key highlights
     summary += "\nKey Conversation Points:\n"
-    for interaction in key_interactions[:3]:
+    for interaction in key_interactions[:3]:  # Limit to top 3 key points
         summary += f"• {interaction}\n"
     
+    # Conversation outcome
     if positive_count > negative_count:
         summary += "\nOutcome: Constructive and potentially successful interaction."
     elif negative_count > positive_count:
@@ -103,220 +117,127 @@ def calculate_overall_sentiment(sentiment_scores):
 def handle_objection(text):
     query_embedding = model.encode([text])
     distances, indices = objection_handler.index.search(query_embedding, 1)
-    if distances[0][0] < 1.5:
+    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 transcribe_audio(audio_bytes, sample_rate=16000):
+    """Transcribe audio using the transcribe_with_chunks function from sentiment_analysis.py."""
     try:
+        # Save audio bytes to a temporary WAV file
         with BytesIO() as wav_buffer:
             with wave.open(wav_buffer, 'wb') as wf:
-                wf.setnchannels(1)
-                wf.setsampwidth(2)
-                wf.setframerate(sample_rate)
+                wf.setnchannels(1)  # Mono audio
+                wf.setsampwidth(2)  # 2 bytes for int16
+                wf.setframerate(sample_rate)  # Sample rate
                 wf.writeframes(audio_bytes)
 
-            st.write("Audio saved, attempting transcription...")
-            chunks = transcribe_with_chunks(wav_buffer.getvalue())
+            # Use the transcribe_with_chunks function from sentiment_analysis.py
+            chunks = transcribe_with_chunks({})  # Pass an empty objections_dict for now
             if chunks:
-                st.write(f"Transcribed chunks: {chunks}")
-                return chunks[-1][0]
+                return chunks[-1][0]  # Return the latest transcribed text
     except Exception as e:
-        st.error(f"Error transcribing audio: {e}")
+        print(f"Error transcribing audio: {e}")
     return None
 
-class AudioProcessor(AudioProcessorBase):
-    def __init__(self):
-        self.transcription_queue = transcription_queue
+def audio_processing_thread(audio_frame):
+    """Thread function to process audio frames."""
+    # Convert audio frame to bytes
+    audio_data = audio_frame.to_ndarray()
+    print(f"Audio data shape: {audio_data.shape}")  # Debug: Check audio data shape
+    print(f"Audio data sample: {audio_data[:10]}")  # Debug: Check first 10 samples
+
+    audio_bytes = (audio_data * 32767).astype(np.int16).tobytes()  # Convert to int16 format
 
-    def recv(self, frame):
-        audio_data = frame.to_ndarray()
-        st.write(f"Received audio frame: {audio_data.shape}")
-        audio_bytes = (audio_data * 32767).astype(np.int16).tobytes()
-        text = transcribe_audio(audio_bytes)
-        if text:
-            st.write(f"Transcribed text: {text}")
-            self.transcription_queue.put(text)
-        return frame
+    # Transcribe the audio
+    text = transcribe_audio(audio_bytes)
+    if text:
+        transcription_queue.put(text)  # Add transcribed text to the queue
 
 def real_time_analysis():
     st.info("Listening... Say 'stop' to end the process.")
 
+    def audio_frame_callback(audio_frame):
+        # Start a new thread to process the audio frame
+        threading.Thread(target=audio_processing_thread, args=(audio_frame,)).start()
+        return audio_frame
+
+    # Start WebRTC audio stream
     webrtc_ctx = webrtc_streamer(
         key="real-time-audio",
         mode=WebRtcMode.SENDONLY,
-        audio_processor_factory=AudioProcessor,
+        audio_frame_callback=audio_frame_callback,
         media_stream_constraints={"audio": True, "video": False},
     )
 
-    if webrtc_ctx.state.playing:
-        while not transcription_queue.empty():
-            text = transcription_queue.get()
-            st.write(f"*Recognized Text:* {text}")
+    # Display transcribed text from the queue
+    while not transcription_queue.empty():
+        text = transcription_queue.get()
+        st.write(f"*Recognized Text:* {text}")
 
-            sentiment, score = analyze_sentiment(text)
-            st.write(f"*Sentiment:* {sentiment} (Score: {score})")
+        # Analyze sentiment
+        sentiment, score = analyze_sentiment(text)
+        st.write(f"*Sentiment:* {sentiment} (Score: {score})")
 
-            objection_response = handle_objection(text)
-            st.write(f"*Objection Response:* {objection_response}")
+        # Handle objection
+        objection_response = handle_objection(text)
+        st.write(f"*Objection Response:* {objection_response}")
 
-            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)
+        # 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:
-                    recommendations = product_recommender.get_recommendations(text)
+            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)
-
-def load_google_sheets_data():
-    try:
-        data = fetch_call_data(config["google_sheet_id"])
-        if data.empty:
-            st.warning("No data available in the Google Sheet.")
-        else:
-            return data
-    except Exception as e:
-        st.error(f"Error loading data from Google Sheets: {e}")
-    return None
+        if recommendations:
+            st.write("*Product Recommendations:*")
+            for rec in recommendations:
+                st.write(rec)
 
 def run_app():
     st.set_page_config(page_title="Sales Call Assistant", layout="wide")
     st.title("AI Sales Call Assistant")
 
-    st.markdown("""
-        <style>
-            html, body {
-                font-family: 'Roboto', sans-serif;
-                background-color: #f5f7fa;
-            }
-            .header-container {
-                background: linear-gradient(135deg, #2980b9, #6dd5fa, #ffffff);
-                padding: 20px;
-                border-radius: 15px;
-                margin-bottom: 30px;
-                text-align: center;
-                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-            }
-            .section {
-                background: linear-gradient(135deg, #ffffff, #f5f7fa);
-                padding: 25px;
-                border-radius: 15px;
-                margin-bottom: 30px;
-                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-            }
-            .header {
-                font-size: 2.5em;
-                font-weight: 800;
-                color: #2980b9;
-                margin: 0;
-                padding: 10px;
-                letter-spacing: 1px;
-            }
-            .subheader {
-                font-size: 1.8em;
-                font-weight: 600;
-                color: #2980b9;
-                margin-top: 20px;
-                margin-bottom: 10px;
-                text-align: left;
-            }
-            .table-container {
-                background: #ffffff;
-                padding: 20px;
-                border-radius: 10px;
-                margin: 20px 0;
-                box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-            }
-            .stButton > button {
-                background: linear-gradient(135deg, #2980b9, #6dd5fa);
-                color: white;
-                border: none;
-                padding: 10px 20px;
-                border-radius: 5px;
-                transition: all 0.3s ease;
-                box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-            }
-            .stButton > button:hover {
-                background: linear-gradient(135deg, #2396dc, #6dd5fa);
-                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.2);
-            }
-            .stTabs [data-baseweb="tab-list"] {
-                gap: 24px;
-                background: #f5f7fa;
-                padding: 10px;
-                border-radius: 10px;
-            }
-            .stTabs [data-baseweb="tab"] {
-                background-color: transparent;
-                border-radius: 4px;
-                color: #2980b9;
-                font-weight: 600;
-                padding: 10px 16px;
-            }
-            .stTabs [aria-selected="true"] {
-                background: linear-gradient(120deg, #2980b9, #6dd5fa);
-                color: white;
-            }
-            .success {
-                background: linear-gradient(135deg, #43A047, #2E7D32);
-                color: white;
-                padding: 10px;
-                border-radius: 5px;
-                margin: 10px 0;
-            }
-            .error {
-                background: linear-gradient(135deg, #E53935, #C62828);
-                color: white;
-                padding: 10px;
-                border-radius: 5px;
-                margin: 10px 0;
-            }
-            .warning {
-                background: linear-gradient(135deg, #FB8C00, #F57C00);
-                color: white;
-                padding: 10px;
-                border-radius: 5px;
-                margin: 10px 0;
-            }
-        </style>
-    """, unsafe_allow_html=True)
-    
-    st.markdown("""
-        <div class="header-container">
-            <h1 class="header">AI Sales Call Assistant</h1>
-        </div>
-    """, unsafe_allow_html=True)
-
     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.markdown('<div class="section">', unsafe_allow_html=True)
         st.header("Real-Time Sales Call Analysis")
-        st.markdown('</div>', unsafe_allow_html=True)
-        if st.button("Start Listening"):
-            real_time_analysis()
+        real_time_analysis()
 
     elif app_mode == "Dashboard":
-        st.markdown('<div class="section">', unsafe_allow_html=True)
         st.header("Call Summaries and Sentiment Analysis")
-        data = load_google_sheets_data()
-        if data is not None:
-            try:
+        try:
+            data = fetch_call_data(config["google_sheet_id"])
+            if data.empty:
+                st.warning("No data available in the Google Sheet.")
+            else:
+                # Sentiment Visualizations
                 sentiment_counts = data['Sentiment'].value_counts()
-
-                product_mentions = filter_product_mentions(data[['Chunk']].values.tolist(), product_titles)
-                product_mentions_df = pd.DataFrame(list(product_mentions.items()), columns=['Product', 'Count'])
-
+                
+                # Pie Chart
                 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)
+
+                # Bar Chart
+                with col2:
+                    st.subheader("Sentiment Counts")
                     fig_bar = px.bar(
                         x=sentiment_counts.index, 
                         y=sentiment_counts.values, 
@@ -331,46 +252,41 @@ def run_app():
                     )
                     st.plotly_chart(fig_bar)
 
-                with col2:
-                    st.subheader("Most Mentioned Products")
-                    fig_products = px.pie(
-                        values=product_mentions_df['Count'], 
-                        names=product_mentions_df['Product'], 
-                        title='Most Mentioned Products'
-                    )
-                    st.plotly_chart(fig_products)
-
+                # Existing Call Details Section
                 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']])
 
+                # Dropdown to select Call ID
                 unique_call_ids = data[data['Call ID'] != '']['Call ID'].unique()
                 call_id = st.selectbox("Select a Call ID to view details:", unique_call_ids)
 
+                # Display selected Call ID details
                 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']}")
                     
+                    # Expand summary section
                     st.subheader("Full Call Summary")
                     st.text_area("Summary:", 
                                  value=call_details.iloc[0]['Summary'], 
                                  height=200, 
                                  disabled=True)
                     
+                    # Show all chunks for the selected call
                     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("---")
+                            st.write("---")  # Separator between chunks
                 else:
                     st.error("No details available for the selected Call ID.")
-            except Exception as e:
-                st.error(f"Error processing data: {e}")
-        st.markdown('</div>', unsafe_allow_html=True)
+        except Exception as e:
+            st.error(f"Error loading dashboard: {e}")
 
 if __name__ == "__main__":
-    run_app()
+    run_app()