Upload app.py with huggingface_hub

app.py

@@ -1,50 +1,35 @@
 """
-MAKER Framework - Hugging Face Space
-=====================================
-Reliable AI Agent with Web Search & File Upload
-Based on: https://arxiv.org/abs/2511.09030
+MAKER Agent - Clean Chat Interface
 """
 
 import gradio as gr
 import asyncio
-import json
-import re
-import base64
 from collections import Counter
-from dataclasses import dataclass, field
-from typing import Any, Callable, Optional
+from dataclasses import dataclass
+from typing import Callable
 from pathlib import Path
 
 # ============================================================================
-# MAKER Core (Embedded)
+# Core
 # ============================================================================
 
 @dataclass
 class VotingConfig:
     k: int = 3
     max_samples: int = 30
-    temperature_first: float = 0.0
     temperature_rest: float = 0.1
     parallel_samples: int = 3
 
-@dataclass
-class RedFlagConfig:
-    max_response_chars: int = 3000
-    min_response_length: int = 5
-    banned_patterns: list = field(default_factory=lambda: [r"I don't know", r"I cannot"])
-
 
 class LLMClient:
-    """Universal LLM client."""
-    
     def __init__(self, provider: str, api_key: str, model: str = None):
         self.provider = provider.lower()
         self.api_key = api_key
         self.model = model
         self._client = None
-        self._setup_client()
+        self._setup()
     
-    def _setup_client(self):
+    def _setup(self):
         if self.provider == "openai":
             from openai import AsyncOpenAI
             self._client = AsyncOpenAI(api_key=self.api_key)
@@ -66,332 +51,176 @@ class LLMClient:
             self._client = AsyncOpenAI(api_key=self.api_key, base_url="https://openrouter.ai/api/v1")
             self.model = self.model or "openai/gpt-4o-mini"
     
-    async def generate(self, prompt: str, temperature: float = 0.0, max_tokens: int = 1000) -> str:
+    async def generate(self, messages: list, temperature: float = 0.0) -> str:
         if self.provider == "anthropic":
-            r = await self._client.messages.create(
-                model=self.model, max_tokens=max_tokens,
-                messages=[{"role": "user", "content": prompt}]
-            )
+            system = ""
+            conv = []
+            for m in messages:
+                if m["role"] == "system":
+                    system = m["content"]
+                else:
+                    conv.append(m)
+            kwargs = {"model": self.model, "max_tokens": 2000, "messages": conv}
+            if system:
+                kwargs["system"] = system
+            r = await self._client.messages.create(**kwargs)
             return r.content[0].text
         else:
             r = await self._client.chat.completions.create(
-                model=self.model,
-                messages=[{"role": "user", "content": prompt}],
-                temperature=temperature, max_tokens=max_tokens
+                model=self.model, messages=messages,
+                temperature=temperature, max_tokens=2000
             )
             return r.choices[0].message.content
 
 
 class WebSearch:
-    """Web search using DuckDuckGo (free)."""
-    
     @staticmethod
-    async def search(query: str, num_results: int = 5) -> list:
+    async def search(query: str) -> str:
         try:
             from duckduckgo_search import DDGS
             results = []
             with DDGS() as ddgs:
-                for r in ddgs.text(query, max_results=num_results):
-                    results.append({
-                        "title": r.get("title", ""),
-                        "url": r.get("href", ""),
-                        "snippet": r.get("body", "")
-                    })
-            return results
-        except Exception as e:
-            return [{"title": "Error", "url": "", "snippet": str(e)}]
+                for r in ddgs.text(query, max_results=5):
+                    results.append(f"• {r.get('title', '')}: {r.get('body', '')}")
+            return "\n".join(results) if results else ""
+        except:
+            return ""
 
 
 class FileHandler:
-    """Handle file uploads."""
-    
     @staticmethod
-    async def load_file(file_path: str) -> dict:
-        path = Path(file_path)
-        ext = path.suffix.lower()
-        
+    def load(path: str) -> dict:
+        p = Path(path)
+        ext = p.suffix.lower()
         try:
