Update app.py

app.py

@@ -1,61 +1,37 @@
 import os
 os.system("playwright install")
+# app.py (Final version with async API)
+
 import gradio as gr
-from playwright.sync_api import sync_playwright, Error as PlaywrightError
+from playwright.async_api import async_playwright, Error as PlaywrightError
 from bs4 import BeautifulSoup
 import urllib.parse
 import datetime
 import atexit
 import re
+import os
 from itertools import cycle
-import uuid # For generating unique tab IDs
-
-try:
-    p = sync_playwright().start()
-    browser = p.firefox.launch(headless=True, timeout=60000)
-    print("✅ Playwright browser launched successfully.")
-except Exception as e:
-    print(f"❌ Could not launch Playwright browser. Original error: {e}")
-    exit()
-
-# This dictionary is the key to the solution. It maps a tab's unique ID
-# to its live, non-copyable Playwright Page and Context object.
-LIVE_CONTEXTS = {}  # { tab_id: { "context": PlaywrightContext, "page": PlaywrightPage } }
-
-def cleanup():
-    """Ensures all browser resources are closed when the app shuts down."""
-    print(f"🧹 Cleaning up: Closing {len(LIVE_CONTEXTS)} browser contexts...")
-    for tab_id, resources in LIVE_CONTEXTS.items():
-        if not resources["context"].is_closed():
-            resources["context"].close()
-    browser.close()
-    p.stop()
-atexit.register(cleanup)
+import uuid
 
+# --- 1. ASYNC GLOBAL RESOURCES ---
+# We will initialize these in a Gradio startup event.
+P = None
+BROWSER = None
+REVOLVER = None
+LIVE_CONTEXTS = {} # { tab_id: { "context": PlaywrightContext, "page": PlaywrightPage } }
 
+# --- 2. PLAIN DATA STATE CLASSES (Unchanged) ---
 class TabState:
-    """A plain data class representing a tab's state. Fully copyable."""
     def __init__(self, tab_id, proxy_used="Direct Connection"):
-        self.id = tab_id
-        self.url = "about:blank"
-        self.title = "New Tab"
+        self.id, self.url, self.title = tab_id, "about:blank", "New Tab"
         self.parsed_text = "Welcome! Navigate to a URL or search to get started."
-        self.links = []
-        self.proxy_used = proxy_used
+        self.links, self.proxy_used = [], proxy_used
 
 class BrowserState:
-    """A plain data class representing the browser's overall state."""
-    def __init__(self):
-        self.tabs = []  # A list of TabState objects
-        self.active_tab_id = None
-        # Add bookmarks, history etc. here if needed
-    
-    def get_active_tab(self) -> TabState | None:
-        if not self.active_tab_id: return None
-        return next((t for t in self.tabs if t.id == self.active_tab_id), None)
+    def __init__(self): self.tabs, self.active_tab_id = [], None
+    def get_active_tab(self): return next((t for t in self.tabs if t.id == self.active_tab_id), None)
 
-
-class CredentialRevolver: # (This class is unchanged)
+class CredentialRevolver: # Unchanged
     def __init__(self, proxy_string: str):
         self.proxies = self._parse_proxies(proxy_string)
         if self.proxies: self.proxy_cycler = cycle(self.proxies)
@@ -69,142 +45,97 @@ class CredentialRevolver: # (This class is unchanged)
     def get_next(self): return next(self.proxy_cycler) if self.proxy_cycler else None
     def count(self): return len(self.proxies)
 
-proxy_list_str = os.getenv("PROXY_LIST", "")
-revolver = CredentialRevolver(proxy_list_str)
+# --- 3. ASYNC LOGIC ---
+# All functions interacting with Playwright are now `async def`
 
-def _fetch_and_update_tab_state(tab_state: TabState, url: str):
-    """
-    The core function. It uses the tab_state's ID to find the LIVE page,
-    navigates it, and then updates the copyable tab_state object.
-    """
+async def _fetch_and_update_tab_state(tab_state: TabState, url: str):
     log = f"▶️ Navigating to {url}..."
     live_page = LIVE_CONTEXTS[tab_state.id]["page"]
-
     try:
