#!/usr/bin/env python3 """ scrape_products.py — Fetch the RocketReviews.com product index and scrape each detail page, saving structured JSON to source/products/. Output ------ source/products/index.jsonl one record per product (raw index fields) source/products/detail/{id}.json full parsed detail per product Usage ----- python scripts/products/01_scrape.py python scripts/products/01_scrape.py --delay 2.0 --limit 10 python scripts/products/01_scrape.py --force # re-scrape existing files """ from __future__ import annotations import argparse import json import logging import re import sys import time from datetime import datetime, timezone from pathlib import Path from typing import Optional import requests from bs4 import BeautifulSoup, NavigableString, Tag from requests.adapters import HTTPAdapter from urllib3.util.retry import Retry # --------------------------------------------------------------------------- # Config # --------------------------------------------------------------------------- BASE_URL = "https://www.rocketreviews.com" INDEX_URL = f"{BASE_URL}/data/products/products.php?search=&type=" USER_AGENT = "RocketReviews-Dataset/1.0" DEFAULT_DELAY = 1.0 # seconds between requests ROOT = Path(__file__).parent.parent.parent SOURCE_DIR = ROOT / "source" / "products" DETAIL_DIR = SOURCE_DIR / "detail" # --------------------------------------------------------------------------- # Logging # --------------------------------------------------------------------------- logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", handlers=[logging.StreamHandler(sys.stdout)], ) log = logging.getLogger(__name__) # --------------------------------------------------------------------------- # HTTP session # --------------------------------------------------------------------------- def _build_session() -> requests.Session: s = requests.Session() s.headers["User-Agent"] = USER_AGENT retry = Retry( total=3, backoff_factor=2.0, status_forcelist=[429, 500, 502, 503, 504], allowed_methods=["GET"], ) s.mount("https://", HTTPAdapter(max_retries=retry)) s.mount("http://", HTTPAdapter(max_retries=retry)) return s class RateLimiter: def __init__(self, delay: float) -> None: self.delay = delay self._last: float = 0.0 def wait(self) -> None: elapsed = time.monotonic() - self._last if elapsed < self.delay: time.sleep(self.delay - elapsed) self._last = time.monotonic() # --------------------------------------------------------------------------- # Parsing helpers # --------------------------------------------------------------------------- def _re_first(pattern: str, text: str, group: int = 1) -> Optional[str]: m = re.search(pattern, text) return m.group(group) if m else None def _slug_to_label(slug: str) -> str: """Convert a hyphenated slug to a title-cased label.""" return slug.replace("-", " ").title() def _kit_index_int(field: str, html: str) -> Optional[int]: """ Extract an integer value from a /kit-index-{field}-{value}.html href. Used for fields stored as integers (e.g. skill-level). """ val = _re_first(rf"/kit-index-{field}-(\d+)\.html", html) return int(val) if val else None def _kit_index_scaled(field: str, html: str, scale: int = 10000) -> Optional[float]: """ Extract a scaled integer from a /kit-index-{field}-{value}.html href and divide by scale. Used for diameter, length, weight (4 decimal places). """ val = _re_first(rf"/kit-index-{field}-(\d+)\.html", html) return int(val) / scale if val else None def _kit_index_slug(field: str, html: str) -> Optional[str]: """ Extract and humanize a slug value from a /kit-index-{field}-{slug}.html href. Used for power class, recovery type, status. """ val = _re_first(rf"/kit-index-{field}-([a-z][a-z-]*)\.html", html) return _slug_to_label(val) if val else None def _parse_manufacturer(html: str, soup: BeautifulSoup) -> dict: """Extract manufacturer name and URLs from the page.""" # Canonical manufacturer page: e.g. /estes-1093.html mfr_canonical = _re_first(r'href="(/[a-z][a-z0-9-]+-\d+\.html)"', html) url = f"{BASE_URL}{mfr_canonical}" if mfr_canonical else None # Alias: kit-index filter page e.g. /kit-index-manufacturer-estes.html mfr_alias = _re_first(r"(/kit-index-manufacturer-[^\"']+\.html)", html) url_alias = f"{BASE_URL}{mfr_alias}" if mfr_alias else None mfr_link = soup.find("a", href=re.compile(r"/kit-index-manufacturer-")) name = mfr_link.get_text(strip=True) if mfr_link else None return { "name": name, "url": url, "url_alias": url_alias, } def _parse_designer(html: str) -> Optional[dict]: """ Extract designer name and URL from /kit-index-designer-{name}-{id}.html. Returns None if no designer is present. """ m = re.search(r"(/kit-index-designer-([a-z][a-z-]*)-\d+\.html)", html) if not m: return None return { "name": _slug_to_label(m.group(2)), "url": f"{BASE_URL}{m.group(1)}", } def _parse_styles(html: str) -> list[str]: """Extract all style labels from /kit-index-style-{name}-{id}.html hrefs.""" return [ _slug_to_label(m) for m in re.findall(r"/kit-index-style-([a-z][a-z-]*)-\d+\.html", html) ] def _parse_recommended_motors(soup: BeautifulSoup) -> list[str]: """ Find the 'Recommended Motors' label and extract the motor designations that follow it as comma-separated text. """ strong = soup.find("strong", string=re.compile(r"Recommended Motors?", re.I)) if not strong: return [] # Collect text from following siblings until next text = "" for sib in strong.next_siblings: if isinstance(sib, Tag) and sib.name == "strong": break text += sib.get_text() if isinstance(sib, Tag) else str(sib) motors = [m.strip() for m in re.split(r"[,\s]+", text.strip()) if m.strip()] return motors def _parse_cp(html: str) -> Optional[dict]: """ Extract CP location and method if present on the product page. CP location href: /kit-index-cp-{value}.html (value = inches * 10000) CP method href: /kit-index-cpmethod-{slug}.html Direction (Front/Rear) extracted from surrounding text. """ location_raw = _re_first(r"/kit-index-cp-(\d+)\.html", html) if not location_raw: return None location_in = int(location_raw) / 10000 # Determine direction from surrounding text direction = "Front" m = re.search(r"(\d+\.\d+)\s+inches\s+from\s+(Front|Rear)", html, re.I) if m: direction = m.group(2).title() method_slug = _re_first(r"/kit-index-cpmethod-([a-z][a-z/]*[a-z-]*)\.html", html) method = _slug_to_label(method_slug) if method_slug else None return { "location_in": location_in, "location_from": direction, "method": method, } def _parse_specs(html: str, soup: BeautifulSoup) -> Optional[dict]: """ Parse kit-specific structured specs from /kit-index-{field}-{value}.html link patterns. Returns None for non-kit product types that lack specs. """ diameter = _kit_index_scaled("diameter", html) length = _kit_index_scaled("length", html) weight = _kit_index_scaled("weight", html) motor_size = _kit_index_int("motor-size", html) skill_level = _kit_index_int("skill-level", html) power_class = _kit_index_slug("power", html) recovery = _kit_index_slug("recovery", html) status_slug = _re_first(r"/kit-index-status-([a-z][a-z-]*)\.html", html) status = _slug_to_label(status_slug) if status_slug else None styles = _parse_styles(html) recommended_motors = _parse_recommended_motors(soup) # If none of the kit-specific fields are present, this isn't a kit-type page if not any([diameter, length, weight, motor_size, skill_level, power_class]): return None return { "diameter_in": diameter, "length_in": length, "weight_oz": weight, "motor_size_mm": motor_size, "power_class": power_class, "skill_level": skill_level, "style": styles, "recovery": recovery, "status": status, "recommended_motors": recommended_motors, } def _parse_detail(html: str, index_rec: dict) -> dict: soup = BeautifulSoup(html, "lxml") product_id = int(index_rec["id"]) # Canonical URL is directly constructable from the product ID url = f"{BASE_URL}/product-{product_id}.html" # Alias URL from the index alias_path = index_rec.get("url", "") url_alias = f"{BASE_URL}{alias_path}" if alias_path else None return { "id": product_id, "url": url, "url_alias": url_alias, "name": index_rec.get("name"), "title": index_rec.get("title"), "type": index_rec.get("type"), "model": index_rec.get("model") or None, "years": index_rec.get("years") or None, "manufacturer": _parse_manufacturer(html, soup), "designer": _parse_designer(html), "scraped_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), "specs": _parse_specs(html, soup), "cp": _parse_cp(html), } # --------------------------------------------------------------------------- # Fetch helpers # --------------------------------------------------------------------------- def fetch_index(session: requests.Session) -> list[dict]: log.info("Fetching product index from %s", INDEX_URL) resp = session.get(INDEX_URL, timeout=30) resp.raise_for_status() records = resp.json().get("records", []) log.info("Index returned %d records.", len(records)) return records def scrape_detail( session: requests.Session, rate: RateLimiter, index_rec: dict, force: bool = False, ) -> Optional[dict]: product_id = int(index_rec["id"]) shard = f"{product_id // 1000:03d}" shard_dir = DETAIL_DIR / shard dest = shard_dir / f"{product_id:06d}.json" if dest.exists() and not force: log.debug("Already scraped %s, skipping.", product_id) return None # Use canonical URL directly — constructable from the ID url = f"{BASE_URL}/product-{product_id}.html" rate.wait() try: resp = session.get(url, timeout=30) resp.raise_for_status() except requests.RequestException as exc: log.warning("Failed to fetch product %s: %s", product_id, exc) return None return _parse_detail(resp.text, index_rec) # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- def main() -> None: parser = argparse.ArgumentParser(description="Scrape RocketReviews.com products.") parser.add_argument( "--delay", type=float, default=DEFAULT_DELAY, help=f"Seconds between requests (default: {DEFAULT_DELAY})", ) parser.add_argument( "--limit", type=int, default=None, help="Stop after scraping this many detail pages (useful for testing)", ) parser.add_argument( "--force", action="store_true", help="Re-scrape products that already have a saved detail file", ) args = parser.parse_args() SOURCE_DIR.mkdir(parents=True, exist_ok=True) DETAIL_DIR.mkdir(parents=True, exist_ok=True) session = _build_session() rate = RateLimiter(args.delay) # ------------------------------------------------------------------ # Step 1: fetch and write the full index # ------------------------------------------------------------------ records = fetch_index(session) scraped_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") index_path = SOURCE_DIR / "index.jsonl" with index_path.open("w", encoding="utf-8") as f: for rec in records: f.write(json.dumps({**rec, "scraped_at": scraped_at}) + "\n") log.info("Wrote %d index records to %s", len(records), index_path) # ------------------------------------------------------------------ # Step 2: scrape each detail page # ------------------------------------------------------------------ if args.limit: records = records[: args.limit] ok = skipped = failed = 0 total = len(records) for i, rec in enumerate(records, 1): result = scrape_detail(session, rate, rec, force=args.force) if result is None: skipped += 1 continue product_id = int(rec["id"]) shard = f"{product_id // 1000:03d}" shard_dir = DETAIL_DIR / shard shard_dir.mkdir(parents=True, exist_ok=True) dest = shard_dir / f"{product_id:06d}.json" try: dest.write_text( json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8" ) ok += 1 log.debug("Saved %s", dest.name) except OSError as exc: log.warning("Could not write %s: %s", dest, exc) failed += 1 if i % 25 == 0 or i == total: log.info( "Progress: %d/%d — ok=%d skipped=%d failed=%d", i, total, ok, skipped, failed, ) log.info("Done — ok=%d skipped=%d failed=%d", ok, skipped, failed) if __name__ == "__main__": main()