Update app.py

app.py

@@ -1,4 +1,3 @@
-# app_simple_plus.py — ASAP Explorer (no table, log-scale map, English-filtered word cloud, top-15 composers)
 import re
 import pandas as pd
 import numpy as np
@@ -9,14 +8,35 @@ from dateutil import parser as dateparser
 import gradio as gr
 from datasets import load_dataset
 import os
+from typing import Tuple, Optional
 
+# =========================
+# Config
+# =========================
 COMPOSITION_PATH = "ASAPcomposition.csv"
 PEOPLE_PATH = "ASAPdata.csv"
 PLOT_TEMPLATE = "plotly_white"
 HF_TOKEN = os.environ.get("HF_TOKEN")
+MIN_ASCII_RATIO = 0.7  # wordcloud English-ish filter
+
+# Small, mobile-friendly visual defaults
+_MOBILE_LAYOUT_KW = dict(
+    margin=dict(l=8, r=8, t=38, b=8),
+    legend=dict(orientation="h", yanchor="bottom", y=-0.25, xanchor="left", x=0),
+    transition_duration=0,
+)
+
+# =========================
+# In-memory caches (avoid recomputation + network hits)
+# =========================
+_COMPOSITIONS_DF: Optional[pd.DataFrame] = None
+_PEOPLE_RAW_DF: Optional[pd.DataFrame] = None
+_PEOPLE_EXP_DF: Optional[pd.DataFrame] = None
+_WC_IMG = None
 
-# ===== Word cloud English filter =====
-MIN_ASCII_RATIO = 0.7  # keep titles whose ASCII-char ratio >= this
+# =========================
+# Utilities
+# =========================
 
 def _ascii_ratio(s: str) -> float:
     if not s:
@@ -25,9 +45,8 @@ def _ascii_ratio(s: str) -> float:
     ascii_count = sum(1 for ch in s if ord(ch) < 128)
     return ascii_count / total if total else 0.0
 
-# =========================
-# Robust Year Parsing
-# =========================
+# ---- Robust Year Parsing ----
+
 def _norm_year_text(s: str) -> str:
     s = s.strip()
     s = s.replace("–", "-").replace("—", "-").replace(" to ", "-")
@@ -37,7 +56,8 @@ def _norm_year_text(s: str) -> str:
     sl = re.sub(r"\s+", " ", sl).strip()
     return sl
 
-def _parse_year_robust(y):
+
+def _parse_year_robust(y) -> Tuple[float, float]:
     if pd.isna(y):
         return (np.nan, np.nan)
     s = _norm_year_text(str(y))
@@ -76,8 +96,10 @@ def _parse_year_robust(y):
         pass
     return (np.nan, np.nan)
 
+
 def _parse_duration(d):
-    if pd.isna(d): return np.nan
+    if pd.isna(d):
+        return np.nan
     s = str(d).strip().lower()
     if ":" in s:
         parts = [p.strip() for p in s.split(":")]
@@ -97,32 +119,26 @@ def _parse_duration(d):
         return np.nan
 
 # =========================
-# Loaders (compositions)
+# Loaders (with caching)
 # =========================
-def load_compositions():
-    ds = load_dataset("csv", data_files="hf://datasets/zliang/ASAP/ASAPcomposition.csv", token=HF_TOKEN)
-    df = ds["train"].to_pandas()
-    df = df.rename(columns={
-        "Name": "Composer",
-        "Composition Title": "Title",
-        "Duration": "Duration",
-        "Year": "Year",
-        "Level": "Level"
-    })
-    starts, ends = [], []
-    for raw in df.get("Year", pd.Series([np.nan] * len(df))):
-        y0, y1 = _parse_year_robust(raw)
-        starts.append(y0); ends.append(y1)
-    df["YearStart"] = starts
-    df["YearEnd"] = ends
-    df["YearParsed"] = df["YearStart"]
-    df["DurationMin"] = df.get("Duration", pd.Series([np.nan]*len(df))).map(_parse_duration)
-    df["LevelStd"] = df.get("Level", pd.Series(["Unknown"]*len(df))).fillna("Unknown")
-    return df
 
