image_crawler.py

#!/usr/bin/env python3
"""
OpenTransformers Image Crawler v1.0
Grabby hands for multimodal training data.

Grabs images + context (alt text, captions, surrounding text)
Perfect for vision-language model training.

Usage:
    python image_crawler.py --seeds seeds.txt --output /workspace/images --max-gb 10
    python image_crawler.py --seed "https://unsplash.com" --min-size 256 --workers 50
"""

import asyncio
import aiohttp
import argparse
import hashlib
import json
import os
import re
import time
import random
import base64
from dataclasses import dataclass, asdict
from datetime import datetime
from pathlib import Path
from typing import Optional, Set, Dict, List, Tuple
from urllib.parse import urljoin, urlparse
from collections import defaultdict
import struct
import io

# ============= IMAGE UTILITIES =============

def get_image_size_from_header(data: bytes) -> Tuple[int, int]:
    """Get image dimensions without downloading full image"""
    if len(data) < 24:
        return (0, 0)
    
    # PNG
    if data[:8] == b'\x89PNG\r\n\x1a\n':
        if data[12:16] == b'IHDR':
            w = struct.unpack('>I', data[16:20])[0]
            h = struct.unpack('>I', data[20:24])[0]
            return (w, h)
    
    # JPEG
    if data[:2] == b'\xff\xd8':
        try:
            i = 2
            while i < len(data) - 8:
                if data[i] != 0xff:
                    i += 1
                    continue
                marker = data[i+1]
                if marker in (0xc0, 0xc1, 0xc2):  # SOF markers
                    h = struct.unpack('>H', data[i+5:i+7])[0]
                    w = struct.unpack('>H', data[i+7:i+9])[0]
                    return (w, h)
                elif marker == 0xd9:  # EOI
                    break
                elif marker in (0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0x01):
                    i += 2
                else:
                    length = struct.unpack('>H', data[i+2:i+4])[0]
                    i += 2 + length
        except:
            pass
    
    # GIF
    if data[:6] in (b'GIF87a', b'GIF89a'):
        w = struct.unpack('<H', data[6:8])[0]
        h = struct.unpack('<H', data[8:10])[0]
        return (w, h)
    
    # WebP
    if data[:4] == b'RIFF' and data[8:12] == b'WEBP':
        if data[12:16] == b'VP8 ':
            w = struct.unpack('<H', data[26:28])[0] & 0x3fff
            h = struct.unpack('<H', data[28:30])[0] & 0x3fff
            return (w, h)
        elif data[12:16] == b'VP8L':
            bits = struct.unpack('<I', data[21:25])[0]
            w = (bits & 0x3fff) + 1
            h = ((bits >> 14) & 0x3fff) + 1
            return (w, h)
    
    return (0, 0)


def extract_images_from_html(html: str, base_url: str) -> List[Dict]:
    """Extract all images with context from HTML"""
    images = []
    
    # Standard img tags
    for match in re.finditer(
        r'<img[^>]+src=["\']([^"\']+)["\'][^>]*>',
        html, re.I | re.DOTALL
    ):
        full_tag = match.group(0)
        src = match.group(1)
        
        if src.startswith('data:'):
            continue
            
        # Get alt text
        alt_match = re.search(r'alt=["\']([^"\']*)["\']', full_tag, re.I)
        alt = alt_match.group(1) if alt_match else ""
        
        # Get title
        title_match = re.search(r'title=["\']([^"\']*)["\']', full_tag, re.I)
        title = title_match.group(1) if title_match else ""
        
        # Get srcset for higher res
        srcset_match = re.search(r'srcset=["\']([^"\']+)["\']', full_tag, re.I)
        srcset = srcset_match.group(1) if srcset_match else ""
        
        # Parse srcset for best resolution
        best_src = src
        if srcset:
            best_width = 0
            for item in srcset.split(','):
                parts = item.strip().split()
                if len(parts) >= 2:
                    url = parts[0]
                    descriptor = parts[1]
                    if descriptor.endswith('w'):
                        try:
                            width = int(descriptor[:-1])
                            if width > best_width:
                                best_width = width
                                best_src = url
                        except:
                            pass
        
        # Get surrounding text (50 chars before/after)
        start = max(0, match.start() - 200)
        end = min(len(html), match.end() + 200)
        context = re.sub(r'<[^>]+>', ' ', html[start:end])
        context = re.sub(r'\s+', ' ', context).strip()
        
        try:
            absolute_url = urljoin(base_url, best_src)
            if absolute_url.startswith(('http://', 'https://')):
                images.append({
                    'url': absolute_url,
                    'alt': alt,
                    'title': title,
                    'context': context[:500]
                })
        except:
            pass
    
    # Also grab og:image and twitter:image
    for meta_prop in ['og:image', 'twitter:image']:
        match = re.search(
            f'<meta[^>]+(?:property|name)=["\'{meta_prop}["\'][^>]+content=["\']([^"\']+)["\']',
            html, re.I
        )
        if not match:
            match = re.search(
                f'<meta[^>]+content=["\']([^"\']+)["\'][^>]+(?:property|name)=["\'{meta_prop}["\']',
                html, re.I
            )
        if match:
            src = match.group(1)
            try:
                absolute_url = urljoin(base_url, src)
                if absolute_url.startswith(('http://', 'https://')):
                    images.append({
                        'url': absolute_url,
                        'alt': f'[{meta_prop}]',
                        'title': '',
                        'context': ''
                    })
            except:
                pass
    
    return images


