update app

src/streamlit_app.py

@@ -1,709 +0,0 @@
-# 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 predict import (
-        predict_sentiments,
-    )  # This function should return list of strings: "positive", "negative", "neutral"
-    from 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!")