Upload 6 files

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.11-slim
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        chromium chromium-driver fonts-liberation libgbm1 libnss3 libgconf-2-4 && \
+    rm -rf /var/lib/apt/lists/*
+
+ENV CHROME_BINARY=/usr/bin/chromium
+ENV CHROME_EXTRA_ARGS="--no-sandbox --disable-dev-shm-usage --disable-gpu --window-size=1920,1080 --headless=new"
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . /app
+WORKDIR /app
+CMD ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8080", "app.main:app"]

app/__init__.py

@@ -0,0 +1 @@
+# ensures app is a proper package for PyInstaller

app/lens_images_core.py

@@ -0,0 +1,303 @@
+
+import os, json, time, hashlib, httpx, base64, re, asyncio, threading, shutil, logging
+from typing import Dict, Any
+from urllib.parse import urlparse
+
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+from selenium.webdriver.chrome.service import Service as ChromeService
+
+LOGGER = logging.getLogger("lens_images_core")
+if not LOGGER.handlers:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    )
+
+COOKIE_JSON_URL = os.getenv("COOKIE_JSON_URL", "")
+UA = "Mozilla/5.0 (Lens OCR Images)"
+
+_COMMON_CHROME_PATHS = [
+    # Linux
+    "/usr/bin/google-chrome", "/usr/bin/chromium", "/usr/bin/chromium-browser",
+    "/snap/bin/chromium",
+    "/opt/google/chrome/google-chrome",
+    # macOS
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    # Windows
+    r"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    r"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+]
+
+def _find_chrome_binary() -> str | None:
+    env = os.getenv("CHROME_BINARY")
+    if env and shutil.which(env):
+        return env
+    for p in _COMMON_CHROME_PATHS:
+        if os.path.isfile(p) and os.access(p, os.X_OK):
+            return p
+    try:
+        import subprocess, shlex
+        out = subprocess.check_output(shlex.split("which google-chrome"), stderr=subprocess.DEVNULL).decode().strip()
+        if out:
+            return out
+    except Exception:
+        pass
+    return None
+
+def _build_chrome() -> webdriver.Chrome:
+    bin_loc = _find_chrome_binary() or "/usr/bin/chromium"
+    drv_path = os.getenv("CHROMEDRIVER", "/usr/bin/chromedriver")
+    opts = ChromeOptions()
+    opts.binary_location = bin_loc
+    
+    extra = os.getenv(
+        "CHROME_EXTRA_ARGS",
+        "--disable-gpu --no-sandbox --disable-dev-shm-usage --window-size=1920,1080 --headless=new",
+    ).split()
+    for a in extra:
+        if a:
+            opts.add_argument(a)
+    service = ChromeService(executable_path=drv_path)
+    return webdriver.Chrome(service=service, options=opts)
+
+_cached_cookie_obj: Dict[str, Any] | None = None
+_cached_cookie_fetched_at: float = 0.0
+_CACHE_TTL = 300
+_BROWSER_TTL = 900
+_cookie_lock = threading.Lock()
+
+_IDLE_TIMEOUT = int(os.getenv("CHROME_IDLE_SECONDS", "60"))
+_driver_lock = threading.Lock()
+_global_driver = None
+_driver_last_use = 0.0
+
+def _ensure_cookie_driver():
+    global _global_driver, _driver_last_use
+    with _driver_lock:
+        if _global_driver is None:
+            LOGGER.info("▶️  starting headless Chrome for cookies")
+            _global_driver = _build_chrome()
+        _driver_last_use = time.time()
+        return _global_driver
+
+def _quit_cookie_driver():
+    global _global_driver
+    try:
+        if _global_driver:
+            _global_driver.quit()
+    except Exception:
+        pass
+    finally:
+        _global_driver = None
+
+def _driver_reaper_loop():
+    global _driver_last_use
+    while True:
+        try:
+            time.sleep(1)
+            with _driver_lock:
+                if _global_driver and (time.time() - _driver_last_use) > _IDLE_TIMEOUT:
+                    LOGGER.info("♻️  quitting idle cookie driver")
+                    _quit_cookie_driver()
+        except Exception:
+            pass
+
+_reaper_started = False
+def _ensure_reaper_started():
+    global _reaper_started
+    if _reaper_started:
+        return
+    try:
+        threading.Thread(target=_driver_reaper_loop, daemon=True).start()
+        _reaper_started = True
+        LOGGER.debug("cookie driver reaper started")
+    except Exception as e:
+        LOGGER.warning("could not start cookie driver reaper: %s", e)
+
+def _grab_cookies_with_browser() -> Dict[str, Any]:
+    drv = _ensure_cookie_driver()
+    with _driver_lock:
+        drv.get("https://lens.google.com/")
+        jar = {}
+        for c in drv.get_cookies():
+            dom = c.get("domain") or ""
+            if dom.endswith(".google.com") or dom.endswith("google.com"):
+                jar[c["name"]] = c["value"]
+    return {"cookies": jar, "_source": "browser"}
+
+async def _cookie_header() -> str:
+    global _cached_cookie_obj, _cached_cookie_fetched_at
+    now = time.time()
+
+    _ensure_reaper_started()
+
+    def extract_obj(obj):
+        if isinstance(obj, dict):
+            return obj.get("cookies", obj)
+        return obj
+
+    with _cookie_lock:
+        if _cached_cookie_obj:
+            ttl = _BROWSER_TTL if _cached_cookie_obj.get("_source") == "browser" else _CACHE_TTL
+            if (now - _cached_cookie_fetched_at) < ttl:
+                return "; ".join(f"{k}={v}" for k, v in extract_obj(_cached_cookie_obj).items())
+
+    if COOKIE_JSON_URL:
+        try:
+            async with httpx.AsyncClient(timeout=5) as cli:
+                resp = await cli.get(COOKIE_JSON_URL)
+                resp.raise_for_status()
+                data = resp.json()
+            with _cookie_lock:
+                data["_source"] = "remote"
+                _cached_cookie_obj, _cached_cookie_fetched_at = data, now
+            return "; ".join(f"{k}={v}" for k, v in extract_obj(data).items())
+        except Exception as e:
+            LOGGER.warning("COOKIE_JSON_URL fetch failed: %s – falling back to headless chrome", e)
+
+    loop = asyncio.get_running_loop()
+    data: Dict[str, Any] = await loop.run_in_executor(None, _grab_cookies_with_browser)
+    with _cookie_lock:
+        _cached_cookie_obj, _cached_cookie_fetched_at = data, now
+    return "; ".join(f"{k}={v}" for k, v in extract_obj(data).items())
+
+def _sap_header(cookie_header: str) -> dict:
+    origin = "https://lens.google.com"
+    sid = None
+    for c in cookie_header.split("; "):
+        if c.startswith("__Secure-3PAPISID=") or c.startswith("SAPISID="):
+            sid = c.split("=", 1)[1]
+            break
+    if not sid:
+        return {}
+    ts = int(time.time())
+    raw = f"{ts} {sid} {origin}"
+    sig = hashlib.sha1(raw.encode()).hexdigest()
+    return {
+        "X-Origin": origin,
+        "X-Goog-AuthUser": "0",
+        "Authorization": f"SAPISIDHASH {ts}_{sig}",
+    }
+
+def _json_url(loc: str, tl: str) -> str:
+    from urllib.parse import urlparse, parse_qs
+
+    q = parse_qs(urlparse(loc).query)
+    return (
+        "https://lens.google.com/translatedimage?"
+        f"vsrid={q.get('vsrid', [None])[0]}&gsessionid={q.get('gsessionid', [None])[0]}"
+        f"&sl=auto&tl={tl}&sf=1.07&ib=1"
+    )
+
+async def translate_lens(image_url: str, lang: str = "en") -> dict:
+    start_ts = time.time()
+    debug: Dict[str, Any] = {"steps": [], "errors": []}
+
+    ck = await _cookie_header()
+    hdr = {
+        "User-Agent": UA,
+        "Cookie": ck,
+        "Referer": "https://lens.google.com/",
+        **_sap_header(ck),
+    }
+
+    async with httpx.AsyncClient() as cli:
+        try:
+            o = urlparse(image_url)
+            referer = f"{o.scheme}://{o.netloc}/" if o.scheme and o.netloc else None
+            hdr_img = {"User-Agent": UA}
+            if referer:
+                hdr_img["Referer"] = referer
+            img_resp = await cli.get(image_url, headers=hdr_img, timeout=10)
+            img_resp.raise_for_status()
+            debug["steps"].append(f"fetched original image {image_url} status={img_resp.status_code}")
+        except httpx.HTTPStatusError as he:
+            code = he.response.status_code if he.response is not None else "NA"
+            debug["errors"].append(f"fetch image HTTP {code} {image_url}")
+            raise RuntimeError(f"fetch image HTTP {code}")
+        except httpx.TimeoutException:
+            debug["errors"].append(f"fetch image TIMEOUT {image_url}")
+            raise RuntimeError("fetch image TIMEOUT")
+        except Exception as e:
+            debug["errors"].append(f"fetch image ERROR {type(e).__name__} {image_url}")
+            raise RuntimeError(f"fetch image ERROR {type(e).__name__}")
+
+        files = {
+            "encoded_image": ("file.jpg", img_resp.content, "image/jpeg"),
+            "sbisrc": (None, "browser"),
+            "rt": (None, "j"),
+        }
+
+        up = await cli.post(
+            "https://lens.google.com/v3/upload",
+            files=files,
+            headers=hdr,
+            follow_redirects=False,
+            timeout=10,
+        )
+        debug["steps"].append(f"upload response status={up.status_code}")
+        if up.status_code not in (302, 303):
+            msg = f"Lens upload failed {up.status_code}"
+            debug["errors"].append(msg)
+            raise RuntimeError(msg)
+
+        loc = up.headers.get("location", "")
+        debug["steps"].append(f"got redirect location: {loc}")
+
+        json_url = _json_url(loc, lang)
+        debug["steps"].append(f"constructed json_url: {json_url}")
+
+        js = await cli.get(json_url, headers=hdr, timeout=5)
+        raw_body = js.text
+        debug["steps"].append("fetched translation JSON")
+
+        body = raw_body.lstrip(")]}'")
+        try:
+            info = json.loads(body)
+        except Exception as e:
+            debug["errors"].append(f"JSON parse failure: {e}; raw_body snippet: {body[:200]}")
+            raise
+
+        data_url = info.get("imageUrl", "")
+        extracted_data_url = ""
+        if data_url:
+            if data_url.startswith("data:image/"):
+                extracted_data_url = data_url
+                debug["steps"].append("imageUrl already data URL")
+            else:
+                try:
+                    html = base64.b64decode(data_url).decode("utf-8", errors="ignore")
+                    m = re.search(r"data:image/[a-zA-Z]+;base64,[A-Za-z0-9+/=]+", html)
+                    if m:
+                        extracted_data_url = m.group(0)
+                        debug["steps"].append("extracted embedded data:image from base64 HTML")
+                    else:
+                        debug["steps"].append("no embedded data:image found inside decoded HTML")
+                except Exception as e:
+                    debug["errors"].append(f"error decoding imageUrl: {e}")
+
+            if not extracted_data_url and (data_url.startswith("http://") or data_url.startswith("https://")):
+                try:
+                    fallback_img = await cli.get(data_url, headers={"User-Agent": UA}, timeout=5)
+                    fallback_img.raise_for_status()
+                    b64 = base64.b64encode(fallback_img.content).decode("utf-8")
+                    extracted_data_url = f"data:image/jpeg;base64,{b64}"
+                    debug["steps"].append("fetched fallback image URL and encoded to data URL")
+                except Exception as e:
+                    debug["errors"].append(f"fallback fetch of imageUrl failed: {e}")
+
+        translated_text = info.get("translatedTextFull", "") or info.get("translatedText", "")
+
+        duration = time.time() - start_ts
+        debug["duration_sec"] = duration
+
+        return {
+            "image": extracted_data_url,
+            "text": translated_text,
+            "loc": loc,
+            "json_url": json_url,
+            "raw_info": info,
+            "debug": debug,
+        }

app/lens_text_core.py

@@ -0,0 +1,387 @@
+
+import os, time, asyncio, base64, re, threading, hashlib, logging, shutil
+from io import BytesIO
+from typing import Any, Dict, List, Union
+from urllib.parse import urlparse
+
+import httpx
+from PIL import Image
+
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+from selenium.webdriver.chrome.service import Service as ChromeService
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+
+CHROME_BINARY_PATH = os.getenv("CHROME_BINARY_PATH", "").strip() 
+
+LOGGER = logging.getLogger("lens_text_core")
+if not LOGGER.handlers:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    )
+
+COOKIE_JSON_URL = os.getenv("COOKIE_JSON_URL", "")
+UA = "Mozilla/5.0 (Lens Text OCR)"
+
+CHROME_EXTRA_ARGS = os.getenv(
+    "CHROME_EXTRA_ARGS",
+    "--disable-gpu --no-sandbox --disable-dev-shm-usage "
+    "--window-size=1920,1080 --headless=new",
+).split()
+
+_CACHE_TTL    = 300  
+_IDLE_TIMEOUT = int(os.getenv("CHROME_IDLE_SECONDS", "60"))
+_BROWSER_TTL  = 900  
+
+_COMMON_CHROME_PATHS = [
+    # Linux
+    "/usr/bin/google-chrome", "/usr/bin/chromium", "/usr/bin/chromium-browser",
+    "/snap/bin/chromium",
+    "/opt/google/chrome/google-chrome",
+    # macOS
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    # Windows
+    r"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    r"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+]
+
+def _find_chrome_binary() -> str:
+    if (env := os.getenv("CHROME_BINARY")):
+        return env
+
+    for cmd in ("google-chrome", "chromium-browser", "chromium", "chrome"):
+        path = shutil.which(cmd)
+        if path:
+            return path
+
+    for path in _COMMON_CHROME_PATHS:
+        if os.path.exists(path):
+            return path
+
+    raise RuntimeError(
+        "Chrome binary not found; set CHROME_BINARY env var or install Chrome/Chromium"
+    )
+
+def _build_chrome(cookie_dict: Dict[str, str] | None = None):
+    bin_loc = _find_chrome_binary()
+    drv_path = os.getenv("CHROMEDRIVER", "/usr/bin/chromedriver")
+    opts = ChromeOptions()
+    opts.binary_location = bin_loc
+    for flag in CHROME_EXTRA_ARGS:
+        try:
+            opts.add_argument(flag)
+        except Exception:
+            pass
+    service = ChromeService(executable_path=drv_path)
+    drv = webdriver.Chrome(service=service, options=opts)
+    
+    drv.execute_cdp_cmd("Network.enable", {})
+    if cookie_dict:
+        for name, val in cookie_dict.items():
+            try:
+                drv.execute_cdp_cmd("Network.setCookie", {
+                    "name": name, "value": val,
+                    "domain": ".google.com", "path": "/", "secure": True
+                })
+            except Exception:
+                pass
+    return drv
+
+_cached_cookie, _cached_cookie_ts, _cookie_lock = None, 0.0, threading.Lock()
+_global_driver, _driver_last_use, _driver_lock  = None, 0.0, threading.Lock()
+
+def _grab_cookies_with_browser() -> Dict[str, Any]:
+    drv = _build_chrome()
+    try:
+        drv.get("https://lens.google.com/")
+        jar = {
+            c["name"]: c["value"]
+            for c in drv.get_cookies()
+            if c.get("domain","").endswith(".google.com") or c.get("domain","").endswith("google.com")
+        }
+        return {"cookies": jar, "_source": "browser"}
+    finally:
+        try: drv.quit()
+        except Exception: pass
+
+async def _cookie_header() -> str:
+    global _cached_cookie, _cached_cookie_ts
+    now = time.time()
+
+    with _cookie_lock:
+        if _cached_cookie:
+            ttl = _BROWSER_TTL if _cached_cookie.get("_source") == "browser" else _CACHE_TTL
+            if (now - _cached_cookie_ts) < ttl:
+                obj = _cached_cookie.get("cookies", _cached_cookie)
+                return "; ".join(f"{k}={v}" for k, v in obj.items())
+
+    if COOKIE_JSON_URL:
+        try:
+            async with httpx.AsyncClient(timeout=4) as cli:
+                resp = await cli.get(COOKIE_JSON_URL)
+                resp.raise_for_status()
+                data = resp.json()
+            with _cookie_lock:
+                data["_source"] = "remote"
+                _cached_cookie, _cached_cookie_ts = data, now
+            obj = data.get("cookies", data)
+            return "; ".join(f"{k}={v}" for k, v in obj.items())
+        except Exception as e:
+            LOGGER.warning("fetch COOKIE_JSON_URL failed: %s – fallback to browser", e)
+
+    loop = asyncio.get_running_loop()
+    data = await loop.run_in_executor(None, _grab_cookies_with_browser)
+
+    with _cookie_lock:
+        _cached_cookie, _cached_cookie_ts = data, now
+
+    obj = data.get("cookies", data)
+    return "; ".join(f"{k}={v}" for k, v in obj.items())
+
+def _sap_header(cookie_hdr: str) -> Dict[str, str]:
+    origin = "https://lens.google.com"
+    sid = None
+    for part in cookie_hdr.split("; "):
+        if part.startswith("__Secure-3PAPISID=") or part.startswith("SAPISID="):
+            sid = part.split("=", 1)[1]
+            break
+    if not sid:
+        return {}
+    ts  = int(time.time())
+    sig = hashlib.sha1(f"{ts} {sid} {origin}".encode()).hexdigest()
+    return {
+        "X-Origin": origin,
+        "X-Goog-AuthUser": "0",
+        "Authorization": f"SAPISIDHASH {ts}_{sig}",
+    }
+
+def _is_alive(drv) -> bool:
+    try:
+        _ = drv.title
+        return True
+    except Exception:
+        return False
+
+def _ensure_driver(cookie_dict: Dict[str, str]):
+    global _global_driver, _driver_last_use
+    with _driver_lock:
+        if _global_driver is None or not _is_alive(_global_driver):
+            try:
+                if _global_driver:
+                    _global_driver.quit()
+            except Exception:
+                pass
+            _global_driver = _build_chrome(cookie_dict)
+        _driver_last_use = time.time()
+        return _global_driver
+
+def _driver_reaper():
+    global _global_driver
+    while True:
+        time.sleep(1)
+        if _global_driver and (time.time() - _driver_last_use) > _IDLE_TIMEOUT:
+            LOGGER.info("♻️  quitting idle driver")
+            try: _global_driver.quit()
+            except Exception: pass
+            _global_driver = None
+
+_reaper_started = False
+def _ensure_reaper_started():
+    global _reaper_started
+    if _reaper_started:
+        return
+    try:
+        threading.Thread(target=_driver_reaper, daemon=True).start()
+        _reaper_started = True
+        LOGGER.debug("text driver reaper started")
+    except Exception as e:
+        LOGGER.warning("could not start text driver reaper: %s", e)
+
+def _parse_calc_value(calc: str, dim: float) -> float:
+    m = re.search(r"calc\(([\d.]+)%\s*([+-])\s*([\d.]+)px\)", calc)
+    if not m: return 0.0
+    pct, op, off = float(m[1]), m[2], float(m[3])
+    base = dim * pct / 100.0
+    return base - off if op == "-" else base + off
+
+def _extract_boxes(drv, w: int, h: int) -> List[Dict[str, Any]]:
+    WebDriverWait(drv, 10).until(EC.visibility_of_element_located((By.CSS_SELECTOR, "div.lv6PAb")))
+    nodes = drv.find_elements(By.XPATH, "//div[contains(@class,'lv6PAb') and @aria-label]")
+
+    out: List[Dict[str,Any]] = []
+    for n in nodes:
+        if not (n.get_attribute("data-line-index") or "").strip():
+            continue
+
+        text  = (n.get_attribute("aria-label") or "").strip()
+        style = n.get_attribute("style") or ""
+        if not text or "calc(" not in style:
+            continue
+
+        kv = {k.strip(): v.strip()
+              for k,v in (p.split(":",1) for p in style.split(";") if ":" in p)}
+
+        top, left = _parse_calc_value(kv.get("top",""),   h), _parse_calc_value(kv.get("left",""),  w)
+        wid, hei  = _parse_calc_value(kv.get("width",""), w), _parse_calc_value(kv.get("height",""),h)
+        rot_m = re.search(r"rotate\(([-\d.]+)deg\)", style); rot = float(rot_m[1]) if rot_m else 0.0
+
+        verts = [
+            {"x": int(left),        "y": int(top)},
+            {"x": int(left+wid),    "y": int(top)},
+            {"x": int(left+wid),    "y": int(top+hei)},
+            {"x": int(left),        "y": int(top+hei)},
+        ]
+        abs_style = f"top: {int(top)}px; left: {int(left)}px; width: {int(wid)}px; height: {int(hei)}px; transform: rotate({rot}deg);"
+
+        out.append({
+            "description": text,
+            "boundingPoly": {"vertices": verts},
+            "rotate": rot,
+            "style": abs_style,
+
+            "raw_style": style,
+            "top_str": kv.get("top",""),
+            "left_str": kv.get("left",""),
+            "width_str": kv.get("width",""),
+            "height_str": kv.get("height",""),
+        })
+    return out
+
+def _merge_by_center_line(anns: List[Dict[str,Any]], m_x: int=10, m_y: int=15) -> List[Dict[str,Any]]:
+    for a in anns:
+        v  = a["boundingPoly"]["vertices"]
+        xs, ys = [p["x"] for p in v], [p["y"] for p in v]
+        a["_l"], a["_r"], a["_t"], a["_b"] = min(xs), max(xs), min(ys), max(ys)
+        a["_cx"], a["_cy"] = (a["_l"]+a["_r"])/2, (a["_t"]+a["_b"])/2
+
+    parent = list(range(len(anns)))
+    def find(i):
+        while parent[i]!=i:
+            parent[i]=parent[parent[i]]
+            i=parent[i]
+        return i
+    def union(i,j):
+        ri,rj = find(i),find(j)
+        if ri!=rj: parent[rj]=ri
+
+    for i in range(len(anns)):
+        for j in range(i+1,len(anns)):
+            ai, aj = anns[i], anns[j]
+            if (abs(ai["_cx"]-aj["_cx"]) < m_x and
+                ai["_t"]-m_y < aj["_b"] and ai["_b"]+m_y > aj["_t"]):
+                union(i,j)
+
+    groups: Dict[int,List[Dict[str,Any]]] = {}
+    for idx,a in enumerate(anns):
+        groups.setdefault(find(idx), []).append(a)
+
+    merged: List[Dict[str,Any]] = []
+    for g in groups.values():
+        if len(g)==1:
+            a = g[0]
+            merged.append({
+                "description": a["description"],
+                "boundingPoly": a["boundingPoly"],
+                "rotate": a["rotate"],
+                "style": a["style"],
+            })
+        else:
+            txt = "\n".join(aa["description"] for aa in g)
+            l,r = min(aa["_l"] for aa in g), max(aa["_r"] for aa in g)
+            t,b = min(aa["_t"] for aa in g), max(aa["_b"] for aa in g)
+            merged.append({
+                "description": txt,
+                "boundingPoly": {"vertices":[
+                    {"x":l,"y":t}, {"x":r,"y":t}, {"x":r,"y":b}, {"x":l,"y":b}]},
+                "rotate": 0.0,
+                "style": f"top: {t}px; left: {l}px; width: {r-l}px; height: {b-t}px; transform: rotate(0deg);",
+            })
+    return merged
+
+async def translate_lens_text(src: Union[str, bytes, BytesIO]) -> Dict[str,Any]:
+    _ensure_reaper_started()
+    if isinstance(src, (bytes,bytearray)):           img_bytes = bytes(src)
+    elif isinstance(src, BytesIO):                   img_bytes = src.getvalue()
+    elif isinstance(src, str):
+        if src.startswith("data:"):                  img_bytes = base64.b64decode(src.split(",",1)[1])
+        else:
+            async with httpx.AsyncClient() as cli:
+                o = urlparse(src)
+                referer = f"{o.scheme}://{o.netloc}/" if o.scheme and o.netloc else None
+                hdr_img = {"User-Agent": UA}
+                if referer: hdr_img["Referer"] = referer
+                try:
+                    r = await cli.get(src, headers=hdr_img, timeout=10)
+                    r.raise_for_status()
+                    img_bytes = r.content
+                except httpx.HTTPStatusError as he:
+                    code = he.response.status_code if he.response is not None else "NA"
+                    raise RuntimeError(f"fetch image HTTP {code}")
+                except httpx.TimeoutException:
+                    raise RuntimeError("fetch image TIMEOUT")
+                except Exception as e:
+                    raise RuntimeError(f"fetch image ERROR {type(e).__name__}")
+    else: raise TypeError("unsupported src type")
+
+    from io import BytesIO as _B
+    with Image.open(_B(img_bytes)) as im:
+        w, h = im.size
+
+    ck = await _cookie_header()
+    hdr = {"User-Agent": UA, "Cookie": ck, "Referer":"https://lens.google.com/", **_sap_header(ck)}
+    async with httpx.AsyncClient(follow_redirects=False) as cli:
+        up = await cli.post("https://lens.google.com/v3/upload",
+                            files={ "encoded_image": ("file.jpg", img_bytes, "image/jpeg"),
+                                    "sbisrc":(None,"browser"), "rt":(None,"j") },
+                            headers=hdr, timeout=10)
+    if up.status_code not in (302,303):
+        raise RuntimeError(f"Lens upload failed: {up.status_code}")
+    loc = up.headers.get("location") or ""
+    if not loc: raise RuntimeError("no redirect location")
+
+    cookie_dict = {k: v for k, v in (p.split("=", 1) for p in ck.split("; ") if "=" in p)}
+
+    loop = asyncio.get_running_loop()
+    drv = await loop.run_in_executor(None, lambda: _ensure_driver(cookie_dict))
+
+    def _blocking() -> List[Dict[str, Any]]:
+        nonlocal drv
+        with _driver_lock:
+            try:
+                try:
+                    drv.get(loc)
+                except:
+                    try:
+                        drv.quit()
+                    except Exception:
+                        pass
+                    drv = _ensure_driver(cookie_dict)
+                    drv.get(loc)
+                return _extract_boxes(drv, w, h)
+            finally:
+                pass
+
+    raw = await loop.run_in_executor(None, _blocking)
+
+    merged  = _merge_by_center_line(raw)
+    fulltxt = " ".join(a["description"] for a in raw).strip()
+
+    return {
+        "textAnnotations":      merged,
+        "rawTextAnnotations":   raw,
+        "fullTextAnnotation":   {"text": fulltxt},
+        "loc":                  loc,
+    }
+
+async def prewarm_driver():
+    try:
+        cookie_hdr = await _cookie_header()
+        cookie_dict = {k: v for k, v in (p.split("=", 1) for p in cookie_hdr.split("; ") if "=" in p)}
+        _ = cookie_dict
+        LOGGER.info("prewarm_driver: cookies ready")
+    except Exception as e:
+        LOGGER.warning("prewarm_driver failed: %s", e)

app/main.py

@@ -0,0 +1,243 @@
+import os, uuid, asyncio, logging
+from datetime import datetime, timedelta
+from typing import Dict, Optional, List, Any
+
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, HttpUrl, root_validator, ValidationError
+from fastapi.encoders import jsonable_encoder
+
+from app.lens_images_core import translate_lens
+from app.lens_text_core   import translate_lens_text
+
+PORT              = int(os.getenv("PORT", 8080))
+MAX_WORKERS       = int(os.getenv("MAX_WORKERS", 8))
+MAX_WORKERS_IMAGES = int(os.getenv("MAX_WORKERS_IMAGES", MAX_WORKERS))
+MAX_WORKERS_TEXT   = int(os.getenv("MAX_WORKERS_TEXT", 3))
+RESULTS_TTL       = int(os.getenv("RESULTS_TTL_SECONDS", 300))
+MAX_B64_IMG_LEN   = int(os.getenv("MAX_BASE64_IMAGE_LENGTH", 5_000_000))
+JOB_DELAY_SEC     = int(os.getenv("JOB_DELAY_SECONDS", 0.1))
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+)
+log = logging.getLogger("ocr_ws")
+
+ENABLE_BACKGROUND_WORKERS = os.getenv("ENABLE_BACKGROUND_WORKERS", "0").strip().lower() in ("1","true","yes","on")
+
+workers_started: bool = False
+_workers_lock = asyncio.Lock()
+
+async def ensure_workers_started():
+    global workers_started
+    if workers_started:
+        return
+    async with _workers_lock:
+        if workers_started:
+            return
+        for _ in range(MAX_WORKERS_IMAGES):
+            asyncio.create_task(worker("lens_images", jobq_img))
+        for _ in range(MAX_WORKERS_TEXT):
+            asyncio.create_task(worker("lens_text", jobq_text))
+        workers_started = True
+        log.info("workers started on-demand")
+
+app = FastAPI()
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"])
+
+jobq_img:  asyncio.Queue = asyncio.Queue()
+jobq_text: asyncio.Queue = asyncio.Queue()
+
+class Position(BaseModel):
+    top: float; left: float; width: float; height: float
+    viewport_width: int; viewport_height: int
+    scroll_x: float; scroll_y: float
+
+class PipelineEvent(BaseModel):
+    stage: str; at: datetime; target: Optional[str] = None
+
+class Context(BaseModel):
+    page_url: Optional[HttpUrl] = None
+    timestamp: Optional[datetime] = None
+
+class Metadata(BaseModel):
+    image_id: str
+    original_image_url: Optional[HttpUrl] = None
+    position: Optional[Position] = None
+    pipeline: List[PipelineEvent] = []
+    ocr_image: Optional[str] = None
+    extra: Optional[Dict[str, Any]] = None
+
+    @root_validator(pre=True)
+    def _no_blob_urls(cls, v):
+        url = v.get("original_image_url")
+        
+        if not url:
+            v["original_image_url"] = None
+            return v
+        if isinstance(url, str) and url.startswith("blob:"):
+            raise ValueError("original_image_url must be http(s)")
+        return v
+
+class Job(BaseModel):
+    mode: str = "lens_images"
+    lang: str = "en"
+    type: str = "image"
+    src: Optional[HttpUrl] = None
+    menu: Optional[str] = None
+    context: Optional[Context] = None
+    metadata: Metadata
+
+    @root_validator(pre=True)
+    def _src_no_blob(cls, v):
+        s = v.get("src")
+        if not s:
+            v["src"] = None
+            return v
+        if isinstance(s, str) and s.startswith("blob:"):
+            raise ValueError("src must be http(s)")
+        return v
+
+class WsMessage(BaseModel):
+    type: str
+    id: Optional[str] = None
+    payload: Optional[Job] = None
+
+jobq: asyncio.Queue = asyncio.Queue()
+pending_ws: Dict[str, WebSocket] = {}   
+results: Dict[str, dict]      = {}    
+
+@app.api_route("/health", methods=["GET", "HEAD"])
+async def health():
+    return {"ok": True, "timestamp": datetime.utcnow().isoformat()}
+
+@app.post("/translate")
+async def translate(job: Job):
+    await ensure_workers_started()
+    if job.mode not in ("lens_images", "lens_text"):
+        raise HTTPException(400, "unsupported mode")
+    jid = uuid.uuid4().hex
+    job.metadata.pipeline.append(PipelineEvent(stage="received_rest", at=datetime.utcnow()))
+    
+    if job.mode == "lens_images":
+        await jobq_img.put((jid, job))
+    else:
+        await jobq_text.put((jid, job))
+    results[jid] = {"status": "queued", "_created_at": datetime.utcnow()}
+    return {"id": jid, "status": "queued"}
+
+
+@app.get("/translate/{jid}")
+async def poll(jid: str):
+    if jid not in results:
+        raise HTTPException(404)
+    payload = results[jid].copy(); payload.pop("_created_at", None)
+    return {"id": jid, **payload}
+
+@app.websocket("/ws")
+async def ws_endpoint(ws: WebSocket):
+    await ws.accept()
+    await ensure_workers_started()
+    try:
+        while True:
+            raw = await ws.receive_json()
+            try:
+                msg = WsMessage(**raw)
+            except ValidationError as ve:
+                await ws.send_json({"type": "error","detail": ve.errors()})
+                continue
+            match msg.type:
+                case "job":
+                    jid = msg.id or uuid.uuid4().hex
+                    pending_ws[jid] = ws
+                    await ws.send_json(jsonable_encoder({"type": "ack", "id": jid}))
+                    
+                    if msg.payload.mode == "lens_images":
+                        await jobq_img.put((jid, msg.payload))
+                    elif msg.payload.mode == "lens_text":
+                        await jobq_text.put((jid, msg.payload))
+                    else:
+                        await ws.send_json({"type": "error","detail": "unsupported_mode"})
+                        pending_ws.pop(jid, None)
+                        continue
+                    results[jid] = {"status": "queued", "_created_at": datetime.utcnow()}
+                case _:
+                    await ws.send_json({"type": "error","detail": "unknown_type"})
+    except WebSocketDisconnect:
+        pass
+    finally:
+        for jid, sock in list(pending_ws.items()):
+            if sock is ws:
+                pending_ws.pop(jid, None)
+
+async def worker(mode: str, q: asyncio.Queue):
+    while True:
+        jid, job = await q.get()
+        try:
+            job.metadata.pipeline.append(PipelineEvent(stage="worker_start", at=datetime.utcnow()))
+            if not job.src:
+                raise RuntimeError("src missing")
+
+            log.info("worker start %s mode=%s src=%s", jid, job.mode, job.src)
+            if mode == "lens_images":
+                res = await translate_lens(str(job.src), job.lang)
+            elif mode == "lens_text":
+                res = await translate_lens_text(str(job.src))
+            else:
+                raise RuntimeError(f"unsupported mode {mode}")
+
+            img_b64 = res.get("image")
+            if img_b64 and len(img_b64) > MAX_B64_IMG_LEN:
+                res.pop("image", None)
+                job.metadata.extra = job.metadata.extra or {}
+                job.metadata.extra.setdefault(job.mode, {})["dropped_ocr_image_due_to_size"] = True
+
+            job.metadata.pipeline.append(PipelineEvent(stage="translated", at=datetime.utcnow()))
+            payload = {**res, "metadata": job.metadata.dict()}
+            serial = jsonable_encoder({"type": "result", "id": jid, "result": payload})
+
+            ws = pending_ws.pop(jid, None)
+            if ws:
+                try:
+                    await ws.send_json(serial)
+                    log.info("sent WS result %s", jid)
+                except Exception:
+                    pending_ws.pop(jid, None)
+
+            results[jid] = {"status": "done", "result": payload, "_created_at": datetime.utcnow()}
+            log.info("worker done %s mode=%s", jid, job.mode)
+        except Exception as e:
+            log.exception("worker error %s", jid, exc_info=e)
+            err_txt  = (str(e) or e.__class__.__name__)
+            err_type = e.__class__.__name__
+            err = {"type": "error", "id": jid, "error": err_txt, "error_type": err_type}
+            ws = pending_ws.pop(jid, None)
+            if ws:
+                try: await ws.send_json(jsonable_encoder(err))
+                except Exception: pass
+            results[jid] = {"status": "error", "result": err_txt, "error_type": err_type, "_created_at": datetime.utcnow()}
+        finally:
+            q.task_done()
+            if JOB_DELAY_SEC > 0:
+                await asyncio.sleep(JOB_DELAY_SEC)
+
+async def cleanup():
+    while True:
+        await asyncio.sleep(60)
+        cutoff = datetime.utcnow() - timedelta(seconds=RESULTS_TTL)
+        for jid in [k for k,v in results.items() if v.get("_created_at") < cutoff]:
+            results.pop(jid, None)
+
+@app.on_event("startup")
+async def startup():
+    if ENABLE_BACKGROUND_WORKERS:
+        for _ in range(MAX_WORKERS_IMAGES):
+            asyncio.create_task(worker("lens_images", jobq_img))
+        for _ in range(MAX_WORKERS_TEXT):
+            asyncio.create_task(worker("lens_text", jobq_text))
+    asyncio.create_task(cleanup())
+    log.info(
+        "startup OK – %d image workers, %d text workers, TTL=%ds (workers_enabled=%s)",
+        MAX_WORKERS_IMAGES, MAX_WORKERS_TEXT, RESULTS_TTL, ENABLE_BACKGROUND_WORKERS
+    )

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.111.0
+uvicorn[standard]==0.29.0
+httpx==0.27.0
+Pillow==10.4.0
+selenium==4.20.0
+pydantic==2.7.2