Update app.py

app.py

@@ -9,7 +9,7 @@ RAG Pipeline (6 steps):
   2. CHUNK    → LangChain splits each article into overlapping 400-char chunks
   3. EMBED    → Sentence Transformers encodes every chunk as a dense vector
   4. STORE    → ChromaDB holds all vectors in an in-memory collection
-  5. RETRIEVE → Semantic search returns the 10 most relevant chunks
+  5. RETRIEVE → Semantic search returns the 6 most relevant chunks
   6. GENERATE → Gemini Flash analyses the retrieved context and returns a structured signal
 
 Built by: Sammie Wong
@@ -18,33 +18,55 @@ Built by: Sammie Wong
 import os
 import json
 import uuid
+import time
 import gradio as gr
 import google.generativeai as genai
 import chromadb
 from chromadb.utils import embedding_functions
 from newsapi import NewsApiClient
-from langchain_text_splitters import RecursiveCharacterTextSplitter 
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 from datetime import datetime, timedelta
 
 
 # ─── STEP 1: FETCH ────────────────────────────────────────────────────────────
 
-def fetch_articles(topic: str, days_back: int, newsapi_key: str) -> list[dict]:
+def fetch_articles(topic: str, days_back: int, newsapi_key: str,
+                   boolean_query: str = "") -> list[dict]:
     """
-    Pull recent news articles from NewsAPI for the given topic.
-    Free tier: up to 100 requests/day, articles from the last 30 days.
+    Pull recent news articles from NewsAPI.
+
+    Two modes:
+      Boolean mode — when boolean_query is provided, passed directly to NewsAPI
+                     q parameter. Supports AND, OR, NOT, "exact phrase", (grouping).
+                     No automatic quoting or fallback — you control the query precisely.
+      Simple mode  — two-pass automatic:
+                     Pass 1: exact phrase match e.g. "green hydrogen"
+                     Pass 2: broad keyword fallback if < 5 results returned
+
+    Free tier: 100 requests/day. Boolean = 1 request; simple = 1–2 requests.
     """
     client = NewsApiClient(api_key=newsapi_key)
     from_date = (datetime.now() - timedelta(days=days_back)).strftime('%Y-%m-%d')
 
-    response = client.get_everything(
-        q=f'"{topic}"',       # Exact phrase match for cleaner signal
+    common_params = dict(
         language='en',
         sort_by='publishedAt',
         from_param=from_date,
-        page_size=50          # NewsAPI free tier maximum
+        page_size=50,
     )
-    return response.get('articles', [])
+
+    if boolean_query.strip():
+        # Boolean mode: pass query directly, no modification
+        response = client.get_everything(q=boolean_query.strip(), **common_params)
+        return response.get('articles', [])
+
+    # Simple mode: two-pass
+    response = client.get_everything(q=f'"{topic}"', **common_params)
+    articles = response.get('articles', [])
+    if len(articles) < 5:
+        response = client.get_everything(q=topic, **common_params)
+        articles = response.get('articles', [])
+    return articles
 
 
 # ─── STEP 2: CHUNK ────────────────────────────────────────────────────────────
@@ -58,18 +80,17 @@ def chunk_articles(articles: list[dict]) -> tuple[list[str], list[dict]]:
     losing meaning at chunk boundaries.
     """
     splitter = RecursiveCharacterTextSplitter(
-        chunk_size=400,   # ~80 words — enough context per chunk
-        chunk_overlap=40  # Overlap prevents boundary information loss
+        chunk_size=400,
+        chunk_overlap=40,
     )
 
     all_chunks, all_metadata = [], []
 
     for article in articles:
-        # Combine title + description + content for the richest signal
         full_text = " ".join(filter(None, [
             article.get('title', ''),
             article.get('description', ''),
-            article.get('content', '')
+            article.get('content', ''),
         ]))
 
         for chunk in splitter.split_text(full_text):
@@ -77,7 +98,7 @@ def chunk_articles(articles: list[dict]) -> tuple[list[str], list[dict]]:
             all_metadata.append({
                 'source':       article['source']['name'],
                 'published_at': article['publishedAt'][:10],
-                'title':        (article.get('title') or '')[:100]
+                'title':        (article.get('title') or '')[:100],
             })
 
     return all_chunks, all_metadata
@@ -91,31 +112,29 @@ def build_vector_store(chunks: list[str], metadatas: list[dict]):
     in an in-memory ChromaDB collection.
 
     Model: all-MiniLM-L6-v2 — fast, accurate, no GPU needed.
-    Storage: EphemeralClient (in-memory) means no disk writes — perfect for
-    a serverless HF Space where each request is stateless.
+    EphemeralClient = fully in-memory, stateless per request.
     """
     embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
         model_name="all-MiniLM-L6-v2"
     )
 
     try:
