| """Harvesting engine: query search engines (icrawler / HTTP fallback) and download raw image binaries. |
| |
| Flow: |
| 1. Build query list from queries.yaml matrix. |
| 2. For each query and engine: |
| - Skip if `harvest_runs` records the run as done. |
| - Surface image URLs and store in `sources` and `hits` tables via `manifest.add_hit`. |
| - Record completed run in `harvest_runs`. |
| 3. Download pending URLs into `data/originals/`, computing SHA-256 ID. |
| 4. Register downloaded files in `images` table with status 'downloaded'. |
| """ |
| from __future__ import annotations |
|
|
| import hashlib |
| import logging |
| import mimetypes |
| import urllib.request |
| import urllib.error |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from pathlib import Path |
| from typing import Sequence |
|
|
| from tqdm import tqdm |
|
|
| from .manifest import Manifest, normalize_url |
| from .queries import QuerySpec, build_queries |
|
|
| log = logging.getLogger(__name__) |
|
|
| HEADERS = { |
| "User-Agent": ( |
| "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 " |
| "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" |
| ), |
| "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8", |
| } |
|
|
| EXT_MAP = { |
| "image/jpeg": ".jpg", |
| "image/jpg": ".jpg", |
| "image/png": ".png", |
| "image/webp": ".webp", |
| "image/gif": ".gif", |
| "image/bmp": ".bmp", |
| "image/tiff": ".tif", |
| "image/heic": ".heic", |
| "image/heif": ".heif", |
| } |
|
|
|
|
| def download_single_url( |
| source: dict, originals_dir: Path, timeout: float = 10.0 |
| ) -> tuple[dict, str | None, str | None, int | None, str | None]: |
| """Download raw binary for one URL. |
| |
| Returns (source, image_id, filepath, http_status, error_message). |
| """ |
| url = source["url"] |
| url_norm = source["url_norm"] |
| req = urllib.request.Request(url, headers=HEADERS) |
|
|
| try: |
| with urllib.request.urlopen(req, timeout=timeout) as resp: |
| content_type = resp.headers.get("Content-Type", "").split(";")[0].strip().lower() |
| data = resp.read() |
| http_status = resp.status |
| except urllib.error.HTTPError as exc: |
| return source, None, None, exc.code, f"HTTPError: {exc.code}" |
| except Exception as exc: |
| return source, None, None, None, f"{type(exc).__name__}: {exc}" |
|
|
| if len(data) < 500: |
| return source, None, None, http_status, "file_too_small_raw" |
|
|
| sha = hashlib.sha256(data).hexdigest() |
| image_id = sha[:16] |
|
|
| ext = EXT_MAP.get(content_type) or Path(url).suffix.lower() |
| if not ext or len(ext) > 5 or ext not in (".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tif", ".heic"): |
| ext = ".jpg" |
|
|
| dst = originals_dir / f"{image_id}{ext}" |
| if not dst.exists(): |
| originals_dir.mkdir(parents=True, exist_ok=True) |
| tmp = dst.with_name(dst.name + f".tmp") |
| tmp.write_bytes(data) |
| tmp.replace(dst) |
|
|
| return source, image_id, str(dst), http_status, None |
|
|
|
|
| def download_pending_sources( |
| manifest: Manifest, originals_dir: Path, data_dir: Path, cfg: dict |
| ) -> dict[str, int]: |
| """Download pending URLs from manifest into `originals_dir`.""" |
| ccfg = cfg.get("crawler", {}) |
| workers = int(ccfg.get("threads", 4)) |
| timeout = float(ccfg.get("timeout", 10.0)) |
|
|
| pending = manifest.pending_sources() |
| stats = {"downloaded": 0, "download_failed": 0} |
| if not pending: |
| log.info("crawler: no pending sources to download") |
| return stats |
|
|
| log.info("crawler: downloading %d pending URL(s)", len(pending)) |
|
|
| def work(src: dict): |
| return download_single_url(src, originals_dir, timeout=timeout) |
|
|
| with ThreadPoolExecutor(max_workers=workers) as ex: |
| futures = [ex.submit(work, s) for s in pending] |
| with manifest.transaction(): |
| for fut in tqdm(as_completed(futures), total=len(futures), desc="download", unit="url"): |
| src, image_id, dst_path, http_status, err = fut.result() |
| if err is None and image_id and dst_path: |
| data_file = Path(dst_path) |
| data = data_file.read_bytes() |
| sha = hashlib.sha256(data).hexdigest() |
| rel_path = str(data_file.relative_to(data_dir)) |
|
|
| manifest.add_image( |
| image_id=image_id, |
| sha256=sha, |
| origin="web", |
| source_ref=src["url"], |
| orig_path=rel_path, |
| orig_format=data_file.suffix.lstrip(".").lower(), |
| filesize=len(data), |
| status="downloaded", |
| ) |
| manifest.mark_source( |
| src["url_norm"], |
| status="downloaded", |
| http_status=http_status, |
| image_id=image_id, |
| attempts=1, |
| ) |
| stats["downloaded"] += 1 |
| else: |
| manifest.mark_source( |
| src["url_norm"], |
| status="failed", |
| http_status=http_status, |
| error=err, |
| attempts=1, |
| ) |
| stats["download_failed"] += 1 |
|
|
| log.info("crawler download stats: %s", stats) |
| return stats |
|
|
|
|
| def run_icrawler_harvest( |
| manifest: Manifest, |
| queries: Sequence[QuerySpec], |
| data_dir: Path, |
| engine_name: str = "bing", |
| max_num: int = 50, |
| force: bool = False, |
| filter_classes: set[str] | Sequence[str] | None = None, |
| ) -> dict[str, int]: |
| """Harvest image binaries using icrawler, save to data/originals, and register in manifest.""" |
| stats = {"runs": 0, "urls_found": 0, "urls_new": 0, "images_harvested": 0} |
| try: |
| if engine_name.lower() == "bing": |
| from icrawler.builtin import BingImageCrawler as CrawlerEngine |
| elif engine_name.lower() == "flickr": |
| from icrawler.builtin import FlickrImageCrawler as CrawlerEngine |
| elif engine_name.lower() == "baidu": |
| from icrawler.builtin import BaiduImageCrawler as CrawlerEngine |
| else: |
| log.warning("Unknown engine '%s', defaulting to Bing", engine_name) |
| from icrawler.builtin import BingImageCrawler as CrawlerEngine |
| except ImportError: |
| log.warning("icrawler is not installed; skipping search engine crawling") |
| return stats |
|
|
| import tempfile |
| import shutil |
|
|
| originals_dir = data_dir / "originals" |
| originals_dir.mkdir(parents=True, exist_ok=True) |
|
|
| filter_set = set(filter_classes) if filter_classes else None |
|
|
| for qspec in queries: |
| if filter_set and qspec.class_hint not in filter_set: |
| continue |
| if not force and manifest.run_done(engine_name, qspec.query): |
| log.debug("Skip harvest done run: %s / %s", engine_name, qspec.query) |
| continue |
|
|
| tmp_dir = Path(tempfile.mkdtemp(prefix="icrawler_")) |
| try: |
| crawler = CrawlerEngine( |
| downloader_threads=2, |
| storage={"root_dir": str(tmp_dir)}, |
| log_level=logging.WARNING, |
| ) |
| crawler.crawl(keyword=qspec.query, max_num=max_num) |
|
|
| found_count = 0 |
| new_count = 0 |
| with manifest.transaction(): |
| for img_file in tmp_dir.glob("*"): |
| if img_file.is_file() and img_file.stat().st_size > 500: |
| found_count += 1 |
| data = img_file.read_bytes() |
| sha = hashlib.sha256(data).hexdigest() |
| image_id = sha[:16] |
| ext = img_file.suffix.lower() |
| if not ext or len(ext) > 5 or ext not in (".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp"): |
| ext = ".jpg" |
|
|
| dst_file = originals_dir / f"{image_id}{ext}" |
| if not dst_file.exists(): |
| dst_file.write_bytes(data) |
|
|
| source_url = f"icrawler://{engine_name}/{qspec.class_hint}/{image_id}" |
| is_new = manifest.add_hit( |
| source_url, engine_name, qspec.query, class_hint=qspec.class_hint, lang=qspec.lang |
| ) |
| if is_new: |
| new_count += 1 |
|
|
| rel_path = str(dst_file.relative_to(data_dir)) |
| manifest.add_image( |
| image_id=image_id, |
| sha256=sha, |
| origin="web", |
| source_ref=source_url, |
| orig_path=rel_path, |
| orig_format=ext.lstrip("."), |
| filesize=len(data), |
| status="downloaded", |
| ) |
| manifest.mark_source( |
| source_url, |
| status="downloaded", |
| image_id=image_id, |
| ) |
| stats["images_harvested"] += 1 |
|
|
| manifest.record_run( |
| engine_name, qspec.query, qspec.class_hint, max_num, found_count, new_count |
| ) |
| stats["runs"] += 1 |
| stats["urls_found"] += found_count |
| stats["urls_new"] += new_count |
| except Exception as exc: |
| log.error("icrawler harvest failed for %s (%s): %s", qspec.query, engine_name, exc) |
| finally: |
| shutil.rmtree(tmp_dir, ignore_errors=True) |
|
|
| log.info("harvest stats (%s): %s", engine_name, stats) |
| return stats |
|
|
|
|
| def run( |
| manifest: Manifest, cfg: dict, data_dir: Path, engine: str = "bing", max_num: int = 50, force: bool = False, filter_classes: set[str] | Sequence[str] | None = None |
| ) -> dict[str, int]: |
| """Full crawler workflow: harvest queries and download raw images.""" |
| qcfg = cfg.get("queries") or {} |
| if not qcfg: |
| from .config import load_queries |
| qcfg = load_queries(cfg) |
|
|
| queries = build_queries(qcfg) |
| harvest_stats = run_icrawler_harvest(manifest, queries, data_dir, engine_name=engine, max_num=max_num, force=force, filter_classes=filter_classes) |
|
|
| originals_dir = data_dir / "originals" |
| download_stats = download_pending_sources(manifest, originals_dir, data_dir, cfg) |
|
|
| return {**harvest_stats, **download_stats} |
|
|