def extract_links(html: str, base_url: str) -> Set[str]:
    """Extract page links for crawling"""
    links = set()
    for match in re.finditer(r'href=["\']([^"\']+)["\']', html, re.I):
        href = match.group(1)
        if href.startswith(('#', 'javascript:', 'mailto:', 'tel:', 'data:')):
            continue
        try:
            absolute = urljoin(base_url, href)
            if absolute.startswith(('http://', 'https://')):
                absolute = absolute.split('#')[0]
                if len(absolute) < 500:
                    links.add(absolute)
        except:
            pass
    return links


def get_domain(url: str) -> str:
    try:
        return urlparse(url).netloc.lower()
    except:
        return ""


# ============= DATA STRUCTURES =============

@dataclass
class CrawledImage:
    url: str
    source_page: str
    domain: str
    timestamp: str
    alt: str
    title: str
    context: str
    width: int
    height: int
    format: str
    size_bytes: int
    hash: str
    # base64 data stored separately or inline depending on config


class Stats:
    def __init__(self):
        self.pages = 0
        self.images = 0
        self.bytes = 0
        self.skipped_small = 0
        self.skipped_dupe = 0
        self.errors = 0
        self.start = time.time()
        self.by_domain: Dict[str, int] = defaultdict(int)
    
    def report(self) -> str:
        elapsed = time.time() - self.start
        rate = self.images / elapsed if elapsed > 0 else 0
        mb = self.bytes / (1024 * 1024)
        return f"Pages: {self.pages} | Imgs: {self.images} | {mb:.1f} MB | {rate:.1f} img/s | Skip: {self.skipped_small}s/{self.skipped_dupe}d | Err: {self.errors}"


# ============= CRAWLER =============

