Create app_spaces.py

app_spaces.py

@@ -0,0 +1,524 @@
+import streamlit as st
+import requests
+import pandas as pd
+import json
+import os
+import matplotlib.pyplot as plt
+import seaborn as sns
+import base64
+from io import BytesIO
+from PIL import Image, ImageEnhance
+import time
+import threading
+import subprocess
+from typing import Dict, Any, List
+
+# Configure page settings for Hugging Face Spaces
+st.set_page_config(
+    page_title="News Summarization & TTS",
+    page_icon="📰",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Start the API in the background
+def start_api():
+    process = subprocess.Popen(["python", "api.py"])
+    print(f"Started API server with PID {process.pid}")
+    return process
+
+# Check if the API is already running, if not start it
+@st.cache_resource
+def ensure_api_running():
+    try:
+        # Try to connect to the API
+        response = requests.get("http://localhost:8000/docs", timeout=2)
+        if response.status_code == 200:
+            st.sidebar.success("✅ API server is running")
+            print("API already running")
+            return True
+    except Exception as e:
+        print(f"API not running: {str(e)}")
+        pass
+    
+    # API not running, start it
+    print("Starting API server...")
+    st.sidebar.info("Starting API server...")
+    
+    # Start API in a separate thread
+    api_process = start_api()
+    
+    # Wait for API to start
+    api_started = False
+    retries = 0
+    max_retries = 15
+    
+    while not api_started and retries < max_retries:
+        try:
+            time.sleep(2)
+            response = requests.get("http://localhost:8000/docs", timeout=2)
+            if response.status_code == 200:
+                api_started = True
+                st.sidebar.success("✅ API server is running")
+                print("API server started successfully")
+                return True
+        except:
+            retries += 1
+            print(f"Waiting for API to start... (attempt {retries}/{max_retries})")
+    
+    if not api_started:
+        st.sidebar.error("❌ Failed to start API server")
+        print("Failed to start API server")
+        return False
+
+# API Base URL for Spaces deployment
+API_BASE_URL = "http://localhost:8000"
+
+# Function to create plot for sentiment distribution
+def plot_sentiment_distribution(sentiment_data):
+    # Extract and combine sentiment categories
+    categories = []
+    counts = []
+    
+    # Process all sentiment categories
+    for category, count in sentiment_data.items():
+        if count > 0:  # Only include non-zero categories
+            categories.append(category)
+            counts.append(count)
+    
+    # Create a DataFrame for easier plotting
+    df = pd.DataFrame({
+        'Sentiment': categories,
+        'Count': counts
+    })
+    
+    # Set up colors based on sentiment
+    colors = []
+    for sentiment in df['Sentiment']:
+        if sentiment == 'Positive' or sentiment == 'Slightly Positive':
+            colors.append('#10B981')  # Green
+        elif sentiment == 'Negative' or sentiment == 'Slightly Negative':
+            colors.append('#EF4444')  # Red
+        else:
+            colors.append('#6B7280')  # Gray
+    
+    # Create matplotlib figure
+    fig, ax = plt.subplots(figsize=(6, 4))
+    bars = ax.bar(df['Sentiment'], df['Count'], color=colors)
+    
+    # Add count labels on top of bars
+    for bar in bars:
+        height = bar.get_height()
+        ax.text(bar.get_x() + bar.get_width()/2., height + 0.1,
+                str(int(height)), ha='center', va='bottom')
+    
+    # Add labels and title
+    ax.set_xlabel('Sentiment')
+    ax.set_ylabel('Number of Articles')
+    ax.set_title('Sentiment Distribution')
+    
+    # Improve aesthetics
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    
+    return fig
+
+# Function to create word cloud
+def display_word_cloud(topics):
+    from wordcloud import WordCloud
+    
+    # Convert topics to text with frequency
+    text = " ".join(topics)
+    
+    # Generate word cloud
+    wordcloud = WordCloud(
+        width=400,
+        height=200,
+        background_color='white',
+        colormap='viridis',
+        max_words=100,
+        contour_width=1
+    ).generate(text)
+    
+    # Display word cloud
+    fig, ax = plt.subplots(figsize=(10, 5))
+    ax.imshow(wordcloud, interpolation='bilinear')
+    ax.axis('off')
+    
+    return fig
+
+# Function to generate the example output format
+def generate_example_output(company_name: str) -> str:
+    """
+    Generate output in the example format for the given company.
+    Returns the formatted JSON as a string.
+    """
+    try:
+        # Make API request to get the analysis data
+        url = f"{API_BASE_URL}/api/complete_analysis"
+        response = requests.post(url, json={"company_name": company_name})
+        response.raise_for_status()
+        data = response.json()
+        
+        # Format the data to match the example output format exactly
+        formatted_output = {
+            "Company": data["Company"],
+            "Articles": data["Articles"],
+            "Comparative Sentiment Score": {
+                "Sentiment Distribution": data["Comparative Sentiment Score"]["Sentiment Distribution"],
+                "Coverage Differences": data["Comparative Sentiment Score"]["Coverage Differences"],
+                "Topic Overlap": data["Comparative Sentiment Score"]["Topic Overlap"]
+            },
+            "Final Sentiment Analysis": data["Final Sentiment Analysis"],
+            "Audio": "[Play Hindi Speech]" if data.get("Audio") else "No audio available"
+        }
+        
+        # Convert to JSON string with proper formatting
+        return json.dumps(formatted_output, indent=2)
+        
+    except Exception as e:
+        return json.dumps({
+            "error": str(e),
+            "message": "Failed to generate example output"
+        }, indent=2)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.2rem;
+        font-weight: 600;
+        color: #1E3A8A;
+        margin-bottom: 1rem;
+    }
+    .sub-header {
+        font-size: 1.5rem;
+        font-weight: 500;
+        color: #3B82F6;
+        margin-top: 1.5rem;
+        margin-bottom: 0.5rem;
+    }
+    .info-text {
+        color: #6B7280;
+        font-style: italic;
+    }
+    .section-divider {
+        margin-top: 2rem;
+        margin-bottom: 2rem;
+        border-bottom: 1px solid #E5E7EB;
+    }
+    .stButton>button {
+        background-color: #2563EB;
+        color: white;
+        border-radius: 0.375rem;
+        padding: 0.5rem 1rem;
+        font-weight: 500;
+    }
+    .stButton>button:hover {
+        background-color: #1D4ED8;
+    }
+    .article-card {
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border: 1px solid #E5E7EB;
+        margin-bottom: 1rem;
+    }
+    .sentiment-positive {
+        color: #10B981;
+        font-weight: 500;
+    }
+    .sentiment-negative {
+        color: #EF4444;
+        font-weight: 500;
+    }
+    .sentiment-neutral {
+        color: #6B7280;
+        font-weight: 500;
+    }
+    .topic-tag {
+        background-color: #E5E7EB;
+        color: #374151;
+        border-radius: 9999px;
+        padding: 0.25rem 0.75rem;
+        margin-right: 0.5rem;
+        margin-bottom: 0.5rem;
+        display: inline-block;
+        font-size: 0.875rem;
+    }
+    .audio-container {
+        margin-top: 1rem;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        background-color: #F3F4F6;
+    }
+    .stAlert {
+        border-radius: 0.5rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# App header
+st.markdown("<h1 class='main-header'>📰 News Summarization & Text-to-Speech</h1>", unsafe_allow_html=True)
+st.markdown("This application extracts news articles about a company, performs sentiment analysis, conducts comparative analysis, and generates a text-to-speech output in Hindi. Enter a company name to get started.", unsafe_allow_html=True)
+
+# Start the API server when the app loads
+api_running = ensure_api_running()
+
+# Sidebar
+st.sidebar.markdown("## Input Settings")
+company_name = st.sidebar.text_input("Company Name", value="Tesla")
+
+# Audio playback settings
+st.sidebar.markdown("## Audio Settings")
+audio_speed = st.sidebar.select_slider("TTS Speech Speed:", options=["Slow", "Normal", "Fast"], value="Normal")
+st.sidebar.markdown("---")
+
+# Add option to see JSON in example format
+st.sidebar.markdown("## Developer Options")
+show_json = st.sidebar.checkbox("Show JSON output in example format")
+st.sidebar.markdown("---")
+
+# About section
+st.sidebar.markdown("## About")
+st.sidebar.info("This application was developed for news analysis and translation. It uses web scraping, NLP, and TTS technologies to provide insights about companies.")
+
+# Analyze button
+analyze_button = st.sidebar.button("Analyze Company News", disabled=not api_running)
+
+# Main content
+if analyze_button and company_name and api_running:
+    with st.spinner(f"Analyzing news for {company_name}. This may take a moment..."):
+        try:
+            # Call the API to get results (with longer timeout for Spaces)
+            response = requests.post(f"{API_BASE_URL}/api/complete_analysis", 
+                                    json={"company_name": company_name}, 
+                                    timeout=180)  # 3 minutes timeout
+            response.raise_for_status()  # Raise exception for HTTP errors
+            
+            # Parse JSON response
+            response = response.json()
+            
+            # Display results
+            st.markdown(f"<h2 class='sub-header'>Analysis Results for {response['Company']}</h2>", unsafe_allow_html=True)
+            
+            # Display sentiment overview
+            st.markdown("<h3 class='sub-header'>Sentiment Overview</h3>", unsafe_allow_html=True)
+            
+            # Get sentiment counts
+            sentiment_data = response["Comparative Sentiment Score"]["Sentiment Distribution"]
+            
+            # Create columns for visualization
+            col1, col2 = st.columns([3, 2])
+            
+            with col1:
+                # Extract total counts
+                positive_count = sentiment_data.get("Positive", 0) + sentiment_data.get("Slightly Positive", 0)
+                negative_count = sentiment_data.get("Negative", 0) + sentiment_data.get("Slightly Negative", 0)
+                neutral_count = sentiment_data.get("Neutral", 0)
+                total_count = positive_count + negative_count + neutral_count
+                
+                # Show summary text
+                sentiment_text = f"The company has "
+                if positive_count > negative_count and positive_count > neutral_count:
+                    sentiment_text += f"mostly positive coverage ({positive_count}/{total_count} positive, {negative_count}/{total_count} negative, {neutral_count}/{total_count} neutral)."
+                elif negative_count > positive_count and negative_count > neutral_count:
+                    sentiment_text += f"mostly negative coverage ({positive_count}/{total_count} positive, {negative_count}/{total_count} negative, {neutral_count}/{total_count} neutral)."
+                else:
+                    sentiment_text += f"balanced coverage ({positive_count}/{total_count} positive, {negative_count}/{total_count} negative, {neutral_count}/{total_count} neutral)."
+                
+                st.write(sentiment_text)
+                
+                # Plot sentiment distribution
+                try:
+                    fig = plot_sentiment_distribution(sentiment_data)
+                    st.pyplot(fig)
+                except Exception as e:
+                    st.warning(f"Could not create sentiment chart: {str(e)}")
+            
+            with col2:
+                # Summary of key points
+                st.markdown("<h4>Key Insights</h4>", unsafe_allow_html=True)
+                
+                # Show final sentiment analysis
+                st.write(response["Final Sentiment Analysis"])
+                
+                # Show common topics
+                common_topics = response["Comparative Sentiment Score"]["Topic Overlap"].get("Common Topics", [])
+                if common_topics:
+                    st.markdown("<h4>Common Topics</h4>", unsafe_allow_html=True)
+                    for topic in common_topics:
+                        st.markdown(f"<span class='topic-tag'>{topic}</span>", unsafe_allow_html=True)
+            
+            # Display Hindi TTS audio
+            if "Audio" in response and response["Audio"]:
+                st.markdown("<h3 class='sub-header'>Hindi Audio Summary</h3>", unsafe_allow_html=True)
+                
+                audio_message = response["Audio"]
+                
+                if audio_message == "Failed to generate audio":
+                    st.warning("Hindi audio could not be generated. However, you can still read the Hindi text below.")
+                else:
+                    try:
+                        # Check if the response contains the actual audio file path
+                        audio_file_path = response.get("_audio_file_path")
+                        
+                        if audio_file_path:
+                            # Extract the filename
+                            audio_filename = os.path.basename(audio_file_path)
+                            audio_url = f"{API_BASE_URL}/api/audio/{audio_filename}"
+                        else:
+                            # If no path is provided, just display a message
+                            st.info("Audio is available but the path was not provided.")
+                            audio_url = None
+                        
+                        if audio_url:
+                            # Attempt to download the audio file
+                            audio_response = requests.get(audio_url)
+                            if audio_response.status_code == 200:
+                                # Save temporarily
+                                temp_audio_path = f"temp_audio_{os.path.basename(audio_url)}"
+                                with open(temp_audio_path, "wb") as f:
+                                    f.write(audio_response.content)
+                                
+                                # Play from local file
+                                st.markdown("<div class='audio-container'>", unsafe_allow_html=True)
+                                st.audio(temp_audio_path, format="audio/mp3")
+                                
+                                # Display audio download link
+                                st.markdown(f"<a href='{audio_url}' download='hindi_summary.mp3'>Download Hindi Audio</a>", unsafe_allow_html=True)
+                                
+                                # Clean up temp file (optional)
+                                # os.remove(temp_audio_path)  # Uncomment to delete after use
+                            else:
+                                st.warning(f"Unable to load audio file (HTTP {audio_response.status_code}). You can still read the Hindi text below.")
+                        else:
+                            st.info("Hindi audio summary would be available here.")
+                    except Exception as e:
+                        st.warning(f"Error playing audio: {str(e)}. You can still read the Hindi text below.")
+                
+                # Display the Hindi text with better formatting
+                with st.expander("Show Hindi Text"):
+                    hindi_text = response.get("Hindi Summary", "Hindi text not available.")
+                    
+                    # Format the text for better readability
+                    paragraphs = hindi_text.split("। ")
+                    
+                    for paragraph in paragraphs:
+                        if paragraph.strip():
+                            # Add a period if it doesn't end with one
+                            if not paragraph.strip().endswith("।"):
+                                paragraph += "।"
+                            st.markdown(f"<p style='font-size: 16px; margin-bottom: 10px;'>{paragraph}</p>", unsafe_allow_html=True)
+                
+                st.markdown("</div>", unsafe_allow_html=True)
+                
+                st.markdown("<div class='section-divider'></div>", unsafe_allow_html=True)
+            
+            # Display news articles
+            st.markdown("<h3 class='sub-header'>News Articles</h3>", unsafe_allow_html=True)
+            
+            # Show each article in a card
+            articles = response["Articles"]
+            for i, article in enumerate(articles):
+                with st.container():
+                    st.markdown(f"<div class='article-card'>", unsafe_allow_html=True)
+                    
+                    # Article title and sentiment
+                    sentiment_class = "sentiment-neutral"
+                    if article["Sentiment"] == "Positive" or article["Sentiment"] == "Slightly Positive":
+                        sentiment_class = "sentiment-positive"
+                    elif article["Sentiment"] == "Negative" or article["Sentiment"] == "Slightly Negative":
+                        sentiment_class = "sentiment-negative"
+                    
+                    st.markdown(f"<h4>{i+1}. {article['Title']}</h4>", unsafe_allow_html=True)
+                    st.markdown(f"<span class='{sentiment_class}'>{article['Sentiment']}</span>", unsafe_allow_html=True)
+                    
+                    # Article summary
+                    st.write(article["Summary"])
+                    
+                    # Article topics
+                    for topic in article["Topics"]:
+                        st.markdown(f"<span class='topic-tag'>{topic}</span>", unsafe_allow_html=True)
+                    
+                    st.markdown("</div>", unsafe_allow_html=True)
+            
+            # Display comparative analysis
+            st.markdown("<h3 class='sub-header'>Comparative Analysis</h3>", unsafe_allow_html=True)
+            
+            # Common topics
+            st.markdown("<h4>Common Topics</h4>", unsafe_allow_html=True)
+            common_topics = response["Comparative Sentiment Score"]["Topic Overlap"].get("Common Topics", [])
+            if common_topics:
+                for topic in common_topics:
+                    st.markdown(f"<span class='topic-tag'>{topic}</span>", unsafe_allow_html=True)
+            else:
+                st.write("No common topics found across articles.")
+            
+            # Coverage comparison
+            st.markdown("<h4>Coverage Comparison</h4>", unsafe_allow_html=True)
+            comparisons = response["Comparative Sentiment Score"].get("Coverage Differences", [])
+            if comparisons:
+                # Show first comparison inline
+                first_comparison = comparisons[0]
+                st.write(first_comparison.get("Comparison", ""))
+                st.markdown(f"<p class='info-text'>{first_comparison.get('Impact', '')}</p>", unsafe_allow_html=True)
+            else:
+                st.write("No comparative insights available.")
+            
+            # Display full comparison in expander
+            with st.expander("View All Comparisons"):
+                comparisons = response["Comparative Sentiment Score"].get("Coverage Differences", [])
+                for i, comparison in enumerate(comparisons):
+                    st.markdown(f"<p><strong>{i+1}.</strong> {comparison.get('Comparison', '')}</p>", unsafe_allow_html=True)
+                    st.markdown(f"<p class='info-text'>{comparison.get('Impact', '')}</p>", unsafe_allow_html=True)
+                    st.markdown("<hr>", unsafe_allow_html=True)
+            
+            # Show JSON in example format if requested
+            if show_json:
+                st.markdown("<div class='section-divider'></div>", unsafe_allow_html=True)
+                st.markdown("<h3 class='sub-header'>Example JSON Format</h3>", unsafe_allow_html=True)
+                
+                # Get the formatted JSON
+                json_output = generate_example_output(company_name)
+                
+                # Display the JSON in a code block
+                st.code(json_output, language="json")
+                
+        except requests.exceptions.HTTPError as http_err:
+            if http_err.response.status_code == 404:
+                st.error(f"No news articles found for {company_name}. Please try another company name.")
+            elif http_err.response.status_code == 500:
+                error_detail = "Unknown server error"
+                try:
+                    error_data = http_err.response.json()
+                    if "detail" in error_data:
+                        error_detail = error_data["detail"]
+                except:
+                    pass
+                st.error(f"Server error: {error_detail}")
+            else:
+                st.error(f"HTTP error occurred: {http_err}")
+        except requests.exceptions.ConnectionError:
+            st.error("Failed to connect to the server. Please make sure the API is running.")
+        except requests.exceptions.Timeout:
+            st.error("Request timed out. The analysis might be taking too long to complete.")
+        except Exception as e:
+            st.error(f"An error occurred: {str(e)}")
+elif analyze_button and not api_running:
+    st.error("Cannot perform analysis because the API server is not running. Please check the logs.")
+else:
+    # Display placeholder
+    st.info("Enter a company name and click 'Analyze Company News' to get started.")
+    
+    # Example of what the application does
+    with st.expander("See Example Analysis"):
+        st.write("""
+        This application will provide:
+        
+        1. Sentiment analysis of news articles about the company
+        2. Key topics mentioned in the articles
+        3. Comparative analysis of different articles
+        4. Hindi audio summary of the findings
+        
+        Companies you can try: Apple, Microsoft, Google, Amazon, Tesla, etc.
+        """)