Your Name
291 lines
12 KiB
Python
291 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import os
|
|
import re
|
|
import secrets
|
|
from datetime import datetime, timezone
|
|
from time import struct_time
|
|
from typing import Annotated, Any
|
|
from urllib.parse import parse_qs, urljoin, urlparse
|
|
|
|
import feedparser
|
|
import httpx
|
|
from bs4 import BeautifulSoup
|
|
from fastapi import FastAPI, Header, HTTPException
|
|
from playwright.async_api import async_playwright
|
|
from playwright_captcha import CaptchaType, FrameworkType, TwoCaptchaSolver
|
|
from pydantic import BaseModel, Field, HttpUrl, SecretStr
|
|
from twocaptcha import AsyncTwoCaptcha
|
|
|
|
app = FastAPI(title="Site Parser Worker", version="0.1.0")
|
|
browser_lock = asyncio.Lock()
|
|
|
|
|
|
class ParseRequest(BaseModel):
|
|
url: HttpUrl
|
|
config: dict[str, Any]
|
|
rucaptcha_token: SecretStr | None = None
|
|
browser_state: dict[str, Any] | None = None
|
|
|
|
|
|
class ParsedItem(BaseModel):
|
|
external_id: str
|
|
url: str
|
|
title: str
|
|
text: str
|
|
html: str
|
|
published_at: str | None
|
|
author: str | None
|
|
media: list[dict[str, str]] = Field(default_factory=list)
|
|
|
|
|
|
def require_token(worker_token: str | None) -> None:
|
|
expected = os.getenv("WORKER_TOKEN", "")
|
|
if not expected:
|
|
raise HTTPException(status_code=503, detail="WORKER_TOKEN is not configured")
|
|
if not worker_token or not secrets.compare_digest(worker_token, expected):
|
|
raise HTTPException(status_code=401, detail="Invalid worker token")
|
|
|
|
|
|
def is_cloudflare_challenge(status: int, body: str) -> bool:
|
|
sample = body[:20_000].lower()
|
|
return status in {403, 429, 503} and (
|
|
"just a moment" in sample or "cf-chl" in sample or "challenge-platform" in sample
|
|
)
|
|
|
|
|
|
def iso_date(value: struct_time | None) -> str | None:
|
|
if not value:
|
|
return None
|
|
return datetime(*value[:6], tzinfo=timezone.utc).isoformat()
|
|
|
|
|
|
def youtube_url(value: str, base_url: str = "") -> str | None:
|
|
url = urljoin(base_url, str(value or "").strip())
|
|
parsed = urlparse(url)
|
|
host = (parsed.hostname or "").lower().removeprefix("www.").removeprefix("m.")
|
|
video_id = ""
|
|
if host == "youtu.be":
|
|
video_id = parsed.path.strip("/").split("/", 1)[0]
|
|
elif host in {"youtube.com", "youtube-nocookie.com"}:
|
|
if parsed.path == "/watch":
|
|
video_id = (parse_qs(parsed.query).get("v") or [""])[0]
|
|
elif parsed.path.startswith(("/embed/", "/shorts/", "/live/")):
|
|
video_id = parsed.path.strip("/").split("/", 1)[1]
|
|
if not re.fullmatch(r"[A-Za-z0-9_-]{6,20}", video_id):
|
|
return None
|
|
return f"https://www.youtube.com/watch?v={video_id}"
|
|
|
|
|
|
def clean_html(value: Any, base_url: str = "") -> tuple[str, str, list[dict[str, str]]]:
|
|
html = str(value or "").strip()
|
|
soup = BeautifulSoup(html, "html.parser")
|
|
for element in soup.find_all(["script", "style", "noscript"]):
|
|
element.decompose()
|
|
text = soup.get_text("\n", strip=True)
|
|
media = [
|
|
{"type": "photo", "url": urljoin(base_url, str(image["src"]))}
|
|
for image in soup.find_all("img", src=True)
|
|
]
|
|
for element in soup.find_all(["video", "source"], src=True):
|
|
media.append({"type": "video", "url": urljoin(base_url, str(element["src"]))})
|
|
for element in soup.find_all(["iframe", "a"]):
|
|
url = youtube_url(str(element.get("src") or element.get("href") or ""), base_url)
|
|
if url:
|
|
media.append({"type": "video", "url": url})
|
|
return html, text, media
|
|
|
|
|
|
def parse_rss(xml: str, max_items: int) -> list[ParsedItem]:
|
|
feed = feedparser.parse(xml, sanitize_html=False)
|
|
if feed.bozo and not feed.entries:
|
|
raise ValueError(f"Invalid RSS: {feed.bozo_exception}")
|
|
items = []
|
|
for entry in feed.entries[:max_items]:
|
|
title = BeautifulSoup(str(entry.get("title") or ""), "html.parser").get_text(" ", strip=True)
|
|
url = str(entry.get("link") or "").strip()
|
|
content = (entry.get("content") or [{}])[0].get("value") or entry.get("description") or entry.get("summary") or ""
|
|
html, text, media = clean_html(content, url)
|
|
for enclosure in entry.get("enclosures") or []:
|
|
enclosure_url = urljoin(url, str(enclosure.get("href") or enclosure.get("url") or "").strip())
|
|
media_type = str(enclosure.get("type") or "")
|
|
if enclosure_url and (not media_type or media_type.startswith("image/")):
|
|
media.append({"type": "photo", "url": enclosure_url})
|
|
elif enclosure_url and media_type.startswith("video/"):
|
|
media.append({"type": "video", "url": enclosure_url})
|
|
items.append(
|
|
ParsedItem(
|
|
external_id=str(entry.get("id") or entry.get("guid") or url).strip(),
|
|
url=url,
|
|
title=title,
|
|
text=text,
|
|
html=html,
|
|
published_at=iso_date(entry.get("published_parsed") or entry.get("updated_parsed")),
|
|
author=str(entry.get("author") or "").strip() or None,
|
|
media=list({item["url"]: item for item in media}.values()),
|
|
)
|
|
)
|
|
return items
|
|
|
|
|
|
async def fetch_in_browser(
|
|
url: str,
|
|
rucaptcha_token: str,
|
|
browser_state: dict[str, Any] | None,
|
|
) -> tuple[str, dict[str, Any]]:
|
|
# ponytail: one browser at a time; use a queue only when parallel source parsing is needed.
|
|
async with browser_lock:
|
|
async with async_playwright() as playwright:
|
|
browser = await playwright.chromium.launch(channel="chrome", headless=False)
|
|
context = await browser.new_context(storage_state=browser_state) if browser_state else await browser.new_context()
|
|
page = await context.new_page()
|
|
async with TwoCaptchaSolver(
|
|
framework=FrameworkType.PLAYWRIGHT,
|
|
page=page,
|
|
async_two_captcha_client=AsyncTwoCaptcha(rucaptcha_token),
|
|
max_attempts=1,
|
|
) as solver:
|
|
await page.goto(url, wait_until="domcontentloaded", timeout=60_000)
|
|
if "just a moment" in (await page.title()).lower():
|
|
await solver.solve_captcha(
|
|
captcha_container=page,
|
|
captcha_type=CaptchaType.CLOUDFLARE_INTERSTITIAL,
|
|
)
|
|
try:
|
|
await page.locator("pre").wait_for(state="visible", timeout=60_000)
|
|
except Exception as exc:
|
|
raise RuntimeError(f"RSS did not load after Cloudflare challenge: {await page.title()}") from exc
|
|
xml = await page.locator("pre").inner_text()
|
|
state = await context.storage_state()
|
|
await browser.close()
|
|
return xml, state
|
|
|
|
|
|
async def enrich_items_in_browser(
|
|
items: list[ParsedItem],
|
|
rucaptcha_token: str,
|
|
browser_state: dict[str, Any] | None,
|
|
content_selector: str,
|
|
text_selector: str,
|
|
) -> tuple[list[ParsedItem], dict[str, Any]]:
|
|
async with browser_lock:
|
|
async with async_playwright() as playwright:
|
|
browser = await playwright.chromium.launch(channel="chrome", headless=False)
|
|
context = await browser.new_context(storage_state=browser_state) if browser_state else await browser.new_context()
|
|
page = await context.new_page()
|
|
async with TwoCaptchaSolver(
|
|
framework=FrameworkType.PLAYWRIGHT,
|
|
page=page,
|
|
async_two_captcha_client=AsyncTwoCaptcha(rucaptcha_token),
|
|
max_attempts=1,
|
|
) as solver:
|
|
for item in items:
|
|
if item.text and item.media:
|
|
continue
|
|
await page.goto(item.url, wait_until="domcontentloaded", timeout=60_000)
|
|
if "just a moment" in (await page.title()).lower():
|
|
await solver.solve_captcha(
|
|
captcha_container=page,
|
|
captcha_type=CaptchaType.CLOUDFLARE_INTERSTITIAL,
|
|
)
|
|
try:
|
|
content = page.locator(content_selector).first
|
|
await content.wait_for(state="visible", timeout=60_000)
|
|
except Exception as exc:
|
|
raise RuntimeError(f"Item content not found: {item.url} ({content_selector})") from exc
|
|
html, text, media = clean_html(await content.inner_html(), item.url)
|
|
if text_selector:
|
|
text_content = content.locator(text_selector).first
|
|
text = clean_html(await text_content.inner_html())[1] if await text_content.count() else ""
|
|
item.html = html
|
|
item.text = text
|
|
item.media = list({entry["url"]: entry for entry in [*item.media, *media]}.values())
|
|
state = await context.storage_state()
|
|
await browser.close()
|
|
return items, state
|
|
|
|
|
|
@app.get("/health")
|
|
async def health() -> dict[str, bool]:
|
|
return {"ok": True}
|
|
|
|
|
|
@app.post("/v1/parse")
|
|
async def parse_source(
|
|
request: ParseRequest,
|
|
worker_token: Annotated[str | None, Header(alias="X-Worker-Token")] = None,
|
|
) -> dict[str, Any]:
|
|
require_token(worker_token)
|
|
config = request.config
|
|
if not config:
|
|
raise HTTPException(status_code=422, detail="config is required and cannot be empty")
|
|
if config.get("format") != "rss":
|
|
raise HTTPException(status_code=422, detail="Only config.format=rss is supported")
|
|
access = str(config.get("access") or "auto")
|
|
if access not in {"auto", "http", "cloudflare"}:
|
|
raise HTTPException(status_code=422, detail="config.access must be auto, http or cloudflare")
|
|
try:
|
|
max_items = int(config.get("max_items", 20))
|
|
except (TypeError, ValueError) as exc:
|
|
raise HTTPException(status_code=422, detail="config.max_items must be an integer") from exc
|
|
if not 1 <= max_items <= 100:
|
|
raise HTTPException(status_code=422, detail="config.max_items must be between 1 and 100")
|
|
follow_links = config.get("follow_links", False)
|
|
if not isinstance(follow_links, bool):
|
|
raise HTTPException(status_code=422, detail="config.follow_links must be true or false")
|
|
content_selector = str(config.get("content_selector") or "").strip()
|
|
text_selector = str(config.get("text_selector") or "").strip()
|
|
if follow_links and not content_selector:
|
|
raise HTTPException(status_code=422, detail="config.content_selector is required when follow_links=true")
|
|
url = str(request.url)
|
|
xml = ""
|
|
state = request.browser_state
|
|
fetched_via = "http"
|
|
if access != "cloudflare":
|
|
try:
|
|
async with httpx.AsyncClient(follow_redirects=True, timeout=30) as client:
|
|
response = await client.get(url, headers={"User-Agent": "Mozilla/5.0 SiteParser/0.1"})
|
|
except httpx.HTTPError as exc:
|
|
raise HTTPException(status_code=502, detail=f"Source request failed: {exc}") from exc
|
|
if not is_cloudflare_challenge(response.status_code, response.text):
|
|
try:
|
|
response.raise_for_status()
|
|
except httpx.HTTPStatusError as exc:
|
|
raise HTTPException(status_code=502, detail=f"Source returned HTTP {response.status_code}") from exc
|
|
xml = response.text
|
|
elif access == "http":
|
|
raise HTTPException(status_code=502, detail="Cloudflare challenge received in http-only mode")
|
|
if not xml:
|
|
if not request.rucaptcha_token:
|
|
raise HTTPException(status_code=422, detail="rucaptcha_token is required for Cloudflare")
|
|
fetched_via = "cloudflare"
|
|
try:
|
|
xml, state = await fetch_in_browser(url, request.rucaptcha_token.get_secret_value(), state)
|
|
except Exception as exc:
|
|
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
|
try:
|
|
items = parse_rss(xml, max_items)
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
|
if follow_links:
|
|
if not request.rucaptcha_token:
|
|
raise HTTPException(status_code=422, detail="rucaptcha_token is required when follow_links=true")
|
|
try:
|
|
items, state = await enrich_items_in_browser(
|
|
items,
|
|
request.rucaptcha_token.get_secret_value(),
|
|
state,
|
|
content_selector,
|
|
text_selector,
|
|
)
|
|
except Exception as exc:
|
|
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
|
fetched_via += "+item-pages"
|
|
return {
|
|
"source_url": url,
|
|
"fetched_via": fetched_via,
|
|
"items": [item.model_dump() for item in items],
|
|
"browser_state": state,
|
|
}
|