-        live_page.goto(url, wait_until='domcontentloaded', timeout=30000)
+        await live_page.goto(url, wait_until='domcontentloaded', timeout=30000)
         tab_state.url = live_page.url
-        tab_state.title = live_page.title() or "No Title"
+        tab_state.title = await live_page.title() or "No Title"
         log += f"\n✅ Arrived at: {tab_state.url}"
-
-        html_content = live_page.content()
+        html_content = await live_page.content()
         soup = BeautifulSoup(html_content, 'lxml')
         for script in soup(["script", "style", "nav", "footer"]): script.extract()
         tab_state.parsed_text = soup.get_text(separator='\n', strip=True)
-
-        tab_state.links = []
-        for link in soup.find_all('a', href=True):
-            href = link['href']
-            absolute_url = urllib.parse.urljoin(tab_state.url, href)
-            if absolute_url.startswith('http') and not re.match(r'javascript:|mailto:', absolute_url):
-                link_text = link.get_text(strip=True) or "[No Link Text]"
-                tab_state.links.append({'text': link_text, 'url': absolute_url})
+        tab_state.links = [{'text': link.get_text(strip=True) or "[No Link Text]", 'url': urllib.parse.urljoin(tab_state.url, link['href'])} for link in soup.find_all('a', href=True) if link['href'] and link['href'].startswith('http')]
         log += f"\n🔗 Found {len(tab_state.links)} links."
     except PlaywrightError as e:
         error_message = str(e); tab_state.title = "Error"; tab_state.url = url
         tab_state.parsed_text = f"❌ Failed to load page.\n\nError: {error_message}"
         tab_state.links = []; log += f"\n❌ {error_message}"
-    
     return log
 
-def handle_action(browser_state: BrowserState, action: str, value=None):
-    """Main event handler. It modifies the browser_state and interacts with LIVE_CONTEXTS."""
-    log = ""
-    active_tab_state = browser_state.get_active_tab()
-
+async def handle_action(browser_state: BrowserState, action: str, value=None):
+    log = ""; active_tab_state = browser_state.get_active_tab()
     if action == "new_tab":
         tab_id = str(uuid.uuid4())
-        proxy_config = revolver.get_next()
-        
-        context = browser.new_context(proxy=proxy_config)
-        page = context.new_page()
+        proxy_config = REVOLVER.get_next()
+        context = await BROWSER.new_context(proxy=proxy_config)
+        page = await context.new_page()
         LIVE_CONTEXTS[tab_id] = {"context": context, "page": page}
-
         new_tab = TabState(tab_id, proxy_used=proxy_config['server'] if proxy_config else "Direct")
         browser_state.tabs.append(new_tab)
         browser_state.active_tab_id = tab_id
-        
-        # Now navigate the new tab
-        log = _fetch_and_update_tab_state(new_tab, "https://www.whatsmyip.org/")
-    
+        log = await _fetch_and_update_tab_state(new_tab, "https://www.whatsmyip.org/")
     elif action == "go" and active_tab_state:
         url = value if (urllib.parse.urlparse(value).scheme and urllib.parse.urlparse(value).netloc) else f"https://duckduckgo.com/html/?q={urllib.parse.quote_plus(value)}"
-        log = _fetch_and_update_tab_state(active_tab_state, url)
-        
-    elif action == "click" and active_tab_state:
+        log = await _fetch_and_update_tab_state(active_tab_state, url)
+    elif action == "click" and active_tab_state and value is not None:
         try:
             link_index = int(value)
             if 0 <= link_index < len(active_tab_state.links):
-                link_url = active_tab_state.links[link_index]['url']
-                log = _fetch_and_update_tab_state(active_tab_state, link_url)
+                log = await _fetch_and_update_tab_state(active_tab_state, active_tab_state.links[link_index]['url'])
             else: log = "Invalid link number."
         except: log = "Please enter a valid number to click."
-        
     elif action == "close_tab" and active_tab_state:
-        if len(browser_state.tabs) <= 1:
-            log = "Cannot close the last tab."
-        else:
+        if len(browser_state.tabs) > 1:
             tab_to_close_id = browser_state.active_tab_id
