Update app.py

app.py

@@ -6,16 +6,20 @@ from typing import Dict, Optional
 from itertools import cycle
 
 # Install playwright if not present
-os.system("playwright install")
+# 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, TimeoutError as PlaywrightTimeoutError
+from playwright.async_api import async_playwright
 
 # --- Flask App Initialization ---
 app = Flask(__name__)
 
-# --- Credential and State Management (largely unchanged) ---
+# --- Credential and State Management (unchanged) ---
 class CredentialRevolver:
     def __init__(self, proxy_string: str):
         self.proxies = self._parse_proxies(proxy_string)
@@ -43,6 +47,7 @@ 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 = {
@@ -121,24 +126,25 @@ async def perform_web_browse(action: str, query: str, browser_name: str, search_
     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"]
-            if browser_key == 'firefox': browser_instance = await p.firefox.launch(headless=True)
-            elif browser_key == 'chromium': browser_instance = await p.chromium.launch(headless=True)
-            elif browser_key == 'webkit': browser_instance = await p.webkit.launch(headless=True)
-            else: raise ValueError(f"Invalid browser name: {browser_name}")
+            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
+            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":
-        if not query.startswith(('http://', 'https://')):
-            url = f"http://{query}"
-        else:
-            url = query
+    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)
         if not url_template:
@@ -156,7 +162,6 @@ 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"]):
@@ -178,27 +183,31 @@ async def perform_web_browse(action: str, query: str, browser_name: str, search_
         if 'page' in locals() and not page.is_closed(): await page.close()
         if 'context' in locals(): await context.close()
 
+# --- API Endpoint Definitions ---
+
+@app.route('/', methods=['GET'])
+def index():
+    """
+    Root endpoint to provide API status and usage instructions.
+    """
+    return jsonify({
+        "status": "online",
+        "message": "Welcome to the Web Browse API!",
+        "api_endpoint": "/web_browse",
+        "instructions": "Send a POST request to /web_browse with a JSON payload to use the service.",
+        "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)"
+        },
+        "example_curl": """curl -X POST YOUR_SPACE_URL/web_browse -H "Content-Type: application/json" -d '{"action": "Search", "query": "latest news on AI"}'"""
+    })
 
-# --- API Endpoint Definition ---
 @app.route('/web_browse', methods=['POST'])
 def web_browse():
     """
     API endpoint to perform a web search or scrape a URL.
-    This endpoint expects a JSON payload with the following parameters:
-    - "action": "Search" or "Scrape URL" (required)
-    - "query": The search term or the URL to scrape (required)
-    - "browser_name": "firefox", "chromium", or "webkit" (optional, default: "firefox")
-    - "search_engine_name": Name of the search engine (optional, default: "DuckDuckGo")
-    
-    Example usage with curl:
-    curl -X POST http://127.0.0.1:5000/web_browse \
-         -H "Content-Type: application/json" \
-         -d '{
-               "action": "Search",
-               "query": "latest news on AI",
-               "browser_name": "firefox",
-               "search_engine_name": "Google"
-             }'
     """
     if not request.is_json:
         return jsonify({"status": "error", "error_message": "Invalid input: payload must be JSON"}), 400
@@ -206,8 +215,8 @@ def web_browse():
     data = request.get_json()
     action = data.get('action')
     query = data.get('query')
-    browser_name = data.get('browser_name', 'firefox') # Default to firefox
-    search_engine_name = data.get('search_engine_name', 'DuckDuckGo') # Default to DuckDuckGo
+    browser_name = data.get('browser_name', 'firefox')
+    search_engine_name = data.get('search_engine_name', 'DuckDuckGo')
 
     if not action or not query:
         return jsonify({"status": "error", "error_message": "Missing required parameters: 'action' and 'query' are mandatory."}), 400
@@ -215,17 +224,20 @@ def web_browse():
     if action not in ["Search", "Scrape URL"]:
         return jsonify({"status": "error", "error_message": "Invalid 'action'. Must be 'Search' or 'Scrape URL'."}), 400
 
-    # Run the async function in the current event loop
     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))
-        status_code = 200 if result.get("status") == "success" else 500
-        return jsonify(result), status_code
+        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)}")
         return jsonify({"status": "error", "query": query, "error_message": f"An unexpected server error occurred: {str(e)}"}), 500
 
-
 # --- Main Application Runner ---
 if __name__ == "__main__":
-    print(f"Flask server starting... {REVOLVER.count()} proxies loaded.")
-    print("API Endpoint available at POST http://127.0.0.1:7860/web_browse")
-    app.run(host='0.0.0.0', port=7860, debug=True)
+    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)