Update app.py

app.py

@@ -6,7 +6,7 @@ import json
 import os
 import plotly.express as px
 import altair as alt
-from utils import analyze_company_data, TextToSpeechConverter  # Import TextToSpeechConverter
+from utils import analyze_company_data, TextToSpeechConverter
 
 # Set page config
 st.set_page_config(
@@ -43,151 +43,327 @@ def process_company(company_name):
         return {"articles": [], "comparative_sentiment_score": {}, "final_sentiment_analysis": "", "audio_path": None}
 
 def main():
-    st.title("News Summarization App")
-    st.write("Analyze news articles and get sentiment analysis for any company.")
-
-    # User input
-    company_name = st.text_input("Enter company name:", "Tesla")
-
-    if st.button("Analyze"):
-        with st.spinner("Analyzing news articles..."):
-            try:
-                # Process company data
-                data = analyze_company_data(company_name)
-                
-                if not data["articles"]:
-                    st.error("No articles found for analysis.")
-                    return
-                
-                # Display overall sentiment
-                st.subheader("Overall Sentiment Analysis")
-                st.write(data["final_sentiment_analysis"])
-                
-                # Create DataFrame for sentiment scores
-                sentiment_df = pd.DataFrame(data["comparative_sentiment_score"])
-                
-                # Display sentiment distribution by source
-                st.subheader("Sentiment Distribution by Source")
-                
-                # Convert sentiment labels to numeric values for visualization
-                sentiment_map = {'positive': 1, 'neutral': 0, 'negative': -1}
-                numeric_df = sentiment_df.replace(sentiment_map)
-                
-                # Calculate sentiment distribution
-                sentiment_dist = numeric_df.apply(lambda x: x.value_counts(normalize=True).to_dict())
-                
-                # Create a new DataFrame for visualization
-                viz_data = []
-                for source in sentiment_df.columns:
-                    dist = sentiment_dist[source]
-                    for sentiment, percentage in dist.items():
-                        viz_data.append({
-                            'Source': source,
-                            'Sentiment': sentiment,
-                            'Percentage': percentage * 100
-                        })
-                
-                viz_df = pd.DataFrame(viz_data)
-                
-                # Create stacked bar chart
-                fig = px.bar(viz_df, 
-                           x='Source', 
-                           y='Percentage',
-                           color='Sentiment',
-                           title='Sentiment Distribution by Source',
-                           barmode='stack')
-                
-                fig.update_layout(
-                    yaxis_title='Percentage',
-                    xaxis_title='News Source',
-                    legend_title='Sentiment'
-                )
-                
-                st.plotly_chart(fig)
-                
-                # Display fine-grained sentiment analysis
-                st.subheader("Fine-grained Sentiment Analysis")
-                
-                # Create tabs for different fine-grained analyses
-                tab1, tab2, tab3 = st.tabs(["Financial Sentiment", "Emotional Sentiment", "ESG Sentiment"])
-                
-                with tab1:
-                    st.write("Financial Market Impact Analysis")
-                    financial_data = []
-                    for article in data["articles"]:
-                        if "financial_sentiment" in article:
-                            financial_data.append({
-                                "Article": article["title"],
-                                "Financial Impact": article["financial_sentiment"],
-                                "Confidence": article.get("fine_grained_sentiment", {}).get("models", {}).get("financial", {}).get("confidence", 0)
-                            })
-                    if financial_data:
-                        st.dataframe(pd.DataFrame(financial_data))
-                    else:
-                        st.info("Financial sentiment analysis not available for these articles.")
-                
-                with tab2:
-                    st.write("Emotional Sentiment Analysis")
-                    emotional_data = []
-                    for article in data["articles"]:
-                        if "emotional_sentiment" in article:
-                            emotional_data.append({
-                                "Article": article["title"],
-                                "Emotional Impact": article["emotional_sentiment"],
-                                "Confidence": article.get("fine_grained_sentiment", {}).get("models", {}).get("emotion", {}).get("confidence", 0)
-                            })
-                    if emotional_data:
-                        st.dataframe(pd.DataFrame(emotional_data))
-                    else:
-                        st.info("Emotional sentiment analysis not available for these articles.")
-                
-                with tab3:
-                    st.write("ESG (Environmental, Social, Governance) Analysis")
-                    esg_data = []
-                    for article in data["articles"]:
-                        if "esg_sentiment" in article:
-                            esg_data.append({
-                                "Article": article["title"],
-                                "ESG Impact": article["esg_sentiment"],
-                                "Confidence": article.get("fine_grained_sentiment", {}).get("models", {}).get("esg", {}).get("confidence", 0)
+    st.title("📰 News Summarization and Analysis")
+    
+    # Sidebar
+    st.sidebar.header("Settings")
+    
+    # Replace dropdown with text input
+    company = st.sidebar.text_input(
+        "Enter Company Name",
+        placeholder="e.g., Tesla, Apple, Microsoft, or any other company",
+        help="Enter the name of any company you want to analyze"
+    )
+    
+    if st.sidebar.button("Analyze") and company:
+        if len(company.strip()) < 2:
+            st.sidebar.error("Please enter a valid company name (at least 2 characters)")
+        else:
+            with st.spinner("Analyzing news articles..."):
+                try:
+                    # Process company data
+                    data = analyze_company_data(company)
+                    
+                    if not data["articles"]:
+                        st.error("No articles found for analysis.")
+                        return
+                    
+                    # Display Articles
+                    st.header("📑 News Articles")
+                    for idx, article in enumerate(data["articles"], 1):
+                        with st.expander(f"Article {idx}: {article['title']}"):
+                            st.write("**Content:**", article.get("content", "No content available"))
+                            if "summary" in article:
+                                st.write("**Summary:**", article["summary"])
+                            st.write("**Source:**", article.get("source", "Unknown"))
+                            
+                            # Enhanced sentiment display
+                            if "sentiment" in article:
+                                sentiment_col1, sentiment_col2 = st.columns(2)
+                                with sentiment_col1:
+                                    st.write("**Sentiment:**", article["sentiment"])
+                                    st.write("**Confidence Score:**", f"{article.get('sentiment_score', 0)*100:.1f}%")
+                                
+                                with sentiment_col2:
+                                    # Display fine-grained sentiment if available
+                                    if "fine_grained_sentiment" in article and article["fine_grained_sentiment"]:
+                                        fine_grained = article["fine_grained_sentiment"]
+                                        if "category" in fine_grained:
+                                            st.write("**Detailed Sentiment:**", fine_grained["category"])
+                                        if "confidence" in fine_grained:
+                                            st.write("**Confidence:**", f"{fine_grained['confidence']*100:.1f}%")
+                            
+                            # Display sentiment indices if available
+                            if "sentiment_indices" in article and article["sentiment_indices"]:
+                                st.markdown("**Sentiment Indices:**")
+                                indices = article["sentiment_indices"]
+                                
+                                # Create columns for displaying indices
+                                idx_cols = st.columns(3)
+                                
+                                # Display positivity and negativity in first column
+                                with idx_cols[0]:
+                                    if "positivity_index" in indices:
+                                        st.markdown(f"**Positivity:** {indices['positivity_index']:.2f}")
+                                    if "negativity_index" in indices:
+                                        st.markdown(f"**Negativity:** {indices['negativity_index']:.2f}")
+                                
+                                # Display emotional intensity and controversy in second column
+                                with idx_cols[1]:
+                                    if "emotional_intensity" in indices:
+                                        st.markdown(f"**Emotional Intensity:** {indices['emotional_intensity']:.2f}")
+                                    if "controversy_score" in indices:
+                                        st.markdown(f"**Controversy:** {indices['controversy_score']:.2f}")
+                                
+                                # Display confidence and ESG in third column
+                                with idx_cols[2]:
+                                    if "confidence_score" in indices:
+                                        st.markdown(f"**Confidence:** {indices['confidence_score']:.2f}")
+                                    if "esg_relevance" in indices:
+                                        st.markdown(f"**ESG Relevance:** {indices['esg_relevance']:.2f}")
+                            
+                            # Display entities if available
+                            if "entities" in article and article["entities"]:
+                                st.markdown("**Named Entities:**")
+                                entities = article["entities"]
+                                
+                                # Organizations
+                                if "ORG" in entities and entities["ORG"]:
+                                    st.write("**Organizations:**", ", ".join(entities["ORG"]))
+                                
+                                # People
+                                if "PERSON" in entities and entities["PERSON"]:
+                                    st.write("**People:**", ", ".join(entities["PERSON"]))
+                                
+                                # Locations
+                                if "GPE" in entities and entities["GPE"]:
+                                    st.write("**Locations:**", ", ".join(entities["GPE"]))
+                                
+                                # Money
+                                if "MONEY" in entities and entities["MONEY"]:
+                                    st.write("**Financial Values:**", ", ".join(entities["MONEY"]))
+                            
+                            # Display sentiment targets if available
+                            if "sentiment_targets" in article and article["sentiment_targets"]:
+                                st.markdown("**Sentiment Targets:**")
+                                targets = article["sentiment_targets"]
+                                for target in targets:
+                                    st.markdown(f"**{target['entity']}** ({target['type']}): {target['sentiment']} ({target['confidence']*100:.1f}%)")
+                                    st.markdown(f"> {target['context']}")
+                                    st.markdown("---")
+                            
+                            if "url" in article:
+                                st.write("**[Read More](%s)**" % article["url"])
+                    
+                    # Display Comparative Analysis
+                    st.header("📊 Comparative Analysis")
+                    analysis = data.get("comparative_sentiment_score", {})
+                    
+                    # Sentiment Distribution
+                    if "sentiment_distribution" in analysis:
+                        st.subheader("Sentiment Distribution")
+                        
+                        sentiment_dist = analysis["sentiment_distribution"]
+                        
+                        try:
+                            # Extract basic sentiment data
+                            if isinstance(sentiment_dist, dict):
+                                if "basic" in sentiment_dist and isinstance(sentiment_dist["basic"], dict):
+                                    basic_dist = sentiment_dist["basic"]
+                                elif any(k in sentiment_dist for k in ['positive', 'negative', 'neutral']):
+                                    basic_dist = {k: v for k, v in sentiment_dist.items() 
+                                                if k in ['positive', 'negative', 'neutral']}
+                                else:
+                                    basic_dist = {'positive': 0, 'negative': 0, 'neutral': 1}
+                            else:
+                                basic_dist = {'positive': 0, 'negative': 0, 'neutral': 1}
+                            
+                            # Calculate percentages
+                            total_articles = sum(basic_dist.values())
+                            if total_articles > 0:
+                                percentages = {
+                                    k: (v / total_articles) * 100 
+                                    for k, v in basic_dist.items()
+                                }
+                            else:
+                                percentages = {k: 0 for k in basic_dist}
+                            
+                            # Display as metrics
+                            st.write("**Sentiment Distribution:**")
+                            
+                            col1, col2, col3 = st.columns(3)
+                            with col1:
+                                st.metric(
+                                    "Positive", 
+                                    basic_dist.get('positive', 0),
+                                    f"{percentages.get('positive', 0):.1f}%"
+                                )
+                            with col2:
+                                st.metric(
+                                    "Negative", 
+                                    basic_dist.get('negative', 0),
+                                    f"{percentages.get('negative', 0):.1f}%"
+                                )
+                            with col3:
+                                st.metric(
+                                    "Neutral", 
+                                    basic_dist.get('neutral', 0),
+                                    f"{percentages.get('neutral', 0):.1f}%"
+                                )
+                            
+                            # Create visualization
+                            chart_data = pd.DataFrame({
+                                'Sentiment': ['Positive', 'Negative', 'Neutral'],
+                                'Count': [
+                                    basic_dist.get('positive', 0),
+                                    basic_dist.get('negative', 0),
+                                    basic_dist.get('neutral', 0)
+                                ],
+                                'Percentage': [
+                                    f"{percentages.get('positive', 0):.1f}%",
+                                    f"{percentages.get('negative', 0):.1f}%",
+                                    f"{percentages.get('neutral', 0):.1f}%"
+                                ]
                             })
-                    if esg_data:
-                        st.dataframe(pd.DataFrame(esg_data))
-                    else:
-                        st.info("ESG sentiment analysis not available for these articles.")
-                
-                # Display articles with detailed sentiment analysis
-                st.subheader("Recent Articles")
-                for article in data["articles"]:
-                    with st.expander(article["title"]):
-                        st.write(f"**Source:** {article['source']}")
-                        st.write(f"**Summary:** {article['summary']}")
-                        st.write(f"**Overall Sentiment:** {article['sentiment']}")
+                            
+                            chart = alt.Chart(chart_data).mark_bar().encode(
+                                y='Sentiment',
+                                x='Count',
+                                color=alt.Color('Sentiment', scale=alt.Scale(
+                                    domain=['Positive', 'Negative', 'Neutral'],
+                                    range=['green', 'red', 'gray']
+                                )),
+                                tooltip=['Sentiment', 'Count', 'Percentage']
+                            ).properties(
+                                width=600,
+                                height=300
+                            )
+                            
+                            text = chart.mark_text(
+                                align='left',
+                                baseline='middle',
+                                dx=3
+                            ).encode(
+                                text='Percentage'
+                            )
+                            
+                            chart_with_text = (chart + text)
+                            st.altair_chart(chart_with_text, use_container_width=True)
                         
-                        # Display fine-grained sentiment if available
-                        fine_grained = article.get("fine_grained_sentiment", {})
-                        if fine_grained:
-                            st.write("**Fine-grained Analysis:**")
-                            for model_name, model_data in fine_grained.get("models", {}).items():
-                                st.write(f"- {model_name.title()}: {model_data.get('category', 'N/A')} (Confidence: {model_data.get('confidence', 0):.2f})")
+                        except Exception as e:
+                            st.error(f"Error creating visualization: {str(e)}")
+                    
+                    # Display sentiment indices if available
+                    if "sentiment_indices" in analysis and analysis["sentiment_indices"]:
+                        st.subheader("Sentiment Indices")
                         
-                        # Display sentiment indices if available
-                        indices = article.get("sentiment_indices", {})
-                        if indices:
-                            st.write("**Sentiment Indices:**")
-                            for index_name, value in indices.items():
-                                st.write(f"- {index_name.replace('_', ' ').title()}: {value:.2f}")
+                        indices = analysis["sentiment_indices"]
                         
-                        st.write(f"**URL:** [{article['url']}]({article['url']})")
-                
-                # Display audio player if audio is available
-                if data.get("audio_path") and os.path.exists(data["audio_path"]):
-                    st.subheader("Hindi Audio Summary")
-                    st.audio(data["audio_path"])
+                        try:
+                            if isinstance(indices, dict):
+                                # Display as metrics in columns
+                                cols = st.columns(3)
+                                
+                                display_names = {
+                                    "positivity_index": "Positivity",
+                                    "negativity_index": "Negativity",
+                                    "emotional_intensity": "Emotional Intensity",
+                                    "controversy_score": "Controversy",
+                                    "confidence_score": "Confidence",
+                                    "esg_relevance": "ESG Relevance"
+                                }
+                                
+                                for i, (key, value) in enumerate(indices.items()):
+                                    if isinstance(value, (int, float)):
+                                        with cols[i % 3]:
+                                            display_name = display_names.get(key, key.replace("_", " ").title())
+                                            st.metric(display_name, f"{value:.2f}")
+                                
+                                # Create visualization
+                                chart_data = pd.DataFrame({
+                                    'Index': [display_names.get(k, k.replace("_", " ").title()) for k in indices.keys()],
+                                    'Value': [v if isinstance(v, (int, float)) else 0 for v in indices.values()]
+                                })
+                                
+                                chart = alt.Chart(chart_data).mark_bar().encode(
+                                    x='Value',
+                                    y='Index',
+                                    color=alt.Color('Index')
+                                ).properties(
+                                    width=600,
+                                    height=300
+                                )
+                                
+                                st.altair_chart(chart, use_container_width=True)
+                                
+                                # Add descriptions
+                                with st.expander("Sentiment Indices Explained"):
+                                    st.markdown("""
+                                    - **Positivity**: Measures the positive sentiment in the articles (0-1)
+                                    - **Negativity**: Measures the negative sentiment in the articles (0-1)
+                                    - **Emotional Intensity**: Measures the overall emotional content (0-1)
+                                    - **Controversy**: High when both positive and negative sentiments are strong (0-1)
+                                    - **Confidence**: Confidence in the sentiment analysis (0-1)
+                                    - **ESG Relevance**: Relevance to Environmental, Social, and Governance topics (0-1)
+                                    """)
+                        except Exception as e:
+                            st.error(f"Error creating indices visualization: {str(e)}")
+                    
+                    # Display Final Analysis and Audio
+                    st.header("🎯 Final Analysis")
+                    if "final_sentiment_analysis" in data:
+                        st.write(data["final_sentiment_analysis"])
+                        
+                        # Display sentiment indices in the sidebar
+                        if "sentiment_indices" in analysis and analysis["sentiment_indices"]:
+                            indices = analysis["sentiment_indices"]
+                            if indices and any(isinstance(v, (int, float)) for v in indices.values()):
+                                st.sidebar.markdown("### Sentiment Indices")
+                                for idx_name, idx_value in indices.items():
+                                    if isinstance(idx_value, (int, float)):
+                                        formatted_name = " ".join(word.capitalize() for word in idx_name.replace("_", " ").split())
+                                        st.sidebar.metric(formatted_name, f"{idx_value:.2f}")
+                        
+                        # Display ensemble model information if available
+                        if "ensemble_info" in data:
+                            with st.expander("Ensemble Model Details"):
+                                ensemble = data["ensemble_info"]
+                                
+                                if "agreement" in ensemble:
+                                    st.metric("Model Agreement", f"{ensemble['agreement']*100:.1f}%")
+                                
+                                if "models" in ensemble:
+                                    st.subheader("Individual Model Results")
+                                    models_data = []
+                                    for model_name, model_info in ensemble["models"].items():
+                                        models_data.append({
+                                            "Model": model_name,
+                                            "Sentiment": model_info.get("sentiment", "N/A"),
+                                            "Confidence": f"{model_info.get('confidence', 0)*100:.1f}%"
+                                        })
+                                    
+                                    if models_data:
+                                        st.table(pd.DataFrame(models_data))
+                        
+                        # Audio Playback Section
+                        st.subheader("🔊 Listen to Analysis (Hindi)")
+                        if data.get("audio_path") and os.path.exists(data["audio_path"]):
+                            st.audio(data["audio_path"])
+                        else:
+                            st.warning("Hindi audio summary not available")
+                    
+                    # Total Articles
+                    if "total_articles" in analysis:
+                        st.sidebar.info(f"Found {analysis['total_articles']} articles")
                 
-            except Exception as e:
-                st.error(f"Error analyzing company data: {str(e)}")
-                print(f"Error: {str(e)}")
+                except Exception as e:
+                    st.error(f"Error analyzing company data: {str(e)}")
+                    print(f"Error: {str(e)}")
+
+    # Add a disclaimer
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("### About")
+    st.sidebar.write("This app analyzes news articles and provides sentiment analysis for any company.")
 
 if __name__ == "__main__":
     main()