-        db = chromadb.EphemeralClient()  # ChromaDB >= 0.4.x
+        db = chromadb.EphemeralClient()
     except AttributeError:
-        db = chromadb.Client()           # Fallback for older versions
+        db = chromadb.Client()
 
     collection = db.create_collection(
         name=f"trend_{uuid.uuid4().hex[:8]}",
-        embedding_function=embedding_fn
+        embedding_function=embedding_fn,
     )
 
-    # Insert in batches of 100 to avoid memory spikes
     batch_size = 100
     for i in range(0, len(chunks), batch_size):
-        batch_end = i + batch_size
+        batch = chunks[i:i + batch_size]
         collection.add(
-            documents=chunks[i:batch_end],
-            metadatas=metadatas[i:batch_end],
-            ids=[f"c{i + j}" for j in range(len(chunks[i:batch_end]))]
+            documents=batch,
+            metadatas=metadatas[i:i + batch_size],
+            ids=[f"c{i + j}" for j in range(len(batch))],
         )
 
     return collection
@@ -123,50 +142,64 @@ def build_vector_store(chunks: list[str], metadatas: list[dict]):
 
 # ─── STEP 5: RETRIEVE ─────────────────────────────────────────────────────────
 
-def retrieve_context(collection, topic: str, n_results: int = 10) -> tuple[list[str], list[dict]]:
+def retrieve_context(collection, topic: str, n_results: int = 6) -> tuple[list[str], list[dict]]:
     """
-    Run a semantic similarity search to retrieve the most relevant chunks.
+    Retrieve the most relevant chunks via cosine similarity.
 
-    The query is phrased to surface trend-signal language — not just
-    topic mentions. ChromaDB uses cosine similarity on the embeddings.
+    n_results=6 (down from 10) keeps the Gemini prompt comfortably
+    under the free-tier token-per-minute limit while preserving signal quality.
     """
     query = f"trend momentum growth decline viral popularity media coverage {topic}"
 
     results = collection.query(
         query_texts=[query],
-        n_results=min(n_results, collection.count())
+        n_results=min(n_results, collection.count()),
     )
     return results['documents'][0], results['metadatas'][0]
 
 
 # ─── STEP 6: GENERATE ─────────────────────────────────────────────────────────
 
+# Hard cap on context chars sent to Gemini.
+# 6 chunks × 400 chars = ~2400 chars raw. We cap at 3000 to stay well
+# under the free-tier 32K tokens-per-minute limit.
+MAX_CONTEXT_CHARS = 3000
+
 def analyse_with_gemini(
     topic: str,
     retrieved_docs: list[str],
     retrieved_meta: list[dict],
     total_articles: int,
     days_back: int,
-    gemini_key: str
+    gemini_key: str,
 ) -> dict:
     """
-    Pass the retrieved chunks (NOT all articles) to Gemini Flash for analysis.
-
-    This is the core RAG advantage: the model only sees the most semantically
-    relevant evidence, which produces more focused and accurate analysis
-    than dumping all 50 articles into the prompt.
+    Pass retrieved chunks to Gemini Flash for trend analysis.
 
-    response_mime_type="application/json" tells Gemini to return clean JSON
-    directly — no markdown fences, no preamble, no parsing headaches.
+    Reliability features:
+    - Context is hard-capped at MAX_CONTEXT_CHARS to prevent 429 token-rate errors.
+    - Auto-retry: on a 429 response, waits 15 s then retries up to 2 more times.
+    - response_mime_type="application/json" forces clean JSON — no parsing issues.
     """
