# Standard Library Imports
import os
import io
import re
import base64
import random
from datetime import datetime, timedelta
from collections import Counter
from pathlib import Path # Needed for cache_dir
# Third-party 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 gradio as gr
from wordcloud import WordCloud
from youtube_comment_downloader import YoutubeCommentDownloader
# Lazy import helper functions
def lazy_import_transformers():
try:
from transformers import pipeline
return pipeline
except ImportError:
print("transformers library not found.")
return None
def lazy_import_keybert():
try:
from keybert import KeyBERT
return KeyBERT
except ImportError:
print("keybert library not found.")
return None
def initialize_models():
classifier = None
kw_model = None
try:
pipeline = lazy_import_transformers()
if pipeline:
cache_dir = Path(".cache/huggingface")
cache_dir.mkdir(parents=True, exist_ok=True)
# Set cache directory via environment variable
os.environ['TRANSFORMERS_CACHE'] = str(cache_dir)
classifier = pipeline(
"sentiment-analysis",
model="cardiffnlp/twitter-roberta-base-sentiment-latest"
)
KeyBERT = lazy_import_keybert()
if KeyBERT:
kw_model = KeyBERT()
except Exception as e:
print(f"Error initializing models: {e}")
return classifier, kw_model
# Set transformers logging to error only
import transformers
transformers.logging.set_verbosity_error()
# Load models
classifier, kw_model = initialize_models()
# Label mapping - handling different model outputs
sentiment_map = {
"LABEL_0": "Negative", "LABEL_1": "Neutral", "LABEL_2": "Positive", # RoBERTa format
"negative": "Negative", "neutral": "Neutral", "positive": "Positive", # Standard format
"NEGATIVE": "Negative", "NEUTRAL": "Neutral", "POSITIVE": "Positive" # Uppercase format
}
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
import re
from datetime import datetime, timedelta
def convert_relative_time(relative):
now = datetime.now()
try:
match = re.match(r'(\d+)\s+(second|minute|hour|day|week|month|year)s?\s+ago', relative.lower())
if not match:
return now # fallback to now for unknown formats
value, unit = int(match.group(1)), match.group(2)
if unit == 'second':
dt = now - timedelta(seconds=value)
elif unit == 'minute':
dt = now - timedelta(minutes=value)
elif unit == 'hour':
dt = now - timedelta(hours=value)
elif unit == 'day':
dt = now - timedelta(days=value)
elif unit == 'week':
dt = now - timedelta(weeks=value)
elif unit == 'month':
dt = now - timedelta(days=value * 30)
elif unit == 'year':
dt = now - timedelta(days=value * 365)
else:
dt = now
except Exception as e:
print(f"Failed to parse relative time '{relative}': {e}")
dt = now
return dt
def generate_df(comments):
global global_df
default_data = []
for comment in comments:
text = comment.get('text', '')
timestamp = convert_relative_time(comment.get('time', '0 seconds ago'))
# Truncate long text for model input (e.g. 512 tokens)
truncated_text = text[:512]
# Sentiment analysis
try:
result = classifier(truncated_text)[0]
sentiment = sentiment_map.get(result["label"], "Unknown")
score = round(result["score"], 3)
except Exception as e:
print(f"Sentiment classification failed: {e}")
sentiment = "Unknown"
score = 0.0
# Keyword extraction
try:
keywords = kw_model.extract_keywords(truncated_text, top_n=3)
keyword_str = ", ".join([kw[0] for kw in keywords]) if keywords else "N/A"
except Exception as e:
print(f"Keyword extraction failed: {e}")
keyword_str = "N/A"
default_data.append({
"Datetime": timestamp,
"Text": text,
"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=50,
height=500,
).generate(all_keywords)
# Convert to image for Gradio
return wordcloud.to_image()
# Function to create a scatter plot 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:
df_copy = df.copy()
df_copy["Datetime"] = pd.to_datetime(df_copy["Datetime"])
df_copy["Time_Bin"] = df_copy["Datetime"].dt.floor("1H")
# Grouping comments 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()
)
fig = go.Figure()
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='markers',
name=sentiment,
marker=dict(size=10, color=color, opacity=0.9, line=dict(width=1, color='DarkSlateGrey')),
text=sentiment_df["Keywords"],
hovertemplate='%{y} comments
%{x}
Keywords: %{text}'
)
)
fig.update_layout(
title="Sentiment Distribution Over Time (1-Hour Bins)",
height=500,
xaxis=dict(
title="Time",
type="date",
rangeslider=dict(visible=False),
rangeselector=dict(
buttons=list([
dict(count=1, label="1d", step="day", stepmode="backward"),
dict(count=7, label="1w", step="day", stepmode="backward"),
dict(count=1, label="1m", step="month", stepmode="backward"),
dict(count=6, label="6m", step="month", stepmode="backward"),
dict(count=1, label="1y", step="year", stepmode="backward"),
dict(step="all", label="All")
])
)
),
yaxis=dict(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=500,
autosize=True,
width=None ,
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=500,
autosize=True,
width=None
)
# 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,
autosize=True,
width=None
)
# 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,
autosize=True,
width=None ,
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,
autosize=True,
width=None
)
# 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
def analyze_youtube_comments(video_url):
# Simple YouTube video URL validation
youtube_pattern = r"(https?://)?(www\.)?(youtube\.com/watch\?v=|youtu\.be/)[\w-]{11}"
if not re.match(youtube_pattern, video_url):
raise gr.Error("🚫 Please provide a valid YouTube video link.")
try:
downloader = YoutubeCommentDownloader()
comments = downloader.get_comments_from_url(video_url)
if not comments:
raise gr.Error("⚠️ No comments found for this video.")
return generate_df(comments)
except Exception as e:
raise gr.Error(f"❌ Failed to retrieve comments: {str(e)}")
# Global default data initialization
global_df = generate_default_df()
# Function: Load either a file or a video URL, return dashboard-ready components
def load_and_update_all_components(file, video_url):
global global_df
# Determine which input to process
if file is not None:
updated_df = get_analysis_dataframe(file)
elif video_url:
updated_df = analyze_youtube_comments(video_url)
else:
updated_df = global_df # fallback to default data if nothing provided
# Generate updated metrics and visuals
metrics = create_summary_metrics(updated_df)
global_df = updated_df # Update global state
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(
"""
# A Smart Dashboard for Analyzing Public Sentiment and Perception
#### This interactive dashboard enables users to analyze public sentiment and perception by processing YouTube video comments or customized datasets uploaded as CSV or Excel files. Using advanced natural language processing techniques, the dashboard provides sentiment classification, keyword trends, and visual insights to support data-driven decision-making.
"""
)
# Data Input Section
with gr.Tabs() as input_tabs:
with gr.Tab("🎬 YouTube Video Analysis"):
with gr.Row():
video_url = gr.Textbox(label="YouTube Video URL", placeholder="https://www.youtube.com/watch?v=...")
url_load_btn = gr.Button("🎬 Analyze Comments", variant="primary")
with gr.Tab("📁 File Upload Analysis"):
with gr.Row():
file_input = gr.File(label="Upload CSV or Excel File", file_types=[".csv", ".xlsx"])
file_load_btn = gr.Button("📊 Load & Analyze File", variant="primary")
# Hidden state component
comments_df = gr.DataFrame(value=global_df if global_df is not None else generate_default_df(),
label="Loaded Comment Data", interactive=False, visible=False)
# Dashboard Tabs
with gr.Tabs():
# Tab 1: Main Analytics Dashboard
with gr.Tab("Analytics Dashboard"):
# Summary metrics
metrics = create_summary_metrics(global_df if global_df is not None else generate_default_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="Sentiment Trend", interactive=False)
# Visualizations
gr.Markdown("### 📊 Sentiment Visualizations")
with gr.Tabs():
with gr.Tab("Timeline Analysis"):
timeline_plot = gr.Plot(value=plot_sentiment_timeline(global_df if global_df is not None else generate_default_df()))
with gr.Tab("Sentiment Distribution"):
distribution_plot = gr.Plot(value=plot_sentiment_distribution(global_df if global_df is not None else generate_default_df()))
with gr.Tab("Keyword Analysis"):
keyword_plot = gr.Plot(value=plot_keyword_analysis(global_df if global_df is not None else generate_default_df()))
gr.Markdown("### Word Clouds of keyword")
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")
gr.Markdown("### Data Extracted")
with gr.Row():
comments_display = gr.DataFrame(
value=global_df if global_df is not None else generate_default_df(),
interactive=False
)
with gr.Row():
export_btn = gr.Button("💾 Export & Download CSV", variant="secondary")
with gr.Row():
download_component = gr.File(label="Download", visible=True)
# Tab 2: Quick Analysis
with gr.Tab("Quick Sentiment Analyzer"):
gr.Markdown("""
### Quick Sentiment Analysis Tool
Quickly analyze the sentiment of any comment you enter.
""")
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")
# Tab 3: About & Help
with gr.Tab("About This Dashboard"):
gr.Markdown("""
## About This Dashboard
This dashboard allows you to analyze public sentiment from YouTube video comments or uploaded CSV/Excel files.
It uses natural language processing to detect sentiment, highlight key topics, and reveal emerging trends.
Whether you are tracking opinions or exploring concerns, the dashboard delivers clear, data-driven insights.
### Features:
- **Multiple Data Sources**: Upload CSV/Excel files or analyze YouTube video comments
- **Sentiment Analysis**: Automatically classifies comments as Positive, Neutral, or Negative
- **Keyword Extraction**: Identifies the most important topics in each comment
- **Time Series Analysis**: Tracks sentiment trends over time
- **Word Cloud Visualization**: Visual representation of the most common terms
- **Data Export**: Download collected data for further analysis
### How to Use:
1. Upload a dataset file via the File Upload tab or enter a YouTube URL
2. View overall sentiment metrics and trends in the Analytics Dashboard
3. Add new comments using the comment input box
4. Use the Quick Analyzer for testing sentiment on individual comments
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**](https://portofolio-pi-lac.vercel.app/)
Feel free to reach out with any questions or feedback!
### Contact Information:
- [**WhatsApp**](https://wa.me/250786698014): +250 786 698 014
- [**Email**](mailto:anaclet.ukurikiyeyezu@aims.ac.rw): anaclet.ukurikiyeyezu@aims.ac.rw
"""
)
# Connect events to functions
# File upload event
file_load_btn.click(
fn=lambda file: load_and_update_all_components(file, None),
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
]
)
# YouTube analysis event
url_load_btn.click(
fn=lambda url: load_and_update_all_components(None, url),
inputs=[video_url],
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
]
)
# Word cloud generation event
generate_button.click(
fn=gradio_generate_wordcloud,
inputs=[sentiment_filter],
outputs=[wordcloud_output]
)
# Comment analysis event
analyze_btn.click(
fn=gradio_analyze_comment,
inputs=[quick_comment],
outputs=[sentiment_result, confidence_result, keyword_result]
)
# Add comment event
def add_comment_and_update(comment):
global global_df
updated_df, feedback, _ = gradio_add_comment(comment)
# Update metrics based on the new dataframe
metrics = create_summary_metrics(updated_df)
# Return all updated components
return (
updated_df, # Update hidden state
feedback, "", # Feedback message and clear input
metrics["total"], metrics["positive_pct"], metrics["neutral_pct"], # Update metrics
metrics["negative_pct"], metrics["sentiment_ratio"], metrics["trend"],
plot_sentiment_timeline(updated_df), # Update plots
plot_sentiment_distribution(updated_df),
plot_keyword_analysis(updated_df),
updated_df # Update display table
)
# Export to CSV event
export_btn.click(
fn=export_data_to_csv,
inputs=[comments_display],
outputs=[download_component]
)
# Launch the app
if __name__ == "__main__":
demo.launch(share=False)