Update app.py

app.py

@@ -2,18 +2,45 @@ import yt_dlp
 import os
 import gradio as gr
 import random
-import time
 import threading
-import datetime
-import re
 import requests
 from gradio_client import Client
 from huggingface_hub import InferenceClient
 
 # =====================================================
-# CONFIG & SECRETS
+# 🎨 CSS & UI CONFIGURATION (RESPONSIVE)
+# =====================================================
+custom_css = """
+/* Hide the footer for a cleaner look */
+footer {visibility: hidden}
+
+/* PC Styles */
+.container { max-width: 1200px; margin: auto; padding-top: 20px; }
+.card { border-radius: 12px; border: 1px solid #e5e7eb; padding: 20px; margin-bottom: 20px; }
+
+/* Mobile Response */
+@media (max-width: 768px) {
+    .gradio-container { padding: 5px !important; }
+    .group-container { padding: 10px !important; }
+    button { min-height: 50px; }
+}
+
+/* Error Message Styling */
+.error-box { 
+    text-align: center; 
+    padding: 50px; 
+    background: #FEF2F2; 
+    border: 2px solid #F87171; 
+    border-radius: 10px; 
+    color: #991B1B;
+    font-size: 1.2rem;
+    font-weight: bold;
+}
+"""
+
+# =====================================================
+# ⚙️ CONFIG & CLIENTS
 # =====================================================
-# Downloader Config
 PROXY_SPACE_URL = "lexicalspace/Proxy-Server"
 OUTPUT_DIR = "downloads"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
@@ -22,108 +49,75 @@ MAX_CONCURRENCY = 6
 MAX_QUEUE = 20        
 
 # SEO Config
-# Ensure 'HF_TOKEN' is set in your Space Settings > Secrets
 HF_TOKEN = os.getenv("HF_TOKEN")
 SEO_MODEL_ID = "Qwen/Qwen2.5-Coder-32B-Instruct"
 
-# Initialize SEO Client
-# We wrap this in a try/except to prevent crash if token is missing
 try:
     seo_client = InferenceClient(api_key=HF_TOKEN)
-except Exception:
+except:
     seo_client = None
 
 # =====================================================
-# GLOBAL STATE (Downloader)
+# 🔄 GLOBAL STATE
 # =====================================================
 active_jobs = {}
 job_lock = threading.Lock()
 
 # =====================================================
-# PART 1: DOWNLOADER LOGIC
+# 📥 PART 1: DOWNLOADER LOGIC
 # =====================================================
 def get_proxy_batch():
     try:
         client = Client(PROXY_SPACE_URL)
-        result = client.predict(api_name="/get_proxies_api")
-        proxies = result[0]
-        if proxies:
-            random.shuffle(proxies)
-            return [f"http://{p}" for p in proxies[:6]]
-    except:
-        pass
-    return []
+        return [f"http://{p}" for p in client.predict(api_name="/get_proxies_api")[0][:6]]
+    except: return []
 
 def get_best_proxy():
     try:
-        client = Client(PROXY_SPACE_URL)
-        result = client.predict(api_name="/get_proxies_api")
-        proxies = result[0]
-        if proxies:
-            return f"http://{random.choice(proxies)}"
-    except:
-        pass
-    return None
-
-def parse_time(time_str):
-    if not time_str: return None
-    try:
-        parts = list(map(int, time_str.split(':')))
-        if len(parts) == 1: return parts[0]
-        if len(parts) == 2: return parts[0] * 60 + parts[1]
-        if len(parts) == 3: return parts[0] * 3600 + parts[1] * 60 + parts[2]
-    except:
-        return None
-    return None
+        proxies = Client(PROXY_SPACE_URL).predict(api_name="/get_proxies_api")[0]
+        return f"http://{random.choice(proxies)}" if proxies else None
+    except: return None
 
 def build_format_selector(quality_mode):
