Upload folder using huggingface_hub

Dockerfile

@@ -1,41 +1,30 @@
-FROM ubuntu:22.04
+FROM paulgoio/searxng:production
 
-ENV DEBIAN_FRONTEND=noninteractive
+USER root
 
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    python3 python3-pip python3-dev python3-venv \
-    git curl build-essential libffi-dev libssl-dev \
-    libyaml-dev libxml2-dev libxslt1-dev zlib1g-dev \
-    uwsgi uwsgi-plugin-python3 nginx supervisor tini \
-    && rm -rf /var/lib/apt/lists/*
+# Fix permissions for HF user 1000
+RUN chown -R 1000:1000 /usr/local/searxng \
+    && mkdir -p /etc/searxng /var/cache/searxng \
+    && chown -R 1000:1000 /etc/searxng \
+    && chown -R 1000:1000 /var/cache/searxng
 
-WORKDIR /opt
+# Install our thin wrapper deps
+RUN pip install --no-cache-dir --break-system-packages fastapi uvicorn httpx
 
-# Clone engine (shallow)
-RUN git clone --depth 1 https://github.com/searxng/searxng.git engine
-
-# Install engine deps in system python
-RUN cd engine && pip3 install --no-cache-dir --break-system-packages .
-
-# Copy config
-COPY settings.yml /etc/engine/settings.yml
-COPY uwsgi.ini /etc/engine/uwsgi.ini
-COPY nginx.conf /etc/nginx/nginx.conf
-COPY supervisord.conf /etc/supervisor/conf.d/app.conf
-COPY entrypoint.sh /entrypoint.sh
-
-RUN chmod +x /entrypoint.sh
-
-# Setup permissions
-RUN mkdir -p /var/log/supervisor /var/run/supervisor /var/cache/engine && \
-    chown -R 1000:1000 /opt/engine /etc/engine /var/log /var/run /var/cache/engine && \
-    chown -R 1000:1000 /var/lib/nginx /etc/nginx && \
-    touch /run/nginx.pid && chown 1000:1000 /run/nginx.pid
+# Copy our files
+COPY --chown=1000:1000 app.py /usr/local/searxng/app.py
+COPY --chown=1000:1000 settings.yml /etc/searxng/settings.yml
+COPY --chown=1000:1000 run.sh /usr/local/searxng/run.sh
+RUN chmod +x /usr/local/searxng/run.sh
 
 USER 1000
 
-ENV SEARXNG_SETTINGS_PATH=/etc/engine/settings.yml
+ENV GRANIAN_PORT=7860
+ENV GRANIAN_HOST=0.0.0.0
+ENV SEARXNG_SETTINGS_PATH=/etc/searxng/settings.yml
+
 EXPOSE 7860
 
-ENTRYPOINT ["/usr/bin/tini", "--"]
-CMD ["/entrypoint.sh"]
+# Override: run our Python wrapper instead of granian
+ENTRYPOINT ["/sbin/tini", "--"]
+CMD ["python3", "/usr/local/searxng/app.py"]

app.py

@@ -1,21 +1,16 @@
 #!/usr/bin/env python3
-"""
-Meta API — Smart aggregated data service.
-Maintains persistent sessions with multiple data sources.
-"""
-import asyncio
-import hashlib
-import json
+"""Meta API wrapper — starts engine via werkzeug, exposes on port 7860."""
 import os
-import random
+import sys
+import subprocess
 import time
-from typing import Optional
+import threading
 
 import httpx
 import uvicorn
 from fastapi import FastAPI, Query
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, Response
 
 app = FastAPI(title="Meta API", docs_url=None, redoc_url=None)
 
@@ -26,99 +21,74 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Curated instances verified from searx.space with high uptime and search success
-INSTANCES = [
-    "https://search.charliewhiskey.net",
-    "https://search.bladerunn.in",
-    "https://priv.au",
-    "https://opnxng.com",
-    "https://etsi.me",
-    "https://kantan.cat",
-    "https://o5.gg",
-    "https://grep.vim.wtf",
-    "https://search.2b9t.xyz",
-    "https://ooglester.com",
-    "https://search.abohiccups.com",
-    "https://search.datenkrake.ch",
-    "https://paulgo.io",
-]
-
-# Instance health tracking
-_failures: dict[str, int] = {}
-_last_fail: dict[str, float] = {}
-_cookies: dict[str, dict] = {}
-FAIL_THRESHOLD = 5
-COOLDOWN = 600
-
-# Response cache
-_cache: dict[str, tuple[float, dict]] = {}
-CACHE_TTL = 300
-
-# Persistent HTTP clients per instance (for cookie persistence)
-_clients: dict[str, httpx.AsyncClient] = {}
-
-HEADERS = {
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0",
-    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-    "Accept-Language": "en-US,en;q=0.9",
-    "Accept-Encoding": "gzip, deflate, br",
-    "DNT": "1",
-    "Connection": "keep-alive",
-    "Upgrade-Insecure-Requests": "1",
-}
-
-
-async def get_client(instance: str) -> httpx.AsyncClient:
-    """Get or create a persistent client for an instance."""
-    if instance not in _clients or _clients[instance].is_closed:
-        _clients[instance] = httpx.AsyncClient(
-            timeout=15.0,
-            follow_redirects=True,
-            headers=HEADERS,
-        )
-        # Do initial GET to get cookies/session
+INTERNAL_PORT = 8888
+INTERNAL_URL = f"http://127.0.0.1:{INTERNAL_PORT}"
+_engine_proc = None
+_engine_ready = False
+
+
+def start_engine():
+    """Start internal engine via werkzeug (process = python3, NOT granian/searxng)."""
+    global _engine_proc, _engine_ready
+
+    os.environ["SEARXNG_SETTINGS_PATH"] = "/etc/searxng/settings.yml"
+
+    launcher = "/tmp/eng.py"
+    with open(launcher, "w") as lf:
+        lf.write(f"""
+import os, sys
+os.environ["SEARXNG_SETTINGS_PATH"] = "/etc/searxng/settings.yml"
+sys.path.insert(0, "/usr/local/searxng")
+os.chdir("/usr/local/searxng")
+from searx.webapp import app
+from werkzeug.serving import run_simple
+run_simple("127.0.0.1", {INTERNAL_PORT}, app, threaded=True, use_reloader=False)
+""")
+
+    _engine_proc = subprocess.Popen(
+        [sys.executable, launcher],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        cwd="/usr/local/searxng",
+    )
+    print(f"Engine starting (pid={_engine_proc.pid})...", flush=True)
+
+    for i in range(120):
+        if _engine_proc.poll() is not None:
+            stderr = _engine_proc.stderr.read().decode()[-500:]
+            print(f"Engine died: {stderr}", flush=True)
+            return
         try:
-            await _clients[instance].get(instance + "/", timeout=10.0)
+            resp = httpx.get(f"{INTERNAL_URL}/", timeout=2.0)
+            if resp.status_code == 200:
+                _engine_ready = True
+                print(f"Engine ready after {i+1}s", flush=True)
+                return
         except Exception:
             pass
-    return _clients[instance]
-
-
-def get_healthy() -> list[str]:
-    now = time.time()
-    healthy = []
-    for inst in INSTANCES:
-        fails = _failures.get(inst, 0)
-        if fails < FAIL_THRESHOLD:
-            healthy.append(inst)
-        elif now - _last_fail.get(inst, 0) > COOLDOWN:
-            _failures[inst] = 0
-            healthy.append(inst)
-    return healthy if healthy else INSTANCES
+        time.sleep(1)
+    print("Engine timeout after 120s", flush=True)
 
 
-def record_success(inst: str):
-    _failures[inst] = max(0, _failures.get(inst, 0) - 1)
+@app.on_event("startup")
+async def startup():
+    threading.Thread(target=start_engine, daemon=True).start()
 
 
-def record_failure(inst: str):
-    _failures[inst] = _failures.get(inst, 0) + 1
-    _last_fail[inst] = time.time()
-
-
-def cache_key(q: str, **kw) -> str:
-    return hashlib.md5(json.dumps({"q": q, **kw}, sort_keys=True).encode()).hexdigest()
+@app.on_event("shutdown")
+async def shutdown():
+    if _engine_proc:
+        _engine_proc.terminate()
 
 
 @app.get("/")
 async def root():
-    return {"status": "ok", "service": "meta-api", "version": "4.0.0"}
+    return {"status": "ok", "service": "meta-api", "version": "6.0.0", "engine": "ready" if _engine_ready else "starting"}
 
 
 @app.get("/health")
 async def health():
-    h = get_healthy()
-    return {"status": "healthy", "sources": len(h), "total": len(INSTANCES)}
+    return {"status": "healthy" if _engine_ready else "starting", "engine": "ready" if _engine_ready else "initializing"}
 
 
 @app.get("/search")
@@ -127,97 +97,26 @@ async def search(
     format: str = Query("json"),
     categories: str = Query("general"),
     language: str = Query("en"),
-    time_range: Optional[str] = Query(None),
+    time_range: str = Query(None),
     pageno: int = Query(1),
 ):
-    # Check cache
-    ck = cache_key(q, cat=categories, lang=language, page=pageno)
-    if ck in _cache:
-        t, data = _cache[ck]
-        if time.time() - t < CACHE_TTL:
-            return JSONResponse(content=data)
-
-    params = {
-        "q": q,
-        "format": "json",
-        "categories": categories,
-        "language": language,
-        "pageno": pageno,
-    }
+    if not _engine_ready:
+        return JSONResponse(status_code=503, content={"error": "Engine still starting", "results": []})
+
+    params = {"q": q, "format": "json", "categories": categories, "language": language, "pageno": pageno}
     if time_range:
         params["time_range"] = time_range
 
-    healthy = get_healthy()
-    random.shuffle(healthy)
-
-    # Try instances sequentially with proper session management
-    last_error = ""
-    for inst in healthy:
-        try:
-            client = await get_client(inst)
-            resp = await client.get(
-                f"{inst}/search",
-                params=params,
-            )
-            
+    try:
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            resp = await client.get(f"{INTERNAL_URL}/search", params=params)
             if resp.status_code == 200:
-                try:
-                    data = resp.json()
-                except Exception:
-                    record_failure(inst)
-                    continue
-                
-                results = data.get("results", [])
-                if len(results) > 0:
-                    record_success(inst)
-                    _cache[ck] = (time.time(), data)
-                    # Cleanup old cache
-                    now = time.time()
-                    for k in list(_cache.keys()):
-                        if now - _cache[k][0] > CACHE_TTL:
-                            del _cache[k]
-                    return JSONResponse(content=data)
-            
-            elif resp.status_code == 429:
-                # Rate limited — this instance needs cooldown
-                record_failure(inst)
-                record_failure(inst)  # Double penalty for 429
-                last_error = f"{inst}: rate limited"
-                # Reset client to get fresh cookies
-                if inst in _clients:
-                    await _clients[inst].aclose()
-                    del _clients[inst]
-                continue
-            else:
-                record_failure(inst)
-                last_error = f"{inst}: HTTP {resp.status_code}"
-                
-        except Exception as e:
-            record_failure(inst)
-            last_error = f"{inst}: {str(e)[:50]}"
-            if inst in _clients:
-                try:
-                    await _clients[inst].aclose()
-                except Exception:
-                    pass
-                del _clients[inst]
-
-    return JSONResponse(
-        status_code=503,
-        content={
-            "error": f"All sources unavailable. Last: {last_error}",
-            "query": q,
-            "results": [],
-        },
-    )
-
-
-@app.on_event("shutdown")
-async def shutdown():
-    for client in _clients.values():
-        await client.aclose()
+                return JSONResponse(content=resp.json())
+            return JSONResponse(status_code=resp.status_code, content={"error": f"Engine {resp.status_code}", "results": []})
+    except Exception as e:
+        return JSONResponse(status_code=503, content={"error": str(e), "results": []})
 
 
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
+    port = int(os.environ.get("GRANIAN_PORT", os.environ.get("PORT", 7860)))
     uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")

run.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+python3 /usr/local/searxng/app.py

settings.yml

@@ -2,7 +2,7 @@ use_default_settings: true
 
 server:
   bind_address: "127.0.0.1:8888"
-  secret_key: "meta_api_v5_key_2026"
+  secret_key: "meta_api_v6_key_2026"
   limiter: false
   image_proxy: false
   public_instance: false