convert.py

"""Convert subreddit metadata to Parquet with explicit semantic types.

Usage: python convert.py path/to/subreddits_with_details.csv output_directory
Requires pyarrow. No Reddit requests, filtering, or metadata refresh.
"""

import csv
import hashlib
import itertools
import json
import sys
from datetime import datetime, timedelta, timezone
from decimal import Decimal
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq

EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
TIMESTAMP = pa.timestamp("us", tz="UTC")
TYPES = {
    "created_utc": TIMESTAMP,
    "retrieved_on": TIMESTAMP,
    "over18": pa.bool_(),
    "subscribers": pa.int64(),
}


def parse_cell(name, value):
    if value == "":
        return None
    if name == "created_utc":
        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
        if parsed.tzinfo is None:
            raise ValueError(f"Creation timestamp lacks timezone: {value!r}")
        return parsed.astimezone(timezone.utc)
    if name == "retrieved_on":
        micros = Decimal(value) * 1_000_000
        if not micros.is_finite() or micros != micros.to_integral_value():
            raise ValueError(f"Invalid or sub-microsecond retrieval timestamp: {value!r}")
        return EPOCH + timedelta(microseconds=int(micros))
    if name == "over18":
        if value not in ("True", "False"):
            raise ValueError(f"Unexpected boolean: {value!r}")
        return value == "True"
    if name == "subscribers":
        if not value.isascii() or not value.isdecimal():
            raise ValueError(f"Invalid subscriber count: {value!r}")
        return int(value)
    return value


def verify_cell(name, original, converted):
    """Check output against source using inverse semantic comparisons."""
    if original == "":
        return converted is None
    if converted is None:
        return False
    if name == "created_utc":
        # The source uses either minute or second precision, always UTC.
        return original in (
            converted.strftime("%Y-%m-%dT%H:%M:%SZ"),
            converted.strftime("%Y-%m-%dT%H:%MZ")
            if converted.second == converted.microsecond == 0 else "",
        ) and converted.utcoffset() == timedelta(0)
    if name == "retrieved_on":
        delta = converted - EPOCH
        micros = (delta.days * 86400 + delta.seconds) * 1_000_000 + delta.microseconds
        return Decimal(micros) / 1_000_000 == Decimal(original)
    if name == "over18":
        return type(converted) is bool and str(converted) == original
    if name == "subscribers":
        return type(converted) is int and Decimal(converted) == Decimal(original)
    return converted == original


def sha256(path):
    with path.open("rb") as stream:
        return hashlib.file_digest(stream, "sha256").hexdigest()


def convert(source, output):
    csv.field_size_limit(sys.maxsize)
    output.mkdir(parents=True, exist_ok=True)
    target = output / "data" / "data.parquet"
    target.parent.mkdir(parents=True, exist_ok=True)
    row_count = 0
    with source.open(encoding="utf-8", newline="") as stream:
        reader = csv.reader(stream, strict=True)
        columns = next(reader)
        assert len(set(columns)) == len(columns), "Duplicate source column names"
        schema = pa.schema([(name, TYPES.get(name, pa.string())) for name in columns])
        empty_counts = dict.fromkeys(columns, 0)
        with pq.ParquetWriter(target, schema, compression="zstd", write_page_index=True) as writer:
            while rows := list(itertools.islice(reader, 5000)):
                assert all(len(row) == len(columns) for row in rows), "Ragged CSV row"
                arrays = []
                for index, name in enumerate(columns):
                    values = [row[index] for row in rows]
                    empty_counts[name] += values.count("")
                    arrays.append(pa.array(
                        [parse_cell(name, value) for value in values],
                        type=schema.field(name).type,
                    ))
                writer.write_table(pa.Table.from_arrays(arrays, schema=schema))
                row_count += len(rows)

    # Independently read the original CSV again and compare every output cell.
    verified_rows = 0
    null_counts = dict.fromkeys(columns, 0)
    parquet = pq.ParquetFile(target)
    assert parquet.schema_arrow.equals(schema), "Parquet schema mismatch"
    with source.open(encoding="utf-8", newline="") as stream:
        reader = csv.reader(stream, strict=True)
        assert next(reader) == columns
        for batch in parquet.iter_batches(batch_size=5000):
            assert batch.schema.names == columns
            for name, array in zip(columns, batch.columns):
                null_counts[name] += array.null_count
            for row in zip(*(column.to_pylist() for column in batch.columns)):
                original = next(reader)
                assert all(
                    verify_cell(name, old, new)
                    for name, old, new in zip(columns, original, row)
                ), f"Mismatch at row {verified_rows}"
                verified_rows += 1
        assert next(reader, None) is None, "Source has additional rows"
    assert verified_rows == row_count
    assert null_counts == empty_counts, "Null counts differ from source empty cells"

    manifest = {
        "source": "https://www.kaggle.com/datasets/hashiromer/subreddits-directory",
        "source_filename": source.name,
        "source_bytes": source.stat().st_size,
        "source_sha256": sha256(source),
        "source_license_identifier": "reddit-api",
        "parquet_file": target.relative_to(output).as_posix(),
        "parquet_bytes": target.stat().st_size,
        "parquet_sha256": sha256(target),
        "row_count": row_count,
        "column_count": len(columns),
        "columns": columns,
        "column_types": {field.name: str(field.type) for field in schema},
        "source_empty_string_counts": empty_counts,
        "null_counts": null_counts,
        "validation": {
            "method": "Full cell-by-cell comparison: exact nonempty text, inverse semantic comparisons for typed values, empty cells mapped to null",
            "verified_rows": verified_rows,
            "all_semantic_values_match": True,
            "nonempty_text_unchanged": True,
            "null_counts_match_source_empty_cells": True,
            "row_order_preserved": True,
            "column_order_preserved": True,
        },
        "conversion": {
            "pyarrow_version": pa.__version__,
            "compression": "zstd",
            "csv_encoding": "utf-8",
            "type_inference": False,
            "empty_fields": "Only exact empty strings become null; literal null-like text is preserved",
            "created_utc": "ISO 8601 UTC to timestamp[us, tz=UTC]",
            "retrieved_on": "Unix seconds to timestamp[us, tz=UTC] using exact decimal arithmetic",
            "over18": "True/False text to boolean",
            "subscribers": "Nonnegative integer text to int64",
            "write_page_index": True,
            "metadata_refreshed": False,
        },
    }
    (output / "conversion-manifest.json").write_text(
        json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
    )
    print(json.dumps(manifest, indent=2))


if __name__ == "__main__":
    convert(Path(sys.argv[1]), Path(sys.argv[2]))