Upload 2 files

requirements.txt

@@ -0,0 +1,13 @@
+gradio
+pandas
+numpy
+matplotlib
+seaborn
+plotly
+wordcloud
+textblob
+scikit-learn
+openpyxl
+Pillow
+transformers
+keybert

understanding_public_sentiment_on_the_new_distance_based_fare_system.py

@@ -0,0 +1,833 @@
+
+# Importing the requirements libraries
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import io
+import base64
+import random
+from datetime import datetime, timedelta
+from collections import Counter
+import gradio as gr
+from wordcloud import WordCloud
+import os
+
+from transformers import pipeline
+from keybert import KeyBERT
+
+# Initialize selected models suitable for this task
+classifier = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")
+kw_model = KeyBERT()
+
+# Label mapping, naming them and initialize color according to category
+sentiment_map = {
+    "LABEL_0": "Negative", "LABEL_1": "Neutral", "LABEL_2": "Positive",
+    "negative": "Negative", "neutral": "Neutral", "positive": "Positive",
+    "NEGATIVE": "Negative", "NEUTRAL": "Neutral", "POSITIVE": "Positive"
+}
+color_map = {"Positive": "#2E8B57", "Neutral": "#4682B4", "Negative": "#CD5C5C"}
+
+# Default comments for when no file is uploaded
+comments = [
+    "This new distance fare is really fair. I pay less for short trips!",
+    "It's confusing, I don't know how much I'll pay now.",
+    "RURA should have informed us better about this change.",
+    "Good step towards fairness and modernization.",
+    "Too expensive now! I hate this new system.",
+    "The distance-based system makes so much more sense than flat rates.",
+    "Why should I pay the same for 1km as I would for 10km? This is better.",
+    "Finally a fair system — short-distance commuters benefit the most!",
+    "I'm still unsure how the new rates are calculated. Needs clarity.",
+    "A detailed public awareness campaign would have helped a lot.",
+    "Smart move toward a fairer system, but more awareness is needed.",
+    "I'm paying more now and it feels unjust.",
+    "Flat rates were easier to understand, but this is more logical.",
+    "Paying based on distance is reasonable, but it needs fine-tuning.",
+    "App crashes when I try to calculate my fare. Fix it!",
+    "Drivers are confused about the new system too.",
+    "Great initiative but poor implementation.",
+    "Now I know exactly what I'm paying for. Transparent and fair.",
+    "The fare calculator is very helpful.",
+    "Bus company profits will increase, but what about us passengers?",
+    "I've noticed faster service since the new system launched.",
+    "Rural areas are being charged too much now.",
+    "The new system is making my daily commute more expensive.",
+    "Distance-based fares are the future of transportation.",
+    "I appreciate the transparency but the app needs work.",
+    "This discriminates against people living in rural areas!",
+    "My transportation costs have decreased by 30%!",
+    "We should go back to the old system immediately.",
+    "Kids going to school are now paying more, this is unfair.",
+    "The government did a good job explaining the benefits.",
+    "I've waited years for a fair pricing system like this.",
+    "Very impressed with the new fare calculation technology.",
+    "The app is too complicated for elderly passengers.",
+    "The transition period should have been longer.",
+    "I find the new fare calculator very intuitive.",
+    "This is just another way to extract more money from us.",
+    "Love how I can now predict exactly what my trip will cost.",
+    "The implementation was rushed without proper testing.",
+    "Prices vary too much depending on traffic congestion.",
+    "Works well in urban areas but rural commuters are suffering.",
+    "I've downloaded the fare calculator app - it's brilliant!",
+    "Taxi drivers are confused about calculating fares correctly."
+]
+
+# Global variable to hold the current dataframe
+global_df = None
+
+# Function to generate default dataset from predefined comments
+
+def generate_default_df():
+    global global_df
+    default_data = []
+    start_time = datetime.now() - timedelta(hours=24)
+
+    for i, comment in enumerate(comments):
+        timestamp = start_time + timedelta(hours=random.uniform(0, 24))
+
+        # Analyze sentiment
+        result = classifier(comment)[0]
+        sentiment = sentiment_map[result["label"]]
+        score = round(result["score"], 3)
+
+        # Extract keywords
+        try:
+            keywords = kw_model.extract_keywords(comment, top_n=3)
+            keyword_str = ", ".join([kw[0] for kw in keywords]) if keywords else "N/A"
+        except:
+            keyword_str = "N/A"
+
+        default_data.append({
+            "Datetime": timestamp,
+            "Text": comment,
+            "Sentiment": sentiment,
+            "Score": score,
+            "Keywords": keyword_str
+        })
+
+    default_df = pd.DataFrame(default_data)
+    default_df["Datetime"] = pd.to_datetime(default_df["Datetime"])
+    default_df["Datetime"] = default_df["Datetime"].dt.floor("1H")
+    global_df = default_df.sort_values("Datetime").reset_index(drop=True)
+    return global_df
+
+# Function to process uploaded CSV or Excel file and analyze sentiment
+
+def process_uploaded_file(file):
+    global global_df
+
+    if file is None:
+        global_df = generate_default_df()
+        return global_df
+
+    try:
+        # Read the uploaded file
+        if file.name.endswith('.csv'):
+            user_df = pd.read_csv(file.name)
+        elif file.name.endswith('.xlsx'):
+            user_df = pd.read_excel(file.name)
+        else:
+            raise ValueError("Unsupported file type. Please upload CSV or Excel files only.")
+
+        # Check required columns
+        if 'Text' not in user_df.columns:
+            raise ValueError("File must contain a 'Text' column with comments.")
+
+        # Handle datetime - create if not exists
+        if 'Datetime' not in user_df.columns:
+            # Generate timestamps for uploaded data
+            start_time = datetime.now() - timedelta(hours=len(user_df))
+            user_df['Datetime'] = [start_time + timedelta(hours=i) for i in range(len(user_df))]
+
+        # Clean and prepare data
+        user_df = user_df[['Datetime', 'Text']].copy()
+        user_df["Datetime"] = pd.to_datetime(user_df["Datetime"])
+        user_df["Datetime"] = user_df["Datetime"].dt.floor("1H")
+        user_df = user_df.dropna(subset=['Text'])
+
+        # Analyze sentiment and extract keywords for each comment
+        sentiments = []
+        scores = []
+        keywords_list = []
+
+        for text in user_df["Text"]:
+            try:
+                # Sentiment analysis
+                result = classifier(str(text))[0]
+                sentiment = sentiment_map[result['label']]
+                score = round(result['score'], 3)
+
+                # Keyword extraction
+                keywords = kw_model.extract_keywords(str(text), top_n=3)
+                keyword_str = ", ".join([kw[0] for kw in keywords]) if keywords else "N/A"
+
+                sentiments.append(sentiment)
+                scores.append(score)
+                keywords_list.append(keyword_str)
+            except Exception as e:
+                print(f"Error processing text: {e}")
+                sentiments.append("Neutral")
+                scores.append(0.5)
+                keywords_list.append("N/A")
+
+        user_df["Sentiment"] = sentiments
+        user_df["Score"] = scores
+        user_df["Keywords"] = keywords_list
+
+        global_df = user_df.sort_values("Datetime").reset_index(drop=True)
+        return global_df
+
+    except Exception as e:
+        print(f"Error processing file: {str(e)}")
+        global_df = generate_default_df()
+        return global_df
+
+# Function to wrapper function for file analysis to update dataframe display
+
+def get_analysis_dataframe(file):
+    return process_uploaded_file(file)
+
+# Function to analyze a single comment and return sentiment and keywords
+
+def analyze_text(comment):
+    if not comment or not comment.strip():
+        return "N/A", 0, "N/A"
+
+    try:
+        result = classifier(comment)[0]
+        sentiment = sentiment_map.get(result["label"], result["label"])
+        score = result["score"]
+
+        keywords = kw_model.extract_keywords(comment, top_n=3, keyphrase_ngram_range=(1, 2))
+        keywords_str = ", ".join([kw[0] for kw in keywords]) if keywords else "N/A"
+
+        return sentiment, score, keywords_str
+    except Exception as e:
+        print(f"Error analyzing text: {e}")
+        return "Error", 0, "Error processing text"
+
+# Function to add analyzed comment to global dataframe
+
+def add_to_dataframe(comment, sentiment, score, keywords):
+
+    global global_df
+    timestamp = datetime.now().replace(microsecond=0)
+
+    new_row = pd.DataFrame([{
+        "Datetime": timestamp,
+        "Text": comment,
+        "Sentiment": sentiment,
+        "Score": score,
+        "Keywords": keywords
+    }])
+
+    global_df = pd.concat([global_df, new_row], ignore_index=True)
+    return global_df
+
+# Function to generate and display a simple word cloud based on sentiment filter
+
+def create_wordcloud_simple(df, sentiment_filter=None):
+    if df is None or df.empty:
+        return None
+
+    # Filter by sentiment if provided
+    if sentiment_filter and sentiment_filter != "All":
+        filtered_df = df[df["Sentiment"] == sentiment_filter]
+    else:
+        filtered_df = df
+
+    if filtered_df.empty:
+        print("No data available for the selected sentiment.")
+        return None
+
+    # Combine keywords into a single string
+    keyword_text = filtered_df["Keywords"].fillna("").str.replace("N/A", "").str.replace(",", " ")
+    all_keywords = " ".join(keyword_text)
+
+    if not all_keywords.strip():
+        print("No valid keywords to display in word cloud.")
+        return None
+
+    # Select colormap based on sentiment
+    colormap = "viridis"
+    if sentiment_filter == "Positive":
+        colormap = "Greens"
+    elif sentiment_filter == "Neutral":
+        colormap = "Blues"
+    elif sentiment_filter == "Negative":
+        colormap = "Reds"
+
+    # Create the word cloud
+    wordcloud = WordCloud(
+        background_color='white',
+        colormap=colormap,
+        max_words=100,
+        width=800,
+        height=400
+    ).generate(all_keywords)
+
+    # Convert to image for Gradio
+    return wordcloud.to_image()
+
+# Function to create a timeline visualization showing comment volume by sentiment over time
+
+def plot_sentiment_timeline(df):
+    if df is None or df.empty:
+        return go.Figure().update_layout(title="No data available", height=400)
+
+    try:
+        # Process datetime
+        df_copy = df.copy()
+        df_copy["Datetime"] = pd.to_datetime(df_copy["Datetime"])
+        df_copy["Time_Bin"] = df_copy["Datetime"].dt.floor("1H")
+
+        # Group by time and sentiment
+        grouped = (
+            df_copy.groupby(["Time_Bin", "Sentiment"])
+            .agg(
+                Count=("Text", "count"),
+                Score=("Score", "mean"),
+                Keywords=("Keywords", lambda x: ", ".join(set(", ".join(x).split(", "))) if len(x) > 0 else "")
+            )
+            .reset_index()
+        )
+
+        # Create plot
+        fig = go.Figure()
+
+        # Add a line for each sentiment
+        for sentiment, color in color_map.items():
+            sentiment_df = grouped[grouped["Sentiment"] == sentiment]
+            if sentiment_df.empty:
+                continue
+
+            fig.add_trace(
+                go.Scatter(
+                    x=sentiment_df["Time_Bin"],
+                    y=sentiment_df["Count"],
+                    mode='lines+markers',
+                    name=sentiment,
+                    line=dict(color=color, width=3),
+                    marker=dict(size=6, color=color),
+                    text=sentiment_df["Keywords"],
+                    hovertemplate='<b>%{y} comments</b><br>%{x}<br><b>Keywords:</b> %{text}<extra></extra>'
+                )
+            )
+
+        # Layout updates
+        fig.update_layout(
+            title="Sentiment Analysis  (1-Hour Intervals)",
+            height=500,
+            xaxis=dict(
+                title="Time",
+                tickformat="%Y-%m-%d %H:%M"
+            ),
+            yaxis_title="Number of Comments",
+            template="plotly_white"
+        )
+
+        return fig
+
+    except Exception as e:
+        print(f"Error in timeline plot: {e}")
+        return go.Figure().update_layout(
+            title="Error creating timeline visualization",
+            height=400
+        )
+
+# Function to create a dual-view visualization of sentiment distribution
+
+def plot_sentiment_distribution(df):
+    if df is None or df.empty:
+        return go.Figure().update_layout(title="No data available", height=400)
+
+    try:
+        # Group sentiment counts
+        sentiment_counts = df["Sentiment"].value_counts().reset_index()
+        sentiment_counts.columns = ["Sentiment", "Count"]
+        sentiment_counts["Percentage"] = sentiment_counts["Count"] / sentiment_counts["Count"].sum() * 100
+
+        # Create subplots
+        fig = make_subplots(
+            rows=1, cols=2,
+            specs=[[{"type": "domain"}, {"type": "xy"}]],
+            subplot_titles=("Sentiment Distribution", "Sentiment Counts"),
+            column_widths=[0.5, 0.5]
+        )
+
+        # Pie Chart
+        fig.add_trace(
+            go.Pie(
+                labels=sentiment_counts["Sentiment"],
+                values=sentiment_counts["Count"],
+                textinfo="percent+label",
+                marker=dict(colors=[color_map.get(s, "#999999") for s in sentiment_counts["Sentiment"]]),
+                hole=0.4
+            ),
+            row=1, col=1
+        )
+
+        # Bar Chart
+        fig.add_trace(
+            go.Bar(
+                x=sentiment_counts["Sentiment"],
+                y=sentiment_counts["Count"],
+                text=sentiment_counts["Count"],
+                textposition="auto",
+                marker_color=[color_map.get(s, "#999999") for s in sentiment_counts["Sentiment"]]
+            ),
+            row=1, col=2
+        )
+
+        # Update layout
+        fig.update_layout(
+            title="Sentiment Distribution Overview",
+            height=450,
+            template="plotly_white",
+            showlegend=False
+        )
+
+        return fig
+
+    except Exception as e:
+        print(f"Error in distribution plot: {e}")
+        return go.Figure().update_layout(
+            title="Error creating distribution visualization",
+            height=450
+        )
+
+# Function to create a grouped bar chart visualization of the top keywords across sentiments
+
+def plot_keyword_analysis(df):
+    if df is None or df.empty:
+        return go.Figure().update_layout(title="No data available", height=400)
+
+    try:
+        all_keywords = []
+
+        # Process each sentiment
+        for sentiment in ["Positive", "Neutral", "Negative"]:
+            sentiment_df = df[df["Sentiment"] == sentiment]
+            if sentiment_df.empty:
+                continue
+
+            # Extract and flatten keyword lists
+            for keywords_str in sentiment_df["Keywords"].dropna():
+                if keywords_str and keywords_str.upper() != "N/A":
+                    keywords = [kw.strip() for kw in keywords_str.split(",") if kw.strip()]
+                    for kw in keywords:
+                        all_keywords.append((kw, sentiment))
+
+        if not all_keywords:
+            return go.Figure().update_layout(
+                title="No keyword data available",
+                height=500
+            )
+
+        # Create DataFrame and aggregate keyword counts
+        keywords_df = pd.DataFrame(all_keywords, columns=["Keyword", "Sentiment"])
+        keyword_counts = (
+            keywords_df.groupby(["Keyword", "Sentiment"])
+            .size()
+            .reset_index(name="Count")
+        )
+
+        # Filter top 15 keywords by overall frequency
+        top_keywords = keywords_df["Keyword"].value_counts().nlargest(15).index
+        keyword_counts = keyword_counts[keyword_counts["Keyword"].isin(top_keywords)]
+
+        # Plot grouped bar chart
+        fig = px.bar(
+            keyword_counts,
+            x="Keyword",
+            y="Count",
+            color="Sentiment",
+            color_discrete_map=color_map,
+            text="Count",
+            barmode="group",
+            labels={"Count": "Frequency", "Keyword": ""},
+            title="🔍 Top Keywords by Sentiment"
+        )
+
+        fig.update_layout(
+            legend_title="Sentiment",
+            xaxis=dict(categoryorder="total descending"),
+            yaxis=dict(title="Frequency"),
+            height=500,
+            template="plotly_white"
+        )
+
+        return fig
+
+    except Exception as e:
+        print(f"Error in keyword analysis: {e}")
+        return go.Figure().update_layout(
+            title="Error creating keyword visualization",
+            height=500
+        )
+
+# Function to generate summary sentiment metrics for dashboard visualization
+
+def create_summary_metrics(df):
+    if df is None or df.empty:
+        return {
+            "total": 0, "positive": 0, "neutral": 0, "negative": 0,
+            "positive_pct": 0.0, "neutral_pct": 0.0, "negative_pct": 0.0,
+            "sentiment_ratio": 0.0, "trend": "No data"
+        }
+
+    try:
+        total_comments = len(df)
+
+        # Count sentiments
+        sentiment_counts = df["Sentiment"].value_counts().to_dict()
+        positive = sentiment_counts.get("Positive", 0)
+        neutral = sentiment_counts.get("Neutral", 0)
+        negative = sentiment_counts.get("Negative", 0)
+
+        # Calculate percentages safely
+        def pct(count):
+            return round((count / total_comments) * 100, 1) if total_comments else 0.0
+
+        positive_pct = pct(positive)
+        neutral_pct = pct(neutral)
+        negative_pct = pct(negative)
+
+        # Sentiment ratio (Positive : Negative)
+        sentiment_ratio = round(positive / negative, 2) if negative > 0 else float('inf')
+
+        # Trend detection based on time-series sentiment evolution
+        trend = "Insufficient data"
+        if total_comments >= 5 and "Datetime" in df.columns:
+            sorted_df = df.sort_values("Datetime")
+            mid = total_comments // 2
+            first_half = sorted_df.iloc[:mid]
+            second_half = sorted_df.iloc[mid:]
+
+            # Compute positive sentiment proportion in both halves
+            first_pos_pct = (first_half["Sentiment"] == "Positive").mean()
+            second_pos_pct = (second_half["Sentiment"] == "Positive").mean()
+
+            delta = second_pos_pct - first_pos_pct
+            if delta > 0.05:
+                trend = "Improving"
+            elif delta < -0.05:
+                trend = "Declining"
+            else:
+                trend = "Stable"
+
+        return {
+            "total": total_comments,
+            "positive": positive,
+            "neutral": neutral,
+            "negative": negative,
+            "positive_pct": positive_pct,
+            "neutral_pct": neutral_pct,
+            "negative_pct": negative_pct,
+            "sentiment_ratio": sentiment_ratio,
+            "trend": trend,
+        }
+
+    except Exception as e:
+        print(f"Error in summary metrics: {e}")
+        return {
+            "total": 0, "positive": 0, "neutral": 0, "negative": 0,
+            "positive_pct": 0.0, "neutral_pct": 0.0, "negative_pct": 0.0,
+            "sentiment_ratio": 0.0, "trend": "Error calculating"
+        }
+
+# Function to analyze a single comment for the Quick Analyzer tab
+
+def gradio_analyze_comment(comment):
+
+    try:
+        if not comment or not comment.strip():
+            return "N/A", "0.0%", "N/A"
+
+        sentiment, score, keywords = analyze_text(comment)
+        score_str = f"{score * 100:.1f}%"
+
+        return sentiment, score_str, keywords
+
+    except Exception as e:
+        print(f"Error in gradio_analyze_comment: {e}")
+        return "Error", "0.0%", "Error processing comment"
+
+# Function to add a comment to the dashboard
+
+def gradio_add_comment(comment):
+    global global_df
+
+    if not comment or not comment.strip():
+        return global_df, "Please enter a comment", "", plot_sentiment_timeline(global_df), plot_sentiment_distribution(global_df), plot_keyword_analysis(global_df)
+
+    sentiment, score, keywords = analyze_text(comment)
+    updated_df = add_to_dataframe(comment, sentiment, score, keywords)
+
+    # Generate feedback message
+    feedback = f"✓ Added: {sentiment} comment (Confidence: {score*100:.1f}%)"
+
+    # Update all visualizations
+    timeline_plot = plot_sentiment_timeline(updated_df)
+    distribution_plot = plot_sentiment_distribution(updated_df)
+    keyword_plot = plot_keyword_analysis(updated_df)
+
+    return updated_df, feedback, "", timeline_plot, distribution_plot, keyword_plot
+
+# Function  to generate a word cloud image from the DataFrame
+
+def gradio_generate_wordcloud(sentiment_filter):
+    try:
+        filter_value = sentiment_filter if sentiment_filter != "All" else None
+        return create_wordcloud_simple(global_df, filter_value)
+    except Exception as e:
+        print(f"Error generating word cloud: {e}")
+        return None
+
+
+
+# Function to export the current dataframe to CSV for download
+
+def export_data_to_csv(df_component):
+    global global_df
+    try:
+        if global_df is not None and not global_df.empty:
+            csv_buffer = io.StringIO()
+            global_df.to_csv(csv_buffer, index=False)
+            csv_content = csv_buffer.getvalue()
+
+            # Save to a temporary file
+            filename = f"sentiment_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+            with open(filename, 'w', encoding='utf-8') as f:
+                f.write(csv_content)
+
+            return filename
+        else:
+            return None
+    except Exception as e:
+        print(f"Error exporting data: {e}")
+        return None
+
+
+
+# Initialize the global dataframe with default data
+
+global_df = generate_default_df()
+
+# Function to create an updated function that returns all necessary components when file is loaded
+
+def load_and_update_all_components(file):
+    global global_df
+
+    if file is None:
+        # Return current state if no file
+        metrics = create_summary_metrics(global_df)
+        return (
+            global_df,
+            metrics["total"], metrics["positive_pct"], metrics["neutral_pct"],
+            metrics["negative_pct"], metrics["sentiment_ratio"], metrics["trend"],
+            plot_sentiment_timeline(global_df), plot_sentiment_distribution(global_df),
+            plot_keyword_analysis(global_df), global_df
+        )
+
+    # Load and analyze the uploaded file
+    updated_df = get_analysis_dataframe(file)
+    metrics = create_summary_metrics(updated_df)
+
+    # Update global dataframe
+    global_df = updated_df
+
+    return (
+        updated_df,
+        metrics["total"], metrics["positive_pct"], metrics["neutral_pct"],
+        metrics["negative_pct"], metrics["sentiment_ratio"], metrics["trend"],
+        plot_sentiment_timeline(updated_df), plot_sentiment_distribution(updated_df),
+        plot_keyword_analysis(updated_df), updated_df
+    )
+
+# Create the Gradio interface and dashboard
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # Distance-Based Fare Sentiment Analysis Dashboard
+        ## Analysis of public feedback with advanced visualizations
+        """
+    )
+
+    with gr.Row():
+        file_input = gr.File(label="📁 Upload CSV or Excel File", file_types=[".csv", ".xlsx"])
+        load_btn = gr.Button("Load & Analyze File")
+
+    # Create a DataFrame component to display and update with data
+    comments_df = gr.DataFrame(value=global_df, label="Comment Data", interactive=False, visible=False)
+
+    with gr.Tabs():
+        # Tab 1: Main Dashboard
+        with gr.Tab("Analytics Dashboard"):
+            # Summary metrics
+            metrics = create_summary_metrics(global_df)
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    total_comments = gr.Number(value=metrics["total"], label="Total Comments", interactive=False)
+                with gr.Column(scale=1):
+                    positive_count = gr.Number(value=metrics["positive_pct"], label="Positive %", interactive=False)
+                with gr.Column(scale=1):
+                    neutral_count = gr.Number(value=metrics["neutral_pct"], label="Neutral %", interactive=False)
+                with gr.Column(scale=1):
+                    negative_count = gr.Number(value=metrics["negative_pct"], label="Negative %", interactive=False)
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    pos_neg_ratio = gr.Number(value=metrics["sentiment_ratio"], label="Positive/Negative Ratio", interactive=False)
+                with gr.Column(scale=1):
+                    sentiment_trend = gr.Textbox(value=metrics["trend"], label="entiment Trend", interactive=False)
+
+            feedback_text = gr.Textbox(label="", interactive=False, visible=True)
+
+
+            gr.Markdown("### Sentiment Visualizations")
+
+            with gr.Tabs():
+                with gr.Tab("Timeline Analysis"):
+                    timeline_plot = gr.Plot(value=plot_sentiment_timeline(global_df))
+
+                with gr.Tab("Sentiment Distribution"):
+                    distribution_plot = gr.Plot(value=plot_sentiment_distribution(global_df))
+
+                with gr.Tab("Keyword Analysis"):
+                    keyword_plot = gr.Plot(value=plot_keyword_analysis(global_df))
+
+                with gr.Tab("Word Clouds"):
+                    with gr.Row():
+                        sentiment_filter = gr.Dropdown(
+                            choices=["All", "Positive", "Neutral", "Negative"],
+                            value="All",
+                            label="Sentiment Filter"
+                        )
+                        generate_button = gr.Button("Generate Word Cloud")
+
+                    wordcloud_output = gr.Image(label="Word Cloud")
+
+                    generate_button.click(
+                        fn=gradio_generate_wordcloud,
+                        inputs=sentiment_filter,
+                        outputs=wordcloud_output
+                    )
+
+            gr.Markdown("### Comment Data")
+            with gr.Row():
+                comments_display = gr.DataFrame(value=global_df, label="Comment Data", interactive=False)
+
+            with gr.Row():
+                export_btn = gr.Button("Export & Download CSV", variant="secondary")
+                download_component = gr.File(label="Download", visible=True)
+
+                # Connect the export button to the download function
+                export_btn.click(
+                    fn=export_data_to_csv,
+                    inputs=[comments_display],
+                    outputs=[download_component]
+                )
+
+            # Connect the load button to update ALL components
+            load_btn.click(
+                fn=load_and_update_all_components,
+                inputs=[file_input],
+                outputs=[
+                    comments_df,  # Hidden state component
+                    total_comments, positive_count, neutral_count, negative_count,  # Metric displays
+                    pos_neg_ratio, sentiment_trend,  # Additional metrics
+                    timeline_plot, distribution_plot, keyword_plot,  # Visualizations
+                    comments_display  # Comments table
+                ]
+            )
+
+            # Set up event handlers for adding comments (using global_df)
+            def gradio_add_comment_updated(comment):
+                global global_df
+                global_df, feedback, _ = gradio_add_comment(comment)
+
+                # Return all updated components
+                return (
+                    global_df, feedback, "",  # Updated df, feedback, clear input
+                    plot_sentiment_timeline(global_df),
+                    plot_sentiment_distribution(global_df),
+                    plot_keyword_analysis(global_df),
+                    global_df  # Update the display table too
+                )
+
+        # Tab 2: Quick Analysis
+        with gr.Tab("Quick Sentiment Analyzer"):
+            gr.Markdown("""
+            ### Quick Sentiment Analysis Tool
+            Enter any comment about the distance-based fare system to get instant sentiment analysis
+            """)
+
+            with gr.Row():
+                quick_comment = gr.Textbox(
+                    placeholder="Type your comment here...",
+                    label="Comment for Analysis",
+                    lines=3
+                )
+
+            with gr.Row():
+                analyze_btn = gr.Button("Analyze Sentiment", variant="primary")
+
+            with gr.Row():
+                with gr.Column():
+                    sentiment_result = gr.Textbox(label="Sentiment")
+                with gr.Column():
+                    confidence_result = gr.Textbox(label="Confidence")
+                with gr.Column():
+                    keyword_result = gr.Textbox(label="Key Topics")
+
+            analyze_btn.click(
+                fn=gradio_analyze_comment,
+                inputs=quick_comment,
+                outputs=[sentiment_result, confidence_result, keyword_result]
+            )
+
+        # Tab 3: About & Help
+        with gr.Tab("About this Dashboard"):
+            gr.Markdown("""
+            ## About This Dashboard
+
+            This dashboard provides analysis of perception of individual about Distance-Based Fare system.
+            It analyzes public comments collected from different social media and identify key concerns.
+
+            ### Features:
+
+            - **Sentiment Analysis**: Automatically classifies comments as Positive, Neutral, or Negative
+            - **Keyword Extraction**: Identifies the most important key words in each comment
+            - **Time Series Analysis**: Tracks sentiment trends over time
+            - **Word Cloud Visualization**: Visual representation of the most common Key words
+            - **Data Export**: Download collected data for further analysis
+
+            ### How to Use:
+
+            1. Use the main dashboard to view overall sentiment metrics and trends
+            2. Add new comments via the comment input box
+            3. Use the Quick Analyzer for testing sentiment on individual comments
+            4. Upload your own data files (CSV/Excel) to analyze custom datasets
+            5. Export data in CSV format for external analysis
+
+            ### File Upload Requirements:
+
+            - CSV or Excel files (.csv, .xlsx)
+            - Must contain a 'Text' column with comments
+            - Optional 'Datetime' column (will be auto-generated if missing)
+
+
+            This dashboard is developed by Anaclet UKURIKIYEYEZU, contact: 0786698014
+            """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(share=True)
+