-            if ext in {'.txt', '.md', '.json', '.py', '.js', '.html', '.css', '.csv'}:
-                content = path.read_text(encoding='utf-8', errors='replace')
-                return {"type": "text", "name": path.name, "content": content[:50000]}
-            
-            elif ext == '.pdf':
-                try:
-                    import pymupdf
-                    doc = pymupdf.open(str(path))
-                    text = "\n\n".join([page.get_text() for page in doc])
-                    doc.close()
-                    return {"type": "pdf", "name": path.name, "content": text[:50000]}
-                except ImportError:
-                    return {"type": "error", "name": path.name, "content": "PDF requires: pip install pymupdf"}
-            
+            if ext == '.pdf':
+                import pymupdf
+                doc = pymupdf.open(str(p))
+                text = "\n".join([page.get_text() for page in doc])
+                doc.close()
+                return {"name": p.name, "content": text[:20000]}
             elif ext == '.docx':
-                try:
-                    from docx import Document
-                    doc = Document(str(path))
-                    text = "\n\n".join([p.text for p in doc.paragraphs])
-                    return {"type": "docx", "name": path.name, "content": text[:50000]}
-                except ImportError:
-                    return {"type": "error", "name": path.name, "content": "DOCX requires: pip install python-docx"}
-            
-            elif ext in {'.png', '.jpg', '.jpeg', '.gif', '.webp'}:
-                content = path.read_bytes()
-                b64 = base64.b64encode(content).decode('utf-8')
-                return {"type": "image", "name": path.name, "base64": b64}
-            
+                from docx import Document
+                doc = Document(str(p))
+                text = "\n".join([para.text for para in doc.paragraphs])
+                return {"name": p.name, "content": text[:20000]}
             else:
-                content = path.read_text(encoding='utf-8', errors='replace')
-                return {"type": "text", "name": path.name, "content": content[:50000]}
-        
+                return {"name": p.name, "content": p.read_text(errors='replace')[:20000]}
         except Exception as e:
-            return {"type": "error", "name": path.name, "content": str(e)}
+            return {"name": p.name, "content": f"[Error reading file: {e}]"}
 
 
 class MAKERAgent:
-    """MAKER Framework Agent."""
-    
-    def __init__(self, llm: LLMClient, voting: VotingConfig = None, red_flags: RedFlagConfig = None):
+    def __init__(self, llm: LLMClient, voting: VotingConfig = None):
         self.llm = llm
         self.voting = voting or VotingConfig()
-        self.red_flags = red_flags or RedFlagConfig()
-        self.stats = {"samples": 0, "red_flags": 0, "tool_calls": 0}
-    
-    def _check_red_flags(self, response: str) -> bool:
-        if len(response) > self.red_flags.max_response_chars:
-            return True
-        if len(response) < self.red_flags.min_response_length:
-            return True
-        for pattern in self.red_flags.banned_patterns:
-            if re.search(pattern, response, re.IGNORECASE):
-                return True
-        return False
-    
-    def _parse_json(self, response: str) -> Optional[dict]:
-        response = re.sub(r'^```(?:json)?\s*', '', response.strip())
-        response = re.sub(r'\s*```$', '', response)
-        try:
-            result = json.loads(response)
-            return result if isinstance(result, dict) else None
-        except:
-            return None
-    
-    def _serialize(self, result) -> str:
-        if isinstance(result, dict):
-            return json.dumps(result, sort_keys=True)
-        return str(result)
+        self.history = []
     
-    async def execute(self, prompt: str, expected_keys: list = None, use_tools: bool = False,
-                      file_context: str = None, progress_callback: Callable = None) -> dict:
+    async def chat(self, message: str, search: bool = False, files: str = None) -> str:
+        messages = [{"role": "system", "content": "You are a helpful assistant." + (f"\n\nFiles:\n{files}" if files else "")}]
+        messages.extend(self.history[-10:])
         
-        full_prompt = ""
-        if file_context:
-            full_prompt += f"CONTEXT FROM FILES:\n{file_context}\n\n"
-        full_prompt += prompt
+        user_content = message
+        if search:
+            results = await WebSearch.search(message)
+            if results:
+                user_content += f"\n\n[Web search results]\n{results}"
         
-        if use_tools:
-            full_prompt += '\n\nTo search web: {"tool": "web_search", "query": "..."}'
-        full_prompt += "\n\nRespond with valid JSON only."
+        messages.append({"role": "user", "content": user_content})
         
+        # Voting
         votes: Counter = Counter()
