| """ |
| Shared media extraction and download helpers. |
| |
| Used by: |
| - pipeline/7_collect_media.py (end-to-end reconstruction, iterates per-subreddit |
| submission .zst files) |
| - hydrate/2_download_media.py (benchmark hydration, iterates submissions embedded |
| in hydrated JSON.zst files) |
| |
| Priority hierarchy for URL extraction (early-stopping): |
| 1. `media_metadata` — gallery / inline images (1-N items) |
| 2. `url` — direct image posts |
| 3. `oembed` — video thumbnails |
| 4. `preview` — Reddit-cached preview images |
| |
| Downloads are validated (Content-Type allowlist) and capped at MAX_FILE_SIZE. |
| NSFW / crosspost / video submissions are skipped at the top of |
| `download_submission_media`. |
| """ |
|
|
| import os |
| import time |
| import urllib.parse |
| from typing import Any, Dict, List, Optional, Tuple |
|
|
| import requests |
| from requests.adapters import HTTPAdapter |
| from urllib3.util.retry import Retry |
|
|
| from utils.files import ensure_directory |
|
|
|
|
| |
| |
| |
|
|
| USER_AGENT = "reddit_research_media_collector/1.0" |
|
|
| |
| DOWNLOAD_TIMEOUT = 15 |
| MAX_FILE_SIZE = 50 * 1024 * 1024 |
| REQUEST_DELAY = 0.1 |
|
|
| |
| VIDEO_DOMAINS = frozenset([ |
| 'v.redd.it', 'youtube.com', 'youtu.be', 'vimeo.com', |
| 'streamable.com', 'twitch.tv', 'clips.twitch.tv', |
| 'tiktok.com', 'instagram.com', 'dailymotion.com', |
| ]) |
|
|
| EXTENSIONLESS_MEDIA_HOSTS = frozenset([ |
| 'imgur.com', 'i.imgur.com', 'giphy.com', 'gfycat.com', |
| ]) |
|
|
| IMAGE_EXTENSIONS = frozenset(['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp']) |
|
|
| VALID_CONTENT_TYPES = frozenset([ |
| 'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/bmp', |
| ]) |
|
|
| CONTENT_TYPE_TO_EXT = { |
| 'image/jpeg': '.jpg', |
| 'image/png': '.png', |
| 'image/gif': '.gif', |
| 'image/webp': '.webp', |
| 'image/bmp': '.bmp', |
| } |
|
|
|
|
| |
| |
| |
|
|
| def extract_extension_from_url(url: str) -> Optional[str]: |
| """Extract image extension from URL path (no dot).""" |
| try: |
| path = urllib.parse.urlparse(url).path.lower() |
| if '.' in path: |
| ext = path.split('.')[-1] |
| if ext in IMAGE_EXTENSIONS: |
| return ext |
| except Exception: |
| pass |
| return None |
|
|
|
|
| def is_video_domain(url: str) -> bool: |
| try: |
| domain = urllib.parse.urlparse(url).netloc.lower() |
| return any(vd in domain for vd in VIDEO_DOMAINS) |
| except Exception: |
| return False |
|
|
|
|
| def is_likely_media_url(url: str) -> bool: |
| """True if the URL likely points to a downloadable image.""" |
| try: |
| parsed = urllib.parse.urlparse(url) |
| domain = parsed.netloc.lower() |
| path = parsed.path.lower() |
|
|
| if is_video_domain(url) or 'reddit.com/gallery/' in url: |
| return False |
|
|
| if 'reddit.com' in domain and 'i.redd.it' not in domain: |
| return False |
|
|
| if '.' in path and path.split('.')[-1] in IMAGE_EXTENSIONS: |
| return True |
|
|
| return any(host in domain for host in EXTENSIONLESS_MEDIA_HOSTS) |
| except Exception: |
| return False |
|
|
|
|
| def sanitize_media_id(media_id: str, max_length: int = 50) -> str: |
| return media_id.replace('|', '_').replace('/', '_').replace('\\', '_')[:max_length] |
|
|
|
|
| def categorize_error(error_msg: str) -> str: |
| lower = error_msg.lower() |
| if '404' in error_msg or 'not found' in lower: |
| return '404_not_found' |
| if '403' in error_msg or 'forbidden' in lower: |
| return '403_forbidden' |
| if '429' in error_msg or 'too many' in lower: |
| return '429_rate_limited' |
| if 'timeout' in lower: |
| return 'timeout' |
| if 'connection' in lower: |
| return 'connection_error' |
| if 'ssl' in lower or 'certificate' in lower: |
| return 'ssl_error' |
| if 'content-type' in lower: |
| return 'invalid_content_type' |
| return 'other_error' |
|
|
|
|
| |
| |
| |
|
|
| def create_session() -> requests.Session: |
| """HTTP session with bounded retry for transient server errors.""" |
| session = requests.Session() |
| retry = Retry( |
| total=2, |
| backoff_factor=0.5, |
| status_forcelist=[429, 500, 502, 503, 504], |
| allowed_methods=["GET"], |
| ) |
| adapter = HTTPAdapter(max_retries=retry) |
| session.mount("http://", adapter) |
| session.mount("https://", adapter) |
| session.headers.update({'User-Agent': USER_AGENT}) |
| return session |
|
|
|
|
| def download_file(url: str, output_path: str, session: requests.Session) -> Dict[str, Any]: |
| """ |
| Download `url` to `output_path` with Content-Type validation + size cap. |
| |
| Returns: {'success': bool, 'file_size': int, 'extension': str, 'error': str} |
| """ |
| try: |
| response = session.get(url, stream=True, timeout=DOWNLOAD_TIMEOUT) |
| response.raise_for_status() |
|
|
| content_type = response.headers.get('Content-Type', '').lower().split(';')[0].strip() |
| if content_type not in VALID_CONTENT_TYPES: |
| return {'success': False, 'error': f'Invalid Content-Type: {content_type}'} |
|
|
| extension = CONTENT_TYPE_TO_EXT.get(content_type, '.jpg') |
|
|
| ensure_directory(output_path) |
| file_size = 0 |
| with open(output_path, 'wb') as f: |
| for chunk in response.iter_content(chunk_size=8192): |
| if chunk: |
| file_size += len(chunk) |
| if file_size > MAX_FILE_SIZE: |
| os.remove(output_path) |
| return {'success': False, 'error': 'File too large'} |
| f.write(chunk) |
|
|
| return {'success': True, 'file_size': file_size, 'extension': extension} |
|
|
| except requests.exceptions.Timeout: |
| if os.path.exists(output_path): |
| os.remove(output_path) |
| return {'success': False, 'error': 'Timeout'} |
|
|
| except requests.exceptions.HTTPError as e: |
| if os.path.exists(output_path): |
| os.remove(output_path) |
| return {'success': False, 'error': str(e)} |
|
|
| except Exception as e: |
| if os.path.exists(output_path): |
| os.remove(output_path) |
| return {'success': False, 'error': f'Download error: {str(e)[:50]}'} |
|
|
|
|
| |
| |
| |
|
|
| def is_video_submission(submission: Dict) -> bool: |
| if submission.get('is_video'): |
| return True |
| url = submission.get('url', '') |
| if url and is_video_domain(url): |
| return True |
| media_metadata = submission.get('media_metadata') |
| if media_metadata: |
| for info in media_metadata.values(): |
| if info.get('e') in ['Video', 'RedditVideo']: |
| return True |
| return False |
|
|
|
|
| def make_media_item(url: str, media_id: str, source: str, index: Optional[int] = None) -> Dict: |
| url = url.replace('&', '&') |
| item = { |
| 'url': url, |
| 'media_id': media_id, |
| 'source': source, |
| 'extension_hint': extract_extension_from_url(url), |
| } |
| if index is not None: |
| item['index'] = index |
| return item |
|
|
|
|
| def extract_media_metadata_urls(submission: Dict) -> List[Dict]: |
| media_metadata = submission.get('media_metadata', {}) |
| if not media_metadata: |
| return [] |
| urls = [] |
| for idx, (media_id, info) in enumerate(media_metadata.items()): |
| if info.get('e') == 'Image' and 's' in info and 'u' in info['s']: |
| urls.append(make_media_item(info['s']['u'], media_id, 'media_metadata', idx)) |
| return urls |
|
|
|
|
| def extract_url_field(submission: Dict) -> List[Dict]: |
| url = submission.get('url', '') |
| if url and is_likely_media_url(url): |
| return [make_media_item(url, 'direct', 'url')] |
| return [] |
|
|
|
|
| def extract_oembed_url(submission: Dict) -> List[Dict]: |
| media = submission.get('media') or submission.get('secure_media') |
| if media and 'oembed' in media: |
| thumb = media['oembed'].get('thumbnail_url') |
| if thumb: |
| return [make_media_item(thumb, 'oembed', 'oembed')] |
| return [] |
|
|
|
|
| def extract_preview_url(submission: Dict) -> List[Dict]: |
| preview = submission.get('preview') |
| if not preview or submission.get('is_self'): |
| return [] |
| try: |
| url = preview['images'][0]['source'].get('url') |
| if url: |
| return [make_media_item(url, 'preview', 'preview')] |
| except (KeyError, TypeError, IndexError): |
| pass |
| return [] |
|
|
|
|
| def extract_download_urls(submission: Dict) -> Tuple[List[Dict], Optional[str]]: |
| """Priority hierarchy with early stop.""" |
| for extractor, source in [ |
| (extract_media_metadata_urls, 'media_metadata'), |
| (extract_url_field, 'url'), |
| (extract_oembed_url, 'oembed'), |
| (extract_preview_url, 'preview'), |
| ]: |
| urls = extractor(submission) |
| if urls: |
| return urls, source |
| return [], None |
|
|
|
|
| |
| |
| |
|
|
| def download_submission_media(submission: Dict, media_dir: str, |
| session: requests.Session) -> Dict[str, Any]: |
| """ |
| Download every media URL for one submission. |
| |
| Skips NSFW, crosspost, and video submissions at the top. |
| Filenames: `{media_dir}/{submission_id}_{media_id}.{ext}` (direct/oembed/preview) |
| or `{media_dir}/{submission_id}_{index}_{safe_media_id}.{ext}` (gallery). |
| |
| Returns: |
| { |
| 'submission_id': str, |
| 'status': 'complete' | 'partial' | 'failed' | 'no_media' |
| | 'skipped_nsfw' | 'skipped_crosspost', |
| 'files_downloaded': int, |
| 'file_paths': List[str], # absolute paths of successful downloads |
| 'source': str | None, |
| 'is_video': bool, |
| 'errors': List[str], |
| } |
| """ |
| submission_id = submission.get('id', 'unknown') |
|
|
| if submission.get('over_18') or submission.get('over18'): |
| return { |
| 'submission_id': submission_id, 'status': 'skipped_nsfw', |
| 'files_downloaded': 0, 'file_paths': [], 'errors': [], |
| } |
| if submission.get('crosspost_parent_list') or submission.get('crosspost_parent'): |
| return { |
| 'submission_id': submission_id, 'status': 'skipped_crosspost', |
| 'files_downloaded': 0, 'file_paths': [], 'errors': [], |
| } |
|
|
| urls, source = extract_download_urls(submission) |
| is_video = is_video_submission(submission) |
|
|
| if not urls: |
| return { |
| 'submission_id': submission_id, 'status': 'no_media', |
| 'files_downloaded': 0, 'file_paths': [], 'is_video': is_video, |
| 'errors': [], |
| } |
|
|
| successful = 0 |
| file_paths: List[str] = [] |
| errors: List[str] = [] |
|
|
| for url_info in urls: |
| url = url_info['url'] |
| media_id = url_info['media_id'] |
| ext_hint = url_info.get('extension_hint') |
|
|
| if media_id in ('direct', 'oembed', 'preview'): |
| filename_base = f"{submission_id}_{media_id}" |
| else: |
| idx = url_info.get('index', 0) |
| safe_id = sanitize_media_id(media_id) |
| filename_base = f"{submission_id}_{idx}_{safe_id}" |
|
|
| if ext_hint: |
| cached = os.path.join(media_dir, f"{filename_base}.{ext_hint}") |
| if os.path.exists(cached): |
| successful += 1 |
| file_paths.append(cached) |
| continue |
|
|
| temp_path = os.path.join(media_dir, f"{filename_base}.tmp") |
| result = download_file(url, temp_path, session) |
|
|
| if result['success']: |
| final_path = os.path.join(media_dir, f"{filename_base}{result['extension']}") |
| if os.path.exists(temp_path): |
| os.rename(temp_path, final_path) |
| successful += 1 |
| file_paths.append(final_path) |
| else: |
| errors.append(result['error']) |
|
|
| time.sleep(REQUEST_DELAY) |
|
|
| expected = len(urls) |
| if successful == expected: |
| status = 'complete' |
| elif successful > 0: |
| status = 'partial' |
| else: |
| status = 'failed' |
|
|
| return { |
| 'submission_id': submission_id, |
| 'status': status, |
| 'files_downloaded': successful, |
| 'file_paths': file_paths, |
| 'source': source, |
| 'is_video': is_video, |
| 'errors': errors, |
| } |
|
|
