update app

Dockerfile

@@ -1,21 +0,0 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,709 @@
+# src/streamlit_app.py
+
+import streamlit as st
+import pandas as pd
+import re  # For robust YouTube video ID extraction
+
+# Try to import Plotly, if not available, we'll use Streamlit's basic charts
+try:
+    import plotly.express as px
+
+    PLOTLY_AVAILABLE = True
+except ImportError:
+    PLOTLY_AVAILABLE = False
+    st.sidebar.warning(
+        "Plotly not installed. Charts will be basic. Consider 'pip install plotly'."
+    )  # Optional warning
+
+# Import our custom modules from the src directory
+try:
+    from src.predict import (
+        predict_sentiments,
+    )  # This function should return list of strings: "positive", "negative", "neutral"
+    from src.youtube import (
+        get_video_comments,
+    )  # This function should return a list of comment strings
+except ImportError as e:
+    st.error(
+        f"Failed to import necessary modules (predict.py, youtube.py). Ensure they are in the 'src' directory. Error: {e}"
+    )
+    # Stop the app if core modules are missing
+    st.stop()
+
+
+def extract_video_id(url_or_id: str):
+    """
+    Tries to get the YouTube video ID from different common URL types.
+    Also handles if the input is just the ID itself.
+    A bit of regex to find the ID part in common URLs.
+    """
+    if not url_or_id:
+        return None
+
+    # Patterns for various YouTube URL formats
+    # Order matters: more specific patterns should come first if overlap exists
+    patterns = [
+        r"watch\?v=([a-zA-Z0-9_-]{11})",  # Standard watch URL
+        r"youtu\.be/([a-zA-Z0-9_-]{11})",  # Shortened URL
+        r"embed/([a-zA-Z0-9_-]{11})",  # Embed URL
+        r"shorts/([a-zA-Z0-9_-]{11})",  # Shorts URL
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, url_or_id)
+        if match:
+            return match.group(1)  # The first capturing group is the ID
+
+    # If no pattern matches, check if the input itself is a valid 11-char ID
+    # Basic check: 11 chars, no spaces, not starting with http (already handled by regex above implicitly)
+    if len(url_or_id) == 11 and not (
+        "/" in url_or_id or "?" in url_or_id or "=" in url_or_id or "." in url_or_id
+    ):
+        return url_or_id  # Assume it's a direct ID
+
+    return None  # Return None if no ID found
+
+
+def analyze_youtube_video(video_url_or_id: str):
+    """
+    Main function for the YouTube analysis part.
+    It gets comments, then predicts their sentiments.
+    Then it summarizes the results.
+    """
+    video_id = extract_video_id(video_url_or_id)
+    if not video_id:
+        # Give a more helpful error message to the user
+        st.error(
+            "Oops! That doesn't look like a valid YouTube URL or Video ID. Please check and try again. Example: Z9kGRMglw-I or youtu.be/3?v=Z9kGRMglw-I"
+        )
+        return None  # Stop if no valid ID
+
+    summary_data = {}  # Initialize
+    # comments_with_sentiments = []  # Initialize
+
+    try:
+        with st.spinner(f"Fetching comments & title for video ID: {video_id}..."):
+            video_data = get_video_comments(video_id)
+            comments_text_list = video_data.get("comments", [])
+            video_title = video_data.get("title", "Video Title Not Found")
+            print(
+                f"DEBUG (streamlit_app.py): Received title from youtube.py: '{video_title}'"
+            )
+
+        # Check if we actually got any comments
+        if not comments_text_list:
+            st.warning(
+                "Hmm, no comments found for this video. Are comments enabled? Or is it a very new video?"
+            )
+            # Provide a default empty summary structure
+            summary_data = {
+                "num_comments_fetched": 0,
+                "num_comments_analyzed": 0,
+                "positive": 0,
+                "neutral": 0,
+                "negative": 0,
+                "positive_percentage": 0,
+                "neutral_percentage": 0,
+                "negative_percentage": 0,
+                "num_valid_predictions": 0,
+            }
+            return {"summary": summary_data, "comments_data": []}
+
+        st.info(
+            f"Great! Found {len(comments_text_list)} comments. Now thinking about their feelings (sentiments)..."
+        )
+        # Another spinner for the prediction part, as this can be slow on CPU
+        with st.spinner("Analyzing sentiments with the model... Please wait."):
+            # This calls predict_sentiments from predict.py
+            # Expected to return: ["positive", "negative", "neutral", ...]
+            prediction_results = predict_sentiments(comments_text_list)
+
+        positive_count = 0
+        negative_count = 0
+        neutral_count = 0
+        error_count = 0
+
+        for result in prediction_results:
+            label = result.get("label")
+            if label == "positive":
+                positive_count += 1
+            elif label == "negative":
+                negative_count += 1
+            elif label == "neutral":
+                neutral_count += 1
+            else:
+                error_count += 1
+
+        num_valid_predictions = positive_count + negative_count + neutral_count
+        total_comments_processed = len(prediction_results)
+        if error_count > 0:
+            st.warning(
+                f"Could not predict sentiment properly for {error_count} comments."
+            )
+
+        summary_data = {
+            "video_title": video_title,
+            "num_comments_fetched": len(comments_text_list),
+            "num_comments_analyzed": total_comments_processed,
+            "num_valid_predictions": num_valid_predictions,
+            "positive": positive_count,
+            "negative": negative_count,
+            "neutral": neutral_count,
+            "positive_percentage": (
+                (positive_count / num_valid_predictions) * 100
+                if num_valid_predictions > 0
+                else 0
+            ),
+            "neutral_percentage": (
+                (neutral_count / num_valid_predictions) * 100
+                if num_valid_predictions > 0
+                else 0
+            ),
+            "negative_percentage": (
+                (negative_count / num_valid_predictions) * 100
+                if num_valid_predictions > 0
+                else 0
+            ),
+        }
+
+        comments_data_for_df = []
+        for i in range(len(comments_text_list)):
+            comment_text = comments_text_list[i]
+            result = prediction_results[i]
+            label = result.get("label", "Error")
+            scores = result.get("scores", {})
+            confidence = max(scores.values()) if scores else 0.0
+
+            comments_data_for_df.append(
+                {
+                    "Comment Text": comment_text,
+                    "Predicted Sentiment": label,
+                    "Confidence": confidence,
+                    # "All Scores": scores
+                }
+            )
+
+        return {"summary": summary_data, "comments_data": comments_data_for_df}
+
+    except Exception as e:
+        # Show a general error if anything unexpected happens
+        st.error(f"Uh oh! An error popped up during analysis: {str(e)}")
+        # Also print to console for more detailed debugging when running locally
+        print(f"Full error in analyze_youtube_video: {e}")
+        import traceback
+
+        traceback.print_exc()  # Print full traceback to console
+        return None  # Return None on error
+
+
+# --- Streamlit App UI ---
+
+# Page configuration: Set to centered layout (default) instead of "wide"
+st.set_page_config(page_title="Social Sentiment Analysis", layout="centered")
+
+st.title("📊 SOCIAL SENTIMENT ANALYSIS")
+# A little description for the user
+st.write(
+    """
+    Welcome to the **Social Sentiment Analyzer!** 👋
+
+    This application uses a fine-tuned RoBERTa model to predict the sentiment (Positive, Neutral, or Negative) expressed in text.
+
+    Use the tabs below to choose your input method:
+    * **Analyze Text Input:** Paste or type any English text directly.
+    * **YouTube Analysis:** Enter a YouTube video URL or ID to analyze its comments.
+    * **Twitter/X Analysis:** Support for analyzing Twitter/X posts is coming soon!
+
+    Select a tab to begin!
+    """
+)
+
+# Tabs for different platforms, makes it easy to add Twitter later
+tab_text_input, tab_youtube, tab_twitter = st.tabs(
+    ["Analyze Text Input", "YouTube Analysis", "Twitter/X Analysis (Coming Soon!)"]
+)
+
+with tab_text_input:
+    # Header for this tab
+    st.header("Analyze Sentiment of Your Text")
+    st.write(
+        "Enter a sentence or a short paragraph below to see its predicted sentiment distribution."
+    )
+
+    # Use text_area for potentially longer input
+    # Giving it a unique key helps maintain state if needed
+    user_text = st.text_area(
+        "Enter text here:",
+        key="text_input_area_key",
+        height=100,
+        placeholder="Type or paste your text...",
+    )
+
+    # Button to trigger the analysis
+    if st.button("Analyze Text", key="text_input_analyze_btn"):
+        # Check if the user actually entered something (not just whitespace)
+        if user_text and not user_text.isspace():
+            # Show a spinner while processing
+            with st.spinner("Analyzing your text..."):
+                try:
+                    # Call the prediction function from predict.py
+                    # Pass the input text as a list with one element
+                    prediction_results = predict_sentiments([user_text])
+
+                    # Check if prediction was successful and returned expected format
+                    if (
+                        prediction_results
+                        and isinstance(prediction_results, list)
+                        and len(prediction_results) > 0
+                    ):
+                        # Get the result dictionary for the single input text
+                        result = prediction_results[0]
+                        predicted_label = result.get("label")
+                        scores = result.get(
+                            "scores"
+                        )  # This should be a dict like {'negative': 0.1, ...}
+
+                        # Make sure we got a valid label and scores dictionary
+                        if (
+                            predicted_label
+                            and scores
+                            and isinstance(scores, dict)
+                            and predicted_label != "Error"
+                        ):
+
+                            # Display the top predicted sentiment
+                            st.subheader("Predicted Sentiment:")
+                            # Using Streamlit's built-in status elements for color
+                            if predicted_label == "positive":
+                                st.success(
+                                    f"The model thinks the sentiment is: **{predicted_label.capitalize()}** 👍"
+                                )
+                            elif predicted_label == "negative":
+                                st.error(
+                                    f"The model thinks the sentiment is: **{predicted_label.capitalize()}** 👎"
+                                )
+                            else:  # Neutral or potentially "Unknown" if mapping failed
+                                st.info(
+                                    f"The model thinks the sentiment is: **{predicted_label.capitalize()}** 😐"
+                                )
+
+                            st.write("---")  # Adding a small separator
+                            st.subheader(
+                                "Detailed Probabilities:"
+                            )  # Subheader for this section
+                            if scores and isinstance(scores, dict):
+                                # Using columns here helps align the probabilities nicely
+                                prob_col_neg, prob_col_neu, prob_col_pos = st.columns(3)
+
+                                # Helper to get score safely
+                                def get_score(sentiment_name):
+                                    return scores.get(
+                                        sentiment_name.lower(), 0.0
+                                    )  # Use lowercase to be safe
+
+                                value_font_size = "22px"
+                                value_font_weight = "bold"
+
+                                with prob_col_neg:
+                                    neg_prob = get_score("negative")
+                                    # Display label "Negative"
+                                    st.markdown("**Negative 👎:**")
+                                    # Display the probability, larger font, red color
+                                    st.markdown(
+                                        f"<p style='font-size: {value_font_size}; font-weight: {value_font_weight}; color:red;'>{neg_prob:.1%}</p>",
+                                        unsafe_allow_html=True,
+                                    )
+
+                                with prob_col_neu:
+                                    neu_prob = get_score("neutral")
+                                    # Display label "Neutral"
+                                    st.markdown("**Neutral 😐:**")
+                                    # Display the probability, larger font, grey color
+                                    st.markdown(
+                                        f"<p style='font-size: {value_font_size}; font-weight: {value_font_weight}; color:grey;'>{neu_prob:.1%}</p>",
+                                        unsafe_allow_html=True,
+                                    )
+
+                                with prob_col_pos:
+                                    pos_prob = get_score("positive")
+                                    # Display label "Positive"
+                                    st.markdown("**Positive 👍:**")
+                                    # Display the probability, larger font, green color
+                                    st.markdown(
+                                        f"<p style='font-size: {value_font_size}; font-weight: {value_font_weight}; color:green;'>{pos_prob:.1%}</p>",
+                                        unsafe_allow_html=True,
+                                    )
+
+                            else:
+                                # If scores dict is missing or invalid
+                                st.write("Could not retrieve probability scores.")
+                            st.write("---")  # Another separator before the chart
+
+                            # --- Display Pie Chart of Probabilities ---
+                            st.subheader("Sentiment Probabilities:")
+                            if PLOTLY_AVAILABLE:
+                                # Convert the scores dictionary to a DataFrame suitable for Plotly
+                                # Ensure keys match class_names for consistency if possible
+                                # Assuming scores keys are 'negative', 'neutral', 'positive'
+                                score_items = list(scores.items())
+                                if score_items:  # Check if scores dict is not empty
+                                    df_scores = pd.DataFrame(
+                                        score_items,
+                                        columns=["Sentiment", "Probability"],
+                                    )
+                                    # Convert Probability to numeric just in case
+                                    df_scores["Probability"] = pd.to_numeric(
+                                        df_scores["Probability"]
+                                    )
+
+                                    # Define colors (ensure keys match Sentiment names case)
+                                    color_map = {
+                                        "positive": "green",
+                                        "neutral": "grey",
+                                        "negative": "red",
+                                    }
+                                    # Make keys lowercase for robust mapping
+                                    df_scores["Sentiment"] = df_scores[
+                                        "Sentiment"
+                                    ].str.capitalize()
+                                    df_scores["Sentiment_Lower"] = df_scores[
+                                        "Sentiment"
+                                    ].str.lower()
+                                    color_map_lower = {
+                                        k.lower(): v for k, v in color_map.items()
+                                    }
+
+                                    # Debug print for the dataframe fed to plotly
+                                    # st.write("DEBUG: DataFrame for text input pie chart:")
+                                    # st.dataframe(df_scores)
+
+                                    try:
+                                        # Create the pie chart
+                                        fig_pie_text = px.pie(
+                                            df_scores,
+                                            values="Probability",  # Use the probability column
+                                            names="Sentiment",  # Labels for the slices
+                                            title="Probability Distribution per Class",
+                                            color="Sentiment_Lower",  # Use lowercase for mapping
+                                            color_discrete_map=color_map_lower,
+                                        )  # Map colors
+
+                                        # Update how text is shown on slices
+                                        fig_pie_text.update_traces(
+                                            textposition="inside",
+                                            textinfo="percent+label",
+                                            hovertemplate="Sentiment: %{label}<br>Probability: %{percent}",
+                                        )
+                                        # Maybe add hover info too
+                                        fig_pie_text.update_layout(
+                                            uniformtext_minsize=16,
+                                            uniformtext_mode="hide",
+                                        )  # Improve text fitting
+
+                                        st.plotly_chart(
+                                            fig_pie_text, use_container_width=True
+                                        )
+
+                                    except Exception as plot_e:
+                                        st.error(
+                                            f"Sorry, couldn't create the probability pie chart: {str(plot_e)}"
+                                        )
+                                        print(
+                                            f"Full error during text input Plotly chart generation: {plot_e}"
+                                        )
+                                        import traceback
+
+                                        traceback.print_exc()
+                                        st.write(
+                                            "Raw scores:", scores
+                                        )  # Show raw scores as fallback
+
+                                else:  # If scores dictionary was empty
+                                    st.warning(
+                                        "Received empty scores, cannot plot chart."
+                                    )
+
+                            elif not PLOTLY_AVAILABLE:
+                                st.warning(
+                                    "Plotly not installed, cannot display pie chart. Showing raw scores instead."
+                                )
+                                st.json(
+                                    scores
+                                )  # Display raw scores as JSON if no Plotly
+                            else:
+                                # This case should be covered by the check above, but for safety
+                                st.write("No valid score data available to plot.")
+                            # --- End Pie Chart ---
+
+                        else:
+                            # This handles cases where predict_sentiments returned an error label
+                            st.error(
+                                f"Sentiment analysis failed for the input text. Result: {result}"
+                            )
+
+                    else:
+                        # This handles cases where predict_sentiments returned None or empty list
+                        st.error(
+                            "Received no valid result from the prediction function."
+                        )
+
+                except Exception as analysis_e:
+                    # Catch-all for other errors during analysis for this tab
+                    st.error(
+                        f"An error occurred during text analysis: {str(analysis_e)}"
+                    )
+                    print(f"Full error during text input analysis: {analysis_e}")
+                    import traceback
+
+                    traceback.print_exc()
+
+        else:
+            # If user clicks button without entering text
+            st.warning("Please enter some text in the text area first!")
+
+with tab_youtube:
+    st.header("YouTube Comment Sentiment Analyzer")
+    # Input field for URL or ID
+    video_url_input = st.text_input(
+        "Enter YouTube Video URL or Video ID:",
+        key="youtube_url_input_key",  # Giving it a unique key
+        placeholder="e.g., Z9kGRMglw-I or full URL",
+    )
+
+    # Button to trigger analysis
+    if st.button("Analyze YouTube Comments", key="youtube_analyze_button_key"):
+        if video_url_input:  # Check if user actually entered something
+            # analyze_youtube_video handles spinners internally now
+            analysis_results = analyze_youtube_video(video_url_input)
+
+            if (
+                analysis_results and analysis_results["summary"]
+            ):  # Check if we got valid results
+                summary = analysis_results["summary"]
+                comments_data = analysis_results["comments_data"]
+                video_title_display = summary.get(
+                    "video_title", "Video Title Not Available"
+                )
+
+                st.markdown("---")
+                # Displaying the video title using markdown for potential formatting later
+                st.markdown(f"### Analyzing Video: **{video_title_display}**")
+                st.markdown("---")
+
+                st.subheader("📊 Sentiment Summary")
+
+                # Define desired font sizes (you can adjust these)
+                # label_font_size = (
+                #     "24px"  # Font size for the label text like "Comments Fetched"
+                # )
+                label_font_size = "24px"
+                value_font_size = "28px"  # Font size for the actual count like "137"
+                value_font_weight = "bold"  # Make the count bold
+
+                # Define colors for the sentiment counts
+                positive_color = "green"
+                neutral_color = "grey"
+                negative_color = "red"
+
+                # Using 5 columns
+                col_fetched, col_analyzed, col_pos, col_neu, col_neg = st.columns(5)
+
+                # Metric 1: Comments Fetched
+                with col_fetched:
+                    # Label for fetched comments
+                    st.markdown(
+                        f"<p style='font-size: {label_font_size}; margin-bottom: 0px;'>Comments Fetched</p>",
+                        unsafe_allow_html=True,
+                    )
+                    # The number of fetched comments
+                    st.markdown(
+                        f"<p style='font-size: {value_font_size}; font-weight: {value_font_weight}; margin-top: 0px;'>{summary.get('num_comments_fetched', 0)}</p>",
+                        unsafe_allow_html=True,
+                    )
+
+                # Metric 2: Comments Analyzed
+                with col_analyzed:
+                    # Label for analyzed comments
+                    st.markdown(
+                        f"<p style='font-size: {label_font_size}; margin-bottom: 0px;'>Comments Analyzed</p>",
+                        unsafe_allow_html=True,
+                    )
+                    # The number of analyzed comments
+                    st.markdown(
+                        f"<p style='font-size: {value_font_size}; font-weight: {value_font_weight}; margin-top: 0px;'>{summary.get('num_comments_analyzed', 0)}</p>",
+                        unsafe_allow_html=True,
+                    )
+
+                # Metric 3: Positive
+                with col_pos:
+                    # Label for positive comments, with emoji
+                    st.markdown(
+                        f"<p style='font-size: {label_font_size}; margin-bottom: 0px;'>Positive 👍</p>",
+                        unsafe_allow_html=True,
+                    )
+                    # The count of positive comments, green and bold
+                    st.markdown(
+                        f"<p style='font-size: {value_font_size}; font-weight: {value_font_weight}; color:{positive_color}; margin-top: 0px;'>{summary.get('positive', 0)}</p>",
+                        unsafe_allow_html=True,
+                    )
+
+                # Metric 4: Neutral
+                with col_neu:
+                    # Label for neutral comments
+                    st.markdown(
+                        f"<p style='font-size: {label_font_size}; margin-bottom: 0px;'>Neutral 😐</p>",
+                        unsafe_allow_html=True,
+                    )
+                    # The count of neutral comments, grey and bold
+                    st.markdown(
+                        f"<p style='font-size: {value_font_size}; font-weight: {value_font_weight}; color:{neutral_color}; margin-top: 0px;'>{summary.get('neutral', 0)}</p>",
+                        unsafe_allow_html=True,
+                    )
+
+                # Metric 5: Negative
+                with col_neg:
+                    # Label for negative comments
+                    st.markdown(
+                        f"<p style='font-size: {label_font_size}; margin-bottom: 0px;'>Negative 👎</p>",
+                        unsafe_allow_html=True,
+                    )
+                    # The count of negative comments, red and bold
+                    st.markdown(
+                        f"<p style='font-size: {value_font_size}; font-weight: {value_font_weight}; color:{negative_color}; margin-top: 0px;'>{summary.get('negative', 0)}</p>",
+                        unsafe_allow_html=True,
+                    )
+
+                # Add a visual separator before charts
+                st.markdown("---")
+
+                # Data for charts - make sure it has counts > 0
+                if summary.get("num_valid_predictions", 0) > 0:
+                    # Prepare DataFrame for Plotly charts
+                    sentiment_data_for_plot = [
+                        {"Sentiment": "Positive", "Count": summary.get("positive", 0)},
+                        {"Sentiment": "Neutral", "Count": summary.get("neutral", 0)},
+                        {"Sentiment": "Negative", "Count": summary.get("negative", 0)},
+                    ]
+                    sentiment_counts_df = pd.DataFrame(sentiment_data_for_plot)
+                    # Filter out rows where Count is 0 for cleaner charts
+                    sentiment_counts_df_for_plot = sentiment_counts_df[
+                        sentiment_counts_df["Count"] > 0
+                    ].copy()
+
+                    # Define the color map for charts
+                    # Keys should match the 'Sentiment' column values
+                    color_map = {
+                        "Positive": "green",
+                        "Neutral": "grey",
+                        "Negative": "red",
+                    }
+
+                    if not sentiment_counts_df_for_plot.empty:
+                        st.subheader("📈 Sentiment Distribution Charts")
+                        # Try to use Plotly for richer charts
+                        if PLOTLY_AVAILABLE:
+                            try:
+                                # Pie Chart (Corrected data input for Plotly)
+                                # Plotly pie chart expects a DataFrame where one column is values, another is names
+                                fig_pie = px.pie(
+                                    sentiment_counts_df_for_plot,  # Use the filtered DataFrame
+                                    values="Count",  # Column for pie slice values
+                                    names="Sentiment",  # Column for pie slice names
+                                    title="Pie Chart: Comment Sentiments",
+                                    color="Sentiment",  # Color slices based on the 'Sentiment' category
+                                    color_discrete_map=color_map,
+                                )  # Apply custom colors
+
+                                fig_pie.update_traces(
+                                    textposition="inside",
+                                    textinfo="percent+label",
+                                    hovertemplate="Sentiment: %{label}<br>Count: %{value}<br>Percentage: %{percent}",
+                                )
+
+                                fig_pie.update_layout(
+                                    uniformtext_minsize=16, uniformtext_mode="hide"
+                                )
+
+                                st.plotly_chart(fig_pie, use_container_width=True)
+
+                                # Bar Chart (Using Plotly for consistent coloring)
+                                fig_bar = px.bar(
+                                    sentiment_counts_df_for_plot,  # Use the filtered DataFrame
+                                    x="Sentiment",  # Categories on X-axis
+                                    y="Count",  # Values on Y-axis
+                                    title="Bar Chart: Comment Sentiments",
+                                    color="Sentiment",  # Color bars based on 'Sentiment'
+                                    color_discrete_map=color_map,  # Apply custom colors
+                                    labels={
+                                        "Count": "Number of Comments",
+                                        "Sentiment": "Sentiment Category",
+                                    },
+                                )  # Custom labels
+                                st.plotly_chart(fig_bar, use_container_width=True)
+
+                            except Exception as plot_e:
+                                # Fallback if Plotly fails for some reason other than import
+                                st.error(
+                                    f"Sorry, couldn't create Plotly charts: {plot_e}"
+                                )
+                                st.write(
+                                    "Displaying basic bar chart instead (default colors):"
+                                )
+                                st.bar_chart(
+                                    sentiment_counts_df.set_index("Sentiment")
+                                )  # Fallback with original (unfiltered for bar)
+                        else:
+                            # Fallback to Streamlit's basic bar chart if Plotly is not installed
+                            st.write(
+                                "Displaying basic bar chart (Plotly not installed):"
+                            )
+                            st.bar_chart(
+                                sentiment_counts_df.set_index("Sentiment")
+                            )  # Basic bar chart
+                    else:
+                        # This message shows if all sentiment counts are zero
+                        st.write(
+                            "No sentiment data (Positive, Neutral, Negative all zero) to display in charts."
+                        )
+                else:
+                    # This message shows if no comments were analyzed successfully
+                    st.write(
+                        "Not enough valid sentiment data to display distribution charts."
+                    )
+
+                # Display comments and their sentiments
+                if comments_data:
+                    st.subheader(
+                        f"🔍 Analyzed Comments (showing first {len(comments_data)} results)"
+                    )
+                    comments_display_df = pd.DataFrame(comments_data)
+
+                    if "Confidence" in comments_display_df.columns:
+                        try:
+                            # Format as percentage with 1 decimal place
+                            comments_display_df["Confidence"] = comments_display_df[
+                                "Confidence"
+                            ].map("{:.1%}".format)
+                        except (TypeError, ValueError):
+                            st.warning(
+                                "Could not format confidence scores."
+                            )  # Handle potential errors if confidence is not numeric
+
+                    st.dataframe(
+                        comments_display_df, use_container_width=True, height=400
+                    )
+                else:
+                    st.write("No comments were analyzed to display.")
+            # else: # analyze_youtube_video already handles its own errors by showing st.error
+            #    st.info("Could not complete analysis. Please check the URL or try again.")
+        else:
+            # If user clicks button without entering URL
+            st.warning("Please enter a YouTube URL or Video ID first!")
+
+with tab_twitter:
+    st.header("Twitter/X Post Analysis")
+    st.info("This feature is currently under construction. Please check back later!")
+    # Placeholder for future Twitter input
+    # twitter_url_input = st.text_input("Enter Twitter/X Post URL:", key="twitter_url_input_key")
+    # if st.button("Analyze Tweets", key="twitter_analyze_button_key"):
+    #     st.write("Imagine amazing Twitter analysis happening here... Tweet tweet!")

src/youtube.py

@@ -1,21 +1,14 @@
 import os
 import googleapiclient.discovery
 import googleapiclient.errors
+from dotenv import load_dotenv
 
 # from dotenv import load_dotenv
 import streamlit as st
 
-# load_dotenv()
-# api_key = os.getenv("API_KEY")
+load_dotenv()
+api_key = os.getenv("API_KEY")
 # api_key = st.secrets["API_KEY"]
-try:
-    api_key = os.environ["API_KEY"]
-    # Sử dụng api_key ở đây
-except KeyError:
-    st.error(
-        "Lỗi: Secret 'API_KEY' chưa được cấu hình trong Hugging Face Space Settings."
-    )
-    st.stop()  # Hoặc xử lý lỗi theo cách khác
 
 
 def get_comments(youtube, **kwargs):