Update app.py

app.py

@@ -1,3 +1,5 @@
+# app.py - Your Flask API Server
+
 import os
 import re
 import urllib.parse
@@ -6,12 +8,10 @@ from typing import Dict, Optional
 from itertools import cycle
 
 # Install playwright if not present
-# This is often needed in environments like HF Spaces
 if os.getenv("PLAYWRIGHT_INSTALL_RUN", "false").lower() != "true":
     os.system("playwright install --with-deps")
     os.environ["PLAYWRIGHT_INSTALL_RUN"] = "true"
 
-
 from flask import Flask, request, jsonify
 from bs4 import BeautifulSoup, NavigableString
 from playwright.async_api import async_playwright
@@ -47,7 +47,6 @@ class CredentialRevolver:
         return len(self.proxies)
 
 PLAYWRIGHT_STATE: Dict = {}
-# For Hugging Face Spaces, it's better to use Space secrets for PROXY_LIST
 REVOLVER = CredentialRevolver(os.getenv("PROXY_LIST", ""))
 
 SEARCH_ENGINES = {
@@ -120,40 +119,39 @@ class HTML_TO_MARKDOWN_CONVERTER:
             return f"\n\n![{alt}]({full_src})\n\n"
         return inner_md
 
-# --- Core Web Browsing Logic (unchanged) ---
-async def perform_web_browse(action: str, query: str, browser_name: str, search_engine_name: str):
-    browser_key = browser_name.lower()
+# --- Core Web Browsing Logic ---
+# UPDATED: The function signature now uses `browser` and `search_engine` for consistency.
+async def perform_web_browse(action: str, query: str, browser: str, search_engine: str):
+    browser_key = browser.lower()
     if "playwright" not in PLAYWRIGHT_STATE:
         PLAYWRIGHT_STATE["playwright"] = await async_playwright().start()
 
-    # Use a persistent browser instance to avoid re-launching on every call
     if browser_key not in PLAYWRIGHT_STATE:
         try:
             p = PLAYWRIGHT_STATE["playwright"]
             browser_map = {'firefox': p.firefox, 'chromium': p.chromium, 'webkit': p.webkit}
             browser_launcher = browser_map.get(browser_key)
             if not browser_launcher:
-                 raise ValueError(f"Invalid browser name: {browser_name}")
-            # In some containerized environments, --no-sandbox is needed for chromium
+                 raise ValueError(f"Invalid browser name: {browser}")
             launch_args = ['--no-sandbox'] if browser_key == 'chromium' else []
             browser_instance = await browser_launcher.launch(headless=True, args=launch_args)
             PLAYWRIGHT_STATE[browser_key] = browser_instance
         except Exception as e:
             return {"status": "error", "query": query, "error_message": f"Failed to launch '{browser_key}'. Error: {str(e).splitlines()[0]}"}
-    
+
     browser_instance = PLAYWRIGHT_STATE[browser_key]
 
     if action == "Scrape URL":
         url = query if query.startswith(('http://', 'https://')) else f"http://{query}"
     else: # action == "Search"
-        url_template = SEARCH_ENGINES.get(search_engine_name)
+        url_template = SEARCH_ENGINES.get(search_engine)
         if not url_template:
-            return {"status": "error", "query": query, "error_message": f"Invalid search engine: '{search_engine_name}'."}
+            return {"status": "error", "query": query, "error_message": f"Invalid search engine: '{search_engine}'."}
         url = url_template.format(query=urllib.parse.quote_plus(query))
 
     proxy_config = REVOLVER.get_next()
     proxy_server_used = proxy_config["server"] if proxy_config else "Direct Connection"
-    
+
     context_args = {'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36', 'java_script_enabled': True, 'ignore_https_errors': True, 'bypass_csp': True, 'accept_downloads': False}
     if proxy_config: context_args['proxy'] = proxy_config
 
@@ -163,16 +161,13 @@ async def perform_web_browse(action: str, query: str, browser_name: str, search_
     try:
         response = await page.goto(url, wait_until='domcontentloaded', timeout=25000)
         html_content = await page.content()
-
         if any(phrase in html_content for phrase in ["unusual traffic", "CAPTCHA", "are you human", "not a robot"]):
             raise Exception(f"Anti-bot measure detected on {page.url}. Try another search engine or proxy.")
-
         final_url, title = page.url, await page.title() or "No Title"
         soup = BeautifulSoup(html_content, 'lxml')
         converter = HTML_TO_MARKDOWN_CONVERTER(soup, base_url=final_url)
         markdown_text = converter.convert()
         status_code = response.status if response else 0
-
         return {"status": "success", "query": query, "action": action, "final_url": final_url, "page_title": title, "http_status": status_code, "proxy_used": proxy_server_used, "markdown_content": markdown_text}
     except Exception as e:
         error_message = str(e).splitlines()[0]
@@ -187,9 +182,7 @@ async def perform_web_browse(action: str, query: str, browser_name: str, search_
 
 @app.route('/', methods=['GET'])
 def index():
-    """
-    Root endpoint to provide API status and usage instructions.
-    """
+    """Root endpoint to provide API status and usage instructions."""
     return jsonify({
         "status": "online",
         "message": "Welcome to the Web Browse API!",
@@ -198,46 +191,41 @@ def index():
         "payload_format": {
             "action": "string (required: 'Search' or 'Scrape URL')",
             "query": "string (required: a search term or a full URL)",
-            "browser_name": "string (optional, default: 'firefox'; options: 'firefox', 'chromium', 'webkit')",
-            "search_engine_name": "string (optional, default: 'DuckDuckGo'; see code for all options)"
+            "browser": "string (optional, default: 'firefox'; options: 'firefox', 'chromium', 'webkit')",
+            "search_engine": "string (optional, default: 'DuckDuckGo'; see code for all options)"
         },
-        "example_curl": """curl -X POST YOUR_SPACE_URL/web_browse -H "Content-Type: application/json" -d '{"action": "Search", "query": "latest news on AI"}'"""
+        "example_curl": """curl -X POST YOUR_SPACE_URL/web_browse -H "Content-Type: application/json" -d '{"action": "Search", "query": "latest news on AI", "browser": "webkit"}'"""
     })
 
 @app.route('/web_browse', methods=['POST'])
 def web_browse():
-    """
-    API endpoint to perform a web search or scrape a URL.
-    """
+    """API endpoint to perform a web search or scrape a URL."""
     if not request.is_json:
         return jsonify({"status": "error", "error_message": "Invalid input: payload must be JSON"}), 400
 
     data = request.get_json()
     action = data.get('action')
     query = data.get('query')
-    browser_name = data.get('browser_name', 'firefox')
-    search_engine_name = data.get('search_engine_name', 'DuckDuckGo')
+    # UPDATED: Reading `browser` and `search_engine` from the payload.
+    browser = data.get('browser', 'firefox')
+    search_engine = data.get('search_engine', 'DuckDuckGo')
 
     if not action or not query:
         return jsonify({"status": "error", "error_message": "Missing required parameters: 'action' and 'query' are mandatory."}), 400
-    
     if action not in ["Search", "Scrape URL"]:
         return jsonify({"status": "error", "error_message": "Invalid 'action'. Must be 'Search' or 'Scrape URL'."}), 400
 
     try:
-        # Use asyncio.run() to execute the async function within the sync Flask route
-        result = asyncio.run(perform_web_browse(action, query, browser_name, search_engine_name))
+        # UPDATED: Passing the new variable names to the function.
+        result = asyncio.run(perform_web_browse(action, query, browser, search_engine))
         response_status_code = 200 if result.get("status") == "success" else 500
         return jsonify(result), response_status_code
     except Exception as e:
-        app.logger.error(f"An unexpected server error occurred: {str(e)}")
+        app.logger.error(f"An unexpected server error occurred: {e}", exc_info=True)
         return jsonify({"status": "error", "query": query, "error_message": f"An unexpected server error occurred: {str(e)}"}), 500
 
 # --- Main Application Runner ---
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     print(f"Flask server starting on port {port}... {REVOLVER.count()} proxies loaded.")
-    print(f"API instructions available at GET http://0.0.0.0:{port}/")
-    print(f"API endpoint available at POST http://0.0.0.0:{port}/web_browse")
-    # For production, consider using a more robust WSGI server like Gunicorn or Waitress
     app.run(host='0.0.0.0', port=port)