Upload dehydrated PluRule dataset and hydration scripts

LICENSE

@@ -0,0 +1,29 @@
+MIT License
+
+Copyright (c) 2025 PluRule Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Note: this license covers the code in this repository only. The PluRule
+benchmark dataset is distributed separately and is licensed under the terms
+declared on its release (see the dataset's HuggingFace page). The underlying
+moderator comments and submissions are drawn from the publicly archived
+Pushshift Reddit corpus; their use is bound by Reddit's terms of service.

README.md

@@ -0,0 +1,89 @@
+---
+pretty_name: PluRule
+language:
+  - en
+multilinguality:
+  - multilingual
+task_categories:
+  - text-classification
+  - image-text-to-text
+tags:
+  - reddit
+  - moderation
+  - multimodal
+  - rule-violations
+license: other
+---
+
+# PluRule
+
+**PluRule** is a multilingual, multimodal benchmark for detecting rule
+violations when moderating pluralistic communities on social media.
+
+This dataset repository contains the dehydrated clustered PluRule splits and
+the hydrate scripts needed to reconstruct comment bodies, submissions, and
+optional media from the Pushshift / Arctic Shift archives.
+
+## Files
+
+```text
+data/
+├── train_dehydrated_clustered.json.zst
+├── val_dehydrated_clustered.json.zst
+└── test_dehydrated_clustered.json.zst
+```
+
+The released files contain IDs, metadata, rules, cluster labels, answer
+options, and `[NEEDS_HYDRATION]` placeholders. Reddit text and media are not
+redistributed directly.
+
+## Hydrate
+
+Conda:
+
+```bash
+conda env create -f environment-hydrate.yml
+conda activate plurule-hydrate
+```
+
+Without conda:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements-hydrate.txt
+```
+
+You also need `aria2c` on `PATH` for torrent downloads.
+
+Run from the dataset repository root:
+
+```bash
+python hydrate/0_download.py
+python hydrate/1_hydrate_dataset.py
+python hydrate/2_download_media.py  # optional
+```
+
+After hydration, the reconstructed files are:
+
+```text
+data/train_hydrated_clustered.json.zst
+data/val_hydrated_clustered.json.zst
+data/test_hydrated_clustered.json.zst
+```
+
+For details and troubleshooting, see [`hydrate/README.md`](hydrate/README.md).
+
+## Citation
+
+```bibtex
+@inproceedings{plurule2025,
+  title  = {{PluRule: A Benchmark for Moderating Pluralistic Communities
+            on Social Media}},
+  author = {Kachwala, Zoher and Truong, Bao Tran and Muralidharan, Rasika and
+            Kwak, Haewoon and An, Jisun and Menczer, Filippo},
+  year   = {2026},
+  booktitle = {Proc. ACL},
+  note   = {Forthcoming},
+}
+```

config.py

@@ -0,0 +1,428 @@
+"""
+Simple configuration for Reddit mod collection pipeline.
+
+Edit the base directories below for your environment.
+All other paths are generated automatically based on data flow.
+"""
+
+import os
+import multiprocessing
+
+# =============================================================================
+# BASE CONFIGURATION - Override via environment variables or edit here.
+# =============================================================================
+# Defaults: BASE_DATA = repo root; PUSHSHIFT_DATA = <BASE_DATA>/data/pushshift.
+# Override with:
+#   export PLURULE_BASE_DATA=/your/working/dir
+#   export PLURULE_PUSHSHIFT_DATA=/your/pushshift/mirror
+
+_REPO_ROOT = os.path.dirname(os.path.abspath(__file__))
+
+BASE_DATA = os.environ.get("PLURULE_BASE_DATA", _REPO_ROOT)
+PUSHSHIFT_DATA = os.environ.get(
+    "PLURULE_PUSHSHIFT_DATA", os.path.join(BASE_DATA, "data", "pushshift")
+)
+# Legacy Pushshift-dumps location (Stage 0 when fetching RC_*/RS_* style dumps).
+# Keep consistent with PUSHSHIFT_DATA by default.
+REDDIT_DATA = os.environ.get("PLURULE_REDDIT_DATA", PUSHSHIFT_DATA)
+
+CREDENTIALS_DIR = os.path.join(_REPO_ROOT, "credentials")
+
+# Processing settings
+DATE_RANGE = ("2005-12", "2023-02")  # (start, end) inclusive PushshiftDumps
+MIN_RULES_FOR_MATCHING = 2  # Minimum rules needed for semantic matching (skip subreddits with ≤1 rule)
+GOLD_PERCENTILE = 99.2  # Top 0.8% of similarity scores considered gold matches (Stage 3 Phase 2)
+AMBIGUOUS_PERCENTILE = 98  # Top 2% of similarity scores considered ambiguous matches (Stage 3 Phase 2)
+MIN_MATCHED_COMMENTS = 1 # Minimum matched comments for subreddit inclusion in Stage 3
+MAX_MATCHED_COMMENTS = 500  # Max sample size for matched comments in Stage 3
+
+# Stage 8: Dataset split configuration
+# Note: No minimum threshold - all subreddits with ≥1 pair are included
+# Split logic per subreddit:
+#   n=1: 1 test, 0 val, 0 train
+#   n=2: 1 test, 0 val, 1 train
+#   3≤n<10: 1 test, 1 val, (n-2) train
+#   n≥10: 10% test, 10% val, 80% train (rounded, min 1 each)
+
+EMBEDDING_MODEL = "Qwen/Qwen3-Embedding-8B"  # Model used in Stage 3 for semantic matching
+# Auto-detect number of CPU cores (use all available cores)
+PROCESSES = multiprocessing.cpu_count()
+
+# Alternative: Use 75% of available cores to leave some for system
+# PROCESSES = max(1, int(multiprocessing.cpu_count() * 0.75))
+
+# =============================================================================
+# DATA FLOW MAPPING - Shows what each stage produces and consumes
+# =============================================================================
+
+DATA_FLOW = {
+    # Phase 1: Data Collection
+    'stage0_download_data': {
+        'name': 'Download Reddit Data from Internet Archive',
+        'script': '0_download_data.py',
+        'input_paths': [],  # No inputs - downloads from internet
+        'output_dir': 'reddit_data',
+        'produces': [
+            'comments/YYYY/RC_*.zst',  # Reddit comment files organized by year
+            'submissions/YYYY/RS_*.zst',  # Reddit submission files organized by year
+            '../logs/stage0_download_log.json'  # actually written to PATHS['logs']
+        ]
+    },
+
+    'stage1_mod_comments': {
+        'name': 'Collect Moderator Comments from Pushshift',
+        'script': '1_collect_mod_comments.py',
+        'input_paths': [],  # Uses Pushshift data directly
+        'output_dir': 'top_subreddits',
+        'produces': [
+            '{subreddit}_mod_comments.jsonl.zst',  # in PATHS['top_subreddits'], one per subreddit
+            '../../data/stage1_subreddit_mod_comment_rankings.json'  # actually written to PATHS['data']
+        ],
+        'notes': 'Reads Pushshift subreddit files, filters mod comments. Replaces old Stage 1 + Stage 3.'
+    },
+
+    'stage2_top_sfw': {
+        'name': 'Get SFW Subreddits with Minimum Mod Comments',
+        'script': '2_get_top_sfw_subreddits.py',
+        'input_files': ['stage1_subreddit_mod_comment_rankings.json'],
+        'output_dir': 'data',
+        'produces': ['stage2_sfw_subreddits_min_{MIN_MATCHED_COMMENTS}_comments.json'],
+        'notes': 'Uses Reddit API to filter NSFW, collect subreddit metadata and rules'
+    },
+
+    # Phase 2: Comment Matching
+    # NOTE: Stage 3 (filter_and_consolidate) is now obsolete - Stage 1 directly outputs to top_subreddits/
+
+    'stage3_match_rules': {
+        'name': 'Match Comments to Rules (2-Phase: Similarity Matrices + Global Thresholds)',
+        'script': '3_match_rules.py',
+        'helper_scripts': ['utils/match_rules_bucket.py'],
+        'input_paths': ['top_subreddits'],
+        'input_files': [
+            'stage2_sfw_subreddits_min_{MIN_MATCHED_COMMENTS}_comments.json'
+        ],
+        'output_dir': 'matched_comments',
+        'produces': [
+            '{subreddit}_match.jsonl.zst',  # in PATHS['matched_comments']
+            '{subreddit}_stats.json',  # in PATHS['matched_comments']
+            '{subreddit}_similarity_matrix.pt',  # in PATHS['matched_comments']
+            'cosine_similarity_distribution_all_percentiles.png',  # in PATHS['matched_comments']
+            '../../data/stage3_matching_summary.json',  # actually written to PATHS['data']
+            '../../data/stage3_subreddit_submission_ids.json'  # actually written to PATHS['data']
+        ],
+        'notes': 'Phase 1: Create similarity matrices using vLLM embeddings. Phase 2: Apply global percentile thresholds for matching. Filters ambiguous matches, ranks by JSD.'
+    },
+
+    # Phase 3: Thread Construction
+    'stage4_collect_submission_comments': {
+        'name': 'Collect and Organize Submission Comments from Pushshift',
+        'script': '4_collect_submission_comments.py',
+        'input_paths': [],  # Uses Pushshift data directly
+        'input_files': ['stage3_subreddit_submission_ids.json'],
+        'output_dir': 'organized_comments',
+        'produces': [
+            '{subreddit}/submission_{submission_id}.pkl',  # one file per submission, inside per-subreddit subdir
+            '../../data/stage4_submission_comment_collection_stats.json'  # actually written to PATHS['data']
+        ],
+        'notes': '2-pass per subreddit: filter with process_zst_file_multi → deduplicate with [removed]/[deleted] preservation'
+    },
+
+    'stage5_build_trees_and_threads': {
+        'name': 'Build Comment Trees and Discussion Threads',
+        'script': '5_build_trees_and_threads.py',
+        'input_paths': ['organized_comments', 'matched_comments'],
+        'input_files': [
+            'stage2_sfw_subreddits_min_{MIN_MATCHED_COMMENTS}_comments.json',
+            'stage3_matching_summary.json'
+        ],
+        'output_dir': 'comment_trees',
+        'alternate_output_dirs': ['discussion_threads'],  # Also outputs here
+        'produces': [
+            'comment_trees/{subreddit}_comment_trees.pkl',  # in PATHS['comment_trees']
+            'discussion_threads/{subreddit}_discussion_threads.pkl',  # in PATHS['discussion_threads']
+            '../../data/stage5_trees_and_threads_summary.json'  # actually written to PATHS['data']
+        ],
+        'notes': 'Builds trees (parent-child, depth levels), creates moderated/unmoderated pairs, requires 500+ pairs, ranks by JSD'
+    },
+
+    # Phase 4: Dataset Finalization
+    'stage6_collect_submissions': {
+        'name': 'Collect Submissions from Discussion Threads',
+        'script': '6_collect_submissions.py',
+        'input_paths': ['reddit_submissions'],  # Pushshift submissions
+        'input_files': ['stage5_trees_and_threads_summary.json'],
+        'output_dir': 'submissions',
+        'produces': [
+            '{subreddit}_submissions.zst',  # in PATHS['submissions']
+            '../../data/stage6_submission_collection_stats.json'  # actually written to PATHS['data']
+        ],
+        'notes': '3-phase: extract IDs from stage 5 summary → process RS files from Pushshift → consolidate by subreddit'
+    },
+
+    'stage7_collect_media': {
+        'name': 'Collect Media for Submissions',
+        'script': '7_collect_media.py',
+        'input_paths': ['submissions'],
+        'input_files': ['stage6_submission_collection_stats.json'],
+        'output_dir': 'media',
+        'produces': [
+            '{subreddit}/{submission_id}_{media_id}_{source}.{ext}',  # Downloaded media files in PATHS['media']
+            '../../data/stage7_media_collection_stats.json',  # actually written to PATHS['data']
+            '../../data/stage7_successful_submission_ids.json'  # actually written to PATHS['data']
+        ],
+        'notes': 'Priority: media_metadata → url → oembed → preview. Skips NSFW/crosspost/URL-only selfposts. Validates file types.'
+    },
+
+    'stage8_create_datasets': {
+        'name': 'Create Final Datasets (Hydrated + Dehydrated splits)',
+        'script': '8_create_dehydrated_dataset.py',
+        'input_paths': ['discussion_threads', 'comment_trees', 'submissions', 'media'],
+        'input_files': [
+            'stage2_sfw_subreddits_min_{MIN_MATCHED_COMMENTS}_comments.json',
+            'stage7_successful_submission_ids.json',
+            'stage1_subreddit_mod_comment_rankings.json',
+            'stage3_matching_summary.json',
+            'stage5_trees_and_threads_summary.json',
+            'stage6_submission_collection_stats.json',
+            'stage7_media_collection_stats.json'
+        ],
+        'output_dir': 'data',
+        'produces': [
+            'train_hydrated.json.zst',
+            'val_hydrated.json.zst',
+            'test_hydrated.json.zst',
+            'train_dehydrated.json.zst',
+            'val_dehydrated.json.zst',
+            'test_dehydrated.json.zst',
+            'test_hydrated.json',  # uncompressed test split
+            'stage8_final_datasets_stats.json',
+            'stage8_llm_verification_results.json',
+            'stage8_thread_distribution_analysis.json'
+        ],
+        'notes': 'Adaptive train/val/test splits per subreddit + Qwen3-30B LLM judge verification. Hydrated: full objects. Dehydrated: IDs with [NEEDS_HYDRATION] placeholders.'
+    },
+
+    # Phase 5: Clustering
+    'stage9a_embed_clusters': {
+        'name': 'Embed Subreddits and Rules for Clustering',
+        'script': '9a_embed_clusters.py',
+        'input_files': [
+            'train_hydrated.json.zst',
+            'val_hydrated.json.zst',
+            'test_hydrated.json.zst',
+            'stage2_sfw_subreddits_min_{MIN_MATCHED_COMMENTS}_comments.json'
+        ],
+        'output_dir': 'embeddings',
+        'produces': [
+            'all_subreddit_embeddings.tsv',
+            'all_subreddit_metadata.tsv',
+            'all_rule_embeddings.tsv',
+            'all_rule_metadata.tsv'
+        ],
+        'notes': 'Creates embeddings using vLLM for subreddits (title+description) and rules (rule_comprehensive text).'
+    },
+
+    'stage9b_cluster_embeddings': {
+        'name': 'Cluster Embeddings with UMAP + HDBSCAN',
+        'script': '9b_cluster_embeddings.py',
+        'input_paths': ['embeddings'],
+        'output_dir': 'clustering',
+        'alternate_output_dirs': ['embeddings'],  # reduced TSVs + updated metadata go here
+        'produces': [
+            'clustering/subreddit_grid_search_results.json',
+            'clustering/rule_grid_search_results.json',
+            'embeddings/all_subreddit_embeddings_reduced.tsv',
+            'embeddings/all_rule_embeddings_reduced.tsv',
+            'embeddings/all_subreddit_metadata.tsv',  # MUTATED in place: cluster_id, cluster_label columns added
+            'embeddings/all_rule_metadata.tsv'  # MUTATED in place: cluster_id, cluster_label columns added
+        ],
+        'notes': 'Grid search for optimal UMAP + HDBSCAN parameters. Reduced embeddings + augmented metadata are written back into PATHS["embeddings"]; only grid_search results live in PATHS["clustering"].'
+    },
+
+    'stage9c_label_clusters': {
+        'name': 'Label Clusters with LLM',
+        'script': '9c_label_clusters.py',
+        'input_paths': ['embeddings', 'clustering'],
+        'output_dir': 'clustering',
+        'produces': [
+            'subreddit_cluster_labels.json',
+            'rule_cluster_labels.json',
+            'subreddit_cluster_analysis.txt',
+            'rule_cluster_analysis.txt'
+        ],
+        'notes': 'Uses LLM to generate semantic labels for each cluster via majority voting.'
+    },
+
+    'stage9d_reapply_cluster_labels': {
+        'name': 'Reapply/Override Cluster Labels',
+        'script': '9d_reapply_cluster_labels.py',
+        'input_paths': ['embeddings', 'clustering'],
+        'output_dir': 'clustering',
+        'produces': [
+            'subreddit_cluster_labels.json',
+            'rule_cluster_labels.json'
+        ],
+        'notes': 'Optional manual step to apply label overrides and merge clusters.'
+    },
+
+    # Phase 6: Final Assignment and Evaluation
+    'stage10_assign_cluster_labels': {
+        'name': 'Assign Cluster Labels to Dataset',
+        'script': '10_assign_cluster_labels.py',
+        'input_paths': ['embeddings'],
+        'input_files': [
+            'train_hydrated.json.zst',
+            'val_hydrated.json.zst',
+            'test_hydrated.json.zst'
+        ],
+        'output_dir': 'data',
+        'produces': [
+            'train_hydrated_clustered.json.zst',
+            'val_hydrated_clustered.json.zst',
+            'test_hydrated_clustered.json.zst',
+            'train_dehydrated_clustered.json.zst',
+            'val_dehydrated_clustered.json.zst',
+            'test_dehydrated_clustered.json.zst',
+            'test_hydrated_clustered.json',  # uncompressed
+            'stage10_cluster_assignment_stats.json',
+            'stage10_dataset_stats_table.tex'  # LaTeX table for paper
+        ],
+        'notes': 'Assigns cluster labels to all thread pairs in the dataset based on embedding metadata.'
+    }
+
+    # Human evaluation scripts live in eval/human_eval/ (not pipeline stages).
+}
+
+# =============================================================================
+# AUTO-GENERATED PATHS - Don't edit these
+# =============================================================================
+
+def _generate_paths():
+    """Generate all paths based on base directories and data flow."""
+    paths = {
+        # Input data sources
+        'reddit_comments': f"{REDDIT_DATA}/comments",
+        'reddit_submissions': f"{REDDIT_DATA}/submissions",
+        'reddit_data': f"{REDDIT_DATA}",  # Base directory for downloaded data
+
+        # Base output directories
+        'data': f"{BASE_DATA}/data",
+        'logs': f"{BASE_DATA}/logs",
+
+        # Stage output directories (auto-generated from DATA_FLOW)
+        'mod_comments': f"{BASE_DATA}/data/mod_comments",
+        'top_subreddits': f"{BASE_DATA}/output/top_subreddits",
+        'matched_comments': f"{BASE_DATA}/output/matched_comments",
+        'matched_comments_sample': f"{BASE_DATA}/output/matched_comments_sample",
+        'submission_comments': f"{BASE_DATA}/data/submission_comments",
+        'organized_comments': f"{BASE_DATA}/output/organized_comments",
+        'comment_trees': f"{BASE_DATA}/output/comment_trees",
+        'discussion_threads': f"{BASE_DATA}/output/discussion_threads",
+        'submissions': f"{BASE_DATA}/output/submissions",
+        'media': f"{BASE_DATA}/output/media",
+        'final_dataset': f"{BASE_DATA}/output/final_dataset",
+        'embeddings': f"{BASE_DATA}/output/embeddings",
+        'clustering': f"{BASE_DATA}/output/clustering",
+        'evaluation': f"{BASE_DATA}/data/evaluation"
+    }
+
+    return paths
+
+PATHS = _generate_paths()
+
+# =============================================================================
+# UTILITY FUNCTIONS
+# =============================================================================
+
+def get_stage_info(stage_num):
+    """Get information for a specific stage number (0-13)."""
+    stage_key = f"stage{stage_num}_" + list(DATA_FLOW.keys())[stage_num].split('_', 1)[1]
+    return DATA_FLOW.get(stage_key)
+
+def get_input_paths_for_stage(stage_num):
+    """Get resolved input paths for a stage."""
+    stage_info = get_stage_info(stage_num)
+    if not stage_info:
+        return []
+
+    input_paths = []
+
+    # Add directory paths
+    for path_key in stage_info.get('input_paths', []):
+        input_paths.append(PATHS[path_key])
+
+    # Add specific files
+    for file_name in stage_info.get('input_files', []):
+        # Substitute template variables
+        resolved_file_name = file_name.format(
+            MIN_MATCHED_COMMENTS=MIN_MATCHED_COMMENTS
+        )
+        input_paths.append(os.path.join(PATHS['data'], resolved_file_name))
+
+    return input_paths
+
+def get_output_path_for_stage(stage_num):
+    """Get resolved output path for a stage."""
+    stage_info = get_stage_info(stage_num)
+    if not stage_info:
+        return None
+
+    output_dir = stage_info.get('output_dir')
+    return PATHS.get(output_dir)
+
+def create_directories():
+    """Create necessary output directories (excludes read-only input paths)."""
+    # Skip input directories that should already exist
+    skip_paths = {'reddit_comments', 'reddit_submissions', 'reddit_data'}
+
+    for name, path in PATHS.items():
+        if name not in skip_paths:
+            os.makedirs(path, exist_ok=True)
+
+def validate_stage_inputs(stage_num):
+    """Check if inputs exist for a stage."""
+    input_paths = get_input_paths_for_stage(stage_num)
+
+    for path in input_paths:
+        if os.path.isfile(path):
+            if not os.path.exists(path):
+                return False, f"Missing file: {path}"
+        elif os.path.isdir(path):
+            if not os.path.exists(path) or not os.listdir(path):
+                return False, f"Missing or empty directory: {path}"
+        else:
+            return False, f"Path doesn't exist: {path}"
+
+    return True, "All inputs available"
+
+def print_pipeline_status():
+    """Print status of entire pipeline."""
+    print("Reddit Mod Collection Pipeline Status")
+    print("=" * 80)
+    print()
+
+    for i in range(0, 11):  # Now 0-10 stages (including stage 10)
+        stage_info = get_stage_info(i)
+        if stage_info:
+            valid, msg = validate_stage_inputs(i)
+            output_path = get_output_path_for_stage(i)
+            output_exists = os.path.exists(output_path) if output_path else False
+
+            status = "✓" if valid else "✗"
+            output_status = "✓" if output_exists else "✗"
+
+            print(f"Stage {i:2d}: {stage_info['name']}")
+            print(f"         Script: {stage_info.get('script', 'N/A')}")
+            print(f"         Input: {status} | Output: {output_status}")
+            if not valid:
+                print(f"         Issue: {msg}")
+            if stage_info.get('notes'):
+                print(f"         Notes: {stage_info['notes']}")
+            print()
+
+    print("=" * 80)
+
+if __name__ == "__main__":
+    # When run directly, show pipeline status
+    create_directories()
+    print_pipeline_status()

data/test_dehydrated_clustered.json.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:019634000115a5b7d3271a95d205ca6d76800cf6045ec4486fd897cc1c5ecd38
+size 4671263

data/train_dehydrated_clustered.json.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:235937388c3d0ebae7334c2fed2ae0e5f2fa286263a2bab704097af24b252803
+size 3853781

data/val_dehydrated_clustered.json.zst

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53a5f5144fca20229320cc026863a8beaff735444c3c453dcec48a7b9f205734
+size 1548607

environment-hydrate.yml

@@ -0,0 +1,20 @@
+# Conda environment for PluRule hydration (hydrate/).
+#
+# Setup:
+#   conda env create -f environment-hydrate.yml
+#   conda activate plurule-hydrate
+#   python hydrate/0_download.py
+
+name: plurule-hydrate
+channels:
+  - conda-forge
+dependencies:
+  - python>=3.10
+  - aria2
+  - pip
+  - pip:
+      - zstandard>=0.21.0
+      - orjson>=3.9.0
+      - tqdm>=4.65.0
+      - requests>=2.31.0
+      - torf>=4.2.0

hydrate/0_download.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+PluRule Hydrate Step 0: Download the Pushshift subset needed to hydrate the benchmark.
+
+Reads the dehydrated PluRule dataset, determines which per-subreddit comment
+and submission files are referenced (~3,978 files for ~1,989 subreddits), and
+fetches just those from the academictorrents Pushshift/Arctic Shift archive via
+aria2c. Output layout is first-letter buckets (`<output-dir>/<letter>/<Sub>_...zst`)
+to match the existing pipeline layout.
+
+Modes:
+  (default)      Download via torrent
+  --from-dir X   Skip download; build manifest from an existing local mirror at X
+  --dry-run      Print torrent match report, no download
+
+Usage:
+    python hydrate/0_download.py
+    python hydrate/0_download.py --dry-run
+    python hydrate/0_download.py --from-dir /gpfs/.../Arcticshift/Subreddits/subreddits
+    python hydrate/0_download.py --output-dir /mnt/big/pushshift
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Dict, Set
+
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+
+from config import PUSHSHIFT_DATA
+from utils.files import read_compressed_json
+from utils.logging import setup_stage_logger
+from utils.pushshift_download import (
+    PUSHSHIFT_TORRENT_URL,
+    check_aria2c,
+    ensure_torrent,
+    match_basenames,
+    parse_torrent,
+    reorganize_to_letter_buckets,
+    run_aria2c,
+    scan_local_files,
+)
+
+SPLITS = ("train", "val", "test")
+
+
+def collect_subreddits(dataset_dir: Path, logger) -> Set[str]:
+    """Union of subreddit names referenced across all three dehydrated splits."""
+    subs: Set[str] = set()
+    for split in SPLITS:
+        path = dataset_dir / f"{split}_dehydrated_clustered.json.zst"
+        if not path.exists():
+            logger.error(f"Missing dataset file: {path}")
+            sys.exit(1)
+        data = read_compressed_json(str(path))
+        for entry in data.get("subreddits", []):
+            name = (entry.get("subreddit") or "").lower().strip()
+            if name:
+                subs.add(name)
+    return subs
+
+
+def required_basenames(subreddits: Set[str]) -> Set[str]:
+    """Two files per subreddit (comments + submissions)."""
+    files: Set[str] = set()
+    for sub in subreddits:
+        files.add(f"{sub}_comments.zst")
+        files.add(f"{sub}_submissions.zst")
+    return files
+
+
+def _write_manifest(output_dir: Path, manifest: Dict) -> Path:
+    path = output_dir / "hydrate_manifest.json"
+    with open(path, "w") as f:
+        json.dump(manifest, f, indent=2)
+    return path
+
+
+def _log_summary(logger, required: int, present: int, missing: int, manifest_path: Path) -> None:
+    logger.info("📊 Summary")
+    logger.info(f"   required:  {required}")
+    logger.info(f"   present:   {present}")
+    logger.info(f"   missing:   {missing}")
+    logger.info(f"   manifest:  {manifest_path}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Download the Pushshift subset referenced by the dehydrated PluRule dataset."
+    )
+    parser.add_argument(
+        "--dataset-dir", type=Path, default=Path("./data"),
+        help="Directory containing {train,val,test}_dehydrated_clustered.json.zst",
+    )
+    parser.add_argument(
+        "--output-dir", type=Path, default=Path(PUSHSHIFT_DATA),
+        help=f"Destination (default from config.PUSHSHIFT_DATA: {PUSHSHIFT_DATA})",
+    )
+    parser.add_argument(
+        "--torrent-file", type=Path, default=None,
+        help="Pre-downloaded .torrent file (skip fetch from academictorrents.com)",
+    )
+    parser.add_argument(
+        "--dry-run", action="store_true",
+        help="Preview torrent matches without downloading",
+    )
+    parser.add_argument(
+        "--from-dir", type=Path, default=None,
+        help="Skip torrent; build manifest from an existing local mirror.",
+    )
+    args = parser.parse_args()
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    logger = setup_stage_logger("hydrate0_download")
+    logger.info("=" * 60)
+    logger.info("🚀 Hydrate Step 0: Download Pushshift subset")
+    logger.info("=" * 60)
+
+    # 1. Collect needed basenames from dehydrated dataset
+    logger.info(f"📋 Collecting subreddits from dehydrated datasets in {args.dataset_dir}...")
+    subreddits = collect_subreddits(args.dataset_dir, logger)
+    needed = required_basenames(subreddits)
+    logger.info(f"   {len(subreddits)} unique subreddits → {len(needed)} files required")
+
+    # 2a. --from-dir fast path: build manifest from existing mirror
+    if args.from_dir is not None:
+        if not args.from_dir.exists():
+            logger.error(f"--from-dir not found: {args.from_dir}")
+            sys.exit(1)
+        logger.info(f"📁 Scanning existing mirror at {args.from_dir}...")
+        present, missing, basename_to_path = scan_local_files(args.from_dir, needed)
+
+        manifest = {
+            "dataset_dir": str(args.dataset_dir),
+            "output_dir": str(args.output_dir),
+            "source": "from-dir",
+            "source_dir": str(args.from_dir),
+            "subreddits_count": len(subreddits),
+            "files_required_count": len(needed),
+            "files_present_count": len(present),
+            "files_missing_in_source": sorted(missing),
+            "basename_to_path": basename_to_path,
+        }
+        manifest_path = _write_manifest(args.output_dir, manifest)
+        _log_summary(logger, len(needed), len(present), len(missing), manifest_path)
+        if missing and len(missing) <= 20:
+            logger.warning(f"   missing list: {sorted(missing)}")
+        elif missing:
+            logger.warning(f"   missing sample: {sorted(missing)[:20]} ... (+{len(missing) - 20} more)")
+        return 0
+
+    # 2b. Torrent path
+    torrent_path = args.torrent_file or (args.output_dir / "pushshift.torrent")
+    if args.torrent_file is None:
+        ensure_torrent(torrent_path, PUSHSHIFT_TORRENT_URL)
+    elif not torrent_path.exists():
+        logger.error(f"Torrent file not found: {torrent_path}")
+        sys.exit(1)
+
+    logger.info("🔎 Matching required files against torrent contents...")
+    all_files = parse_torrent(torrent_path)
+    matched, missing_in_torrent = match_basenames(all_files, needed)
+    logger.info(f"   matched: {len(matched)} / not in torrent: {len(missing_in_torrent)}")
+    if missing_in_torrent and len(missing_in_torrent) <= 20:
+        logger.warning(f"   missing: {sorted(missing_in_torrent)}")
+    elif missing_in_torrent:
+        logger.warning(f"   missing sample: {sorted(missing_in_torrent)[:20]} ... "
+                       f"(+{len(missing_in_torrent) - 20} more)")
+
+    manifest: Dict = {
+        "dataset_dir": str(args.dataset_dir),
+        "output_dir": str(args.output_dir),
+        "source": "torrent",
+        "torrent_file": str(torrent_path),
+        "torrent_url": PUSHSHIFT_TORRENT_URL if args.torrent_file is None else None,
+        "subreddits_count": len(subreddits),
+        "files_required_count": len(needed),
+        "files_matched_count": len(matched),
+        "files_missing_in_torrent": sorted(missing_in_torrent),
+    }
+
+    if args.dry_run:
+        manifest["torrent_relative_paths"] = {b: p for b, (_, p) in matched.items()}
+        path = args.output_dir / "hydrate_manifest_dry_run.json"
+        with open(path, "w") as f:
+            json.dump(manifest, f, indent=2)
+        logger.info(f"✅ Dry run complete: {path}")
+        for _, (idx, rel) in list(matched.items())[:3]:
+            logger.info(f"     [{idx:>5}] {rel}")
+        return 0
+
+    if not matched:
+        logger.error("No files matched in torrent; nothing to download.")
+        sys.exit(1)
+
+    # 3. Check what's already in letter-bucket layout (re-run skip)
+    logger.info(f"🔎 Checking existing files in {args.output_dir}...")
+    present, missing_to_dl, _ = scan_local_files(args.output_dir, set(matched.keys()))
+    logger.info(f"   already present: {len(present)} / still need: {len(missing_to_dl)}")
+
+    if missing_to_dl:
+        check_aria2c()
+        logger.info(f"🚀 aria2c: downloading to {args.output_dir}")
+        rc = run_aria2c(torrent_path, [i for i, _ in matched.values()], args.output_dir)
+        if rc != 0:
+            logger.warning(f"⚠️  aria2c exited with code {rc} (partial set may still have downloaded)")
+
+        # 4. Reorganize freshly-downloaded files into letter buckets
+        logger.info("🗂️  Reorganizing into first-letter bucket layout...")
+        _, _, downloaded_map = scan_local_files(args.output_dir, set(matched.keys()))
+        reorganize_to_letter_buckets(args.output_dir, downloaded_map)
+    else:
+        logger.info("✓ All needed files already present; skipping aria2c.")
+
+    # 5. Re-verify and write manifest (authoritative after any moves)
+    present_final, missing_final, verified_map = scan_local_files(args.output_dir, needed)
+    manifest["files_downloaded_count"] = len(present_final)
+    manifest["files_missing_after_download"] = sorted(missing_final)
+    manifest["basename_to_path"] = verified_map
+    manifest_path = _write_manifest(args.output_dir, manifest)
+    _log_summary(logger, len(needed), len(present_final),
+                 len(missing_final) + len(missing_in_torrent), manifest_path)
+
+    return 0 if not missing_final else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hydrate/1_hydrate_dataset.py

@@ -0,0 +1,425 @@
+#!/usr/bin/env python3
+"""
+PluRule Hydrate Step 1: Fill [NEEDS_HYDRATION] placeholders.
+
+Reads the dehydrated PluRule dataset + the Pushshift subset produced by
+hydrate/0_download.py, writes hydrated JSON.zst files whose structure matches
+what pipeline/10_assign_cluster_labels.py's hydrated output produces -- except
+that `media_files` paths remain placeholders until hydrate/2_download_media.py
+runs.
+
+Subreddits appear across multiple splits (every sub appears in test, many
+in val/train), so we hydrate subreddit-centric rather than split-centric:
+each Pushshift zst file is streamed exactly once, and the extracted
+submissions/comments are distributed to whichever split(s) need them.
+
+Per unique subreddit we:
+  1. Union the comment + submission IDs referenced across all splits.
+  2. Stream `{sub}_comments.zst` once, keep only matching IDs.
+  3. Stream `{sub}_submissions.zst` once, keep only matching IDs.
+  4. Fill placeholders in every split's copy of the sub_data.
+  5. Missing IDs become {"hydration_status": "missing", "id": ...}.
+  6. Subreddits whose Pushshift files are absent from the manifest get
+     `hydration_status: "source_unavailable"` on every split's sub_data.
+
+Usage:
+    python hydrate/1_hydrate_dataset.py
+    python hydrate/1_hydrate_dataset.py --splits test
+    python hydrate/1_hydrate_dataset.py --num-workers 8
+"""
+
+import argparse
+import json
+import sys
+import time
+from collections import defaultdict
+from multiprocessing import Pool
+from pathlib import Path
+from typing import Any, Dict, List, Set, Tuple
+
+# Add repo root to path (for utils/)
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+
+try:
+    import zstandard
+    from tqdm import tqdm
+except ImportError as e:
+    sys.exit(
+        f"Missing dependency: {e.name}.\n"
+        f"Install hydrate requirements: pip install -r requirements-hydrate.txt"
+    )
+
+from config import PROCESSES, PUSHSHIFT_DATA
+from utils.files import json_loads, read_compressed_json, write_compressed_json
+from utils.logging import setup_stage_logger
+
+SPLITS = ("train", "val", "test")
+
+
+# ---------------------------------------------------------------------------
+# Streaming reader
+# ---------------------------------------------------------------------------
+
+_READ_CHUNK = 1 << 24  # 16 MB — matches utils.files.read_and_decode
+
+
+def iter_zst_jsonl(path: str):
+    """Yield parsed JSON objects from a .zst-compressed JSONL file.
+
+    Bytes-based line split (safe because '\\n' = 0x0A is never inside a
+    multibyte UTF-8 sequence). Uses a mutable `bytearray` buffer with a
+    cursor to avoid repeated slice allocation.
+    """
+    with open(path, "rb") as f:
+        dctx = zstandard.ZstdDecompressor(max_window_size=2**31)
+        with dctx.stream_reader(f) as reader:
+            buf = bytearray()
+            while True:
+                chunk = reader.read(_READ_CHUNK)
+                if not chunk:
+                    break
+                buf.extend(chunk)
+                start = 0
+                n = len(buf)
+                while start < n:
+                    nl = buf.find(b"\n", start)
+                    if nl < 0:
+                        break
+                    if nl > start:
+                        try:
+                            yield json_loads(bytes(buf[start:nl]))
+                        except Exception:
+                            pass
+                    start = nl + 1
+                if start:
+                    del buf[:start]
+            if buf:
+                try:
+                    yield json_loads(bytes(buf))
+                except Exception:
+                    pass
+
+
+# ---------------------------------------------------------------------------
+# Per-subreddit helpers
+# ---------------------------------------------------------------------------
+
+def _collect_needed_ids(sub_data: Dict) -> Tuple[Set[str], Set[str]]:
+    """Union of comment IDs and submission IDs referenced by one sub_data entry."""
+    comment_ids: Set[str] = set()
+    submission_ids: Set[str] = set(sub_data.get("submissions", {}).keys())
+
+    for pair in sub_data.get("thread_pairs", []):
+        mid = pair.get("mod_comment_id")
+        if mid:
+            comment_ids.add(mid)
+        for tid in pair.get("violating_thread_ids") or []:
+            if tid:
+                comment_ids.add(tid)
+        for tid in pair.get("compliant_thread_ids") or []:
+            if tid:
+                comment_ids.add(tid)
+    return comment_ids, submission_ids
+
+
+def _extract_by_id(path: str, id_field: str, needed: Set[str]) -> Dict[str, Dict]:
+    """Stream a .zst JSONL file; return {id: obj} for ids in `needed`. Early-exits once full."""
+    out: Dict[str, Dict] = {}
+    if not needed:
+        return out
+    target = len(needed)
+    for obj in iter_zst_jsonl(path):
+        oid = obj.get(id_field)
+        if oid in needed and oid not in out:
+            out[oid] = obj
+            if len(out) == target:
+                break
+    return out
+
+
+def _fill_sub_data(
+    sub_data: Dict,
+    comments_by_id: Dict[str, Dict],
+    submissions_by_id: Dict[str, Dict],
+    split_counts: Dict[str, Any],
+) -> None:
+    """Fill [NEEDS_HYDRATION] placeholders in one sub_data in place."""
+    # Submissions
+    for sid, entry in sub_data.get("submissions", {}).items():
+        obj = submissions_by_id.get(sid)
+        if obj is not None:
+            entry["submission_object"] = obj
+            split_counts["hydrated_submissions"] += 1
+        else:
+            entry["submission_object"] = {"hydration_status": "missing", "id": sid}
+            split_counts["missing_submissions"] += 1
+
+    # Thread pairs
+    for pair in sub_data.get("thread_pairs", []):
+        # Mod comment
+        mid = pair.get("mod_comment_id")
+        mod_obj = comments_by_id.get(mid) if mid else None
+        if mod_obj is not None:
+            pair["mod_comment"] = mod_obj
+            split_counts["hydrated_comments"] += 1
+        else:
+            pair["mod_comment"] = {"hydration_status": "missing", "id": mid}
+            split_counts["missing_comments"] += 1
+
+        # Threads (root -> leaf, matching Stage 5 output)
+        for mode in ("violating", "compliant"):
+            ids = pair.get(f"{mode}_thread_ids") or []
+            thread: List[Dict] = []
+            for level, cid in enumerate(ids):
+                obj = comments_by_id.get(cid)
+                if obj is not None:
+                    c = dict(obj)
+                    c["level"] = level
+                    thread.append(c)
+                    split_counts["hydrated_comments"] += 1
+                else:
+                    thread.append({"hydration_status": "missing", "id": cid, "level": level})
+                    split_counts["missing_comments"] += 1
+            pair[f"{mode}_thread"] = thread
+
+
+def hydrate_subreddit_unified(args: Tuple[str, List[Dict], List[Tuple[str, int]], str, str, Set[str], Set[str]]
+                              ) -> Tuple[str, List[Dict], List[Tuple[str, int]], Dict[str, Any]]:
+    """
+    Stream Pushshift files once for a subreddit, fill every split's sub_data copy.
+
+    Returns (name, hydrated_sub_dicts, placements, stats).
+    `placements[i]` is (split, pos) in splits_data[split]["subreddits"] that sub_dicts[i] came from.
+    """
+    name, sub_dicts, placements, c_path, s_path, c_ids, s_ids = args
+
+    comments_by_id = _extract_by_id(c_path, "id", c_ids) if c_ids else {}
+    submissions_by_id = _extract_by_id(s_path, "id", s_ids) if s_ids else {}
+
+    stats: Dict[str, Any] = {
+        "subreddit": name,
+        "splits": [s for s, _ in placements],
+        "per_split": {},
+    }
+
+    for (split, _pos), sub_data in zip(placements, sub_dicts):
+        per = {
+            "hydrated_submissions": 0, "missing_submissions": 0,
+            "hydrated_comments": 0, "missing_comments": 0,
+        }
+        _fill_sub_data(sub_data, comments_by_id, submissions_by_id, per)
+        stats["per_split"][split] = per
+
+    return name, sub_dicts, placements, stats
+
+
+# ---------------------------------------------------------------------------
+# Orchestration
+# ---------------------------------------------------------------------------
+
+def load_manifest(pushshift_dir: Path, logger) -> Dict[str, str]:
+    """Load basename -> absolute path map written by hydrate/0_download.py."""
+    manifest_path = pushshift_dir / "hydrate_manifest.json"
+    if not manifest_path.exists():
+        logger.error(
+            f"Manifest not found: {manifest_path}. Run hydrate/0_download.py first."
+        )
+        sys.exit(1)
+    with open(manifest_path) as f:
+        m = json.load(f)
+    b2p = m.get("basename_to_path", {})
+    if not b2p:
+        logger.error(
+            f"{manifest_path} has no `basename_to_path`. Re-run hydrate/0_download.py."
+        )
+        sys.exit(1)
+    return b2p
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Hydrate the PluRule dehydrated dataset using downloaded Pushshift files."
+    )
+    parser.add_argument("--dataset-dir", type=Path, default=Path("./data"))
+    parser.add_argument("--pushshift-dir", type=Path, default=Path(PUSHSHIFT_DATA),
+                        help=f"Directory containing hydrate_manifest.json (default: {PUSHSHIFT_DATA})")
+    parser.add_argument("--output-dir", type=Path, default=Path("./data"))
+    parser.add_argument(
+        "--splits", nargs="+", choices=SPLITS, default=list(SPLITS),
+        help="Splits to hydrate (default: all)",
+    )
+    parser.add_argument(
+        "--num-workers", type=int, default=PROCESSES,
+        help=f"Parallel workers (default: {PROCESSES}, from config.PROCESSES). "
+             f"Recommend 8-16 for I/O-bound work on network filesystems.",
+    )
+    args = parser.parse_args()
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    logger = setup_stage_logger("hydrate1_hydrate_dataset")
+    logger.info("=" * 60)
+    logger.info("🚀 Hydrate Step 1: Fill [NEEDS_HYDRATION] placeholders")
+    logger.info("=" * 60)
+
+    # 1. Load manifest
+    logger.info(f"📋 Loading manifest from {args.pushshift_dir}...")
+    basename_to_path = load_manifest(args.pushshift_dir, logger)
+    logger.info(f"   {len(basename_to_path)} Pushshift files available")
+
+    # 2. Load ALL selected splits upfront
+    splits_data: Dict[str, Dict] = {}
+    for split in args.splits:
+        path = args.dataset_dir / f"{split}_dehydrated_clustered.json.zst"
+        if not path.exists():
+            logger.warning(f"⚠️  Skipping {split}: {path} not found")
+            continue
+        logger.info(f"📂 Loading {path}")
+        splits_data[split] = read_compressed_json(str(path))
+
+    if not splits_data:
+        logger.error("No split files loaded")
+        sys.exit(1)
+
+    # 3. Build cross-split index: subreddit -> [(split, pos, sub_data_ref), ...]
+    by_subreddit: Dict[str, List[Tuple[str, int, Dict]]] = defaultdict(list)
+    for split, data in splits_data.items():
+        for pos, sub_data in enumerate(data.get("subreddits", [])):
+            name = (sub_data.get("subreddit") or "").lower()
+            if name:
+                by_subreddit[name].append((split, pos, sub_data))
+
+    n_unique = len(by_subreddit)
+    n_entries = sum(len(v) for v in by_subreddit.values())
+    logger.info(f"   {n_unique} unique subreddits across {n_entries} split entries "
+                f"(saves {n_entries - n_unique} redundant stream passes)")
+
+    # 4. Build tasks (one per unique subreddit)
+    tasks = []
+    source_unavailable: List[str] = []
+    task_sizes: List[int] = []  # parallels `tasks`; comments-file bytes
+
+    for name, entries in by_subreddit.items():
+        c_path = basename_to_path.get(f"{name}_comments.zst")
+        s_path = basename_to_path.get(f"{name}_submissions.zst")
+        if not c_path or not s_path:
+            for _split, _pos, sub_data in entries:
+                sub_data["hydration_status"] = "source_unavailable"
+            source_unavailable.append(name)
+            continue
+
+        all_c_ids: Set[str] = set()
+        all_s_ids: Set[str] = set()
+        for _split, _pos, sub_data in entries:
+            c, s = _collect_needed_ids(sub_data)
+            all_c_ids |= c
+            all_s_ids |= s
+
+        sub_dicts = [sd for _, _, sd in entries]
+        placements = [(split, pos) for split, pos, _ in entries]
+        tasks.append((name, sub_dicts, placements, c_path, s_path, all_c_ids, all_s_ids))
+        task_sizes.append(0)  # filled in next step
+
+    if source_unavailable:
+        logger.warning(f"⚠️  {len(source_unavailable)} subreddits have no Pushshift source "
+                       f"(marked `hydration_status: source_unavailable`)")
+
+    # 4b. Stat comments files in parallel and sort tasks largest-first (LPT heuristic).
+    # Streaming the whole comments file is the dominant cost; dispatching biggest
+    # tasks first keeps workers saturated to the end rather than finishing one
+    # huge subreddit alone while everyone else idles.
+    import os as _os
+    from concurrent.futures import ThreadPoolExecutor as _TPE
+
+    logger.info(f"📏 Stat-ing {len(tasks)} comments files to sort largest-first...")
+    t_stat = time.time()
+
+    def _stat(path: str) -> int:
+        try:
+            return _os.path.getsize(path)
+        except OSError:
+            return 0
+
+    with _TPE(max_workers=32) as _p:
+        task_sizes = list(_p.map(lambda t: _stat(t[3]), tasks))
+    logger.info(f"   done in {time.time() - t_stat:.1f}s")
+
+    order = sorted(range(len(tasks)), key=lambda i: task_sizes[i], reverse=True)
+    tasks = [tasks[i] for i in order]
+    task_sizes = [task_sizes[i] for i in order]
+    if tasks:
+        top5 = ", ".join(f"r/{tasks[i][0]} ({task_sizes[i] / (1 << 30):.1f} GB)"
+                         for i in range(min(5, len(tasks))))
+        logger.info(f"   largest first: {top5}")
+
+    # 5. Parallel hydration
+    logger.info(f"🚀 Hydrating {len(tasks)} unique subreddits ({args.num_workers} workers)...")
+    t0 = time.time()
+
+    # Aggregate per-split stats across all subreddits
+    totals_by_split: Dict[str, Dict[str, int]] = {
+        split: {"hydrated_submissions": 0, "missing_submissions": 0,
+                "hydrated_comments": 0, "missing_comments": 0}
+        for split in splits_data
+    }
+
+    with Pool(args.num_workers) as pool, tqdm(total=len(tasks), desc="subreddits") as pbar:
+        for name, hydrated_dicts, placements, stats in pool.imap_unordered(
+                hydrate_subreddit_unified, tasks):
+            # Replace sub_data in each split (pickling lost the by-reference link)
+            for (split, pos), hydrated in zip(placements, hydrated_dicts):
+                splits_data[split]["subreddits"][pos] = hydrated
+            # Accumulate per-split totals
+            for split, per in stats["per_split"].items():
+                for k, v in per.items():
+                    totals_by_split[split][k] += v
+            pbar.update(1)
+
+    elapsed = time.time() - t0
+    logger.info(f"✅ Hydrated in {elapsed:.1f}s")
+
+    # 6. Write each split
+    summary: Dict[str, Any] = {
+        "hydration_date": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "dataset_dir": str(args.dataset_dir),
+        "pushshift_dir": str(args.pushshift_dir),
+        "output_dir": str(args.output_dir),
+        "unique_subreddits": n_unique,
+        "split_entries": n_entries,
+        "source_unavailable_count": len(source_unavailable),
+        "source_unavailable": source_unavailable,
+        "hydration_elapsed_s": round(elapsed, 1),
+        "splits": {},
+    }
+
+    for split, data in splits_data.items():
+        data.setdefault("metadata", {})
+        data["metadata"]["hydrated_from"] = "dehydrated_clustered"
+        data["metadata"]["hydration_date"] = time.strftime("%Y-%m-%d %H:%M:%S")
+        data["metadata"].pop("instructions", None)
+
+        out_path = args.output_dir / f"{split}_hydrated_clustered.json.zst"
+        size_mb = write_compressed_json(data, str(out_path))
+
+        totals = totals_by_split[split]
+        logger.info(f"💾 {split}: {out_path} ({size_mb:.1f} MB) — "
+                    f"subs:{totals['hydrated_submissions']:,}/{totals['missing_submissions']:,} miss, "
+                    f"cmts:{totals['hydrated_comments']:,}/{totals['missing_comments']:,} miss")
+
+        summary["splits"][split] = {
+            "output": str(out_path),
+            "size_mb": round(size_mb, 1),
+            "totals": totals,
+        }
+
+    summary_path = args.output_dir / "hydrate_summary.json"
+    with open(summary_path, "w") as f:
+        json.dump(summary, f, indent=2)
+    logger.info(f"📊 Summary: {summary_path}")
+
+    # Partial hydration is acceptable; exit 0 regardless.
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hydrate/2_download_media.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+PluRule Hydrate Step 2: Download media for hydrated submissions.
+
+Iterates the hydrated JSON.zst files produced by hydrate/1_hydrate_dataset.py,
+downloads each submission's media via the shared `utils.media` helper, and
+writes the actual local file paths back into each submission's `media_files`
+(replacing the `[NEEDS_HYDRATION]` placeholders).
+
+Priority hierarchy and filtering rules match pipeline/7_collect_media.py
+(same shared helper).  Media downloads are best-effort — dead URLs are
+expected and don't abort the script; failures are counted and reported.
+
+Usage:
+    python hydrate/2_download_media.py
+    python hydrate/2_download_media.py --splits test
+    python hydrate/2_download_media.py --num-workers 8
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+
+try:
+    from tqdm import tqdm
+except ImportError as e:
+    sys.exit(
+        f"Missing dependency: {e.name}.\n"
+        f"Install hydrate requirements: pip install -r requirements-hydrate.txt"
+    )
+
+from utils.files import read_compressed_json, write_compressed_json
+from utils.logging import setup_stage_logger
+from utils.media import categorize_error, create_session, download_submission_media
+
+SPLITS = ("train", "val", "test")
+
+
+# ---------------------------------------------------------------------------
+# Per-submission worker (thread-pool; I/O-bound HTTP)
+# ---------------------------------------------------------------------------
+
+def _download_one(args: Tuple[Dict, str]) -> Dict[str, Any]:
+    """Download media for one submission; per-thread requests.Session."""
+    submission_obj, media_dir = args
+    session = _thread_local_session()
+    return download_submission_media(submission_obj, media_dir, session)
+
+
+# ThreadPoolExecutor workers don't persist locals; use module-level cache keyed
+# by thread id so each worker reuses one Session across its tasks.
+import threading
+_SESSIONS = threading.local()
+
+
+def _thread_local_session():
+    s = getattr(_SESSIONS, "session", None)
+    if s is None:
+        s = create_session()
+        _SESSIONS.session = s
+    return s
+
+
+# ---------------------------------------------------------------------------
+# Split driver
+# ---------------------------------------------------------------------------
+
+def hydrate_split_media(
+    split: str,
+    dataset_dir: Path,
+    media_root: Path,
+    num_workers: int,
+    skip_existing: bool,
+    logger,
+) -> Dict[str, Any]:
+    """Update media_files in a hydrated split in place; return stats."""
+    in_path = dataset_dir / f"{split}_hydrated_clustered.json.zst"
+    if not in_path.exists():
+        logger.warning(f"⚠️  Skipping {split}: {in_path} not found")
+        return {}
+
+    logger.info(f"📂 Loading {in_path}")
+    data = read_compressed_json(str(in_path))
+
+    # Collect tasks: (subreddit_idx, submission_id, submission_obj, media_dir)
+    tasks: List[Tuple[int, str, Dict, str]] = []
+    skipped_cached = 0
+
+    for sub_idx, sub_data in enumerate(data.get("subreddits", [])):
+        if sub_data.get("hydration_status") == "source_unavailable":
+            continue
+        subreddit = (sub_data.get("subreddit") or "").lower().strip()
+        if not subreddit:
+            continue
+        media_dir = str(media_root / subreddit)
+
+        for sub_id, entry in sub_data.get("submissions", {}).items():
+            sub_obj = entry.get("submission_object")
+            if not isinstance(sub_obj, dict):
+                continue
+            if sub_obj.get("hydration_status") == "missing":
+                continue
+
+            existing = entry.get("media_files") or []
+            already_on_disk = [p for p in existing if isinstance(p, str) and os.path.exists(p)]
+            expected = entry.get("num_media", 0)
+            if skip_existing and len(already_on_disk) >= expected > 0:
+                entry["media_files"] = already_on_disk
+                skipped_cached += 1
+                continue
+
+            tasks.append((sub_idx, sub_id, sub_obj, media_dir))
+
+    if skipped_cached:
+        logger.info(f"   ✓ {skipped_cached} submissions already have media on disk (skip-existing)")
+    logger.info(f"   {len(tasks)} submissions to process")
+
+    if not tasks:
+        out_path = dataset_dir / f"{split}_hydrated_clustered.json.zst"
+        size_mb = write_compressed_json(data, str(out_path))
+        return {
+            "split": split, "output": str(out_path), "size_mb": round(size_mb, 1),
+            "submissions_processed": 0, "files_downloaded": 0,
+            "status_breakdown": {}, "error_breakdown": {},
+        }
+
+    # Parallel downloads. HTTP is I/O-bound → threads, not processes.
+    status_counts: Dict[str, int] = defaultdict(int)
+    error_counts: Dict[str, int] = defaultdict(int)
+    total_files = 0
+    submissions: Dict[str, int] = {"processed": 0}
+    t0 = time.time()
+
+    with ThreadPoolExecutor(max_workers=num_workers) as pool, \
+         tqdm(total=len(tasks), desc=f"{split} media", unit="sub") as pbar:
+        futures = {
+            pool.submit(_download_one, (sub_obj, media_dir)): (sub_idx, sub_id)
+            for sub_idx, sub_id, sub_obj, media_dir in tasks
+        }
+        for future in as_completed(futures):
+            sub_idx, sub_id = futures[future]
+            try:
+                result = future.result()
+            except Exception as e:
+                error_counts[categorize_error(str(e))] += 1
+                pbar.update(1)
+                continue
+
+            status_counts[result["status"]] += 1
+            total_files += result["files_downloaded"]
+            submissions["processed"] += 1
+
+            for err in result.get("errors", []):
+                error_counts[categorize_error(err)] += 1
+
+            # Update media_files paths in place
+            entry = data["subreddits"][sub_idx]["submissions"][sub_id]
+            entry["media_files"] = result["file_paths"]
+
+            pbar.update(1)
+
+    elapsed = time.time() - t0
+    logger.info(f"   ✅ {submissions['processed']} submissions, {total_files} files in {elapsed:.1f}s")
+
+    # Write updated hydrated JSON
+    data.setdefault("metadata", {})
+    data["metadata"]["media_hydrated_date"] = time.strftime("%Y-%m-%d %H:%M:%S")
+    out_path = dataset_dir / f"{split}_hydrated_clustered.json.zst"
+    size_mb = write_compressed_json(data, str(out_path))
+    logger.info(f"💾 {out_path} ({size_mb:.1f} MB)")
+
+    return {
+        "split": split,
+        "output": str(out_path),
+        "size_mb": round(size_mb, 1),
+        "submissions_processed": submissions["processed"],
+        "files_downloaded": total_files,
+        "status_breakdown": dict(status_counts),
+        "error_breakdown": dict(sorted(error_counts.items(), key=lambda x: -x[1])[:20]),
+        "processing_time_seconds": round(elapsed, 1),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Download media for hydrated PluRule submissions."
+    )
+    parser.add_argument(
+        "--dataset-dir", type=Path, default=Path("./data"),
+        help="Directory containing {split}_hydrated_clustered.json.zst",
+    )
+    parser.add_argument(
+        "--media-dir", type=Path, default=Path("./data/media"),
+        help="Root directory for downloaded media (per-subreddit subdirs auto-created)",
+    )
+    parser.add_argument(
+        "--splits", nargs="+", choices=SPLITS, default=list(SPLITS),
+    )
+    parser.add_argument(
+        "--num-workers", type=int, default=16,
+        help="Parallel HTTP workers (threads, I/O-bound). Default 16.",
+    )
+    parser.add_argument(
+        "--skip-existing", action="store_true",
+        help="Skip submissions whose expected media files already exist on disk.",
+    )
+    args = parser.parse_args()
+
+    args.media_dir.mkdir(parents=True, exist_ok=True)
+
+    logger = setup_stage_logger("hydrate2_download_media")
+    logger.info("=" * 60)
+    logger.info("🚀 Hydrate Step 2: Download submission media")
+    logger.info("=" * 60)
+
+    all_stats: Dict[str, Dict] = {}
+    totals = {"submissions_processed": 0, "files_downloaded": 0}
+    start = time.time()
+
+    for split in args.splits:
+        stats = hydrate_split_media(
+            split, args.dataset_dir, args.media_dir,
+            args.num_workers, args.skip_existing, logger,
+        )
+        if not stats:
+            continue
+        all_stats[split] = stats
+        totals["submissions_processed"] += stats.get("submissions_processed", 0)
+        totals["files_downloaded"] += stats.get("files_downloaded", 0)
+
+    elapsed = time.time() - start
+
+    summary = {
+        "media_hydration_date": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "dataset_dir": str(args.dataset_dir),
+        "media_dir": str(args.media_dir),
+        "splits": list(all_stats.keys()),
+        "totals": totals,
+        "total_time_seconds": round(elapsed, 1),
+        "per_split": all_stats,
+    }
+
+    summary_path = args.dataset_dir / "hydrate_media_summary.json"
+    with open(summary_path, "w") as f:
+        json.dump(summary, f, indent=2)
+
+    logger.info("📊 Summary")
+    logger.info(f"   processed:       {totals['submissions_processed']:,} submissions")
+    logger.info(f"   files downloaded:{totals['files_downloaded']:,}")
+    logger.info(f"   time:            {elapsed:.1f}s")
+    logger.info(f"   summary:         {summary_path}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hydrate/README.md

@@ -0,0 +1,324 @@
+# Hydrating PluRule
+
+This directory contains the three scripts a user runs to **reconstitute the full
+PluRule benchmark** from the released dehydrated dataset.
+
+If you instead want to rebuild PluRule from scratch starting from the raw
+Pushshift archives, see [`../pipeline/README.md`](../pipeline/README.md).
+
+## Why hydration?
+
+The released dataset ships only IDs, metadata, rules, cluster labels, and answer
+options — every comment body, submission, and media file is replaced with a
+`[NEEDS_HYDRATION]` placeholder. This keeps the distribution small and avoids
+redistributing Reddit content that originates from the Pushshift archives. To
+run the benchmark you first populate those placeholders from a local Pushshift
+mirror (which you download from Academic Torrents) and then download the
+submission media.
+
+## Prerequisites
+
+- Python **3.10+**
+- `aria2c` on `PATH` (for torrent download)
+- A BitTorrent port open in your firewall
+- **Disk**: plan for several hundred GB to ~1–2 TB for the Pushshift subset.
+  Large subreddits (`r/askreddit`, `r/worldnews`, …) contribute most of the
+  volume; small subreddits are tens of MB each.
+- **Bandwidth**: torrent throughput depends on seeders; budget several hours.
+
+### Install
+
+The quickest path uses the bundled conda env (pulls `aria2` from conda-forge so
+you don't need root):
+
+```bash
+conda env create -f ../environment-hydrate.yml
+conda activate plurule-hydrate
+```
+
+If you already have a Python environment, install the minimal hydrate deps
+from the yml's `pip:` section (`zstandard`, `orjson`, `tqdm`, `requests`,
+`torf`) and make sure `aria2c` is on PATH:
+
+```
+Debian/Ubuntu:  sudo apt install aria2
+macOS:          brew install aria2
+Fedora/CentOS:  sudo dnf install aria2
+No root:        conda install -c conda-forge aria2
+```
+
+### Get the dehydrated dataset
+
+Place the three dehydrated split files under `./data/`:
+
+```
+data/
+├── train_dehydrated_clustered.json.zst
+├── val_dehydrated_clustered.json.zst
+└── test_dehydrated_clustered.json.zst
+```
+
+<!-- TODO: replace with the HuggingFace / Zenodo URL once the dataset is published -->
+
+## Quick start
+
+Three steps, from repo root:
+
+```bash
+# 1. Download the Pushshift subset referenced by the dataset (~3,978 files)
+python hydrate/0_download.py
+
+# 2. Fill every [NEEDS_HYDRATION] placeholder using the downloaded archives
+python hydrate/1_hydrate_dataset.py
+
+# 3. (Optional) Download submission images
+python hydrate/2_download_media.py
+```
+
+After step 1 the Pushshift subset lives under the path configured in
+`config.PUSHSHIFT_DATA`. After step 2 you have
+`data/{train,val,test}_hydrated_clustered.json.zst`. After step 3 those same
+files have their `media_files` arrays populated with local paths.
+
+---
+
+## 0. `0_download.py` — fetch the Pushshift subset
+
+Reads the dehydrated splits, computes the set of per-subreddit comment and
+submission files referenced (~3,978 files across ~1,989 subreddits), fetches
+only those from the Arctic Shift / Pushshift
+[academictorrent](https://academictorrents.com/details/3e3f64dee22dc304cdd2546254ca1f8e8ae542b4)
+via `aria2c`, and reorganizes them into a first-letter bucket layout:
+
+```
+<output-dir>/
+├── a/
+│   ├── askreddit_comments.zst
+│   ├── askreddit_submissions.zst
+│   └── …
+├── b/
+│   └── …
+└── hydrate_manifest.json
+```
+
+### Common invocations
+
+```bash
+# Default (reads ./data, writes to config.PUSHSHIFT_DATA)
+python hydrate/0_download.py
+
+# Preview torrent match without downloading
+python hydrate/0_download.py --dry-run
+
+# Custom output directory
+python hydrate/0_download.py --output-dir /mnt/big/pushshift
+
+# Skip the torrent; build manifest from an existing local mirror
+python hydrate/0_download.py --from-dir /gpfs/.../Arcticshift/Subreddits/subreddits
+```
+
+### Flags
+
+| Flag | Default | Purpose |
+|---|---|---|
+| `--dataset-dir` | `./data` | where the three `*_dehydrated_clustered.json.zst` files live |
+| `--output-dir` | `config.PUSHSHIFT_DATA` | destination for Pushshift files |
+| `--torrent-file` | *(fetched)* | use a pre-downloaded `.torrent` instead of the Academic Torrents URL |
+| `--dry-run` | off | preview match report without downloading |
+| `--from-dir` | *(off)* | skip torrent; use an existing local mirror |
+
+### What it writes
+
+- Downloaded files under `<output-dir>/<letter>/`
+- `<output-dir>/hydrate_manifest.json` — `basename_to_path` map consumed by step 1
+- `<output-dir>/pushshift.torrent` — cached `.torrent` so re-runs don't re-fetch
+
+### Resuming
+
+`aria2c` keeps `.aria2` control files next to each download. Re-running the
+script picks up where it left off. Files already in the letter-bucket layout
+are detected and not re-downloaded.
+
+### Subreddits missing from the torrent
+
+Expect a small tail (<2%) of subreddits in the dataset that aren't in this
+particular torrent snapshot (renamed, banned, or post-cutoff subs). The script
+reports them and writes their names to `hydrate_manifest.json`; step 1 marks
+those subreddits with `hydration_status: source_unavailable`.
+
+---
+
+## 1. `1_hydrate_dataset.py` — fill the placeholders
+
+Streams each Pushshift file exactly **once** across all three splits (most
+subreddits appear in multiple splits), extracts only the referenced comment
+and submission IDs, and fills the placeholders in each split's JSON.
+
+### Run
+
+```bash
+# Default (reads ./data + config.PUSHSHIFT_DATA, writes ./data)
+python hydrate/1_hydrate_dataset.py
+
+# Only one split
+python hydrate/1_hydrate_dataset.py --splits test
+
+# Tune parallelism (default from config.PROCESSES)
+python hydrate/1_hydrate_dataset.py --num-workers 16
+```
+
+### Flags
+
+| Flag | Default | Purpose |
+|---|---|---|
+| `--dataset-dir` | `./data` | input dehydrated files |
+| `--pushshift-dir` | `config.PUSHSHIFT_DATA` | where `hydrate_manifest.json` lives |
+| `--output-dir` | `./data` | output hydrated files |
+| `--splits` | all | subset of {train, val, test} |
+| `--num-workers` | `config.PROCESSES` | parallel subreddit workers |
+
+### How it fills things
+
+| Placeholder in dehydrated JSON | Filled by step 1 from |
+|---|---|
+| `submissions[sid].submission_object` | `{sub}_submissions.zst` |
+| `thread_pairs[i].mod_comment` | `{sub}_comments.zst` (id = `mod_comment_id`) |
+| `thread_pairs[i].violating_thread` | root→leaf walk of `violating_thread_ids` |
+| `thread_pairs[i].compliant_thread` | root→leaf walk of `compliant_thread_ids` |
+| `submissions[sid].media_files` | **not filled** — see step 2 |
+
+Missing IDs (the Pushshift archive doesn't contain them) become
+`{"hydration_status": "missing", "id": ...}` instead of aborting the script.
+Subreddits whose Pushshift files aren't in the manifest have a
+`hydration_status: "source_unavailable"` flag set on their `sub_data`; their
+thread pairs are left with placeholders in place. Partial hydration is fine for
+these data-quality cases, and the script records them in the summary instead
+of aborting.
+
+### Output
+
+- `./data/{train,val,test}_hydrated_clustered.json.zst` — same schema as
+  `pipeline/10_assign_cluster_labels.py`'s hydrated output
+- `./data/hydrate_summary.json` — per-split counts + list of
+  source-unavailable subreddits
+
+---
+
+## 2. `2_download_media.py` — submission images (optional)
+
+For each hydrated submission, follows the priority hierarchy
+(`media_metadata` → `url` → `oembed` → `preview`), validates Content-Type,
+caps files at 50 MB, and writes actual local paths into each submission's
+`media_files` array in the hydrated JSON.
+
+This step reuses the same extraction + download logic as
+`pipeline/7_collect_media.py` via `utils/media.py`.
+
+### Run
+
+```bash
+# Default
+python hydrate/2_download_media.py
+
+# Only test split, more parallelism
+python hydrate/2_download_media.py --splits test --num-workers 32
+
+# Skip submissions whose media is already on disk
+python hydrate/2_download_media.py --skip-existing
+```
+
+### Flags
+
+| Flag | Default | Purpose |
+|---|---|---|
+| `--dataset-dir` | `./data` | hydrated files from step 1 |
+| `--media-dir` | `./data/media` | where images land (per-subreddit subdirs) |
+| `--splits` | all | subset of {train, val, test} |
+| `--num-workers` | 16 | HTTP threads (I/O-bound; threads, not processes) |
+| `--skip-existing` | off | keep existing `media_files` paths that still exist on disk |
+
+### What to expect
+
+- Media is **best-effort**. Many historical Reddit URLs are dead or rate-limit.
+  A 60–80% success rate is typical. The benchmark works fine without 100%
+  media coverage; models that don't consume images are unaffected.
+- Videos, crossposts, and NSFW submissions are skipped at the top (same rule
+  as the pipeline).
+- Files are named `{submission_id}_{media_id}.{ext}` or
+  `{submission_id}_{index}_{safe_media_id}.{ext}` for gallery items.
+
+### Output
+
+- `./data/media/<subreddit>/<submission_id>_*.{jpg,png,gif,webp,bmp}`
+- Each `submission.media_files` array in the hydrated JSON now holds real paths
+- `./data/hydrate_media_summary.json` — per-split status / error counts
+
+---
+
+## Output format
+
+After all three steps, each `{split}_hydrated_clustered.json.zst` matches the
+schema produced by `pipeline/10_assign_cluster_labels.py`:
+
+```jsonc
+{
+  "metadata": { /* split-level, hydration dates, version */ },
+  "subreddits": [
+    {
+      "subreddit": "excel",
+      "title": "...",
+      "description": "...",
+      "language": "en",
+      "rules": [ /* full rule objects with cluster ids */ ],
+      "subreddit_cluster_id":    2,
+      "subreddit_cluster_label": "tech communities",
+      "submissions": {
+        "<submission_id>": {
+          "submission_object": { /* full submission JSON */ },
+          "num_media": 1,
+          "media_files": ["data/media/excel/<id>_direct.png"]
+        }
+      },
+      "thread_pairs": [
+        {
+          "mod_comment_id": "...",
+          "mod_comment":    { /* full comment */ },
+          "violating_thread":  [ /* root→leaf comments, each with level */ ],
+          "compliant_thread":  [ /* same */ ],
+          "violating_answer_options": [ /* shuffled MCQ */ ],
+          "violating_correct_answer": "(c)",
+          "compliant_answer_options": [ /* shuffled MCQ */ ],
+          "compliant_correct_answer": "(b)",
+          "metadata": {
+            "rule": "No low-effort posts",
+            "rule_cluster_id":    5,
+            "rule_cluster_label": "spam / self-promotion",
+            /* plus similarity score, depths, scores, ancestor IDs, … */
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+## Re-running
+
+All three scripts are safe to re-run:
+
+- Step 0: `aria2c` resumes from `.aria2` control files. Files already in the
+  letter-bucket layout are detected and skipped.
+- Step 1: overwrites `*_hydrated_clustered.json.zst` each run.
+- Step 2: with `--skip-existing`, submissions whose media already exists on
+  disk are not re-downloaded.
+
+## Troubleshooting
+
+| Symptom | Likely cause / fix |
+|---|---|
+| `aria2c not found` | install it (see Prerequisites) |
+| Step 0 very slow | few seeders for some files; try again later, or use `--from-dir` with a local mirror |
+| Step 1 OOMs on a big subreddit | use `--num-workers 1`; the streaming hydrator caps per-subreddit memory at only the needed IDs, not the full file — if you still OOM, file an issue |
+| Step 1 reports many missing IDs for one sub | that subreddit's Pushshift file is truncated or corrupt; re-download just that pair via `aria2c --torrent-file=... --select-file=<idx>` |
+| Step 2 dies with 429s | lower `--num-workers`, the retry logic backs off but heavy parallelism against single hosts (e.g. Imgur) can trip limits |
+| `hydration_status: source_unavailable` on several subs | those subs aren't in the Pushshift torrent snapshot — expected for a small tail of renamed/banned subreddits |

requirements-hydrate.txt

@@ -0,0 +1,5 @@
+zstandard>=0.21.0
+orjson>=3.9.0
+tqdm>=4.65.0
+requests>=2.31.0
+torf>=4.2.0

utils/files.py

@@ -0,0 +1,480 @@
+"""
+File processing utilities for Reddit data pipeline.
+
+Provides shared functions for reading/writing compressed files,
+filtering by date, and parallel processing.
+"""
+
+import os
+import zstandard
+import json
+import time
+import multiprocessing
+from typing import Callable, List, Tuple, Dict, Any
+
+
+
+
+# JSON parsing with fallback
+try:
+    import orjson
+    json_loads = orjson.loads
+    json_dumps = lambda obj: orjson.dumps(obj).decode('utf-8')
+    json_dumps_pretty = lambda obj: orjson.dumps(obj, option=orjson.OPT_INDENT_2).decode('utf-8')
+except ImportError:
+    try:
+        import ujson
+        json_loads = ujson.loads
+        json_dumps = ujson.dumps
+        json_dumps_pretty = lambda obj: ujson.dumps(obj, indent=2)
+    except ImportError:
+        json_loads = json.loads
+        json_dumps = json.dumps
+        json_dumps_pretty = lambda obj: json.dumps(obj, indent=2)
+
+
+def read_and_decode(reader, chunk_size=2**24, max_window_size=(2**29)*2, previous_chunk=None, bytes_read=0):
+    """Recursively decompress and decode chunks with error handling."""
+    chunk = reader.read(chunk_size)
+    bytes_read += chunk_size
+
+    if previous_chunk is not None:
+        chunk = previous_chunk + chunk
+
+    try:
+        return chunk.decode()
+    except UnicodeDecodeError:
+        if bytes_read > max_window_size:
+            raise UnicodeError(f"Unable to decode frame after reading {bytes_read:,} bytes")
+        return read_and_decode(reader, chunk_size, max_window_size, chunk, bytes_read)
+
+
+def process_zst_file(input_file: str, output_file: str, line_processor: Callable[[str], bool],
+                     progress_interval: int = 10_000_000, logger=None) -> Dict[str, int]:
+    """
+    Process a compressed file line by line with single output.
+
+    Args:
+        input_file: Path to input .zst file
+        output_file: Path to output .zst file
+        line_processor: Function that takes a line and returns True if it should be kept
+        progress_interval: Log progress every N lines
+        logger: Optional logger for progress messages (if None, uses print)
+
+    Returns:
+        Dictionary with processing statistics
+    """
+    def single_output_processor(line: str, processors: Dict) -> Dict[str, Any]:
+        """Simple wrapper for single output compatibility."""
+        if line_processor(line):
+            return {'matched': True, 'output_files': [output_file], 'data': line}
+        return {'matched': False}
+
+    return process_zst_file_multi(input_file, single_output_processor, {}, progress_interval, logger)
+
+
+def process_zst_file_multi(input_file: str, line_processor: Callable[[str, Dict], Dict[str, Any]],
+                          processor_state: Dict[str, Any], progress_interval: int = 10_000_000, logger=None) -> Dict[str, int]:
+    """
+    Process a compressed file line by line with multi-output support.
+
+    Args:
+        input_file: Path to input .zst file
+        line_processor: Function that takes (line, state) and returns:
+                       {'matched': bool, 'output_files': List[str], 'data': Any, 'state_updates': Dict}
+                       or {'matched': False} for skipped lines
+        processor_state: Mutable state dict passed to line_processor
+        progress_interval: Log progress every N lines
+        logger: Optional logger for progress messages (if None, uses print)
+
+    Returns:
+        Dictionary with processing statistics including per-output stats
+    """
+    stats = {
+        "lines_processed": 0,
+        "lines_matched": 0,
+        "error_lines": 0,
+        "output_stats": {}
+    }
+    start_time = time.time()
+
+    file_size = os.path.getsize(input_file)
+    msg = f"Processing {os.path.basename(input_file)} ({file_size / (1024**3):.1f} GB)"
+    if logger:
+        logger.info(msg)
+    else:
+        print(msg)
+
+    # Track open writers for multiple outputs
+    open_writers = {}
+
+    try:
+        # Open input file
+        with open(input_file, 'rb') as f:
+            reader = zstandard.ZstdDecompressor(max_window_size=2**31).stream_reader(f)
+
+            buffer = ''
+            while True:
+                chunk = read_and_decode(reader)
+                if not chunk:
+                    break
+
+                lines = (buffer + chunk).split("\n")
+
+                for line in lines[:-1]:
+                    if line.strip():
+                        stats["lines_processed"] += 1
+
+                        # Progress logging
+                        if stats["lines_processed"] % progress_interval == 0:
+                            elapsed = time.time() - start_time
+                            rate = stats["lines_processed"] / elapsed if elapsed > 0 else 0
+                            progress_msg = (f"  Progress: {stats['lines_processed']:,} lines, "
+                                          f"{stats['lines_matched']:,} matched ({rate:,.0f} lines/sec)")
+                            if logger:
+                                logger.info(progress_msg)
+                            else:
+                                print(progress_msg)
+
+                        try:
+                            result = line_processor(line.strip(), processor_state)
+
+                            if result.get('matched', False):
+                                output_files = result.get('output_files', [])
+                                data = result.get('data', line.strip())
+
+                                # Write to each specified output file
+                                for output_file in output_files:
+                                    # Lazy-open writers
+                                    if output_file not in open_writers:
+                                        ensure_directory(output_file)
+                                        file_handle = open(output_file, 'wb')
+                                        open_writers[output_file] = zstandard.ZstdCompressor(level=3, threads=4).stream_writer(file_handle)
+                                        stats["output_stats"][output_file] = 0
+
+                                    # Write data
+                                    writer = open_writers[output_file]
+                                    if isinstance(data, str):
+                                        writer.write(data.encode('utf-8'))
+                                    else:
+                                        writer.write(json_dumps(data).encode('utf-8'))
+                                    writer.write(b'\n')
+
+                                    stats["output_stats"][output_file] += 1
+
+                                # Update processor state if provided
+                                state_updates = result.get('state_updates', {})
+                                processor_state.update(state_updates)
+
+                                stats["lines_matched"] += 1
+
+                        except Exception:
+                            stats["error_lines"] += 1
+
+                buffer = lines[-1]
+
+            reader.close()
+
+        # Close all writers
+        for output_file, writer in open_writers.items():
+            writer.close()
+
+    except Exception as e:
+        # Ensure all writers are closed on error
+        for writer in open_writers.values():
+            try:
+                writer.close()
+            except:
+                pass
+        msg = f"Error processing {input_file}: {e}"
+        if logger:
+            logger.error(msg)
+        else:
+            print(msg)
+        raise
+
+    elapsed = time.time() - start_time
+    rate = stats["lines_processed"] / elapsed if elapsed > 0 else 0
+    msg = (f"Completed {os.path.basename(input_file)}: {stats['lines_processed']:,} lines, "
+           f"{stats['lines_matched']:,} matched in {elapsed:.1f}s ({rate:,.0f} lines/sec)")
+    if logger:
+        logger.info(msg)
+    else:
+        print(msg)
+
+    return stats
+
+
+def read_zst_lines(file_path: str, max_lines: int = None) -> List[str]:
+    """
+    Read lines from a compressed file.
+
+    Args:
+        file_path: Path to .zst file
+        max_lines: Maximum number of lines to read (None = all)
+
+    Returns:
+        List of lines (strings)
+    """
+    lines = []
+    lines_read = 0
+
+    with open(file_path, 'rb') as f:
+        reader = zstandard.ZstdDecompressor(max_window_size=2**31).stream_reader(f)
+
+        buffer = ''
+        while True:
+            chunk = read_and_decode(reader)
+            if not chunk:
+                break
+
+            chunk_lines = (buffer + chunk).split("\n")
+
+            for line in chunk_lines[:-1]:
+                if line.strip():
+                    lines.append(line.strip())
+                    lines_read += 1
+
+                    if max_lines and lines_read >= max_lines:
+                        reader.close()
+                        return lines
+
+            buffer = chunk_lines[-1]
+
+        reader.close()
+
+    return lines
+
+
+def write_json_file(data: Any, file_path: str, pretty: bool = False):
+    """Write data to JSON file.
+
+    Args:
+        data: Data to write
+        file_path: Path to write to
+        pretty: If True, use indentation for readability (for stats/summary files)
+                If False, use compact format (for data files like comments/submissions)
+    """
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+    with open(file_path, 'w') as f:
+        if pretty:
+            f.write(json_dumps_pretty(data))
+        else:
+            f.write(json_dumps(data))
+
+
+def read_json_file(file_path: str) -> Any:
+    """Read data from JSON file."""
+    with open(file_path, 'r') as f:
+        return json.loads(f.read())
+
+
+def get_files_in_date_range(folder: str, prefix: str, date_range: Tuple[str, str], logger=None) -> List[str]:
+    """
+    Get files in a folder that match prefix and fall within date range.
+    Searches recursively through subdirectories.
+
+    Args:
+        folder: Directory to search (searches recursively)
+        prefix: File prefix (e.g., "RC_", "RS_")
+        date_range: Tuple of (start_date, end_date) in YYYY-MM format
+        logger: Optional logger for messages (if None, uses print)
+
+    Returns:
+        List of file paths sorted by date (newest first)
+    """
+    import glob
+
+    if not os.path.exists(folder):
+        msg = f"Warning: Directory {folder} does not exist"
+        if logger:
+            logger.warning(msg)
+        else:
+            print(msg)
+        return []
+
+    start_date, end_date = date_range
+    files = []
+
+    # Search recursively for files matching pattern
+    pattern = os.path.join(folder, '**', f'{prefix}*.zst')
+
+    for file_path in glob.glob(pattern, recursive=True):
+        filename = os.path.basename(file_path)
+
+        # Skip corrupted files
+        if filename.endswith('corrupted.zst'):
+            continue
+
+        # Check if filename matches expected pattern
+        if filename.startswith(prefix) and filename.endswith('.zst'):
+            try:
+                # Extract date from filename (e.g., RC_2023-01.zst -> 2023-01)
+                date_part = filename.split('_')[1].split('.')[0]
+
+                if start_date <= date_part <= end_date:
+                    files.append(file_path)
+
+            except (IndexError, ValueError):
+                msg = f"Warning: Could not parse date from filename: {filename}"
+                if logger:
+                    logger.warning(msg)
+                else:
+                    print(msg)
+
+    # Sort by date (newest first)
+    files.sort(reverse=True)
+    msg = f"Found {len(files)} {prefix} files in date range {start_date} to {end_date}"
+    if logger:
+        logger.info(msg)
+    else:
+        print(msg)
+
+    return files
+
+
+def process_files_parallel(files: List[str], process_func: Callable, processes: int = None, logger=None) -> List[Any]:
+    """
+    Process multiple files in parallel.
+
+    Args:
+        files: List of file paths or argument tuples
+        process_func: Function to process each file
+        processes: Number of parallel processes (default: from config)
+        logger: Optional logger for messages (if None, uses print)
+
+    Returns:
+        List of results from processing
+    """
+    if processes is None:
+        from config import PROCESSES
+        processes = PROCESSES
+
+    msg = f"Processing {len(files)} files with {processes} processes"
+    if logger:
+        logger.info(msg)
+    else:
+        print(msg)
+    start_time = time.time()
+
+    with multiprocessing.Pool(processes=processes) as pool:
+        results = pool.map(process_func, files)
+
+    elapsed = time.time() - start_time
+    msg = f"Parallel processing completed in {elapsed:.1f}s"
+    if logger:
+        logger.info(msg)
+    else:
+        print(msg)
+
+    return results
+
+
+def get_file_size_gb(file_path: str) -> float:
+    """Get file size in GB."""
+    return os.path.getsize(file_path) / (1024**3)
+
+
+def write_zst_lines(file_path: str, lines: List[str], level: int = 3, threads: int = 4):
+    """
+    Write lines to a compressed file.
+
+    Args:
+        file_path: Path to output .zst file
+        lines: List of strings to write (one per line)
+        level: Compression level (1-22, default 3)
+        threads: Number of threads for compression (default 4)
+    """
+    ensure_directory(file_path)
+
+    with open(file_path, 'wb') as f:
+        compressor = zstandard.ZstdCompressor(level=level, threads=threads)
+        with compressor.stream_writer(f) as writer:
+            for line in lines:
+                writer.write(line.encode('utf-8'))
+                writer.write(b'\n')
+
+
+def write_zst_json_objects(file_path: str, objects: List[Any], level: int = 3, threads: int = 4):
+    """
+    Write JSON objects to a compressed file.
+
+    Args:
+        file_path: Path to output .zst file
+        objects: List of objects to write as JSON (one per line)
+        level: Compression level (1-22, default 3)
+        threads: Number of threads for compression (default 4)
+    """
+    ensure_directory(file_path)
+
+    with open(file_path, 'wb') as f:
+        compressor = zstandard.ZstdCompressor(level=level, threads=threads)
+        with compressor.stream_writer(f) as writer:
+            for obj in objects:
+                json_line = json_dumps(obj)
+                writer.write(json_line.encode('utf-8'))
+                writer.write(b'\n')
+
+
+def ensure_directory(file_path: str):
+    """Ensure directory exists for a file path."""
+    directory = os.path.dirname(file_path)
+    if directory:
+        os.makedirs(directory, exist_ok=True)
+
+
+def write_compressed_json(data: Any, file_path: str, level: int = 3, logger=None) -> float:
+    """
+    Write a JSON object to a compressed file.
+
+    Args:
+        data: Data to write (will be serialized to JSON)
+        file_path: Path to output .zst file
+        level: Compression level (1-22, default 3)
+        logger: Optional logger for messages
+
+    Returns:
+        Size of compressed file in MB
+    """
+    ensure_directory(file_path)
+
+    with open(file_path, 'wb') as f:
+        cctx = zstandard.ZstdCompressor(level=level)
+        with cctx.stream_writer(f) as compressor:
+            try:
+                # Try orjson/ujson first (faster)
+                json_str = json_dumps(data)
+            except (TypeError, ValueError):
+                # Fall back to standard json.dumps if orjson fails (e.g., non-string dict keys)
+                json_str = json.dumps(data)
+            compressor.write(json_str.encode('utf-8'))
+
+    size_mb = os.path.getsize(file_path) / (1024 * 1024)
+
+    if logger:
+        logger.info(f"  ✅ {file_path} ({size_mb:.1f} MB)")
+
+    return size_mb
+
+
+def read_compressed_json(file_path: str, logger=None) -> Any:
+    """
+    Read a JSON object from a compressed file.
+
+    Args:
+        file_path: Path to input .zst file
+        logger: Optional logger for messages
+
+    Returns:
+        Deserialized JSON data
+    """
+    if logger:
+        logger.info(f"  Loading {file_path}...")
+
+    with open(file_path, 'rb') as f:
+        dctx = zstandard.ZstdDecompressor()
+        with dctx.stream_reader(f) as reader:
+            data = json_loads(reader.read().decode('utf-8'))
+
+    return data

utils/logging.py

@@ -0,0 +1,159 @@
+"""
+Centralized logging utilities for Reddit mod collection pipeline.
+Simple unified logger that works for both main process and multiprocessing.
+"""
+
+import logging
+import multiprocessing
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+from utils.files import ensure_directory
+
+
+def setup_stage_logger(stage_name: str, log_level: str = "INFO", worker_identifier: str = None) -> logging.Logger:
+    """
+    Set up a unified logger for a pipeline stage that works with multiprocessing.
+    Creates stage-specific directories and separate logs for main vs worker processes.
+
+    Args:
+        stage_name: Name of the stage (e.g., "stage1_collect_mod_comments")
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
+        worker_identifier: Meaningful name for worker (e.g., "RC_2023-02", "askreddit").
+                          If provided, creates worker log; if None, creates main log.
+
+    Returns:
+        Configured logger instance that works in both main and worker processes
+    """
+    from config import PATHS
+
+    # Extract stage number from stage_name (e.g., "stage1_collect_mod_comments" -> "1")
+    stage_match = re.match(r'stage(\d+)_', stage_name)
+    stage_num = stage_match.group(1) if stage_match else "unknown"
+
+    # Create stage-specific log directory using full stage name
+    base_log_dir = Path(PATHS['logs'])
+    stage_log_dir = base_log_dir / stage_name
+    stage_log_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create timestamp for log file
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    # Simple naming for main vs worker processes
+    if worker_identifier:
+        # Use meaningful worker identifier (e.g., "RC_2023-02", "askreddit", "subreddits/askreddit")
+        log_file = stage_log_dir / f"{worker_identifier}_{timestamp}.log"
+        # Ensure parent directory exists for the log file (handles subdirectories in worker_identifier)
+        ensure_directory(str(log_file))
+    else:
+        log_file = stage_log_dir / f"main_{timestamp}.log"
+
+    # Create logger with process-safe name
+    if worker_identifier:
+        logger_name = f"{stage_name}_{worker_identifier}"
+    else:
+        logger_name = f"{stage_name}_main"
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(getattr(logging, log_level.upper()))
+
+    # Clear any existing handlers to avoid duplicates
+    logger.handlers.clear()
+
+    # Create formatters with process info
+    file_formatter = logging.Formatter(
+        '%(asctime)s - PID:%(process)d - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+
+    console_formatter = logging.Formatter(
+        'PID:%(process)d - %(levelname)s - %(message)s'
+    )
+
+    # Thread-safe file handler (multiple processes can write to same file)
+    file_handler = logging.FileHandler(log_file, encoding='utf-8')
+    file_handler.setLevel(logging.DEBUG)  # Log everything to file
+    file_handler.setFormatter(file_formatter)
+
+    # Note: Using default file handler locking for multiprocessing safety
+    logger.addHandler(file_handler)
+
+    # Console handler (for real-time feedback)
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(getattr(logging, log_level.upper()))
+    console_handler.setFormatter(console_formatter)
+    logger.addHandler(console_handler)
+
+    # Log the initialization
+    if worker_identifier:
+        logger.info(f"Worker logger initialized for {stage_name} ({worker_identifier})")
+    else:
+        logger.info(f"Main logger initialized for {stage_name}")
+    logger.info(f"Log file: {log_file}")
+
+    return logger
+
+
+def get_stage_logger(stage_num: int, stage_description: str = None, worker_identifier: str = None) -> logging.Logger:
+    """
+    Get a logger for a specific stage number.
+
+    Args:
+        stage_num: Stage number (0-9)
+        stage_description: Optional description for the stage
+        worker_identifier: Meaningful name for worker (e.g., "RC_2023-02", "askreddit").
+                          If provided, creates worker log; if None, creates main log.
+
+    Returns:
+        Configured logger instance
+    """
+    if stage_description:
+        stage_name = f"stage{stage_num}_{stage_description}"
+    else:
+        stage_name = f"stage{stage_num}"
+
+    return setup_stage_logger(stage_name, worker_identifier=worker_identifier)
+
+
+def log_stage_start(logger: logging.Logger, stage_num: int, stage_name: str):
+    """Log the start of a pipeline stage."""
+    logger.info("=" * 60)
+    logger.info(f"🚀 Stage {stage_num}: {stage_name}")
+    logger.info("=" * 60)
+
+
+def log_stage_end(logger: logging.Logger, stage_num: int, success: bool = True, elapsed_time: float = None):
+    """Log the end of a pipeline stage."""
+    status = "✅ COMPLETED" if success else "❌ FAILED"
+    time_str = f" in {elapsed_time:.1f}s" if elapsed_time else ""
+    logger.info(f"{status}: Stage {stage_num}{time_str}")
+    logger.info("=" * 60)
+
+
+def log_progress(logger: logging.Logger, current: int, total: int, item_name: str = "items"):
+    """Log progress with percentage."""
+    percentage = (current / total) * 100 if total > 0 else 0
+    logger.info(f"📊 Progress: {current:,}/{total:,} {item_name} ({percentage:.1f}%)")
+
+
+def log_stats(logger: logging.Logger, stats_dict: dict, title: str = "Statistics"):
+    """Log statistics in a formatted way."""
+    logger.info(f"📈 {title}:")
+    for key, value in stats_dict.items():
+        if isinstance(value, (int, float)):
+            logger.info(f"  {key}: {value:,}")
+        else:
+            logger.info(f"  {key}: {value}")
+
+
+def log_error_and_continue(logger: logging.Logger, error: Exception, context: str = ""):
+    """Log an error but continue processing."""
+    context_str = f" in {context}" if context else ""
+    logger.error(f"❌ Error{context_str}: {str(error)}")
+    logger.debug(f"Full traceback{context_str}:", exc_info=True)
+
+
+def log_file_operation(logger: logging.Logger, operation: str, file_path: str, success: bool = True):
+    """Log file operations (read, write, etc.)."""
+    status = "✅" if success else "❌"
+    logger.debug(f"{status} {operation}: {file_path}")

utils/media.py

@@ -0,0 +1,390 @@
+"""
+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
+
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+USER_AGENT = "reddit_research_media_collector/1.0"
+
+# Download limits
+DOWNLOAD_TIMEOUT = 15                # seconds per request
+MAX_FILE_SIZE = 50 * 1024 * 1024     # 50 MB hard cap
+REQUEST_DELAY = 0.1                  # between downloads for one submission
+
+# Domain / extension allowlists
+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',
+}
+
+
+# ---------------------------------------------------------------------------
+# URL helpers
+# ---------------------------------------------------------------------------
+
+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'
+
+
+# ---------------------------------------------------------------------------
+# Session / file download
+# ---------------------------------------------------------------------------
+
+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]}'}
+
+
+# ---------------------------------------------------------------------------
+# URL extraction (priority hierarchy)
+# ---------------------------------------------------------------------------
+
+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
+
+
+# ---------------------------------------------------------------------------
+# Top-level per-submission driver
+# ---------------------------------------------------------------------------
+
+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,
+    }

utils/pushshift_download.py

@@ -0,0 +1,292 @@
+"""
+Shared helpers for fetching the Pushshift/Arctic Shift subreddit torrent.
+
+Used by:
+  - pipeline/0_download_data.py  (full torrent → PUSHSHIFT_DATA)
+  - hydrate/0_download.py        (subset referenced by dehydrated dataset)
+
+Normalises on-disk layout to `<root>/<first-letter>/<Subreddit>_{comments,submissions}.zst`
+regardless of where the files came from (torrent native shards or a pre-existing
+local mirror), so downstream pipeline stages can look up files consistently via
+`<PUSHSHIFT_DATA>/<letter>/<sub>_comments.zst`.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Set, Tuple
+
+try:
+    import requests
+    import torf
+    from tqdm import tqdm
+except ImportError as e:
+    raise ImportError(
+        f"utils.pushshift_download requires `requests`, `torf`, and `tqdm` "
+        f"(missing: {e.name}). Install: pip install -r requirements-hydrate.txt"
+    )
+
+
+PUSHSHIFT_INFOHASH = "3e3f64dee22dc304cdd2546254ca1f8e8ae542b4"
+PUSHSHIFT_TORRENT_URL = (
+    f"https://academictorrents.com/download/{PUSHSHIFT_INFOHASH}.torrent"
+)
+
+
+# ---------------------------------------------------------------------------
+# Torrent metadata
+# ---------------------------------------------------------------------------
+
+def _decode(x):
+    """bencode values come back as bytes; normalise to str."""
+    return x.decode("utf-8", errors="replace") if isinstance(x, bytes) else x
+
+
+def fetch_torrent(url: str, dest: Path) -> None:
+    """Download .torrent metadata to `dest`."""
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    resp = requests.get(url, stream=True, timeout=60)
+    resp.raise_for_status()
+    with open(dest, "wb") as f:
+        for chunk in resp.iter_content(1 << 16):
+            f.write(chunk)
+
+
+def ensure_torrent(torrent_path: Path, fallback_url: str = PUSHSHIFT_TORRENT_URL) -> Path:
+    """Return a usable .torrent path. Fetches from `fallback_url` if missing."""
+    if torrent_path.exists() and torrent_path.stat().st_size > 0:
+        print(f"📄 Using cached torrent: {torrent_path}")
+        return torrent_path
+    print(f"📥 Fetching torrent from {fallback_url}")
+    fetch_torrent(fallback_url, torrent_path)
+    return torrent_path
+
+
+def parse_torrent(torrent_path: Path) -> List[Tuple[int, str, str]]:
+    """
+    Return [(1-based index, basename_lower, relative_path)] for every file in the torrent.
+
+    Uses raw metainfo iteration (orders of magnitude faster than torf's File tree).
+    """
+    print("   parsing torrent metadata...")
+    t = torf.Torrent.read(str(torrent_path))
+    info = t.metainfo.get("info", {})
+    files_meta = info.get("files")
+
+    out: List[Tuple[int, str, str]] = []
+
+    if files_meta is None:
+        # Single-file torrent
+        basename = _decode(info.get("name", ""))
+        if basename:
+            out.append((1, basename.lower(), basename))
+        return out
+
+    print(f"   torrent contains {len(files_meta):,} file entries")
+    for idx, f in enumerate(files_meta, start=1):
+        path_parts = f.get("path") or f.get(b"path") or []
+        if not path_parts:
+            continue
+        rel_path = "/".join(_decode(p) for p in path_parts)
+        basename_lower = _decode(path_parts[-1]).lower()
+        out.append((idx, basename_lower, rel_path))
+    return out
+
+
+def match_basenames(
+    all_files: Iterable[Tuple[int, str, str]],
+    needed: Optional[Set[str]] = None,
+) -> Tuple[Dict[str, Tuple[int, str]], Set[str]]:
+    """
+    Filter parsed torrent entries by a `needed` basename set (all lowercase).
+
+    If `needed` is None, returns every entry (full-torrent mode).
+    Returns (basename_lower -> (index, rel_path), missing-needed set).
+    """
+    matched: Dict[str, Tuple[int, str]] = {}
+    for idx, basename_lower, rel_path in all_files:
+        if needed is None or basename_lower in needed:
+            matched[basename_lower] = (idx, rel_path)
+    missing = set() if needed is None else (needed - set(matched.keys()))
+    return matched, missing
+
+
+# ---------------------------------------------------------------------------
+# aria2c driver
+# ---------------------------------------------------------------------------
+
+def check_aria2c() -> None:
+    """Abort with install instructions if aria2c isn't on PATH."""
+    if shutil.which("aria2c") is None:
+        sys.exit(
+            "aria2c not found. Install it first:\n"
+            "  conda (no root):        conda install -c conda-forge aria2\n"
+            "  Debian/Ubuntu:          sudo apt install aria2\n"
+            "  macOS:                  brew install aria2\n"
+            "  Fedora/CentOS:          sudo dnf install aria2\n"
+            "Or download the .torrent manually in any BitTorrent client that supports "
+            "file selection (qBittorrent, Transmission)."
+        )
+
+
+def run_aria2c(
+    torrent_path: Path,
+    indices: Optional[List[int]],
+    output_dir: Path,
+) -> int:
+    """
+    Invoke aria2c. Returns exit code.
+
+    If `indices` is None → download all files in the torrent.
+    Else → pass `--select-file=i,j,...` (1-based).
+    """
+    cmd = [
+        "aria2c",
+        f"--torrent-file={torrent_path}",
+        f"--dir={output_dir}",
+        "--seed-time=0",
+        "--max-connection-per-server=16",
+        "--split=16",
+        "--continue=true",
+        "--file-allocation=none",
+        "--bt-save-metadata=false",
+        "--bt-remove-unselected-file=true",
+        "--console-log-level=warn",
+        "--summary-interval=30",
+    ]
+    if indices is not None:
+        cmd.insert(2, f"--select-file=" + ",".join(str(i) for i in sorted(indices)))
+    return subprocess.run(cmd).returncode
+
+
+# ---------------------------------------------------------------------------
+# Layout: first-letter buckets
+# ---------------------------------------------------------------------------
+
+def _first_bucket_for(sub_or_basename: str) -> str:
+    """First-letter bucket for a subreddit or basename. '_' for non-alphanumeric."""
+    head = sub_or_basename.split("_", 1)[0]
+    if not head:
+        return "_"
+    c = head[0].lower()
+    return c if c.isalnum() else "_"
+
+
+def reorganize_to_letter_buckets(
+    output_dir: Path,
+    basename_to_current_path: Dict[str, str],
+    cleanup_empty_dirs: bool = True,
+) -> Dict[str, str]:
+    """
+    Move files into `<output_dir>/<first-letter>/<filename>` layout.
+    Same-filesystem renames are instantaneous. Returns updated map.
+    """
+    output_dir = Path(output_dir)
+    new_map: Dict[str, str] = {}
+    moved = already = 0
+
+    for basename_lower, current_path in basename_to_current_path.items():
+        current = Path(current_path)
+        target_dir = output_dir / _first_bucket_for(basename_lower)
+        target_dir.mkdir(exist_ok=True)
+        # Preserve original filename casing.
+        target = target_dir / current.name
+
+        try:
+            same = current.resolve() == target.resolve()
+        except FileNotFoundError:
+            same = False
+
+        if same:
+            new_map[basename_lower] = str(target)
+            already += 1
+            continue
+
+        if target.exists():
+            # Duplicate: prefer the target location, remove the stray.
+            if current.exists():
+                try:
+                    current.unlink()
+                except OSError:
+                    pass
+            new_map[basename_lower] = str(target)
+            already += 1
+            continue
+
+        try:
+            current.rename(target)
+        except OSError:
+            # Cross-filesystem fallback
+            shutil.move(str(current), str(target))
+        new_map[basename_lower] = str(target)
+        moved += 1
+
+    if cleanup_empty_dirs:
+        for entry in os.scandir(output_dir):
+            if not entry.is_dir(follow_symlinks=False):
+                continue
+            if len(entry.name) == 1:  # keep letter buckets
+                continue
+            try:
+                os.rmdir(entry.path)  # non-empty dirs raise OSError; we ignore
+            except OSError:
+                pass
+
+    print(f"   reorganized: {moved} moved, {already} already in place")
+    return new_map
+
+
+def scan_local_files(
+    source_dir: Path,
+    needed: Optional[Set[str]] = None,
+) -> Tuple[List[str], List[str], Dict[str, str]]:
+    """
+    Enumerate files in a local mirror.
+
+    Fast path: first-letter bucket layout → ~36 `os.scandir` calls.
+    Falls back to full `os.walk` if no letter buckets detected.
+
+    Returns (present_basenames, missing_basenames, basename_lower -> abs path).
+    If `needed` is None → every file found; `missing` is empty.
+    """
+    source_dir = Path(source_dir)
+    if not source_dir.exists():
+        return [], sorted(needed or []), {}
+
+    try:
+        top_dirs = [e for e in os.scandir(source_dir) if e.is_dir(follow_symlinks=False)]
+    except OSError as e:
+        raise RuntimeError(f"Cannot scan {source_dir}: {e}")
+
+    letter_buckets = [e for e in top_dirs if len(e.name) == 1]
+    basename_to_path: Dict[str, str] = {}
+
+    if letter_buckets:
+        print(f"   detected first-letter bucket layout ({len(letter_buckets)} buckets)")
+        try:
+            bucket_iter = tqdm(letter_buckets, desc="   scanning buckets", unit="bucket")
+        except Exception:
+            bucket_iter = letter_buckets
+        for bucket in bucket_iter:
+            try:
+                with os.scandir(bucket.path) as it:
+                    for entry in it:
+                        if entry.is_file(follow_symlinks=False):
+                            basename_to_path[entry.name.lower()] = entry.path
+            except OSError:
+                continue
+    else:
+        print("   no bucket layout detected; full recursive walk...")
+        for root, _, files in os.walk(source_dir):
+            for f in files:
+                basename_to_path[f.lower()] = os.path.join(root, f)
+
+    if needed is None:
+        return sorted(basename_to_path.keys()), [], basename_to_path
+
+    present = [b for b in needed if b in basename_to_path]
+    missing = [b for b in needed if b not in basename_to_path]
+    kept = {b: basename_to_path[b] for b in present}
+    return present, missing, kept