class ImageCrawler:
    USER_AGENTS = [
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
    ]
    
    IMAGE_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'}
    
    def __init__(
        self,
        output_dir: str = 'image_data',
        max_workers: int = 50,
        max_pages: int = 100000,
        max_bytes: int = 10 * 1024**3,
        timeout: int = 30,
        min_size: int = 256,  # Minimum dimension
        max_size: int = 8192,  # Maximum dimension  
        min_bytes: int = 10000,  # 10KB minimum
        max_bytes_per_image: int = 20 * 1024**2,  # 20MB max per image
        save_inline: bool = False,  # Save base64 in JSONL vs separate files
    ):
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(parents=True, exist_ok=True)
        (self.output_dir / 'images').mkdir(exist_ok=True)
        
        self.max_workers = max_workers
        self.max_pages = max_pages
        self.max_bytes = max_bytes
        self.timeout = timeout
        self.min_size = min_size
        self.max_size = max_size
        self.min_bytes = min_bytes
        self.max_bytes_per_image = max_bytes_per_image
        self.save_inline = save_inline
        
        self.page_queue: asyncio.Queue = asyncio.Queue()
        self.seen_pages: Set[str] = set()
        self.seen_images: Set[str] = set()
        self.seen_hashes: Set[str] = set()
        self.stats = Stats()
        self.running = True
        
        self.output_file = None
        self.output_lock = asyncio.Lock()
    
    def _should_crawl_page(self, url: str) -> bool:
        if url in self.seen_pages:
            return False
        skip_ext = {'.jpg', '.jpeg', '.png', '.gif', '.pdf', '.zip', '.mp3', '.mp4',
                   '.avi', '.mov', '.exe', '.css', '.js', '.ico', '.svg'}
        lower = url.lower()
        if any(lower.endswith(ext) for ext in skip_ext):
            return False
        return True
    
    async def _fetch_page(self, session: aiohttp.ClientSession, url: str) -> Tuple[Optional[str], Set[str]]:
        """Fetch a page and extract images + links"""
        try:
            headers = {'User-Agent': random.choice(self.USER_AGENTS)}
            async with session.get(url, headers=headers, timeout=self.timeout,
                                   ssl=False, allow_redirects=True) as resp:
                ct = resp.headers.get('content-type', '').lower()
                if 'text/html' not in ct:
                    return None, set()
                html = await resp.text(errors='ignore')
                links = extract_links(html, url)
                return html, links
        except:
            return None, set()
    
    async def _fetch_image(self, session: aiohttp.ClientSession, img_info: Dict, source_page: str) -> Optional[Dict]:
        """Fetch and validate a single image"""
        url = img_info['url']
        
        if url in self.seen_images:
            return None
        self.seen_images.add(url)
        
        try:
            headers = {'User-Agent': random.choice(self.USER_AGENTS)}
            async with session.get(url, headers=headers, timeout=self.timeout,
                                   ssl=False, allow_redirects=True) as resp:
                
                ct = resp.headers.get('content-type', '').lower()
                if not any(t in ct for t in ['image/jpeg', 'image/png', 'image/gif', 'image/webp']):
                    return None
                
                # Check content-length first
                cl = resp.headers.get('content-length')
                if cl:
                    size = int(cl)
                    if size < self.min_bytes or size > self.max_bytes_per_image:
                        self.stats.skipped_small += 1
                        return None
                
                data = await resp.read()
                
                if len(data) < self.min_bytes:
                    self.stats.skipped_small += 1
                    return None
                
                # Get dimensions
                width, height = get_image_size_from_header(data)
                if width < self.min_size or height < self.min_size:
                    self.stats.skipped_small += 1
                    return None
                if width > self.max_size or height > self.max_size:
                    self.stats.skipped_small += 1
                    return None
                
                # Dedupe by hash
                img_hash = hashlib.md5(data).hexdigest()
                if img_hash in self.seen_hashes:
                    self.stats.skipped_dupe += 1
                    return None
                self.seen_hashes.add(img_hash)
                
                # Determine format
                fmt = 'unknown'
                if data[:8] == b'\x89PNG\r\n\x1a\n':
                    fmt = 'png'
                elif data[:2] == b'\xff\xd8':
                    fmt = 'jpeg'
                elif data[:6] in (b'GIF87a', b'GIF89a'):
                    fmt = 'gif'
                elif data[:4] == b'RIFF' and data[8:12] == b'WEBP':
                    fmt = 'webp'
                
                result = {
                    'url': url,
                    'source_page': source_page,
                    'domain': get_domain(url),
                    'timestamp': datetime.utcnow().isoformat(),
                    'alt': img_info.get('alt', ''),
                    'title': img_info.get('title', ''),
                    'context': img_info.get('context', ''),
                    'width': width,
                    'height': height,
                    'format': fmt,
                    'size_bytes': len(data),
                    'hash': img_hash,
                }
                
                if self.save_inline:
                    result['data'] = base64.b64encode(data).decode('ascii')
                else:
                    # Save to file
                    ext = {'jpeg': 'jpg', 'png': 'png', 'gif': 'gif', 'webp': 'webp'}.get(fmt, 'bin')
                    fname = f"{img_hash}.{ext}"
                    fpath = self.output_dir / 'images' / fname
                    with open(fpath, 'wb') as f:
                        f.write(data)
                    result['file'] = fname
                
                return result
                
        except Exception as e:
            self.stats.errors += 1
            return None
    
    async def _worker(self, session: aiohttp.ClientSession, worker_id: int):
        """Worker processes pages and their images"""
        while self.running:
            try:
                page_url = await asyncio.wait_for(self.page_queue.get(), timeout=10.0)
            except asyncio.TimeoutError:
                if self.page_queue.empty():
                    break
                continue
            
            if self.stats.bytes >= self.max_bytes or self.stats.pages >= self.max_pages:
                self.running = False
                break
            
            html, links = await self._fetch_page(session, page_url)
            
            if html:
                self.stats.pages += 1
                
                # Extract and fetch images
                images = extract_images_from_html(html, page_url)
                for img_info in images:
                    if not self.running:
                        break
                    
                    result = await self._fetch_image(session, img_info, page_url)
                    if result:
                        self.stats.images += 1
                        self.stats.bytes += result['size_bytes']
                        self.stats.by_domain[result['domain']] += 1
                        
                        async with self.output_lock:
                            self.output_file.write(json.dumps(result) + '\n')
                
                # Queue new pages
                for link in links:
                    if self._should_crawl_page(link) and self.stats.pages < self.max_pages:
                        self.seen_pages.add(link)
                        await self.page_queue.put(link)
                
                if self.stats.pages % 50 == 0:
                    print(f"[{datetime.now().strftime('%H:%M:%S')}] {self.stats.report()}")
            
            self.page_queue.task_done()
    
    async def crawl(self, seeds: List[str]):
        print(f"OpenTransformers Image Crawler starting")
        print(f"Seeds: {len(seeds)} | Workers: {self.max_workers} | Min size: {self.min_size}px")
        print(f"Target: {self.max_pages} pages / {self.max_bytes/1024**3:.1f} GB")
        print("-" * 60)
        
        for seed in seeds:
            self.seen_pages.add(seed)
            await self.page_queue.put(seed)
        
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        output_path = self.output_dir / f'images_{timestamp}.jsonl'
        self.output_file = open(output_path, 'w', buffering=1)
        
        connector = aiohttp.TCPConnector(limit=self.max_workers, ssl=False)
        async with aiohttp.ClientSession(connector=connector) as session:
            workers = [asyncio.create_task(self._worker(session, i)) for i in range(self.max_workers)]
            await asyncio.gather(*workers)
        
        self.output_file.close()
        
        print("-" * 60)
        print(f"DONE! {self.stats.report()}")
        print(f"Metadata: {output_path}")
        if not self.save_inline:
            img_dir = self.output_dir / 'images'
            img_count = len(list(img_dir.glob('*')))
            img_size = sum(f.stat().st_size for f in img_dir.glob('*')) / (1024**2)
            print(f"Images: {img_dir} ({img_count} files, {img_size:.1f} MB)")