-        results_map = {}
-        samples, flagged = 0, 0
-        tool_results = []
+        samples = 0
         
-        if progress_callback:
-            progress_callback(0.1, "Getting first sample...")
-        
-        response = await self.llm.generate(full_prompt, temperature=0.0)
+        response = await self.llm.generate(messages, temperature=0.0)
         samples += 1
-        self.stats["samples"] += 1
-        
-        # Handle tool calls
-        if use_tools:
-            parsed = self._parse_json(response)
-            if parsed and parsed.get("tool") == "web_search":
-                query = parsed.get("query", "")
-                if progress_callback:
-                    progress_callback(0.2, f"Searching: {query}...")
-                
-                search_results = await WebSearch.search(query)
-                tool_results.append({"query": query, "results": search_results})
-                self.stats["tool_calls"] += 1
-                
-                search_text = "\n".join([f"- {r['title']}: {r['snippet']}" for r in search_results[:5]])
-                full_prompt += f"\n\nSEARCH RESULTS:\n{search_text}\n\nNow provide final JSON answer."
-                response = await self.llm.generate(full_prompt, temperature=0.0)
-                samples += 1
-        
-        # Parse response
-        if self._check_red_flags(response):
-            flagged += 1
-            self.stats["red_flags"] += 1
-        else:
-            parsed = self._parse_json(response)
-            if parsed and (not expected_keys or all(k in parsed for k in expected_keys)):
-                key = self._serialize(parsed)
-                votes[key] += 1
-                results_map[key] = parsed
+        votes[response] += 1
         
-        # Voting loop
-        round_num = 1
         while samples < self.voting.max_samples:
-            if votes:
-                top = votes.most_common(2)
-                top_count = top[0][1]
-                second_count = top[1][1] if len(top) > 1 else 0
-                if top_count - second_count >= self.voting.k:
-                    break
-            
-            round_num += 1
-            if progress_callback:
-                progress_callback(0.2 + 0.6 * (samples / self.voting.max_samples), f"Voting round {round_num}...")
+            top = votes.most_common(2)
+            if top[0][1] - (top[1][1] if len(top) > 1 else 0) >= self.voting.k:
+                break
             
             for _ in range(self.voting.parallel_samples):
                 if samples >= self.voting.max_samples:
                     break
-                
-                response = await self.llm.generate(full_prompt, temperature=self.voting.temperature_rest)
+                r = await self.llm.generate(messages, temperature=self.voting.temperature_rest)
                 samples += 1
-                self.stats["samples"] += 1
-                
-                if self._check_red_flags(response):
-                    flagged += 1
-                    continue
-                
-                parsed = self._parse_json(response)
-                if parsed and (not expected_keys or all(k in parsed for k in expected_keys)):
-                    key = self._serialize(parsed)
-                    votes[key] += 1
-                    if key not in results_map:
-                        results_map[key] = parsed
+                votes[r] += 1
         
-        if progress_callback:
-            progress_callback(1.0, "Complete!")
+        winner = votes.most_common(1)[0][0] if votes else "Sorry, I couldn't generate a response."
         
-        if votes:
-            top_key, top_count = votes.most_common(1)[0]
-            return {
-                "success": True, "result": results_map[top_key],
-                "votes": top_count, "total_samples": samples,
-                "red_flagged": flagged, "vote_distribution": dict(votes),
-                "tool_results": tool_results
-            }
+        self.history.append({"role": "user", "content": message})
+        self.history.append({"role": "assistant", "content": winner})
         
-        return {"success": False, "result": None, "votes": 0, "total_samples": samples,
-                "red_flagged": flagged, "vote_distribution": {}, "tool_results": tool_results}
-
-
-# ============================================================================
-# Custom CSS
-# ============================================================================
-
-CUSTOM_CSS = """
-.gradio-container {
-    max-width: 1200px !important;
-}
-
-.header-title {
-    background: linear-gradient(90deg, #6366f1, #8b5cf6, #a855f7);
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    font-size: 2.5rem !important;
-    font-weight: 800 !important;
-    text-align: center;
-}
-
-.header-sub {
-    color: #64748b !important;
-    text-align: center;
-    margin-bottom: 1.5rem !important;
-}
-
-.primary-btn {
-    background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%) !important;
-    border: none !important;
-    font-weight: 600 !important;
-    border-radius: 8px !important;
-}
+        return winner
+    
+    def clear(self):
+        self.history = []
 
-.primary-btn:hover {
-    transform: translateY(-2px) !important;
-    box-shadow: 0 4px 12px rgba(99, 102, 241, 0.4) !important;
-}
-"""
 
 # ============================================================================