-    context = "\n\n".join([
-        f"[{m['source']} · {m['published_at']}]\n{doc}"
-        for doc, m in zip(retrieved_docs, retrieved_meta)
-    ])
+    # Build context, truncating to stay inside token-rate limit
+    context_parts = []
+    total_chars = 0
+    for doc, m in zip(retrieved_docs, retrieved_meta):
+        entry = f"[{m['source']} · {m['published_at']}]\n{doc}"
+        if total_chars + len(entry) > MAX_CONTEXT_CHARS:
+            # Include a truncated version rather than skipping entirely
+            remaining = MAX_CONTEXT_CHARS - total_chars
+            if remaining > 80:
+                context_parts.append(entry[:remaining] + "…")
+            break
+        context_parts.append(entry)
+        total_chars += len(entry)
+
+    context = "\n\n".join(context_parts)
 
     prompt = f"""You are a senior trend analyst at a social listening company (like Pulsar, Brandwatch, or Sprinklr).
 
-You have been given the {len(retrieved_docs)} most semantically relevant news excerpts about "{topic}", 
+You have been given the {len(context_parts)} most semantically relevant news excerpts about "{topic}",
 retrieved via RAG from a corpus of {total_articles} articles published in the last {days_back} days.
 
 RETRIEVED CONTEXT:
@@ -200,104 +233,120 @@ Phase definitions:
     model = genai.GenerativeModel(
         model_name="gemini-2.0-flash",
         generation_config=genai.GenerationConfig(
-            response_mime_type="application/json",  # Forces clean JSON output
-            max_output_tokens=900,
-        )
+            response_mime_type="application/json",
+            max_output_tokens=600,
+        ),
     )
-    response = model.generate_content(prompt)
-    return json.loads(response.text)
+
+    # Retry loop: up to 3 attempts, 15-second pause on 429
+    last_error = None
+    for attempt in range(3):
+        try:
+            response = model.generate_content(prompt)
+            return json.loads(response.text)
+        except Exception as e:
+            last_error = e
+            if "429" in str(e) and attempt < 2:
+                wait = 15 * (attempt + 1)   # 15 s, then 30 s
+                time.sleep(wait)
+                continue
+            break
+
+    raise last_error
 
 
 # ─── PIPELINE ORCHESTRATOR ────────────────────────────────────────────────────
 
-def run_analysis(topic: str, days_back: int, newsapi_key_input: str, gemini_key_input: str):
+def run_analysis(topic: str, days_back: int, newsapi_key_input: str, gemini_key_input: str,
+                 boolean_query: str = ""):
     """
