Update app.py

app.py

@@ -11,39 +11,27 @@ from itertools import cycle
 import uuid
 
 # --- 1. GLOBAL RESOURCES & STATE ---
-# These are initialized on the first request to be compatible with Spaces.
+# Initialized on the first request to be compatible with Spaces.
 P = None
 BROWSER = None
 REVOLVER = None
-LIVE_CONTEXTS = {}  # { tab_id: { "context": PlaywrightContext, "page": PlaywrightPage } }
+LIVE_CONTEXTS = {}
 APP_STARTED = False
 
-# --- 2. PLAIN DATA STATE CLASSES (Copyable) ---
+# --- 2. PLAIN DATA STATE CLASSES ---
 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.parsed_text = "Welcome! Navigate to a URL or search to get started."
-        self.links = []
-        self.proxy_used = proxy_used
+        self.id, self.url, self.title = tab_id, "about:blank", "New Tab"
+        self.parsed_text, self.links, self.proxy_used = "Welcome!", [], proxy_used
 
 class BrowserState:
-    """A plain data class representing the browser's overall state."""
-    def __init__(self):
-        self.tabs = []
-        self.active_tab_id = None
-    def get_active_tab(self):
-        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:
-    """Manages a rotating list of proxies from an environment variable."""
     def __init__(self, proxy_string: str):
         self.proxies = self._parse_proxies(proxy_string)
-        if self.proxies: self.proxy_cycler = cycle(self.proxies)
-        else: self.proxy_cycler = None
+        self.proxy_cycler = cycle(self.proxies) if self.proxies else None
     def _parse_proxies(self, proxy_string: str):
         proxies = []
         for line in proxy_string.strip().splitlines():
@@ -53,42 +41,38 @@ class CredentialRevolver:
                 proxies.append({"server": server, "username": parsed.username, "password": parsed.password})
             except: pass
         return proxies
-    def get_next(self):
-        return next(self.proxy_cycler) if self.proxy_cycler else None
-    def count(self):
-        return len(self.proxies)
+    def get_next(self): return next(self.proxy_cycler) if self.proxy_cycler else None
+    def count(self): return len(self.proxies) if self.proxies else 0
 
 # --- 3. CORE ASYNC LOGIC ---
 async def _fetch_and_update_tab_state(tab_state: TabState, url: str):
-    """Uses Playwright to navigate and BeautifulSoup to parse, updating the TabState object."""
     log = f"▶️ Navigating to {url}..."; live_page = LIVE_CONTEXTS[tab_state.id]["page"]
     try:
         await live_page.goto(url, wait_until='domcontentloaded', timeout=30000)
         tab_state.url = live_page.url; tab_state.title = await live_page.title() or "No Title"
         log += f"\n✅ Arrived at: {tab_state.url}"
         html_content = await live_page.content(); soup = BeautifulSoup(html_content, 'lxml')
-        for script in soup(["script", "style", "nav", "footer"]): script.extract()
+        for el in soup(["script", "style", "nav", "footer", "aside"]): el.extract()
         tab_state.parsed_text = soup.get_text(separator='\n', strip=True)
         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.get('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
+    except Exception as e:
+        error_message = str(e).splitlines()[0]; 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
 
 async def handle_action(browser_state: BrowserState, action: str, value=None):
-    """Modifies the state based on user actions."""
     log = ""; active_tab_state = browser_state.get_active_tab()
     if action == "new_tab":
         tab_id, proxy_config = str(uuid.uuid4()), 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")
+        new_tab = TabState(tab_id, proxy_used=proxy_config['server'].split('@')[-1] if proxy_config else "Direct")
         browser_state.tabs.append(new_tab); browser_state.active_tab_id = tab_id
         log = await _fetch_and_update_tab_state(new_tab, "https://www.whatsmyip.org/")
-    elif action == "go" and active_tab_state:
+    elif action == "go" and active_tab_state and value:
         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 = await _fetch_and_update_tab_state(active_tab_state, url)
     elif action == "click" and active_tab_state and value is not None:
@@ -108,13 +92,10 @@ async def handle_action(browser_state: BrowserState, action: str, value=None):
         browser_state.active_tab_id = value; log = f"Switched to tab."
     return browser_state, log
 
-# **BUG FIX 1: NameError Fix**
-# This function is now defined before it is called by the master_handler.
 def update_ui_components(browser_state: BrowserState):
-    """Generates a dictionary of UI updates from the state. Not async."""
     active_tab = browser_state.get_active_tab()
     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)]
+    tab_choices = [(f"Tab {i}: {t.title[:25]}... ({t.proxy_used})", t.id) for i, t in enumerate(browser_state.tabs)]
     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]}..."),
@@ -126,7 +107,7 @@ def update_ui_components(browser_state: BrowserState):
 with gr.Blocks(theme=gr.themes.Soft(), title="Real Browser Demo") as demo:
     browser_state = gr.State(BrowserState())
     gr.Markdown("# 🛰️ Real Browser Demo (Final Working Version)")
-    # UI Layout is the same...
+    
     with gr.Row():
         with gr.Column(scale=3):
             url_textbox = gr.Textbox(label="URL or Search Term", interactive=True); go_btn = gr.Button("Go", variant="primary")
@@ -152,26 +133,32 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Real Browser Demo") as demo:
         new_state, log = await handle_action(current_state, action, value)
         ui_updates = update_ui_components(new_state)
         
-        # **BUG FIX 2: ValueError Fix**
-        # We must return a tuple with a value for EACH output component, in the correct order.
         return (
-            new_state, # 1. For the browser_state output
-            ui_updates[page_content], # 2.
-            ui_updates[url_textbox], # 3.
-            ui_updates[links_display], # 4.
-            ui_updates[tab_selector], # 5.
-            log # 6. The log textbox is now updated correctly
+            new_state,
+            ui_updates[page_content],
+            ui_updates[url_textbox],
+            ui_updates[links_display],
+            ui_updates[tab_selector],
+            log
         )
     
-    # Define simple async lambdas for each event to ensure clean wiring
-    on_load = lambda s: master_handler(s, "new_tab", None)
-    on_go_click = lambda s, v: master_handler(s, "go", v)
-    on_click_link = lambda s, v: master_handler(s, "click", v)
-    on_new_tab = lambda s: master_handler(s, "new_tab", None)
-    on_close_tab = lambda s: master_handler(s, "close_tab", None)
-    on_switch_tab = lambda s, v: master_handler(s, "switch_tab", v)
+    # ** THE DEFINITIVE FIX FOR GRADIO'S ASYNC RETURN VALUE ERROR **
+    # Each event listener is its own async function that awaits the handler.
+    # This ensures Gradio correctly receives the unpacked tuple of return values.
+
+    async def on_load(state):
+        return await master_handler(state, "new_tab", None)
+    async def on_go_click(state, value):
+        return await master_handler(state, "go", value)
+    async def on_click_link(state, value):
+        return await master_handler(state, "click", value)
+    async def on_new_tab(state):
+        return await master_handler(state, "new_tab", None)
+    async def on_close_tab(state):
+        return await master_handler(state, "close_tab", None)
+    async def on_switch_tab(state, value):
+        return await master_handler(state, "switch_tab", value)
         
-    # Wire up the new, clean event handlers
     demo.load(on_load, inputs=[browser_state], outputs=[browser_state, *all_outputs])
     go_btn.click(on_go_click, [browser_state, url_textbox], [browser_state, *all_outputs], show_progress="full")
     url_textbox.submit(on_go_click, [browser_state, url_textbox], [browser_state, *all_outputs], show_progress="full")