-    if quality_mode == "Audio Only (Best)":
-        return {'format': 'bestaudio/best', 'postprocessors': [{'key': 'FFmpegExtractAudio','preferredcodec': 'mp3'}], 'ext': 'mp3'}
-    elif quality_mode == "Video (4K / Best)":
-        return {'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best', 'ext': 'mp4'}
-    elif quality_mode == "Video (1080p)":
-        return {'format': 'bestvideo[height<=1080][ext=mp4]+bestaudio[ext=m4a]/best[height<=1080][ext=mp4]', 'ext': 'mp4'}
-    elif quality_mode == "Video (720p)":
-        return {'format': 'bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/best[height<=720][ext=mp4]', 'ext': 'mp4'}
-    elif quality_mode == "Video (360p / Data Saver)":
-        return {'format': 'bestvideo[height<=360][ext=mp4]+bestaudio[ext=m4a]/best[height<=360][ext=mp4]', 'ext': 'mp4'}
-    return {}
+    if "Audio" in quality_mode: return {'format': 'bestaudio/best', 'postprocessors': [{'key': 'FFmpegExtractAudio','preferredcodec': 'mp3'}], 'ext': 'mp3'}
+    if "4K" in quality_mode: return {'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best', 'ext': 'mp4'}
+    height = 1080 if "1080" in quality_mode else 720 if "720" in quality_mode else 360
+    return {'format': f'bestvideo[height<={height}][ext=mp4]+bestaudio[ext=m4a]/best[height<={height}][ext=mp4]', 'ext': 'mp4'}
 
 def fetch_metadata(url):
-    if not url: return None, "⚠️ Please enter a URL first.", None, None, None
-    api_url = f"https://noembed.com/embed?url={url}"
+    if not url: return None, "⚠️ Please enter a URL.", None, None, None
     try:
-        response = requests.get(api_url, timeout=10)
-        data = response.json()
-        if "error" in data: return None, f"❌ API Error: {data.get('error')}", gr.update(interactive=False), None, None
+        data = requests.get(f"https://noembed.com/embed?url={url}", timeout=5).json()
+        if "error" in data: return None, f"❌ Error: {data['error']}", None, None, None
         
-        title = data.get('title', 'Unknown Title')
-        uploader = data.get('author_name', 'Unknown Channel')
-        thumb = data.get('thumbnail_url', None)
-        desc = f"### 🎬 {title}\n**👤 Channel:** {uploader}\n**⏱️ Duration:** N/A (API Limit)\n**👁️ Views:** N/A (API Limit)"
+        title = data.get('title', 'Media File')
+        desc = f"### 🎬 {title}\n**👤 Author:** {data.get('author_name', 'Unknown')}"
         safe_title = "".join([c for c in title if c.isalnum() or c in " ._-"])
-        return thumb, desc, gr.update(interactive=True), gr.update(value=safe_title), "✅ Metadata fetched"
+        return data.get('thumbnail_url'), desc, gr.update(interactive=True), safe_title, "✅ Ready"
     except Exception as e:
-        return None, f"❌ Error: {str(e)}", gr.update(interactive=False), None, None
+        return None, f"❌ Error: {str(e)}", None, None, None
 
-def run_downloader(engine_name, url, quality, start_time, end_time, custom_name, cookies, progress):
-    log = [f"🚀 Engine: {engine_name} | Quality: {quality}"]
+def run_downloader(engine_mode, url, quality, custom_name, cookies, progress=gr.Progress()):
+    if not url: return None, "⚠️ No URL provided", ""
+    
+    # Engine Selection
+    engine_name = "V2 (Fast)" if "V2" in engine_mode or ("Auto" in engine_mode and len(url) > 60) else "V1 (Stable)"
+    
     with job_lock:
-        if active_jobs.get(url) == "running": return None, "⛔ Already running", "Blocked"
+        if active_jobs.get(url) == "running": return None, "⛔ Already running", ""
         active_jobs[url] = "running"
     
-    format_opts = build_format_selector(quality)
-    filename_tmpl = f"{custom_name}.%(ext)s" if custom_name else '%(title)s.%(ext)s'
+    log = [f"🚀 Engine: {engine_name} | Q: {quality}"]
+    opts = build_format_selector(quality)
+    fname = f"{custom_name}.%(ext)s" if custom_name else '%(title)s.%(ext)s'
     
+    # Setup Proxy & Client
     proxies = get_proxy_batch() if "V1" in engine_name else ([get_best_proxy()] if get_best_proxy() else [None])
-    strategies = ["android", "ios", "web"] if "V1" in engine_name else ["android", "ios", "web", "tv"]
+    strategies = ["android", "web", "ios"]
     