-    Runs the full 6-step RAG pipeline and returns formatted Gradio outputs.
-    Returns 6 values matching the 6 gr.Markdown output components.
+    Orchestrates the full 6-step RAG pipeline.
+    Returns 6 Markdown strings for the Gradio output components.
     """
     EMPTY = ("", "", "", "", "", "")
 
     if not topic.strip():
-        return ("⚠️ Please enter a topic.", *EMPTY[1:])
+        return ("⚠️ Please enter a topic label (used for the Gemini prompt even in Boolean mode).", *EMPTY[1:])
 
-    # Resolve API keys: UI input → environment variable → error
     news_key   = newsapi_key_input.strip()  or os.environ.get("NEWSAPI_KEY", "")
     gemini_key = gemini_key_input.strip()   or os.environ.get("GEMINI_API_KEY", "")
 
     if not news_key:
-        return ("⚠️ NewsAPI key is required. Get a free key at newsapi.org", *EMPTY[1:])
+        return ("⚠️ NewsAPI key required. Free key at newsapi.org", *EMPTY[1:])
     if not gemini_key:
-        return ("⚠️ Gemini API key is required. Get a free key at aistudio.google.com", *EMPTY[1:])
+        return ("⚠️ Gemini key required. Free key at aistudio.google.com", *EMPTY[1:])
+
+    using_boolean = bool(boolean_query.strip())
+    search_label  = boolean_query.strip() if using_boolean else topic
 
     try:
-        # ── Step 1: Fetch ──────────────────────────────────────────────────
-        articles = fetch_articles(topic, int(days_back), news_key)
+        # Step 1
+        articles = fetch_articles(topic, int(days_back), news_key, boolean_query)
         if not articles:
-            return (
-                f"⚠️ No articles found for **'{topic}'** in the last {days_back} days.\n\n"
-                "Try a broader topic, shorter name, or longer date range.",
-                *EMPTY[1:]
+            hint = (
+                f"Boolean query returned no results: `{boolean_query}`\n\nCheck your operators and try broader terms."
+                if using_boolean else
+                f"No articles found for **'{topic}'** in the last {days_back} days.\n\nTry a shorter or broader topic name."
             )
+            return (f"⚠️ {hint}", *EMPTY[1:])
 
-        # ── Steps 2–4: Chunk → Embed → Store ──────────────────────────────
+        # Steps 2–4
         chunks, metadatas = chunk_articles(articles)
         collection = build_vector_store(chunks, metadatas)
 
-        # ── Step 5: Retrieve ───────────────────────────────────────────────
+        # Step 5
         retrieved_docs, retrieved_meta = retrieve_context(collection, topic)
 
-        # ── Step 6: Generate ───────────────────────────────────────────────
+        # Step 6
         result = analyse_with_gemini(
             topic, retrieved_docs, retrieved_meta,
-            len(articles), int(days_back), gemini_key
+            len(articles), int(days_back), gemini_key,
         )
 
-        # ── Format outputs ─────────────────────────────────────────────────
-        phase_icons = {
-            "Early": "🌱", "Rising": "📈", "Peak": "🔥",
-            "Declining": "📉", "Fading": "🌫️"
-        }
-        phase_colors = {
-            "Early": "#22c55e", "Rising": "#3b82f6", "Peak": "#f97316",
-            "Declining": "#ef4444", "Fading": "#94a3b8"
-        }
-        phase     = result.get("phase", "Unknown")
-        icon      = phase_icons.get(phase, "❓")
-        color     = phase_colors.get(phase, "#6b7280")
-
-        phase_md = f"## {icon} {phase.upper()}"
-
-        scores_md = f"""### 📊 Metrics
-| | |
-|---|---|
-| **Confidence** | `{result.get('confidence', '—')}%` |
-| **Momentum Score** | `{result.get('momentum_score', '—')} / 100` |
-| **Media Spread** | `{result.get('media_spread', '—')}` |
-| **Articles Fetched** | `{len(articles)}` |
-| **Chunks in Vector Store** | `{len(chunks)}` |
-| **Chunks Retrieved via RAG** | `{len(retrieved_docs)}` |"""
-
-        summary_md = f"### 📝 Narrative\n{result.get('summary', '')}"
-
-        signals_md = "### 🔍 Key Signals\n" + "\n".join(
-            [f"- {s}" for s in result.get('key_signals', [])]
-        ) + "\n\n**Top Themes:** " + "  ".join(
-            [f"`{t}`" for t in result.get('top_themes', [])]
+        # ── Format outputs ────────────────────────────────────────────────
+        phase_icons  = {"Early": "🌱", "Rising": "📈", "Peak": "🔥", "Declining": "📉", "Fading": "🌫️"}
+        phase        = result.get("phase", "Unknown")
+        icon         = phase_icons.get(phase, "❓")
+        phase_md     = f"## {icon} {phase.upper()}"
+
+        mode_label = f"Boolean: `{boolean_query.strip()}`" if using_boolean else "Simple (auto)"
+        scores_md = (
+            f"### 📊 Metrics\n| | |\n|---|---|\n"
+            f"| **Confidence** | `{result.get('confidence', '—')}%` |\n"
+            f"| **Momentum Score** | `{result.get('momentum_score', '—')} / 100` |\n"
+            f"| **Media Spread** | `{result.get('media_spread', '—')}` |\n"
+            f"| **Search Mode** | {mode_label} |\n"
+            f"| **Articles Fetched** | `{len(articles)}` |\n"
+            f"| **Chunks in Vector Store** | `{len(chunks)}` |\n"
+            f"| **Chunks Sent to Gemini** | `{len(retrieved_docs)}` |"
         )
 
+        summary_md    = f"### 📝 Narrative\n{result.get('summary', '')}"
+        signals_md    = (
+            "### 🔍 Key Signals\n"
+            + "\n".join(f"- {s}" for s in result.get('key_signals', []))
+            + "\n\n**Top Themes:** "
+            + "  ".join(f"`{t}`" for t in result.get('top_themes', []))
+        )
         prediction_md = f"### 🔮 30-Day Prediction\n_{result.get('prediction_30d', '')}_"
-
-        sources_md = "### 📰 Articles Used in RAG Retrieval\n" + "\n".join([
+        sources_md    = "### 📰 Sources Retrieved via RAG\n" + "\n".join(
             f"- **{m['source']}** ({m['published_at']}): _{m['title']}_"
             for m in retrieved_meta[:6]
-        ])
+        )
 
         return phase_md, scores_md, summary_md, signals_md, prediction_md, sources_md
 
     except json.JSONDecodeError:
-        return ("⚠️ Could not parse analysis response. Please try again.", *EMPTY[1:])
+        return ("⚠️ Could not parse Gemini response. Please try again.", *EMPTY[1:])
     except Exception as e:
-        return (f"⚠️ Error: {str(e)}", *EMPTY[1:])
+        err = str(e)
+        if "429" in err:
+            return (
+                "⚠️ **Rate limit hit (429).** Gemini free tier allows ~15 requests/minute.\n\n"
+                "Wait 60 seconds and try again — the retry logic above handled 2 attempts already.",
+                *EMPTY[1:]
+            )
+        return (f"⚠️ Error: {err}", *EMPTY[1:])
 
 
 # ─── GRADIO UI ────────────────────────────────────────────────────────────────
@@ -315,24 +364,28 @@ footer { display: none !important; }
 """
 
 HOWTO = """
-**Step 1 — Fetch:** NewsAPI retrieves up to 50 articles matching your topic from the selected date range.
+**Step 1 — Fetch:** NewsAPI retrieves up to 50 articles. Two modes: *Simple* (auto exact-phrase then broad fallback) or *Boolean* — where your query is passed directly to NewsAPI supporting `AND`, `OR`, `NOT`, `"exact phrase"`, and `(grouping)`. Boolean mode gives you precise control over what enters the RAG corpus.
 
-**Step 2 — Chunk:** LangChain's `RecursiveCharacterTextSplitter` breaks each article into overlapping 400-character chunks (~80 words). Overlap prevents information loss at chunk boundaries.
+**Step 2 — Chunk:** LangChain's `RecursiveCharacterTextSplitter` breaks each article into overlapping 400-character chunks. Overlap prevents information loss at chunk boundaries.
 
-**Step 3 — Embed:** Each chunk is encoded into a 384-dimensional dense vector using `all-MiniLM-L6-v2` (Sentence Transformers) — optimised for semantic similarity, runs without a GPU.
+**Step 3 — Embed:** Each chunk is encoded into a 384-dimensional dense vector using `all-MiniLM-L6-v2` (Sentence Transformers) — no GPU needed.
 
-**Step 4 — Store:** All vectors are loaded into a ChromaDB `EphemeralClient` collection (fully in-memory — no disk writes, stateless per request).
+**Step 4 — Store:** All vectors are loaded into a ChromaDB `EphemeralClient` collection (fully in-memory, stateless per request).
 
-**Step 5 — Retrieve:** A trend-signal query is run against the vector store. ChromaDB uses cosine similarity to return the 10 most semantically relevant chunks from across all articles.
+**Step 5 — Retrieve:** A trend-signal query runs against the vector store. ChromaDB returns the 6 most semantically relevant chunks via cosine similarity.
 
-**Step 6 — Generate:** Gemini Flash receives *only* the retrieved chunks as context — not all 50 articles. This is the core RAG advantage: focused, grounded, efficient analysis with a minimal prompt. `response_mime_type="application/json"` guarantees clean structured output.
+**Step 6 — Generate:** Gemini Flash receives only the retrieved chunks (capped at 3,000 chars) — not all 50 articles. This keeps the prompt inside the free-tier token-rate limit and is the core RAG advantage. Auto-retries on 429 with a 15-second wait.
 """
 
