Upload scraper.py with huggingface_hub

scraper.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+"""
+OpenTransformers Web Crawler v1.0
+Your data. Your company. No apologies.
+
+Usage:
+    python scraper.py --seeds seeds.txt --output /workspace/crawl --workers 100 --max-pages 50000
+    python scraper.py --seed "https://news.ycombinator.com" --depth 3 --same-domain
+"""
+
+import asyncio
+import aiohttp
+import argparse
+import hashlib
+import json
+import os
+import re
+import time
+import random
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Set, Dict, List
+from urllib.parse import urljoin, urlparse
+from collections import defaultdict
+import gzip
+
+
+class BoilerplateRemover:
+    """Extract article text, strip nav/footer/ads"""
+    
+    IGNORE_TAGS = {'script', 'style', 'nav', 'header', 'footer', 'aside', 
+                   'noscript', 'iframe', 'svg', 'form', 'button', 'input',
+                   'meta', 'link', 'head'}
+    BLOCK_TAGS = {'p', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 
+                  'li', 'tr', 'article', 'section', 'blockquote', 'pre', 'code'}
+    
+    @staticmethod
+    def extract(html: str) -> str:
+        if not html:
+            return ""
+        for tag in BoilerplateRemover.IGNORE_TAGS:
+            html = re.sub(f'<{tag}[^>]*>.*?</{tag}>', ' ', html, flags=re.DOTALL | re.IGNORECASE)
+        html = re.sub(r'<!--.*?-->', '', html, flags=re.DOTALL)
+        for tag in BoilerplateRemover.BLOCK_TAGS:
+            html = re.sub(f'</?{tag}[^>]*>', '\n', html, flags=re.IGNORECASE)
+        text = re.sub(r'<[^>]+>', ' ', html)
+        text = text.replace('&nbsp;', ' ').replace('&amp;', '&').replace('&lt;', '<')
+        text = text.replace('&gt;', '>').replace('&quot;', '"').replace('&#39;', "'")
+        text = re.sub(r'[ \t]+', ' ', text)
+        text = re.sub(r'\n\s*\n', '\n\n', text)
+        text = re.sub(r'\n{3,}', '\n\n', text)
+        return text.strip()
+
+
+def extract_links(html: str, base_url: str) -> Set[str]:
+    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 ""
+
+
+@dataclass
+class CrawledPage:
+    url: str
+    domain: str
+    timestamp: str
+    status: int
+    text: str
+    text_len: int
+    html_len: int
+    links: int
+    fetch_ms: int
+    hash: str
+
+
+class Stats:
+    def __init__(self):
+        self.pages = 0
+        self.bytes = 0
+        self.errors = 0
+        self.start = time.time()
+        self.by_domain: Dict[str, int] = defaultdict(int)
+    
+    def log(self, page: Optional[CrawledPage] = None, error: bool = False):
+        if error:
+            self.errors += 1
+        elif page:
+            self.pages += 1
+            self.bytes += page.text_len
+            self.by_domain[page.domain] += 1
+    
+    def report(self) -> str:
+        elapsed = time.time() - self.start
+        rate = self.pages / elapsed if elapsed > 0 else 0
+        mb = self.bytes / (1024 * 1024)
+        return f"Pages: {self.pages} | {mb:.1f} MB | {rate:.1f} p/s | Err: {self.errors} | Domains: {len(self.by_domain)}"
+
+
+class Crawler:
+    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',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+    ]
+    
+    def __init__(self, output_dir: str = 'crawl_data', max_workers: int = 100,
+                 max_pages: int = 50000, max_bytes: int = 10*1024**3,
+                 timeout: int = 30, same_domain: bool = False,
+                 min_text_len: int = 200, max_text_len: int = 500000,
+                 politeness: float = 0.1):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.max_workers = max_workers
+        self.max_pages = max_pages
+        self.max_bytes = max_bytes
+        self.timeout = timeout
+        self.same_domain = same_domain
+        self.min_text_len = min_text_len
+        self.max_text_len = max_text_len
+        self.politeness = politeness
+        self.queue: asyncio.Queue = asyncio.Queue()
+        self.seen: Set[str] = set()
+        self.seen_hashes: Set[str] = set()
+        self.domain_last_hit: Dict[str, float] = {}
+        self.seed_domains: Set[str] = set()
+        self.stats = Stats()
+        self.running = True
+        self.output_file = None
+        self.output_lock = asyncio.Lock()
+        
+    def _should_crawl(self, url: str) -> bool:
+        if url in self.seen:
+            return False
+        skip_ext = {'.jpg', '.jpeg', '.png', '.gif', '.pdf', '.zip', '.mp3', '.mp4', 
+                   '.avi', '.mov', '.exe', '.dmg', '.iso', '.tar', '.gz', '.css', '.js',
+                   '.woff', '.woff2', '.ttf', '.ico', '.svg', '.webp'}
+        lower = url.lower()
+        if any(lower.endswith(ext) for ext in skip_ext):
+            return False
+        if self.same_domain:
+            if get_domain(url) not in self.seed_domains:
+                return False
+        return True
+    
+    async def _fetch(self, session: aiohttp.ClientSession, url: str) -> Optional[CrawledPage]:
+        domain = get_domain(url)
+        if domain in self.domain_last_hit:
+            since = time.time() - self.domain_last_hit[domain]
+            if since < self.politeness:
+                await asyncio.sleep(self.politeness - since)
+        self.domain_last_hit[domain] = time.time()
+        
+        start = time.time()
+        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 and 'text/plain' not in ct:
+                    return None
+                html = await resp.text(errors='ignore')
+                fetch_ms = int((time.time() - start) * 1000)
+                text = BoilerplateRemover.extract(html)
+                if len(text) < self.min_text_len or len(text) > self.max_text_len:
+                    return None
+                content_hash = hashlib.md5(text.encode()).hexdigest()[:16]
+                if content_hash in self.seen_hashes:
+                    return None
+                self.seen_hashes.add(content_hash)
+                links = extract_links(html, url)
+                for link in links:
+                    if self._should_crawl(link) and self.stats.pages < self.max_pages:
+                        self.seen.add(link)
+                        await self.queue.put(link)
+                return CrawledPage(url=url, domain=domain, timestamp=datetime.utcnow().isoformat(),
+                                  status=resp.status, text=text, text_len=len(text),
+                                  html_len=len(html), links=len(links), fetch_ms=fetch_ms, hash=content_hash)
+        except:
+            return None
+    
+    async def _worker(self, session: aiohttp.ClientSession, worker_id: int):
+        while self.running:
+            try:
+                url = await asyncio.wait_for(self.queue.get(), timeout=10.0)
+            except asyncio.TimeoutError:
+                if self.queue.empty():
+                    break
+                continue
+            if self.stats.pages >= self.max_pages or self.stats.bytes >= self.max_bytes:
+                self.running = False
+                break
+            page = await self._fetch(session, url)
+            if page:
+                self.stats.log(page)
+                async with self.output_lock:
+                    self.output_file.write(json.dumps(asdict(page)) + '\n')
+                if self.stats.pages % 100 == 0:
+                    print(f"[{datetime.now().strftime('%H:%M:%S')}] {self.stats.report()}")
+            else:
+                self.stats.log(error=True)
+            self.queue.task_done()
+    
+    async def crawl(self, seeds: List[str]):
+        print(f"OpenTransformers Crawler starting")
+        print(f"Seeds: {len(seeds)} | Workers: {self.max_workers} | Target: {self.max_pages} pages / {self.max_bytes/1024**3:.1f} GB")
+        print("-" * 60)
+        for seed in seeds:
+            self.seed_domains.add(get_domain(seed))
+            self.seen.add(seed)
+            await self.queue.put(seed)
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        output_path = self.output_dir / f'crawl_{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"Output: {output_path} ({output_path.stat().st_size / 1024**2:.1f} MB)")
+        print("Compressing...")
+        with open(output_path, 'rb') as f_in:
+            with gzip.open(str(output_path) + '.gz', 'wb') as f_out:
+                f_out.writelines(f_in)
+        gz_size = Path(str(output_path) + '.gz').stat().st_size
+        print(f"Compressed: {gz_size / 1024**2:.1f} MB")
+
+
+def main():
+    p = argparse.ArgumentParser(description='OpenTransformers Web 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='crawl_data')
+    p.add_argument('--workers', type=int, default=100)
+    p.add_argument('--max-pages', type=int, default=50000)
+    p.add_argument('--max-gb', type=float, default=10.0)
+    p.add_argument('--timeout', type=int, default=30)
+    p.add_argument('--same-domain', action='store_true')
+    p.add_argument('--min-text', type=int, default=200)
+    p.add_argument('--politeness', type=float, default=0.1)
+    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 = Crawler(output_dir=args.output, max_workers=args.workers,
+                     max_pages=args.max_pages, max_bytes=int(args.max_gb * 1024**3),
+                     timeout=args.timeout, same_domain=args.same_domain,
+                     min_text_len=args.min_text, politeness=args.politeness)
+    asyncio.run(crawler.crawl(seeds))
+
+
+if __name__ == '__main__':
+    main()