-            
-            # Find and remove tab from state
             tab_index = browser_state.tabs.index(active_tab_state)
             browser_state.tabs.pop(tab_index)
-            
-            # Set new active tab
             new_index = tab_index - 1 if tab_index > 0 else 0
             browser_state.active_tab_id = browser_state.tabs[new_index].id
-            
-            # Close and remove live resources
             resources = LIVE_CONTEXTS.pop(tab_to_close_id)
-            if not resources['context'].is_closed():
-                resources['context'].close()
+            await resources['context'].close()
             log = f"💣 Tab closed."
-            
-    elif action == "switch_tab":
-        try:
-            # The value from the radio button is the tab_id itself
-            browser_state.active_tab_id = value
-            log = f"Switched to tab."
-        except: log = "Invalid tab format."
-    
-    # Return the modified state object. Gradio will handle copying it for the UI update.
+        else: log = "Cannot close the last tab."
+    elif action == "switch_tab" and value is not None:
+        browser_state.active_tab_id = value; log = f"Switched to tab."
     return browser_state, log
 
-
-def update_ui_components(browser_state: BrowserState):
-    """Generates all UI component values from the plain browser_state object."""
+def update_ui_components(browser_state: BrowserState): # This function is not async
     active_tab = browser_state.get_active_tab()
-    if not active_tab:
-        return {
-            page_content: gr.Markdown("No active tabs. Please create a new one."),
-            url_textbox: "", links_display: "",
-            tab_selector: gr.Radio(choices=[], label="Active Tabs"),
-        }
-        
-    # Use the tab ID as the value for the radio button
+    if not active_tab: return {page_content: gr.Markdown("No active tabs."), url_textbox: "", links_display: "", tab_selector: gr.Radio(choices=[])}
     tab_choices = [(f"Tab {i}: {t.title[:25]}... (via {t.proxy_used})", t.id) for i, t in enumerate(browser_state.tabs)]
-    
-    links_md = "### 🔗 Links on Page\n"
-    if active_tab.links:
-        for i, link in enumerate(active_tab.links[:25]): links_md += f"{i}. [{link['text'][:80]}]({link['url']})\n"
-    else: links_md += "_No links found._"
-        
+    links_md = "### 🔗 Links on Page\n" + ('\n'.join(f"{i}. [{link['text'][:80]}]({link['url']})" for i, link in enumerate(active_tab.links[:25])) if active_tab.links else "_No links found._")
     return {
         page_content: gr.Markdown(f"# {active_tab.title}\n**URL:** {active_tab.url}\n\n---\n\n{active_tab.parsed_text[:2000]}..."),
-        url_textbox: gr.Textbox(value=active_tab.url),
-        links_display: gr.Markdown(links_md),
+        url_textbox: gr.Textbox(value=active_tab.url), links_display: gr.Markdown(links_md),
         tab_selector: gr.Radio(choices=tab_choices, value=active_tab.id, label="Active Tabs"),
     }
 
-# --- Gradio UI Layout ---
+# --- 4. GRADIO UI AND STARTUP/SHUTDOWN EVENTS ---
+async def startup():
+    global P, BROWSER, REVOLVER
+    print("🚀 App starting up...")
+    P = await async_playwright().start()
+    BROWSER = await P.firefox.launch(headless=True)
+    proxy_list_str = os.getenv("PROXY_LIST", "")
+    REVOLVER = CredentialRevolver(proxy_list_str)
+    print(f"✅ Playwright started. {REVOLVER.count()} proxies loaded.")
+
+async def shutdown():
+    print("🧹 App shutting down...")
+    if BROWSER: await BROWSER.close()
+    if P: await P.stop()
+    print("✅ Playwright stopped.")
+
 with gr.Blocks(theme=gr.themes.Soft(), title="Real Browser Demo") as demo:
-    # Initialize the state with our new, copyable BrowserState class
     browser_state = gr.State(BrowserState())
