Update app.py

app.py

@@ -1,431 +1,80 @@
-"""Streamlit frontend for the News Summarization application."""
-
-import streamlit as st
-import requests
-import pandas as pd
-import json
-from config import API_BASE_URL
-import os
-import plotly.express as px
-import altair as alt
-
-st.set_page_config(
-    page_title="News Summarization App",
-    page_icon="📰",
-    layout="wide"
-)
-
-def analyze_company(company_name):
-    """Send analysis request to API."""
-    try:
-        response = requests.post(
-            f"{API_BASE_URL}/api/analyze",
-            json={"name": company_name}
-        )
-        if response.status_code == 200:
-            data = response.json()
-            # Print the response data for debugging
-            print("API Response Data:")
-            print(json.dumps(data, indent=2))
-            
-            # Download audio file if available
-            if 'audio_url' in data:
-                audio_response = requests.get(f"{API_BASE_URL}{data['audio_url']}")
-                if audio_response.status_code == 200:
-                    data['audio_content'] = audio_response.content
-            return data
-        else:
-            st.error(f"Error from API: {response.text}")
-            return {"articles": [], "comparative_sentiment_score": {}, "final_sentiment_analysis": "", "audio_url": None}
-    except Exception as e:
-        st.error(f"Error analyzing company: {str(e)}")
-        return {"articles": [], "comparative_sentiment_score": {}, "final_sentiment_analysis": "", "audio_url": None}
-
-def main():
-    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..."):
-                result = analyze_company(company)
-                
-                if result and result.get("articles"):
-                    # Display Articles
-                    st.header("📑 News Articles")
-                    for idx, article in enumerate(result["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 = result.get("comparative_sentiment_score", {})
-                    
-                    # Sentiment Distribution
-                    if "sentiment_distribution" in analysis:
-                        st.subheader("Sentiment Distribution")
-                        
-                        # Debug: Print sentiment distribution data
-                        print("Sentiment Distribution Data:")
-                        print(json.dumps(analysis["sentiment_distribution"], indent=2))
-                        
-                        sentiment_dist = analysis["sentiment_distribution"]
-                        
-                        # Create a very simple visualization that will definitely work
-                        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 simple text and 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 a simple bar chart using Altair
-                            
-                            # Create a simple DataFrame with consistent capitalization and percentages
-                            chart_data = pd.DataFrame({
-                                'Sentiment': ['Positive', 'Negative', 'Neutral'],
-                                'Count': [
-                                    basic_dist.get('positive', 0),  # Map lowercase keys to capitalized display
-                                    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}%"
-                                ]
-                            })
-                            
-                            # Add debug output to see what's in the data
-                            print("Chart Data for Sentiment Distribution:")
-                            print(chart_data)
-                            
-                            # Create a simple bar chart with percentages
-                            chart = alt.Chart(chart_data).mark_bar().encode(
-                                y='Sentiment',  # Changed from x to y for horizontal bars
-                                x='Count',      # Changed from y to x for horizontal bars
-                                color=alt.Color('Sentiment', scale=alt.Scale(
-                                    domain=['Positive', 'Negative', 'Neutral'],
-                                    range=['green', 'red', 'gray']
-                                )),
-                                tooltip=['Sentiment', 'Count', 'Percentage']  # Add tooltip with percentage
-                            ).properties(
-                                width=600,
-                                height=300
-                            )
-                            
-                            # Add text labels with percentages
-                            text = chart.mark_text(
-                                align='left',
-                                baseline='middle',
-                                dx=3  # Nudge text to the right so it doesn't overlap with the bar
-                            ).encode(
-                                text='Percentage'
-                            )
-                            
-                            # Combine the chart and text
-                            chart_with_text = (chart + text)
-                            
-                            st.altair_chart(chart_with_text, use_container_width=True)
-                        
-                        except Exception as e:
-                            st.error(f"Error creating visualization: {str(e)}")
-                            st.write("Fallback to simple text display:")
-                            if isinstance(sentiment_dist, dict):
-                                if "basic" in sentiment_dist:
-                                    st.write(f"Positive: {sentiment_dist['basic'].get('positive', 0)}")
-                                    st.write(f"Negative: {sentiment_dist['basic'].get('negative', 0)}")
-                                    st.write(f"Neutral: {sentiment_dist['basic'].get('neutral', 0)}")
-                                else:
-                                    st.write(f"Positive: {sentiment_dist.get('positive', 0)}")
-                                    st.write(f"Negative: {sentiment_dist.get('negative', 0)}")
-                                    st.write(f"Neutral: {sentiment_dist.get('neutral', 0)}")
-                            else:
-                                st.write("No valid sentiment data available")
-                    
-                    # Display sentiment indices if available
-                    if "sentiment_indices" in analysis and analysis["sentiment_indices"]:
-                        st.subheader("Sentiment Indices")
-                        
-                        # Debug: Print sentiment indices
-                        print("Sentiment Indices:")
-                        print(json.dumps(analysis["sentiment_indices"], indent=2))
-                        
-                        # Get the indices data
-                        indices = analysis["sentiment_indices"]
-                        
-                        # Create a very simple visualization that will definitely work
-                        try:
-                            if isinstance(indices, dict):
-                                # Display as simple metrics in columns
-                                cols = st.columns(3)
-                                
-                                # Define display names and descriptions
-                                display_names = {
-                                    "positivity_index": "Positivity",
-                                    "negativity_index": "Negativity",
-                                    "emotional_intensity": "Emotional Intensity",
-                                    "controversy_score": "Controversy",
-                                    "confidence_score": "Confidence",
-                                    "esg_relevance": "ESG Relevance"
-                                }
-                                
-                                # Display each index as a metric
-                                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 a simple bar chart using Altair
-                                
-                                # Create a simple DataFrame
-                                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()]
-                                })
-                                
-                                # Create a simple bar chart
-                                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)
-                                    """)
-                            else:
-                                st.warning("Sentiment indices data is not in the expected format.")
-                                st.write("No valid sentiment indices available")
-                        except Exception as e:
-                            st.error(f"Error creating indices visualization: {str(e)}")
-                            st.write("Fallback to simple text display:")
-                            if isinstance(indices, dict):
-                                for key, value in indices.items():
-                                    if isinstance(value, (int, float)):
-                                        st.write(f"{key.replace('_', ' ').title()}: {value:.2f}")
-                            else:
-                                st.write("No valid sentiment indices data available")
-                    
-                    # Source Distribution
-                    if "source_distribution" in analysis:
-                        st.subheader("Source Distribution")
-                        source_df = pd.DataFrame.from_dict(
-                            analysis["source_distribution"],
-                            orient='index',
-                            columns=['Count']
-                        )
-                        st.bar_chart(source_df)
-                    
-                    # Common Topics
-                    if "common_topics" in analysis:
-                        st.subheader("Common Topics")
-                        st.write(", ".join(analysis["common_topics"]) if analysis["common_topics"] else "No common topics found")
-                    
-                    # Coverage Differences
-                    if "coverage_differences" in analysis:
-                        st.subheader("Coverage Analysis")
-                        for diff in analysis["coverage_differences"]:
-                            st.write("- " + diff)
-                    
-                    # Display Final Sentiment and Audio
-                    st.header("🎯 Final Analysis")
-                    if "final_sentiment_analysis" in result:
-                        st.write(result["final_sentiment_analysis"])
-                        
-                        # Display sentiment indices in the sidebar if available
-                        if "sentiment_indices" in analysis and analysis["sentiment_indices"]:
-                            indices = analysis["sentiment_indices"]
-                            # Verify we have valid data
-                            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 result:
-                            with st.expander("Ensemble Model Details"):
-                                ensemble = result["ensemble_info"]
-                                
-                                # Model agreement
-                                if "agreement" in ensemble:
-                                    st.metric("Model Agreement", f"{ensemble['agreement']*100:.1f}%")
-                                
-                                # Individual model results
-                                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 'audio_content' in result:
-                            st.audio(result['audio_content'], format='audio/mp3')
-                        else:
-                            st.warning("Hindi audio summary not available")
-                    
-                    # Total Articles
-                    if "total_articles" in analysis:
-                        st.sidebar.info(f"Found {analysis['total_articles']} articles")
-
-    # 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()
+"""Streamlit frontend for the News Summarization application."""
+
+import streamlit as st
+import pandas as pd
+import json
+import os
+import plotly.express as px
+import altair as alt
+from utils import analyze_company_data  # Import the analysis function directly
+
+st.set_page_config(
+    page_title="News Summarization App",
+    page_icon="📰",
+    layout="wide"
+)
+
+def process_company(company_name):
+    """Process company data directly."""
+    try:
+        # Call the analysis function directly from utils
+        data = analyze_company_data(company_name)
+        
+        # Generate audio if needed
+        if 'summary' in data:
+            from gtts import gTTS
+            tts = gTTS(text=data['summary'], lang='en')
+            audio_path = os.path.join('audio_output', f'{company_name}_summary.mp3')
+            os.makedirs('audio_output', exist_ok=True)
+            tts.save(audio_path)
+            data['audio_path'] = audio_path
+            
+        return data
+    except Exception as e:
+        st.error(f"Error processing company: {str(e)}")
+        return {"articles": [], "comparative_sentiment_score": {}, "final_sentiment_analysis": "", "audio_path": None}
+
+def main():
+    st.title("📰 News Summarization and Analysis")
+    
+    # Sidebar
+    st.sidebar.header("Settings")
+    
+    # Company name input
+    company_name = st.text_input("Enter Company Name", "")
+    
+    if company_name:
+        with st.spinner("Analyzing company news..."):
+            data = process_company(company_name)
+            
+            # Display results
+            if data["articles"]:
+                st.subheader("📊 Analysis Results")
+                
+                # Display sentiment analysis
+                if data["final_sentiment_analysis"]:
+                    st.write("Sentiment Analysis:", data["final_sentiment_analysis"])
+                
+                # Display articles
+                st.subheader("📰 Recent Articles")
+                for article in data["articles"]:
+                    with st.expander(article["title"]):
+                        st.write(article["summary"])
+                        st.write("Source:", article["source"])
+                        st.write("Sentiment:", article["sentiment"])
+                
+                # Display audio if available
+                if data.get("audio_path"):
+                    st.audio(data["audio_path"])
+                
+                # Display visualizations
+                if data.get("comparative_sentiment_score"):
+                    st.subheader("📈 Sentiment Distribution")
+                    sentiment_df = pd.DataFrame(data["comparative_sentiment_score"])
+                    fig = px.bar(sentiment_df, title="Sentiment Analysis by Source")
+                    st.plotly_chart(fig)
+            else:
+                st.warning("No articles found for this company.")
+
+if __name__ == "__main__":
+    main()