-    s_sec, e_sec = parse_time(start_time), parse_time(end_time)
-    download_ranges = (lambda info, ydl: [{'start_time': s_sec or 0, 'end_time': e_sec or float('inf')}]) if (s_sec or e_sec) else None
-
-    success, final_file, cookie_path = False, None, None
-    if cookies:
-        cookie_path = f"cookies_{random.randint(1000,9999)}.txt"
+    success, final_file = False, None
+    cookie_path = f"cookies_{random.randint(1000,9999)}.txt" if cookies else None
+    if cookies: 
         with open(cookie_path, "w") as f: f.write(cookies)
 
     for proxy in proxies:
@@ -131,145 +125,125 @@ def run_downloader(engine_name, url, quality, start_time, end_time, custom_name,
         for strat in strategies:
             if success: break
             ydl_opts = {
-                'outtmpl': os.path.join(OUTPUT_DIR, filename_tmpl), 'noplaylist': True, 'quiet': True, 'force_ipv4': True,
-                'extractor_args': {'youtube': {'player_client': [strat]}}, **format_opts
+                'outtmpl': os.path.join(OUTPUT_DIR, fname),
+                'quiet': True, 'noplaylist': True,
+                'extractor_args': {'youtube': {'player_client': [strat]}},
+                **opts
             }
             if proxy: ydl_opts['proxy'] = proxy
-            if download_ranges: ydl_opts['download_ranges'] = download_ranges
             if cookie_path: ydl_opts['cookiefile'] = cookie_path
-            
-            def hook(d):
-                if d['status'] == 'downloading':
-                    total = d.get('total_bytes') or d.get('total_bytes_estimate')
-                    if total: progress(d.get('downloaded_bytes', 0) / total)
-            ydl_opts['progress_hooks'] = [hook]
 
             try:
                 with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                     info = ydl.extract_info(url, download=True)
-                    name = ydl.prepare_filename(info)
-                    base, _ = os.path.splitext(name)
-                    final_file = f"{base}.{format_opts.get('ext', 'mp4')}"
-                    if not os.path.exists(final_file):
-                        for f in os.listdir(OUTPUT_DIR):
-                            if f.startswith(os.path.basename(base)): final_file = os.path.join(OUTPUT_DIR, f); break
+                    fpath = ydl.prepare_filename(info)
+                    final_file = fpath.rsplit('.', 1)[0] + '.' + opts['ext']
                     if os.path.exists(final_file): success = True
             except: continue
-            
+
     if cookie_path and os.path.exists(cookie_path): os.remove(cookie_path)
     with job_lock: active_jobs.pop(url, None)
-    return (final_file, "✅ Complete", "\n".join(log)) if success else (None, "❌ Failed", "\n".join(log))
-
-def download_router(mode, quality, start, end, custom_name, cookies, url, progress=gr.Progress()):
-    engine = "V2 • Fast Engine" if "V2" in mode else "V1 • Stable Engine"
-    if "Auto" in mode: engine = "V2 • Fast Engine" if (len(url) > 70 or "list=" in url) else "V1 • Stable Engine"
-    return run_downloader(engine, url, quality, start, end, custom_name, cookies, progress)
+    
+    return (final_file, "✅ Download Complete", "\n".join(log)) if success else (None, "❌ Failed", "\n".join(log))
 
 # =====================================================
-# PART 2: SEO GENERATOR LOGIC
+# ⚡ PART 2: SEO LOGIC
 # =====================================================
-def generate_seo(code_snippet, file_type):
-    if not seo_client: return "🔒 Error: 'HF_TOKEN' not found in Secrets."
-    if not code_snippet.strip(): return "⚠️ Error: Please paste some code first."
-
-    system_instruction = f"""
-    You are an expert Technical SEO Specialist. Analyze the user's {file_type} code.
-    Your Goal: Generate Google-compliant JSON-LD structured data and SEO meta tags.
-    Output Format (Strict Markdown):
-    ## SEO Metadata
-    **Title:** [Engaging Title, max 60 chars]
-    **Description:** [Summary including keywords, max 160 chars]
-    **Keywords:** [5-8 comma-separated keywords]
-    ## JSON-LD Structured Data
-    ```json
-    [Insert VALID JSON-LD here]
-    ```
-    """
+def generate_seo(code, ftype):
+    if not seo_client: return "🔒 Error: HF_TOKEN missing in Secrets."
+    if not code: return "⚠️ Please paste code."
+    
+    prompt = f"Analyze this {ftype} code. Return valid JSON-LD and SEO Title/Description/Keywords."
     try:
-        response = seo_client.chat_completion(
-            model=SEO_MODEL_ID,
-            messages=[{"role": "system", "content": system_instruction}, {"role": "user", "content": f"Analyze:\n{code_snippet}"}],
-            max_tokens=1500, temperature=0.2
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
+        return seo_client.chat_completion("Qwen/Qwen2.5-Coder-32B-Instruct", messages=[{"role": "user", "content": prompt}], max_tokens=1000).choices[0].message.content
+    except Exception as e: return f"❌ Error: {str(e)}"
 
 # =====================================================
-# PART 3: COMBINED UI WITH ROUTING
+# 🧭 PART 3: ROUTING & UI
 # =====================================================
-def handle_deep_link(request: gr.Request):
+def router(request: gr.Request):
     """
-    Reads the URL parameters to decide which tab to open.
-    Example: ?mode=seo -> Opens SEO Tab
-    Example: ?mode=downloader -> Opens Downloader Tab
+    Determines which tool to show based on ?mode= URL parameter.
     """
     params = request.query_params
-    mode = params.get("mode") or params.get("tool")
-    
-    if mode == "seo":
-        return gr.Tabs(selected="seo_tab")
+    mode = params.get("mode")
+
+    # STRICT MODE: If mode is missing or wrong, show Error Page
+    if not mode:
+        # Default fallback (Optional: Change to 'dl_col' if you want a default tool)
+        return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+        
+    if mode == "downloader":
+        return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+    elif mode == "seo":
+        return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
     else:
-        return gr.Tabs(selected="dl_tab")
+        # WRONG URL -> Error Page
+        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
 
-# MAIN APP BLOCK
-with gr.Blocks(title="Lexical Space Tools", theme=gr.themes.Soft()) as app:
+# =====================================================
+# 🖥️ MAIN APP
+# =====================================================
+with gr.Blocks(css=custom_css, title="Lexical Space Tools", theme=gr.themes.Soft()) as app:
     
-    # We assign IDs to tabs so we can select them programmatically
-    with gr.Tabs() as main_tabs:
+    # --- 1. DOWNLOADER UI ---
+    with gr.Column(visible=False, elem_classes="container") as dl_col:
+        gr.Markdown("# 🚀 UltraMax Downloader")
         
-        # --- TAB 1: DOWNLOADER ---
-        with gr.TabItem("🚀 UltraMax Downloader", id="dl_tab"):
-            gr.Markdown("### 📥 Universal Media Downloader")
-            with gr.Row(variant="panel"):
-                url_input = gr.Textbox(label="Media URL", placeholder="Paste YouTube/Insta/TikTok link...", show_label=False, scale=4)
-                fetch_btn = gr.Button("🔍 Fetch Info", variant="primary", scale=1)
-            
+        with gr.Group(elem_classes="card"):
             with gr.Row():
-                thumb_preview = gr.Image(label="Thumbnail", interactive=False, height=180)
-                with gr.Column(scale=3):
-                    info_display = gr.Markdown("### ⏳ Waiting for link...")
-                    fetch_status = gr.Label(value="Idle", show_label=False)
-
-            with gr.Row(variant="panel"):
-                quality_select = gr.Dropdown(["Audio Only (Best)", "Video (4K / Best)", "Video (1080p)", "Video (720p)", "Video (360p / Data Saver)"], value="Audio Only (Best)", label="Quality")
-                engine_mode = gr.Radio(["Auto (Smart)", "V1 (Stable)", "V2 (Fast)"], value="Auto (Smart)", label="Engine")
-                
-            with gr.Accordion("⚙️ Advanced (Cut / Rename / Auth)", open=False):
-                with gr.Row():
-                    start_time = gr.Textbox(label="Start", placeholder="00:00")
-                    end_time = gr.Textbox(label="End", placeholder="01:30")
-                    custom_filename = gr.Textbox(label="Filename", placeholder="MyFile")
-                cookies_input = gr.Textbox(label="Cookies", placeholder="Netscape format...", lines=1)
-
-            dl_btn = gr.Button("⬇️ START DOWNLOAD", variant="stop", interactive=False, size="lg")
-            with gr.Accordion("📂 Output & Logs", open=True):
-                with gr.Row():
-                    file_out = gr.File(label="Output")
-                    log_out = gr.Textbox(label="Logs", lines=4)
-
-            # Downloader Events
-            fetch_btn.click(fetch_metadata, [url_input], [thumb_preview, info_display, dl_btn, custom_filename, fetch_status])
-            dl_btn.click(download_router, [engine_mode, quality_select, start_time, end_time, custom_filename, cookies_input, url_input], [file_out, fetch_status, log_out], concurrency_limit=MAX_CONCURRENCY)
-
-        # --- TAB 2: SEO GENERATOR ---
-        with gr.TabItem("⚡ SEO Generator", id="seo_tab"):
-            gr.Markdown("### 🔍 AI SEO & JSON-LD Generator")
+                url_input = gr.Textbox(label="URL", placeholder="Paste link...", scale=3, show_label=False)
+                fetch_btn = gr.Button("🔍 Fetch", variant="primary", scale=1)
+            
             with gr.Row():
+                thumb = gr.Image(label="Preview", height=150, interactive=False, show_label=False)
                 with gr.Column():
-                    input_type = gr.Radio(["python", "html"], label="File Type", value="python")
-                    code_input = gr.Code(language="python", label="Paste Code", lines=15)
-                    seo_btn = gr.Button("✨ Generate SEO Data", variant="primary", size="lg")
-                with gr.Column():
-                    output_markdown = gr.Markdown(label="Results")
+                    desc = gr.Markdown("### ⏳ Ready")
+                    status = gr.Label(value="Idle", show_label=False)
 
-            # SEO Events
-            input_type.change(lambda x: gr.Code(language=x), inputs=input_type, outputs=code_input)
-            seo_btn.click(generate_seo, [code_input, input_type], [output_markdown])
+        with gr.Accordion("⚙️ Settings (Quality / Rename)", open=False):
+            with gr.Row():
+                qual = gr.Dropdown(["Audio Only (Best)", "Video (1080p)", "Video (720p)"], value="Audio Only (Best)", label="Quality")
+                eng = gr.Radio(["Auto", "V1 (Stable)", "V2 (Fast)"], value="Auto", label="Engine")
+            fname = gr.Textbox(label="Filename (Optional)", placeholder="MyFile")
+            cookies = gr.Textbox(label="Cookies", placeholder="Netscape format...", lines=1)
 
-    # --- DEEP LINKING EVENT ---
-    # This runs when the page loads to check the URL
-    app.load(fn=handle_deep_link, inputs=None, outputs=main_tabs)
+        dl_btn = gr.Button("⬇️ Download Now", variant="stop", interactive=False, size="lg")
+        
+        with gr.Group(elem_classes="card"):
+            out_file = gr.File(label="Download")
+            out_log = gr.Textbox(label="Logs", lines=2)
+
+        # Events
+        fetch_btn.click(fetch_metadata, [url_input], [thumb, desc, dl_btn, fname, status])
+        dl_btn.click(run_downloader, [eng, url_input, qual, fname, cookies], [out_file, status, out_log])
+
+    # --- 2. SEO UI ---
+    with gr.Column(visible=False, elem_classes="container") as seo_col:
+        gr.Markdown("# ⚡ AI SEO Generator")
+        with gr.Group(elem_classes="card"):
+            ftype = gr.Radio(["python", "html"], label="Type", value="python")
+            code_in = gr.Code(language="python", lines=15, label="Code")
+            seo_btn = gr.Button("✨ Generate", variant="primary")
+        
+        res = gr.Markdown(label="Result")
+        
+        ftype.change(lambda x: gr.Code(language=x), inputs=ftype, outputs=code_in)
+        seo_btn.click(generate_seo, [code_in, ftype], [res])
+
+    # --- 3. ERROR / 404 UI ---
+    with gr.Column(visible=False, elem_classes="container") as error_col:
+        gr.HTML("""
+        <div class="error-box">
+            <h1>⚠️ Access Denied</h1>
+            <p>No tool is available at this URL.</p>
+            <p style="font-size: 1rem; color: #555;">Please check your link or contact the administrator.</p>
+        </div>
+        """)
+
+    # --- ROUTING HANDLER ---
+    # Checks URL on load and toggles visibility of columns
+    app.load(fn=router, inputs=None, outputs=[dl_col, seo_col, error_col])
 
 if __name__ == "__main__":
-    app.queue(max_size=MAX_QUEUE).launch()
+    app.queue(max_size=20).launch()