app.py

from streamlit_webrtc import webrtc_streamer, WebRtcMode, AudioProcessorBase
from sentiment_analysis import analyze_sentiment, transcribe_with_chunks
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
import queue
import threading

# Initialize components
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):
    # Your existing function implementation
    pass

def is_valid_input(text):
    # Your existing function implementation
    pass

def is_relevant_sentiment(sentiment_score):
    # Your existing function implementation
    pass

def calculate_overall_sentiment(sentiment_scores):
    # Your existing function implementation
    pass

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."

class AudioProcessor(AudioProcessorBase):
    def __init__(self):
        self.sr = 16000  # Sample rate
        self.q = transcription_queue

    def recv(self, frame):
        audio_data = frame.to_ndarray()
        audio_bytes = (audio_data * 32767).astype(np.int16).tobytes()  # Convert to int16 format
        
        # Debugging: Check audio data
        print(f"Audio data shape: {audio_data.shape}")
        print(f"Audio data sample: {audio_data[:10]}")
        
        # Transcribe the audio
        text = self.transcribe_audio(audio_bytes)
        if text:
            self.q.put(text)  # Add transcribed text to the queue

        return frame

    def transcribe_audio(self, audio_bytes):
        try:
            # Use the transcribe_with_chunks function from sentiment_analysis.py
            chunks = transcribe_with_chunks({})  # Pass an empty objections_dict for now
            if chunks:
                return chunks[-1][0]  # Return the latest transcribed text
        except Exception as e:
            print(f"Error transcribing audio: {e}")
        return None

def real_time_analysis():
    st.info("Listening... Say 'stop' to end the process.")

    # Start WebRTC audio stream
    webrtc_ctx = webrtc_streamer(
        key="real-time-audio",
        mode=WebRtcMode.SENDONLY,
        audio_processor_factory=AudioProcessor,
        media_stream_constraints={"audio": True, "video": False},
    )

    if webrtc_ctx.state.playing:
        # Display transcribed text from the queue
        while not transcription_queue.empty():
            text = transcription_queue.get()
            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)

def fetch_data_and_display():
    try:
        st.header("Call Summaries and Sentiment Analysis")
        data = fetch_call_data(config["google_sheet_id"])
        
        # Debugging: Log fetched data
        print(f"Fetched data: {data}")
        
        if data.empty:
            st.warning("No data available in the Google Sheet.")
        else:
            # Sentiment Visualizations
            sentiment_counts = data['Sentiment'].value_counts()
            
            # 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, 
                    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)

            # 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("---")  # Separator between chunks
            else:
                st.error("No details available for the selected Call ID.")
    except Exception as e:
        st.error(f"Error loading dashboard: {e}")

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":
        fetch_data_and_display()

if __name__ == "__main__":
    run_app()