-# State & Functions
+# State
 # ============================================================================
 
-current_agent = None
-loaded_files = {}
+agent = None
+file_content = ""
 
-def create_agent(provider, api_key, model, k_votes):
-    global current_agent
-    if not api_key:
-        return "❌ Please enter API key"
+def connect(provider, key, model, k):
+    global agent
+    if not key.strip():
+        return "❌ Enter API key"
     try:
-        llm = LLMClient(provider, api_key, model if model else None)
-        current_agent = MAKERAgent(llm, VotingConfig(k=k_votes))
-        return f"✅ Agent ready: {provider} / {llm.model}"
+        agent = MAKERAgent(LLMClient(provider, key.strip(), model.strip() or None), VotingConfig(k=k))
+        return f"✅ Connected: {agent.llm.model}"
     except Exception as e:
-        return f"❌ Error: {e}"
+        return f"❌ {e}"
+
+def load_files(files):
+    global file_content
+    if not files:
+        file_content = ""
+        return "No files"
+    
+    parts = []
+    names = []
+    for f in files:
+        data = FileHandler.load(f.name)
+        parts.append(f"[{data['name']}]\n{data['content']}")
+        names.append(data['name'])
+    
+    file_content = "\n\n".join(parts)
+    return f"📎 {', '.join(names)}"
 
-async def run_query_async(prompt, use_search, use_files, expected_keys, progress=gr.Progress()):
-    global current_agent, loaded_files
+def respond(message, history, search, files):
+    global agent, file_content
     
-    if not current_agent:
-        return {"error": "Create agent first"}, "❌ No agent", ""
+    if files:
+        load_files(files)
     
-    file_context = None
-    if use_files and loaded_files:
-        parts = [f"=== {n} ===\n{i.get('content', '')[:10000]}" 
-                 for n, i in loaded_files.items() if i["type"] != "image"]
-        file_context = "\n\n".join(parts) if parts else None
+    if not agent:
+        return history + [[message, "⚠️ Connect to an LLM first (open Settings below)"]], ""
     
-    keys = [k.strip() for k in expected_keys.split(",") if k.strip()] if expected_keys else None
+    if not message.strip():
+        return history, ""
     
-    def update_progress(pct, msg):
-        progress(pct, desc=msg)
+    async def run():
+        return await agent.chat(message.strip(), search, file_content or None)
     
+    loop = asyncio.new_event_loop()
     try:
-        result = await current_agent.execute(prompt, keys, use_search, file_context, update_progress)
-        
-        stats = f"""### Stats
-- **Success**: {'✅' if result['success'] else '❌'}
-- **Votes**: {result['votes']}
-- **Samples**: {result['total_samples']}
-- **Red-flagged**: {result['red_flagged']}"""
-        
-        votes = "### Vote Distribution\n" + "\n".join([f"- {v} votes: {k[:80]}..." for k, v in 
-                sorted(result['vote_distribution'].items(), key=lambda x: -x[1])[:3]]) if result['vote_distribution'] else ""
-        
-        return result['result'], stats, votes
-    except Exception as e:
-        return {"error": str(e)}, f"❌ {e}", ""
-
-def run_query(prompt, use_search, use_files, expected_keys, progress=gr.Progress()):
-    return asyncio.run(run_query_async(prompt, use_search, use_files, expected_keys, progress))
-
-def handle_files(files):
-    global loaded_files
-    if not files:
-        loaded_files = {}
-        return "No files"
-    
-    loaded_files = {}
-    results = []
-    for f in files:
-        info = asyncio.run(FileHandler.load_file(f.name))
-        loaded_files[info['name']] = info
-        if info['type'] == 'error':
-            results.append(f"❌ {info['name']}: {info['content']}")
-        elif info['type'] == 'image':
-            results.append(f"🖼️ {info['name']}")
-        else:
-            results.append(f"✅ {info['name']} ({len(info.get('content', ''))} chars)")
+        response = loop.run_until_complete(run())
+    finally:
+        loop.close()
     