-with gr.Blocks(theme=gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="slate",
-    font=[gr.themes.GoogleFont("DM Sans"), "ui-sans-serif", "sans-serif"]
-), css=CSS, title="Trend Longevity Analyser") as demo:
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="slate",
+        font=[gr.themes.GoogleFont("DM Sans"), "ui-sans-serif", "sans-serif"],
+    ),
+    css=CSS,
+    title="Trend Longevity Analyser",
+) as demo:
 
     with gr.Column(elem_id="title-block"):
         gr.Markdown("""
@@ -342,39 +395,46 @@ with gr.Blocks(theme=gr.themes.Soft(
 
     gr.Markdown("---")
 
-    # ── Inputs ────────────────────────────────────────────────────────────────
     with gr.Accordion("🔑 API Keys", open=False):
         gr.Markdown(
-            "_Keys entered here are used only for your request and never stored. "
-            "If you're hosting this Space privately, set `NEWSAPI_KEY` and "
-            "`GEMINI_API_KEY` as Secrets instead._"
+            "_Keys are used only for your request and never stored. "
+            "Set `NEWSAPI_KEY` and `GEMINI_API_KEY` as Space Secrets to avoid entering them each time._"
         )
         with gr.Row():
-            newsapi_input = gr.Textbox(label="NewsAPI Key",        placeholder="Get free key at newsapi.org",        type="password")
-            gemini_input  = gr.Textbox(label="Google Gemini API Key", placeholder="Get free key at aistudio.google.com", type="password")
+            newsapi_input = gr.Textbox(label="NewsAPI Key",          placeholder="newsapi.org — free",         type="password")
+            gemini_input  = gr.Textbox(label="Google Gemini API Key", placeholder="aistudio.google.com — free", type="password")
 
     with gr.Row():
         with gr.Column(scale=4):
             topic_input = gr.Textbox(
-                label="Topic / Trend",
-                placeholder="e.g.  'Gen Z workplace burnout'  ·  'green hydrogen'  ·  'AI companions'",
-                lines=1
+                label="Topic Label",
+                placeholder="e.g.  Gen Z workplace burnout  ·  green hydrogen  ·  AI companions",
+                info="Used as the display name and passed to Gemini. Always required.",
+                lines=1,
             )
         with gr.Column(scale=1):
-            days_input = gr.Slider(label="Days Back", minimum=7, maximum=30, value=30, step=7,
-                                   info="Free NewsAPI tier = 30 days max")
+            days_input = gr.Slider(
+                label="Days Back", minimum=7, maximum=30, value=30, step=7,
+                info="Free NewsAPI tier = 30 days max",
+            )
+
+    boolean_input = gr.Textbox(
+        label="⚡ Boolean Search Query (optional — overrides simple search)",
+        placeholder='e.g.  "Gen Z" AND (burnout OR "quiet quitting") NOT productivity',
+        info='Operators: AND  OR  NOT  "exact phrase"  (grouping)  — passed directly to NewsAPI',
+        lines=1,
+    )
 
     analyse_btn = gr.Button("🔍  Analyse Trend", variant="primary", size="lg")
 
     gr.Markdown("---")
 
-    # ── Outputs ───────────────────────────────────────────────────────────────
     phase_output = gr.Markdown(elem_classes=["phase-box"])
 
     with gr.Row():
         with gr.Column():
-            scores_output     = gr.Markdown(elem_classes=["metric-card"])
-            signals_output    = gr.Markdown()
+            scores_output  = gr.Markdown(elem_classes=["metric-card"])
+            signals_output = gr.Markdown()
         with gr.Column():
             summary_output    = gr.Markdown()
             prediction_output = gr.Markdown()
@@ -386,18 +446,16 @@ with gr.Blocks(theme=gr.themes.Soft(
 
     gr.Markdown(
         "_Built by [Sammie Wong](https://linkedin.com/in/) · "
-        "Source: [GitHub](https://github.com/) · "
         "Powered by [NewsAPI](https://newsapi.org) + [ChromaDB](https://www.trychroma.com) + "
-        "[Gemini Flash](https://aistudio.google.com)_",
+        "[Gemini Flash](https://aistudio.google.com)_"
     )
 
-    # ── Wire up ───────────────────────────────────────────────────────────────
     analyse_btn.click(
         fn=run_analysis,
-        inputs=[topic_input, days_input, newsapi_input, gemini_input],
+        inputs=[topic_input, days_input, newsapi_input, gemini_input, boolean_input],
         outputs=[phase_output, scores_output, summary_output,
-                 signals_output, prediction_output, sources_output]
+                 signals_output, prediction_output, sources_output],
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()