-
-    gr.Markdown("# 🛰️ Real Browser Demo (with Proxies & State Fix)")
-    gr.Markdown(f"This demo runs a real headless browser. **{revolver.count()} proxies loaded**.")
-    # (The rest of the UI layout is the same)
-    # ...
-    # --- Gradio Interface Layout ---
+    gr.Markdown("# 🛰️ Real Browser Demo (Async API)")
+    # UI Layout is the same...
     with gr.Row():
         with gr.Column(scale=3):
             url_textbox = gr.Textbox(label="URL or Search Term", interactive=True)
@@ -217,30 +148,42 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Real Browser Demo") as demo:
             with gr.Accordion("Clickable Links", open=True):
                 links_display = gr.Markdown("...")
                 with gr.Row(): click_num_box = gr.Number(label="Link #", scale=1, minimum=0, step=1); click_btn = gr.Button("Click Link", scale=2)
-
+    
     all_outputs = [page_content, url_textbox, links_display, tab_selector, log_display]
 
-    def master_handler(current_state, action, value):
-        new_state, log = handle_action(current_state, action, value)
-        # The update_ui_components function now only needs the state
+    async def master_handler(current_state, action, value):
+        new_state, log = await handle_action(current_state, action, value)
         ui_updates = update_ui_components(new_state)
         ui_updates[log_display] = log
-        # IMPORTANT: Return the new_state object to update gr.State
         return new_state, ui_updates
 
-    # Initial load: create the first tab
-    demo.load(
-        lambda s: master_handler(s, "new_tab", None)[1], # Just return the UI updates
-        inputs=[browser_state],
-        outputs=list(all_outputs)
-    )
-
-    # Event listeners now call the master_handler
-    go_btn.click(lambda s, v: master_handler(s, "go", v), [browser_state, url_textbox], [browser_state, *all_outputs], show_progress="full")
-    url_textbox.submit(lambda s, v: master_handler(s, "go", v), [browser_state, url_textbox], [browser_state, *all_outputs], show_progress="full")
-    click_btn.click(lambda s, v: master_handler(s, "click", v), [browser_state, click_num_box], [browser_state, *all_outputs], show_progress="full")
-    new_tab_btn.click(lambda s: master_handler(s, "new_tab", None), [browser_state], [browser_state, *all_outputs], show_progress="full")
-    close_tab_btn.click(lambda s: master_handler(s, "close_tab", None), [browser_state], [browser_state, *all_outputs])
-    tab_selector.input(lambda s, v: master_handler(s, "switch_tab", v), [browser_state, tab_selector], [browser_state, *all_outputs])
+    # Initial Load - create first tab
+    async def initial_load(s):
+        _, ui_updates = await master_handler(s, "new_tab", None)
+        return ui_updates
+    
+    demo.load(initial_load, inputs=[browser_state], outputs=list(all_outputs))
+
+    # Event listeners - Gradio automatically awaits async functions
+    go_btn.click(master_handler, [browser_state, url_textbox], [browser_state, *all_outputs], fn_name="go", show_progress="full")
+    url_textbox.submit(master_handler, [browser_state, url_textbox], [browser_state, *all_outputs], fn_name="go", show_progress="full")
+    click_btn.click(master_handler, [browser_state, click_num_box], [browser_state, *all_outputs], fn_name="click", show_progress="full")
+    new_tab_btn.click(master_handler, [browser_state], [browser_state, *all_outputs], fn_name="new_tab", show_progress="full")
+    close_tab_btn.click(master_handler, [browser_state], [browser_state, *all_outputs], fn_name="close_tab")
+    tab_selector.input(master_handler, [browser_state, tab_selector], [browser_state, *all_outputs], fn_name="switch_tab")
+
+# The `startup` and `shutdown` events are not available in standard `Blocks`.
+# We manage this by doing the startup inside the first `load` event.
+# The global setup is the best way for Spaces.
+# A small tweak to make it work without official startup events:
+# The startup logic is moved to the global scope but needs an async context.
+# We will use the existing startup/shutdown logic and assume the Gradio version supports it or handles it gracefully.
+# The best practice would be to use a framework that has explicit startup/shutdown events like FastAPI.
+# For Gradio Spaces, the singleton pattern with async calls in handlers is the way to go.
+
+# Let's adjust for standard Gradio deployment.
+# We'll run startup manually before launching.
+import asyncio
+asyncio.run(startup())
 
 demo.launch()