-    return "\n".join(results)
+    return history + [[message, response]], ""
 
+def clear():
+    global agent, file_content
+    if agent:
+        agent.clear()
+    file_content = ""
+    return [], None
 
 # ============================================================================
 # UI
@@ -399,162 +228,47 @@ def handle_files(files):
 
 with gr.Blocks(title="MAKER Agent") as demo:
     
-    gr.HTML("""
-        <div style="text-align: center; padding: 20px 0;">
-            <h1 class="header-title">🔧 MAKER Agent</h1>
-            <p class="header-sub">Reliable AI with Voting & Red-Flagging | Based on arxiv.org/abs/2511.09030</p>
-        </div>
-    """)
+    gr.Markdown("## 🔧 MAKER Agent")
     
-    with gr.Tabs():
-        
-        # Setup Tab
-        with gr.Tab("⚙️ Setup"):
-            gr.Markdown("### Configure your LLM provider")
-            with gr.Row():
-                with gr.Column():
-                    provider = gr.Dropdown(
-                        ["openai", "anthropic", "groq", "together", "openrouter"],
-                        value="openai", label="Provider"
-                    )
-                    api_key = gr.Textbox(label="API Key", type="password", placeholder="sk-...")
-                    model = gr.Textbox(label="Model (optional)", placeholder="Leave blank for default")
-                
-                with gr.Column():
-                    k_votes = gr.Slider(1, 10, value=3, step=1, label="K (votes needed to win)",
-                                       info="Higher = more reliable but slower")
-                    gr.Markdown("""
-                    ### How MAKER Works
-                    1. **Voting**: Samples multiple responses, winner needs K votes ahead
-                    2. **Red-Flagging**: Discards suspicious outputs (too long, malformed)
-                    3. **Tools**: Optional web search for current information
-                    """)
-            
-            setup_btn = gr.Button("🚀 Create Agent", elem_classes="primary-btn")
-            setup_status = gr.Markdown("👆 Enter your API key and click Create Agent to start")
-            setup_btn.click(create_agent, [provider, api_key, model, k_votes], setup_status)
-        
-        # Query Tab
-        with gr.Tab("💬 Query"):
-            gr.Markdown("### Ask a question")
-            with gr.Row():
-                with gr.Column(scale=2):
-                    prompt = gr.Textbox(
-                        label="Your Query", 
-                        lines=4, 
-                        placeholder="Ask anything... The agent will use voting to ensure reliable answers.\n\nExample: What are the key factors for startup success? Return as JSON with keys: factors, explanation"
-                    )
-                    with gr.Row():
-                        use_search = gr.Checkbox(label="🔍 Enable Web Search", info="Search DuckDuckGo for current info")
-                        use_files = gr.Checkbox(label="📁 Use Uploaded Files", info="Include file content in context")
-                    expected_keys = gr.Textbox(
-                        label="Expected JSON keys (optional)", 
-                        placeholder="answer, confidence, sources",
-                        info="Comma-separated list of required keys in response"
-                    )
-                    run_btn = gr.Button("▶️ Run Query", elem_classes="primary-btn")
-                
-                with gr.Column(scale=1):
-                    gr.Markdown("""### Example Queries
-                    
-**Simple Analysis:**
-```
-What factors lead to startup success?
-```
-
-**With Web Search:**
-```
-What are the latest AI news this week?
-```
-
-**With Expected Keys:**
-```
-Analyze the pros and cons of remote work.
-Expected keys: pros, cons, recommendation
-```
-""")
-            
-            gr.Markdown("---")
-            gr.Markdown("### Results")
-            
-            with gr.Row():
-                with gr.Column(scale=2):
-                    result_json = gr.JSON(label="Response")
-                with gr.Column(scale=1):
-                    stats_md = gr.Markdown("*Run a query to see stats*")
-                    votes_md = gr.Markdown("")
-            
-            run_btn.click(
-                run_query, 
-                [prompt, use_search, use_files, expected_keys],
-                [result_json, stats_md, votes_md]
+    chatbot = gr.Chatbot(height=450, show_label=False, bubble_full_width=False)
+    
+    # Input row with everything together
+    with gr.Group():
+        with gr.Row():
+            msg = gr.Textbox(
+                placeholder="Message MAKER...",
+                show_label=False,
+                scale=10,
+                container=False
             )
+            send = gr.Button("↑", variant="primary", scale=1, min_width=50)
         
-        # Files Tab
-        with gr.Tab("📁 Files"):
-            gr.Markdown("### Upload files for analysis")
-            gr.Markdown("Supported formats: PDF, DOCX, TXT, MD, JSON, CSV, PNG, JPG")
-            
-            file_upload = gr.File(
-                label="Upload Files", 
+        with gr.Row():
+            files = gr.File(
                 file_count="multiple",
-                file_types=[".pdf", ".docx", ".txt", ".md", ".json", ".csv", ".png", ".jpg", ".jpeg"]
+                file_types=[".pdf", ".docx", ".txt", ".md", ".json", ".csv", ".py"],
+                label="",
+                scale=3
             )
-            file_status = gr.Markdown("*No files uploaded*")
-            file_upload.change(handle_files, file_upload, file_status)
-            
-            gr.Markdown("""
-            ### How to use files
-            1. Upload your files above
-            2. Go to the **Query** tab
-            3. Check **"Use Uploaded Files"**
-            4. Ask questions about your documents!
-            """)
-        
-        # About Tab
-        with gr.Tab("ℹ️ About"):
-            gr.Markdown("""
-## About MAKER Framework
-
-**MAKER** (Massively Decomposed Agentic Processes) achieves near-zero errors through:
-
-| Pillar | Description |
-|--------|-------------|
-| **Maximal Decomposition** | Break tasks into single-step atomic operations |
-| **K-Voting** | Sample multiple times, winner needs K votes ahead |
-| **Red-Flagging** | Discard suspicious outputs (don't try to repair them) |
-
-### Key Insight
-
-> *"Reliability is an engineering problem, not a model problem."*
-
-Instead of waiting for better models, you can achieve near-zero errors TODAY using smaller, cheaper models with statistical voting.
-
-### Results from the Paper
-
-The researchers achieved **1,000,000 steps with ZERO errors** using gpt-4.1-mini!
-
-### Links
-
-- 📄 **Paper**: [arxiv.org/abs/2511.09030](https://arxiv.org/abs/2511.09030)
-- 🎥 **Video Explanation**: [YouTube](https://youtube.com/watch?v=TJ-vWGCosdQ)
-
-### Supported LLM Providers
-
-| Provider | Example Models |
-|----------|----------------|
-| OpenAI | gpt-4o-mini, gpt-4o |
-| Anthropic | claude-sonnet, claude-opus |
-| Groq | llama-3.3-70b (very fast!) |
-| Together | Llama, Mistral, Qwen |
-| OpenRouter | 100+ models |
-""")
+            search = gr.Checkbox(label="🔍 Web search", scale=1)
+            clear_btn = gr.Button("Clear chat", scale=1)
+    
+    # Settings
+    with gr.Accordion("⚙️ Settings", open=False):
+        with gr.Row():
+            provider = gr.Dropdown(["groq", "openai", "anthropic", "together", "openrouter"], value="groq", label="Provider")
+            api_key = gr.Textbox(label="API Key", type="password")
+            model = gr.Textbox(label="Model", placeholder="default")
+            k = gr.Slider(1, 7, value=3, step=1, label="K (reliability)")
+        with gr.Row():
+            connect_btn = gr.Button("Connect", variant="primary")
+            status = gr.Markdown("*Not connected*")
+        gr.Markdown("Free API: [console.groq.com](https://console.groq.com) • [Paper](https://arxiv.org/abs/2511.09030)")
     
-    gr.HTML("""
-        <div style="text-align:center; color:#64748b; padding:20px; border-top: 1px solid #e2e8f0; margin-top: 20px;">
-            MAKER Framework | Based on <a href="https://arxiv.org/abs/2511.09030" style="color:#6366f1">arxiv.org/abs/2511.09030</a>
-        </div>
-    """)
+    # Events
+    connect_btn.click(connect, [provider, api_key, model, k], status)
+    msg.submit(respond, [msg, chatbot, search, files], [chatbot, msg])
+    send.click(respond, [msg, chatbot, search, files], [chatbot, msg])
+    clear_btn.click(clear, None, [chatbot, files])
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()