def main():
    p = argparse.ArgumentParser(description='OpenTransformers Image Crawler')
    p.add_argument('--seeds', type=str, help='File with seed URLs')
    p.add_argument('--seed', type=str, action='append', help='Single seed URL')
    p.add_argument('--output', type=str, default='image_data')
    p.add_argument('--workers', type=int, default=50)
    p.add_argument('--max-pages', type=int, default=100000)
    p.add_argument('--max-gb', type=float, default=10.0)
    p.add_argument('--timeout', type=int, default=30)
    p.add_argument('--min-size', type=int, default=256, help='Min image dimension (px)')
    p.add_argument('--max-size', type=int, default=8192, help='Max image dimension (px)')
    p.add_argument('--min-kb', type=int, default=10, help='Min image size (KB)')
    p.add_argument('--inline', action='store_true', help='Save base64 in JSONL instead of files')
    
    args = p.parse_args()
    
    seeds = []
    if args.seeds:
        with open(args.seeds) as f:
            seeds.extend(line.strip() for line in f if line.strip())
    if args.seed:
        seeds.extend(args.seed)
    if not seeds:
        print("ERROR: Provide --seeds file or --seed URLs")
        return
    
    crawler = ImageCrawler(
        output_dir=args.output,
        max_workers=args.workers,
        max_pages=args.max_pages,
        max_bytes=int(args.max_gb * 1024**3),
        timeout=args.timeout,
        min_size=args.min_size,
        max_size=args.max_size,
        min_bytes=args.min_kb * 1024,
        save_inline=args.inline,
    )
    
    asyncio.run(crawler.crawl(seeds))


if __name__ == '__main__':
    main()