Upload video_crawler.py with huggingface_hub

video_crawler.py

@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+"""
+OpenTransformers Video Crawler v1.0
+Grabby hands for video data - uses yt-dlp for broad site support.
+
+Grabs videos + metadata (title, description, duration, tags)
+Supports YouTube, Vimeo, Twitter, Reddit, and 1000+ sites via yt-dlp.
+
+Usage:
+    python video_crawler.py --seeds video_seeds.txt --output /workspace/video --max-gb 50
+    python video_crawler.py --seed "https://www.youtube.com/watch?v=dQw4w9WgXcQ" --max-duration 300
+"""
+
+import asyncio
+import subprocess
+import argparse
+import hashlib
+import json
+import os
+import re
+import time
+import random
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Set, Dict, List
+from urllib.parse import urljoin, urlparse
+import aiohttp
+
+# Video URL patterns yt-dlp can handle
+VIDEO_PATTERNS = [
+    r'youtube\.com/watch\?v=',
+    r'youtu\.be/',
+    r'vimeo\.com/\d+',
+    r'twitter\.com/.*/status/',
+    r'x\.com/.*/status/',
+    r'reddit\.com/r/.*/comments/',
+    r'tiktok\.com/',
+    r'instagram\.com/p/',
+    r'instagram\.com/reel/',
+    r'facebook\.com/.*/videos/',
+    r'twitch\.tv/',
+    r'dailymotion\.com/video/',
+    r'streamable\.com/',
+    r'v\.redd\.it/',
+    r'gfycat\.com/',
+    r'imgur\.com/.*\.(mp4|gifv)',
+]
+
+VIDEO_PATTERN_RE = re.compile('|'.join(VIDEO_PATTERNS), re.I)
+
+
+def is_video_url(url: str) -> bool:
+    """Check if URL is a video we can download"""
+    return bool(VIDEO_PATTERN_RE.search(url))
+
+
+def extract_video_urls(html: str, base_url: str) -> List[str]:
+    """Extract video URLs from HTML"""
+    urls = set()
+    
+    # Find all links
+    for match in re.finditer(r'href=["\']([^"\']+)["\']', html, re.I):
+        href = match.group(1)
+        try:
+            absolute = urljoin(base_url, href)
+            if is_video_url(absolute):
+                urls.add(absolute)
+        except:
+            pass
+    
+    # Find embedded URLs in text/scripts
+    for match in re.finditer(r'https?://[^\s"\'<>]+', html):
+        url = match.group(0)
+        if is_video_url(url):
+            urls.add(url.rstrip('.,;:'))
+    
+    return list(urls)
+
+
+def extract_page_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:')):
+            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
+
+
+class VideoCrawler:
+    USER_AGENTS = [
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+    ]
+    
+    def __init__(
+        self,
+        output_dir: str = 'video_data',
+        max_workers: int = 5,  # Lower for video - heavy downloads
+        max_pages: int = 10000,
+        max_bytes: int = 50 * 1024**3,  # 50GB default
+        max_duration: int = 300,  # 5 min max per video
+        max_height: int = 720,  # 720p max
+        metadata_only: bool = False,  # Just grab metadata, no video
+    ):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        (self.output_dir / 'videos').mkdir(exist_ok=True)
+        
+        self.max_workers = max_workers
+        self.max_pages = max_pages
+        self.max_bytes = max_bytes
+        self.max_duration = max_duration
+        self.max_height = max_height
+        self.metadata_only = metadata_only
+        
+        self.page_queue: asyncio.Queue = asyncio.Queue()
+        self.video_queue: asyncio.Queue = asyncio.Queue()
+        self.seen_pages: Set[str] = set()
+        self.seen_videos: Set[str] = set()
+        self.running = True
+        
+        self.stats = {'pages': 0, 'videos': 0, 'bytes': 0, 'skipped': 0, 'errors': 0}
+        self.start_time = time.time()
+        
+        self.output_file = None
+        self.output_lock = asyncio.Lock()
+    
+    def _report(self) -> str:
+        elapsed = time.time() - self.start_time
+        mb = self.stats['bytes'] / (1024**2)
+        return f"Pages: {self.stats['pages']} | Videos: {self.stats['videos']} | {mb:.1f} MB | Skip: {self.stats['skipped']} | Err: {self.stats['errors']}"
+    
+    async def _fetch_page(self, session: aiohttp.ClientSession, url: str):
+        try:
+            headers = {'User-Agent': random.choice(self.USER_AGENTS)}
+            async with session.get(url, headers=headers, timeout=30, 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_page_links(html, url)
+                return html, links
+        except:
+            return None, set()
+    
+    def _download_video(self, url: str, source_page: str) -> Optional[Dict]:
+        """Download video using yt-dlp"""
+        video_hash = hashlib.md5(url.encode()).hexdigest()[:16]
+        output_template = str(self.output_dir / 'videos' / f'{video_hash}.%(ext)s')
+        
+        # Build yt-dlp command
+        cmd = [
+            'yt-dlp',
+            '--no-playlist',
+            '--max-filesize', '500M',
+            '--socket-timeout', '30',
+            '-f', f'bestvideo[height<={self.max_height}]+bestaudio/best[height<={self.max_height}]',
+            '--merge-output-format', 'mp4',
+            '-o', output_template,
+            '--print-json',
+            '--no-progress',
+        ]
+        
+        if self.max_duration:
+            cmd.extend(['--match-filter', f'duration<={self.max_duration}'])
+        
+        if self.metadata_only:
+            cmd.extend(['--skip-download', '--write-info-json'])
+        
+        cmd.append(url)
+        
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=300  # 5 min timeout
+            )
+            
+            if result.returncode != 0:
+                self.stats['errors'] += 1
+                return None
+            
+            # Parse JSON output
+            info = json.loads(result.stdout.strip().split('\n')[-1])
+            
+            # Find downloaded file
+            video_file = None
+            if not self.metadata_only:
+                for f in (self.output_dir / 'videos').glob(f'{video_hash}.*'):
+                    if f.suffix in ('.mp4', '.mkv', '.webm', '.mov'):
+                        video_file = f.name
+                        break
+            
+            file_size = 0
+            if video_file:
+                file_size = (self.output_dir / 'videos' / video_file).stat().st_size
+            
+            return {
+                'url': url,
+                'source_page': source_page,
+                'timestamp': datetime.utcnow().isoformat(),
+                'title': info.get('title', ''),
+                'description': info.get('description', '')[:1000] if info.get('description') else '',
+                'duration': info.get('duration', 0),
+                'width': info.get('width', 0),
+                'height': info.get('height', 0),
+                'fps': info.get('fps', 0),
+                'view_count': info.get('view_count', 0),
+                'like_count': info.get('like_count', 0),
+                'uploader': info.get('uploader', ''),
+                'upload_date': info.get('upload_date', ''),
+                'tags': info.get('tags', [])[:20] if info.get('tags') else [],
+                'categories': info.get('categories', []),
+                'extractor': info.get('extractor', ''),
+                'format': info.get('format', ''),
+                'size_bytes': file_size,
+                'hash': video_hash,
+                'file': video_file
+            }
+            
+        except subprocess.TimeoutExpired:
+            self.stats['errors'] += 1
+            return None
+        except Exception as e:
+            self.stats['errors'] += 1
+            return None
+    
+    async def _page_worker(self, session: aiohttp.ClientSession, worker_id: int):
+        """Crawl pages and find video URLs"""
+        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 video URLs
+                video_urls = extract_video_urls(html, page_url)
+                for video_url in video_urls:
+                    if video_url not in self.seen_videos:
+                        self.seen_videos.add(video_url)
+                        await self.video_queue.put((video_url, page_url))
+                
+                # Queue new pages
+                for link in links:
+                    if link not in self.seen_pages and self.stats['pages'] < self.max_pages:
+                        self.seen_pages.add(link)
+                        await self.page_queue.put(link)
+                
+                if self.stats['pages'] % 20 == 0:
+                    print(f"[{datetime.now().strftime('%H:%M:%S')}] {self._report()} | Queue: {self.video_queue.qsize()}")
+            
+            self.page_queue.task_done()
+    
+    async def _video_worker(self, worker_id: int):
+        """Download videos from queue"""
+        loop = asyncio.get_event_loop()
+        
+        while self.running:
+            try:
+                video_url, source_page = await asyncio.wait_for(self.video_queue.get(), timeout=10.0)
+            except asyncio.TimeoutError:
+                if self.video_queue.empty() and self.page_queue.empty():
+                    break
+                continue
+            
+            if self.stats['bytes'] >= self.max_bytes:
+                self.running = False
+                break
+            
+            # Run yt-dlp in thread pool (blocking operation)
+            result = await loop.run_in_executor(
+                None, 
+                self._download_video, 
+                video_url, 
+                source_page
+            )
+            
+            if result:
+                self.stats['videos'] += 1
+                self.stats['bytes'] += result.get('size_bytes', 0)
+                
+                async with self.output_lock:
+                    self.output_file.write(json.dumps(result) + '\n')
+                
+                print(f"  ✓ {result['title'][:50]}... ({result.get('duration', 0)}s)")
+            else:
+                self.stats['skipped'] += 1
+            
+            self.video_queue.task_done()
+    
+    async def crawl(self, seeds: List[str]):
+        print(f"OpenTransformers Video Crawler starting")
+        print(f"Seeds: {len(seeds)} | Page workers: {self.max_workers} | Video workers: 3")
+        print(f"Target: {self.max_pages} pages / {self.max_bytes/1024**3:.1f} GB / {self.max_duration}s max")
+        print("-" * 60)
+        
+        # Separate direct video URLs from page URLs
+        for seed in seeds:
+            if is_video_url(seed):
+                self.seen_videos.add(seed)
+                await self.video_queue.put((seed, 'seed'))
+            else:
+                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'video_{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:
+            # Start page crawlers
+            page_workers = [
+                asyncio.create_task(self._page_worker(session, i)) 
+                for i in range(self.max_workers)
+            ]
+            # Start video downloaders (fewer, heavier)
+            video_workers = [
+                asyncio.create_task(self._video_worker(i))
+                for i in range(3)
+            ]
+            
+            await asyncio.gather(*page_workers, *video_workers)
+        
+        self.output_file.close()
+        
+        print("-" * 60)
+        print(f"DONE! {self._report()}")
+        print(f"Metadata: {output_path}")
+        video_dir = self.output_dir / 'videos'
+        files = list(video_dir.glob('*.mp4')) + list(video_dir.glob('*.webm')) + list(video_dir.glob('*.mkv'))
+        total_size = sum(f.stat().st_size for f in files) / (1024**3)
+        print(f"Videos: {len(files)} files, {total_size:.2f} GB in {video_dir}")
+
+
+def main():
+    p = argparse.ArgumentParser(description='OpenTransformers Video 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='video_data')
+    p.add_argument('--workers', type=int, default=5)
+    p.add_argument('--max-pages', type=int, default=10000)
+    p.add_argument('--max-gb', type=float, default=50.0)
+    p.add_argument('--max-duration', type=int, default=300, help='Max video duration (seconds)')
+    p.add_argument('--max-height', type=int, default=720, help='Max video height (pixels)')
+    p.add_argument('--metadata-only', action='store_true', help='Only grab metadata, skip video download')
+    
+    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 = VideoCrawler(
+        output_dir=args.output,
+        max_workers=args.workers,
+        max_pages=args.max_pages,
+        max_bytes=int(args.max_gb * 1024**3),
+        max_duration=args.max_duration,
+        max_height=args.max_height,
+        metadata_only=args.metadata_only,
+    )
+    
+    asyncio.run(crawler.crawl(seeds))
+
+
+if __name__ == '__main__':
+    main()