-# =========================
-# Demonyms & country normalization (people)
-# =========================
+def _col(df, *candidates):
+    cols = {c.lower().strip(): c for c in df.columns}
+    for cand in candidates:
+        k = cand.lower().strip()
+        if k in cols:
+            return cols[k]
+    return None
+
+
+def _basic_clean_nat(s: str) -> str:
+    s = str(s)
+    s = s.replace("(", " ").replace(")", " ")
+    s = re.sub(r"[.\u200b]", " ", s)
+    s = re.sub(r"\s+", " ", s)
+    return s.strip()
+
+
 _COUNTRY_ALIASES = {
     "czech republic": "Czechia",
     "viet nam": "Vietnam",
@@ -179,19 +195,6 @@ _DEMONYM_TO_COUNTRY = {
     "australian": "Australia", "new zealander": "New Zealand", "fijian": "Fiji", "samoan": "Samoa", "tongan": "Tonga",
 }
 
-def _col(df, *candidates):
-    cols = {c.lower().strip(): c for c in df.columns}
-    for cand in candidates:
-        k = cand.lower().strip()
-        if k in cols: return cols[k]
-    return None
-
-def _basic_clean_nat(s: str) -> str:
-    s = str(s)
-    s = s.replace("(", " ").replace(")", " ")
-    s = re.sub(r"[.\u200b]", " ", s)
-    s = re.sub(r"\s+", " ", s)
-    return s.strip()
 
 def _normalize_country_or_demonym(token: str):
     if token is None or (isinstance(token, float) and np.isnan(token)):
@@ -199,20 +202,25 @@ def _normalize_country_or_demonym(token: str):
     t = _basic_clean_nat(token).lower()
     t = re.sub(r"\b(citizen|national|born|of|the|composer)\b", " ", t)
     t = re.sub(r"\s+", " ", t).strip()
-    if t in _DEMONYM_TO_COUNTRY: return _DEMONYM_TO_COUNTRY[t]
-    if t in _COUNTRY_ALIASES: return _COUNTRY_ALIASES[t]
+    if t in _DEMONYM_TO_COUNTRY:
+        return _DEMONYM_TO_COUNTRY[t]
+    if t in _COUNTRY_ALIASES:
+        return _COUNTRY_ALIASES[t]
     short = {
         "usa": "United States", "u.s.a": "United States", "u.s": "United States", "us": "United States",
         "uk": "United Kingdom", "england": "United Kingdom", "scotland": "United Kingdom", "wales": "United Kingdom",
         "korea": "South Korea", "russia": "Russia",
     }
-    if t in short: return short[t]
-    if re.search(r"[a-z]", t):  # likely a country already
+    if t in short:
+        return short[t]
+    if re.search(r"[a-z]", t):
         return t.title()
     return np.nan
 
+
 def _split_and_normalize_nationalities(value):
-    if pd.isna(value): return []
+    if pd.isna(value):
+        return []
     s = _basic_clean_nat(value)
     s = re.sub(r"\s*(/|;|&|\band\b|,)\s*", ",", s, flags=re.I)
     parts = [p for p in (x.strip() for x in s.split(",")) if p]
@@ -223,56 +231,137 @@ def _split_and_normalize_nationalities(value):
             out.append(norm)
     return out
 
+
+# ---- Data loaders (cached in-module) ----
+
+def load_compositions() -> pd.DataFrame:
+    global _COMPOSITIONS_DF
+    if _COMPOSITIONS_DF is not None:
+        return _COMPOSITIONS_DF
+
+    ds = load_dataset(
+        "csv",
+        data_files="hf://datasets/zliang/ASAP/ASAPcomposition.csv",
+        token=HF_TOKEN,
+    )
+    df = ds["train"].to_pandas()
+    df = df.rename(
+        columns={
+            "Name": "Composer",
+            "Composition Title": "Title",
+            "Duration": "Duration",
+            "Year": "Year",
+            "Level": "Level",
+        }
+    )
+
+    # Vectorized-ish year parsing (fast enough and clearer)
+    parsed = df.get("Year", pd.Series([np.nan] * len(df))).map(_parse_year_robust)
+    df["YearStart"] = [p[0] for p in parsed]
+    df["YearEnd"] = [p[1] for p in parsed]
+    df["YearParsed"] = df["YearStart"]
+
+    df["DurationMin"] = df.get("Duration", pd.Series([np.nan] * len(df))).map(_parse_duration)
+    df["LevelStd"] = df.get("Level", pd.Series(["Unknown"] * len(df))).fillna("Unknown")
+
+    _COMPOSITIONS_DF = df
+    return df
+
+
 def load_people():
-    ds = load_dataset("csv", data_files="hf://datasets/zliang/ASAP/ASAPdata.csv", token=HF_TOKEN)
+    global _PEOPLE_RAW_DF, _PEOPLE_EXP_DF
+    if _PEOPLE_RAW_DF is not None and _PEOPLE_EXP_DF is not None:
+        return _PEOPLE_RAW_DF, _PEOPLE_EXP_DF
+
+    ds = load_dataset(
+        "csv",
+        data_files="hf://datasets/zliang/ASAP/ASAPdata.csv",
+        token=HF_TOKEN,
+    )
     df = ds["train"].to_pandas()
+
+    # Robust rename with fallbacks
     col_gender = _col(df, "Gender", "gender")
     col_nat = _col(df, "Nationality", "Country", "nationality", "country")
     col_eth = _col(df, "Ethnicity", "ethnicity")
     col_era = _col(df, "Music Era", "Era", "Period", "music era", "era", "period")
-    if col_gender: df = df.rename(columns={col_gender: "Gender"})
-    else: df["Gender"] = np.nan
-    if col_nat: df = df.rename(columns={col_nat: "Nationality"})
-    else: df["Nationality"] = np.nan
-    if col_eth: df = df.rename(columns={col_eth: "Ethnicity"})
-    else: df["Ethnicity"] = np.nan
-    if col_era: df = df.rename(columns={col_era: "Music Era"})
-    else: df["Music Era"] = np.nan
+
+    if col_gender:
+        df = df.rename(columns={col_gender: "Gender"})
+    else:
+        df["Gender"] = np.nan
+
+    if col_nat:
+        df = df.rename(columns={col_nat: "Nationality"})
+    else:
+        df["Nationality"] = np.nan
+
+    if col_eth:
+        df = df.rename(columns={col_eth: "Ethnicity"})
+    else:
+        df["Ethnicity"] = np.nan
+
+    if col_era:
+        df = df.rename(columns={col_era: "Music Era"})
+    else:
+        df["Music Era"] = np.nan
+
     df["NationalityList"] = df["Nationality"].apply(_split_and_normalize_nationalities)
     df_exp = df.explode("NationalityList").rename(columns={"NationalityList": "NationalityNorm"})
     df_exp["NationalityNorm"] = df_exp["NationalityNorm"].replace({"": np.nan})
+
+    _PEOPLE_RAW_DF, _PEOPLE_EXP_DF = df, df_exp
     return df, df_exp
 
 # =========================
-# Visuals — Compositions
+# Visuals (tuned for speed + mobile)
 # =========================
+
+def _apply_mobile_layout(fig: go.Figure) -> go.Figure:
+    fig.update_layout(**_MOBILE_LAYOUT_KW, template=PLOT_TEMPLATE)
+    fig.update_xaxes(title_standoff=4)
+    fig.update_yaxes(title_standoff=4)
+    return fig
+
+
 def area_timeline(df):
     d = df.dropna(subset=["YearParsed"])
-    if d.empty: return go.Figure()
-    counts = d.groupby(["YearParsed", "LevelStd"])["Title"].count().reset_index(name="Count")
-    counts = counts.sort_values("YearParsed")
-    counts["Smoothed"] = counts.groupby("LevelStd")["Count"].transform(lambda s: s.rolling(3, min_periods=1).mean())
-    fig = px.area(counts, x="YearParsed", y="Smoothed", color="LevelStd",
-                  title="Compositions per Year by Level", template=PLOT_TEMPLATE)
-    fig.update_layout(margin=dict(l=10, r=10, t=50, b=10), legend_title="Level")
-    fig.update_xaxes(title="Year"); fig.update_yaxes(title="Smoothed count")
-    return fig
+    if d.empty:
+        return go.Figure()
+
+    counts = (
+        d.groupby(["YearParsed", "LevelStd"], observed=True)["Title"]
+        .count()
+        .rename("Count")
+        .reset_index()
+        .sort_values("YearParsed")
+    )
+    # quick smoothing (window=3)
+    counts["Smoothed"] = (
+        counts.groupby("LevelStd", observed=True)["Count"].transform(lambda s: s.rolling(3, min_periods=1).mean())
+    )
+
+    fig = px.area(
+        counts,
+        x="YearParsed",
+        y="Smoothed",
+        color="LevelStd",
+        title="Compositions per Year by Level",
+    )
+    fig.update_xaxes(title="Year")
+    fig.update_yaxes(title="Smoothed count")
+    return _apply_mobile_layout(fig)
+
 
 def bar_top_composers(df, top_n=15):
     if df.empty:
         return go.Figure()
 
-    # group + sort
     d = (
-        df.groupby("Composer")["Title"].count()
-          .sort_values(ascending=False)
-          .head(top_n)
-          .reset_index()
-          .rename(columns={"Title": "Count"})
+        df.groupby("Composer", observed=True)["Title"].count().sort_values(ascending=False).head(top_n).reset_index()
     )
-
-    # order composers by descending count
-    composer_order = d["Composer"].tolist()
+    d = d.rename(columns={"Title": "Count"})
+    order = d["Composer"].tolist()
 
     fig = px.bar(
         d,
@@ -280,69 +369,59 @@ def bar_top_composers(df, top_n=15):
         y="Composer",
         orientation="h",
         title=f"Top {top_n} Composers by Number of Compositions",
-        template=PLOT_TEMPLATE
-    )
-
-    # force y-axis order: most at top → least at bottom
-    fig.update_layout(
-        yaxis=dict(categoryorder="array", categoryarray=composer_order[::-1]),
-        margin=dict(l=10, r=10, t=50, b=10)
     )
-
-    return fig
+    fig.update_layout(yaxis=dict(categoryorder="array", categoryarray=order[::-1]))
+    return _apply_mobile_layout(fig)
 
 
 def treemap_composer_level(df):
-    if df.empty: return go.Figure()
-    d = df.groupby(["Composer", "LevelStd"])["Title"].count().reset_index(name="Count")
-    fig = px.treemap(d, path=["Composer", "LevelStd"], values="Count",
-                     title="Catalog Structure: Composer → Level", template=PLOT_TEMPLATE)
-    fig.update_layout(margin=dict(l=10, r=10, t=50, b=10))
-    return fig
+    if df.empty:
+        return go.Figure()
+    d = df.groupby(["Composer", "LevelStd"], observed=True)["Title"].count().reset_index(name="Count")
+    fig = px.treemap(d, path=["Composer", "LevelStd"], values="Count", title="Catalog Structure: Composer → Level")
+    return _apply_mobile_layout(fig)
+
 
 def make_wordcloud(df):
+    global _WC_IMG
+    if _WC_IMG is not None:
+        return _WC_IMG
+
     titles = df["Title"].dropna().astype(str)
-    # English filter: keep titles with sufficient ASCII ratio
     titles = [t for t in titles if _ascii_ratio(t) >= MIN_ASCII_RATIO]
     if not titles:
         return None
     text = " ".join(titles)
     stopwords = set(STOPWORDS)
-    stopwords.update({"Piano", "II", "IV","V","III","Piece","Pieces","Op","VII","IX","VIII"})  # 👈 add more as needed
-    wc = WordCloud(width=1200, height=500, background_color="white",
-                   stopwords=stopwords, collocations=True)
-    return wc.generate(text).to_image()
+    stopwords.update({"Piano", "II", "IV", "V", "III", "Piece", "Pieces", "Op", "VII", "IX", "VIII"})
+    wc = WordCloud(width=1200, height=500, background_color="white", stopwords=stopwords, collocations=True)
+    _WC_IMG = wc.generate(text).to_image()
+    return _WC_IMG
 
-# =========================
-# Visuals — People (pies + LOG map)
-# =========================
-def pie(df_people_exp_or_raw, column, title, max_slices=12):
-    if column not in df_people_exp_or_raw.columns:
+
+def pie_counts(series: pd.Series, title: str, max_slices: int = 12):
+    s = series.dropna()
+    if s.empty:
         return go.Figure()
-    s = df_people_exp_or_raw[column].dropna()
-    if s.empty: return go.Figure()
     counts = s.value_counts(dropna=False)
     if len(counts) > max_slices:
-        head = counts.iloc[:max_slices-1]
-        other = pd.Series({"Other": counts.iloc[max_slices-1:].sum()})
+        head = counts.iloc[: max_slices - 1]
+        other = pd.Series({"Other": counts.iloc[max_slices - 1 :].sum()})
         counts = pd.concat([head, other])
     d = counts.reset_index()
-    d.columns = [column, "Count"]
-    fig = px.pie(d, names=column, values="Count", title=title, template=PLOT_TEMPLATE, hole=0.35)
+    d.columns = ["label", "Count"]
+    fig = px.pie(d, names="label", values="Count", title=title, hole=0.35)
     fig.update_traces(textposition="inside", textinfo="percent+label")
-    fig.update_layout(margin=dict(l=10, r=10, t=50, b=10))
-    return fig
+    return _apply_mobile_layout(fig)
+
 
 def world_map_nationality(df_people_exp):
-    # Exploded + normalized nationalities expected here
     s = df_people_exp["NationalityNorm"].dropna()
     if s.empty:
         return go.Figure()
 
     counts = s.value_counts().reset_index()
     counts.columns = ["country", "count"]
-
-    # ---- log transform in the data (avoid coloraxis.type) ----
     counts["count_log10"] = np.log10(counts["count"] + 1.0)
 
     fig = px.choropleth(
@@ -352,93 +431,130 @@ def world_map_nationality(df_people_exp):
         color="count_log10",
         color_continuous_scale="Blues",
         title="Global Distribution by Nationality (log scale)",
-        template=PLOT_TEMPLATE,
         hover_data={"count": True, "count_log10": False, "country": False},
     )
 
-    # Colorbar: show a few human-friendly ticks with labels in raw counts
-    if not counts.empty:
-        vmax = int(counts["count"].max())
-        # choose nice ticks (1, 3, 10, 30, 100, ...)
-        raw_ticks = []
-        step = 1
-        base = [1, 3]
-        while step <= vmax:
-            for b in base:
-                val = b * step
-                if val <= vmax:
-                    raw_ticks.append(val)
-            step *= 10
-        raw_ticks = sorted(set([1] + raw_ticks + [vmax]))
-
-        tickvals = np.log10(np.array(raw_ticks, dtype=float) + 1.0)
-        ticktext = [str(v) for v in raw_ticks]
-
-        fig.update_layout(
-            margin=dict(l=10, r=10, t=50, b=10),
-            coloraxis_colorbar=dict(title="Count", tickvals=tickvals, ticktext=ticktext),
-        )
-    else:
-        fig.update_layout(margin=dict(l=10, r=10, t=50, b=10), coloraxis_colorbar_title="Count")
-
-    return fig
+    # Colorbar ticks in raw counts
+    vmax = int(counts["count"].max())
+    raw_ticks = [1]
+    step = 1
+    base = [1, 3]
+    while step <= vmax:
+        for b in base:
+            val = b * step
+            if val <= vmax:
+                raw_ticks.append(val)
+        step *= 10
+    raw_ticks = sorted(set(raw_ticks + [vmax]))
+    tickvals = np.log10(np.array(raw_ticks, dtype=float) + 1.0)
+    ticktext = [str(v) for v in raw_ticks]
+
+    fig.update_layout(coloraxis_colorbar=dict(title="Count", tickvals=tickvals, ticktext=ticktext))
+    return _apply_mobile_layout(fig)
 
 # =========================
-# Pipeline
+# Pipelines (computed per-tab, lazily)
 # =========================
-def compute_all():
-    comp = load_compositions()
+
+def compute_people_viz():
     ppl_raw, ppl_exp = load_people()
     return (
-        # compositions
+        pie_counts(ppl_raw["Gender"], "Gender"),
+        pie_counts(ppl_exp["NationalityNorm"], "Nationality"),
+        pie_counts(ppl_raw["Ethnicity"], "Ethnicity"),
+        pie_counts(ppl_raw["Music Era"], "Music Era"),
+        world_map_nationality(ppl_exp),
+    )
+
+
+def compute_compositions_overview():
+    comp = load_compositions()
+    return (
         area_timeline(comp),
         bar_top_composers(comp),
+    )
+
+
+def compute_categories_viz():
+    comp = load_compositions()
+    return (
         treemap_composer_level(comp),
         make_wordcloud(comp),
-        # people pies + log map
-        pie(ppl_raw, "Gender", "Gender"),
-        pie(ppl_exp, "NationalityNorm", "Nationality"),
-        pie(ppl_raw, "Ethnicity", "Ethnicity"),
-        pie(ppl_raw, "Music Era", "Music Era"),
-        world_map_nationality(ppl_exp)
     )
 
 # =========================
-# UI (simple, no uploads, no filters, no table)
+# UI (lazy-load tabs; responsive stacking)
 # =========================
+
 theme = gr.themes.Soft(primary_hue="blue", neutral_hue="slate")
 
-with gr.Blocks(title="A Seat At The Piano", theme=theme) as demo:
+with gr.Blocks(title="A Seat At The Piano — ASAP Explorer", theme=theme, css="""
+/***** Lightweight responsive tweaks *****/
+.gradio-container {max-width: 1200px}
+.plotly-graph-div {height: auto !important}
+@media (max-width: 700px){
+  .gr-row {flex-direction: column !important}
+}
+""") as demo:
     gr.Markdown(
-        f"## 🎼 ASAP Explorer\n"
-        f"A Seat at the Piano was founded in the summer of 2020 in the midst of social and racial reckoning around the world. We are a team of classically trained pianists with varying backgrounds and experiences, who strive to raise the voices of those who are less heard and to inspire more thoughtful, inclusive programming within the performing and pedagogical spheres.\n"
+        "## 🎼 ASAP Explorer\n"
+        "A Seat at the Piano was founded in the summer of 2020 in the midst of social and racial reckoning around the world.\n"
+        "We strive to raise the voices of those who are less heard and to inspire more thoughtful, inclusive programming."
     )
 
-    with gr.Tabs():
-        with gr.Tab("Composer Demographics"):
-            with gr.Row():
-                pie_gender = gr.Plot()
-                pie_nat = gr.Plot()
-            with gr.Row():
-                pie_eth = gr.Plot()
-                pie_era = gr.Plot()
-            world_map = gr.Plot()
-        with gr.Tab("Compositions Overview"):
-            timeline_plot = gr.Plot()
-            top_plot = gr.Plot()
-        with gr.Tab("Compositions Catogories"):
-            tree_plot = gr.Plot()
-            wc_img = gr.Image(type="pil")
+    with gr.Tabs() as tabs:
+        with gr.Tab("Composer Demographics") as tab_people:
+            with gr.Row(equal_height=False):
+                pie_gender = gr.Plot(label="Gender")
+                pie_nat = gr.Plot(label="Nationality")
+            with gr.Row(equal_height=False):
+                pie_eth = gr.Plot(label="Ethnicity")
+                pie_era = gr.Plot(label="Music Era")
+            world_map = gr.Plot(label="Global Map (log scale)")
+
+        with gr.Tab("Compositions Overview") as tab_overview:
+            with gr.Row(equal_height=False):
+                timeline_plot = gr.Plot(label="Timeline")
+            with gr.Row(equal_height=False):
+                top_plot = gr.Plot(label="Top Composers")
+
+        with gr.Tab("Composition Categories") as tab_cats:
+            with gr.Row(equal_height=False):
+                tree_plot = gr.Plot(label="Composer → Level Treemap")
+            with gr.Row(equal_height=False):
+                wc_img = gr.Image(type="pil", label="Word Cloud")
+
+    # --- Lazy load on tab select (much faster initial render) ---
+    tab_people.select(
+        fn=compute_people_viz,
+        inputs=None,
+        outputs=[pie_gender, pie_nat, pie_eth, pie_era, world_map],
+        queue=False,
+    )
 
+    tab_overview.select(
+        fn=compute_compositions_overview,
+        inputs=None,
+        outputs=[timeline_plot, top_plot],
+        queue=False,
+    )
+
+    tab_cats.select(
+        fn=compute_categories_viz,
+        inputs=None,
+        outputs=[tree_plot, wc_img],
+        queue=False,
+    )
 
+    # Optional: pre-warm smallest tab to show something immediately (cheap plots)
+    # Comment out if you want totally empty initial view
     demo.load(
-        compute_all,
+        fn=compute_compositions_overview,
         inputs=None,
-        outputs=[
-            timeline_plot, top_plot, tree_plot, wc_img,
-            pie_gender, pie_nat, pie_eth, pie_era, world_map
-        ],
+        outputs=[timeline_plot, top_plot],
+        queue=False,
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    # Gradio queues can add overhead; keep it off for snappier single-user use
+    demo.launch(quiet=True)