Upload append_author_to_repaired_dataset.ipynb

append_author_to_repaired_dataset.ipynb

@@ -0,0 +1,686 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Append an author dataset to the repaired multi-author dataset\n",
+        "\n",
+        "This notebook assigns globally sequential image IDs, writes the author into each JSONL record, appends the Parquet index, validates all new byte references, and submits exactly one Hugging Face commit.\n",
+        "\n",
+        "Set `SOURCE_PREFIX` and `AUTHOR_VALUE` in the configuration section before running. **The final code cell performs the upload when run.**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Install/update required packages in Colab\n",
+        "!pip -q install -U \"huggingface_hub>=0.25,<2.0\" pyarrow tqdm\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# ============================================================\n",
+        "# APPEND A NEW AUTHOR DATASET TO THE REPAIRED ROOT DATASET\n",
+        "#\n",
+        "# Repaired structure:\n",
+        "#   captions.parquet\n",
+        "#   images/part_00000.jsonl ... images/part_XXXXX.jsonl\n",
+        "#\n",
+        "# Every JSONL image record has:\n",
+        "#   idx      = GLOBAL image-record ID (not author-local)\n",
+        "#   author   = author name\n",
+        "#   image, caption, tags, plus any other source fields\n",
+        "#\n",
+        "# Every Parquet caption row has exactly:\n",
+        "#   idx, prompt, tags, author, json_file, byte_offset, byte_length\n",
+        "#\n",
+        "# One commit:\n",
+        "#   - replaces captions.parquet\n",
+        "#   - adds only new images/part_XXXXX.jsonl shards\n",
+        "#   - does not modify existing image shards\n",
+        "# ============================================================\n",
+        "\n",
+        "# Run in Google Colab after installing: huggingface_hub, pyarrow, tqdm.\n",
+        "\n",
+        "# Must be set before importing huggingface_hub.\n",
+        "import os\n",
+        "os.environ[\"HF_HUB_DISABLE_XET\"] = \"1\"\n",
+        "\n",
+        "# ============================================================\n",
+        "# 1. IMPORTS\n",
+        "# ============================================================\n",
+        "\n",
+        "import json\n",
+        "import re\n",
+        "import tempfile\n",
+        "from pathlib import Path\n",
+        "\n",
+        "import pyarrow as pa\n",
+        "import pyarrow.parquet as pq\n",
+        "from tqdm.auto import tqdm\n",
+        "from google.colab import userdata\n",
+        "\n",
+        "from huggingface_hub import (\n",
+        "    HfApi,\n",
+        "    hf_hub_download,\n",
+        "    CommitOperationAdd,\n",
+        ")\n",
+        "\n",
+        "# ============================================================\n",
+        "# 2. CONFIGURATION\n",
+        "# ============================================================\n",
+        "\n",
+        "REPO_ID = \"codeShare/adcom_captioned_ai_images\"\n",
+        "REPO_TYPE = \"dataset\"\n",
+        "BASE_REVISION = \"main\"\n",
+        "\n",
+        "#@markdown Folder in the repository containing the incoming author JSONL files\n",
+        "SOURCE_PREFIX = \"authors/new_name/\" #@param {type:\"string\"}\n",
+        "\n",
+        "#@markdown Exact author value to write into BOTH JSONL and Parquet\n",
+        "AUTHOR_VALUE = \"new_name\" #@param {type:\"string\"}\n",
+        "\n",
+        "#@markdown Target maximum shard size in MiB\n",
+        "CHUNK_SIZE_MB = 300 #@param {type:\"integer\"}\n",
+        "\n",
+        "#@markdown Number of upload threads (keep at 1)\n",
+        "UPLOAD_THREADS = 1 #@param {type:\"integer\"}\n",
+        "\n",
+        "#@markdown Stop on the first malformed source record (recommended)\n",
+        "STRICT_SOURCE_VALIDATION = True #@param {type:\"boolean\"}\n",
+        "\n",
+        "DEST_PARQUET = \"captions.parquet\"\n",
+        "DEST_IMAGE_DIR = \"images\"\n",
+        "EXPECTED_COLUMNS = [\n",
+        "    \"idx\",\n",
+        "    \"prompt\",\n",
+        "    \"tags\",\n",
+        "    \"author\",\n",
+        "    \"json_file\",\n",
+        "    \"byte_offset\",\n",
+        "    \"byte_length\",\n",
+        "]\n",
+        "\n",
+        "SOURCE_PREFIX = SOURCE_PREFIX.strip().strip(\"/\") + \"/\"\n",
+        "AUTHOR_VALUE = AUTHOR_VALUE.strip()\n",
+        "CHUNK_SIZE_BYTES = int(CHUNK_SIZE_MB) * 1024 * 1024\n",
+        "COMMIT_MESSAGE = f\"Append {AUTHOR_VALUE} captions and image shards\"\n",
+        "\n",
+        "if not SOURCE_PREFIX.startswith(\"authors/\"):\n",
+        "    raise ValueError(\"SOURCE_PREFIX must point to a folder under authors/.\")\n",
+        "if not AUTHOR_VALUE:\n",
+        "    raise ValueError(\"AUTHOR_VALUE cannot be empty.\")\n",
+        "if CHUNK_SIZE_MB < 1:\n",
+        "    raise ValueError(\"CHUNK_SIZE_MB must be at least 1.\")\n",
+        "if UPLOAD_THREADS != 1:\n",
+        "    raise ValueError(\"UPLOAD_THREADS must be exactly 1.\")\n",
+        "\n",
+        "print(\"Repository:\", REPO_ID)\n",
+        "print(\"Source folder:\", SOURCE_PREFIX)\n",
+        "print(\"Author:\", AUTHOR_VALUE)\n",
+        "print(\"Chunk target:\", CHUNK_SIZE_MB, \"MiB\")\n",
+        "print(\"Xet disabled:\", os.environ[\"HF_HUB_DISABLE_XET\"])\n",
+        "\n",
+        "# ============================================================\n",
+        "# 3. AUTHENTICATION AND REPOSITORY SNAPSHOT\n",
+        "# ============================================================\n",
+        "\n",
+        "HF_TOKEN = userdata.get(\"HF_TOKEN\")\n",
+        "if not HF_TOKEN:\n",
+        "    raise RuntimeError(\n",
+        "        \"HF_TOKEN was not found in Colab Secrets. Add a secret named HF_TOKEN.\"\n",
+        "    )\n",
+        "\n",
+        "api = HfApi(token=HF_TOKEN)\n",
+        "whoami = api.whoami()\n",
+        "print(\"Authenticated as:\", whoami.get(\"name\", \"Hugging Face user\"))\n",
+        "\n",
+        "repo_info = api.repo_info(\n",
+        "    repo_id=REPO_ID,\n",
+        "    repo_type=REPO_TYPE,\n",
+        "    revision=BASE_REVISION,\n",
+        ")\n",
+        "BASE_COMMIT = repo_info.sha\n",
+        "if not BASE_COMMIT:\n",
+        "    raise RuntimeError(\"Could not capture the starting repository commit.\")\n",
+        "\n",
+        "repo_files = api.list_repo_files(\n",
+        "    repo_id=REPO_ID,\n",
+        "    repo_type=REPO_TYPE,\n",
+        "    revision=BASE_REVISION,\n",
+        ")\n",
+        "repo_file_set = set(repo_files)\n",
+        "\n",
+        "if DEST_PARQUET not in repo_file_set:\n",
+        "    raise RuntimeError(f\"Missing root file: {DEST_PARQUET}\")\n",
+        "\n",
+        "source_shards = sorted(\n",
+        "    p for p in repo_files\n",
+        "    if p.startswith(SOURCE_PREFIX) and p.lower().endswith(\".jsonl\")\n",
+        ")\n",
+        "if not source_shards:\n",
+        "    raise RuntimeError(f\"No .jsonl source files found under {SOURCE_PREFIX}\")\n",
+        "\n",
+        "# The repaired dataset now uses root images/. Do not silently write to a\n",
+        "# different path or accidentally build on the retired images_repaired/ layout.\n",
+        "existing_image_files = sorted(\n",
+        "    p for p in repo_files\n",
+        "    if p.startswith(DEST_IMAGE_DIR + \"/\") and p.lower().endswith(\".jsonl\")\n",
+        ")\n",
+        "if not existing_image_files:\n",
+        "    raise RuntimeError(\n",
+        "        \"No existing images/*.jsonl shards found. \"\n",
+        "        \"Expected the repaired root layout under images/.\"\n",
+        "    )\n",
+        "\n",
+        "if any(p.startswith(\"images_repaired/\") for p in repo_files):\n",
+        "    print(\n",
+        "        \"WARNING: images_repaired/ still exists in the repository. \"\n",
+        "        \"This append script will use images/ only and will not modify it.\"\n",
+        "    )\n",
+        "\n",
+        "part_pattern = re.compile(r\"^images/part_(\\d+)\\.jsonl$\")\n",
+        "existing_chunk_numbers = [\n",
+        "    int(m.group(1))\n",
+        "    for p in existing_image_files\n",
+        "    for m in [part_pattern.match(p)]\n",
+        "    if m\n",
+        "]\n",
+        "if not existing_chunk_numbers:\n",
+        "    raise RuntimeError(\n",
+        "        \"Found images/*.jsonl files, but none match part_XXXXX.jsonl.\"\n",
+        "    )\n",
+        "\n",
+        "next_chunk_index = max(existing_chunk_numbers) + 1\n",
+        "\n",
+        "print(\"\\nRepository snapshot\")\n",
+        "print(\"Starting commit:\", BASE_COMMIT)\n",
+        "print(\"Existing root image shards:\", len(existing_image_files))\n",
+        "print(\"Next new shard index:\", next_chunk_index)\n",
+        "print(\"Incoming source shards:\", len(source_shards))\n",
+        "for p in source_shards:\n",
+        "    print(\"  \", p)\n",
+        "\n",
+        "# ============================================================\n",
+        "# 4. DOWNLOAD AND CHECK EXISTING PARQUET\n",
+        "# ============================================================\n",
+        "\n",
+        "existing_parquet_path = hf_hub_download(\n",
+        "    repo_id=REPO_ID,\n",
+        "    repo_type=REPO_TYPE,\n",
+        "    filename=DEST_PARQUET,\n",
+        "    revision=BASE_REVISION,\n",
+        "    token=HF_TOKEN,\n",
+        ")\n",
+        "existing_table = pq.read_table(existing_parquet_path)\n",
+        "existing_schema = existing_table.schema\n",
+        "\n",
+        "if existing_schema.names != EXPECTED_COLUMNS:\n",
+        "    raise RuntimeError(\n",
+        "        \"Unexpected captions.parquet columns.\\n\"\n",
+        "        f\"Expected: {EXPECTED_COLUMNS}\\n\"\n",
+        "        f\"Found:    {existing_schema.names}\"\n",
+        "    )\n",
+        "\n",
+        "# Validate the logical Arrow types needed by the repaired index.\n",
+        "expected_types = {\n",
+        "    \"idx\": pa.types.is_integer,\n",
+        "    \"prompt\": pa.types.is_string,\n",
+        "    \"tags\": lambda t: pa.types.is_string(t) or pa.types.is_large_string(t),\n",
+        "    \"author\": lambda t: pa.types.is_string(t) or pa.types.is_large_string(t),\n",
+        "    \"json_file\": lambda t: pa.types.is_string(t) or pa.types.is_large_string(t),\n",
+        "    \"byte_offset\": pa.types.is_integer,\n",
+        "    \"byte_length\": pa.types.is_integer,\n",
+        "}\n",
+        "for name, checker in expected_types.items():\n",
+        "    if not checker(existing_schema.field(name).type):\n",
+        "        raise RuntimeError(\n",
+        "            f\"Unexpected type for {name!r}: {existing_schema.field(name).type}\"\n",
+        "        )\n",
+        "\n",
+        "if existing_table.num_rows == 0:\n",
+        "    raise RuntimeError(\"Existing captions.parquet is unexpectedly empty.\")\n",
+        "\n",
+        "existing_idx = existing_table.column(\"idx\").to_pylist()\n",
+        "if any(v is None or int(v) < 0 for v in existing_idx):\n",
+        "    raise RuntimeError(\"Existing Parquet contains null or negative idx values.\")\n",
+        "\n",
+        "# Multiple caption rows may intentionally point to the same image idx.\n",
+        "# Therefore do NOT require idx uniqueness in captions.parquet.\n",
+        "next_global_idx = max(int(v) for v in existing_idx) + 1\n",
+        "\n",
+        "existing_prompts = set(\n",
+        "    p for p in existing_table.column(\"prompt\").to_pylist()\n",
+        "    if isinstance(p, str)\n",
+        ")\n",
+        "\n",
+        "print(\"\\nExisting Parquet rows:\", existing_table.num_rows)\n",
+        "print(\"Existing unique prompts:\", len(existing_prompts))\n",
+        "print(\"Next GLOBAL image idx:\", next_global_idx)\n",
+        "print(\"Existing schema:\")\n",
+        "print(existing_schema)\n",
+        "\n",
+        "# ============================================================\n",
+        "# 5. PREPARE OUTPUT SHARDS\n",
+        "# ============================================================\n",
+        "\n",
+        "temp_dir = Path(tempfile.mkdtemp(prefix=\"repaired_author_append_\"))\n",
+        "new_rows = []\n",
+        "new_chunk_paths = []\n",
+        "seen_prompts = set(existing_prompts)\n",
+        "\n",
+        "stats = {\n",
+        "    \"source_records\": 0,\n",
+        "    \"added_records\": 0,\n",
+        "    \"duplicate_prompts\": 0,\n",
+        "    \"invalid_records\": 0,\n",
+        "}\n",
+        "\n",
+        "current_file = None\n",
+        "current_path = None\n",
+        "current_size = 0\n",
+        "current_chunk_index = next_chunk_index\n",
+        "next_idx = next_global_idx\n",
+        "\n",
+        "def close_chunk():\n",
+        "    global current_file\n",
+        "    if current_file is not None:\n",
+        "        current_file.flush()\n",
+        "        os.fsync(current_file.fileno())\n",
+        "        current_file.close()\n",
+        "        current_file = None\n",
+        "\n",
+        "def open_chunk():\n",
+        "    global current_file, current_path, current_size, current_chunk_index\n",
+        "\n",
+        "    close_chunk()\n",
+        "    filename = f\"part_{current_chunk_index:05d}.jsonl\"\n",
+        "    current_path = temp_dir / filename\n",
+        "    current_file = open(current_path, \"wb\")\n",
+        "    current_size = 0\n",
+        "\n",
+        "    repo_path = f\"{DEST_IMAGE_DIR}/{filename}\"\n",
+        "    if repo_path in repo_file_set:\n",
+        "        raise RuntimeError(f\"Refusing to overwrite existing shard: {repo_path}\")\n",
+        "\n",
+        "    new_chunk_paths.append({\n",
+        "        \"repo_path\": repo_path,\n",
+        "        \"local_path\": current_path,\n",
+        "    })\n",
+        "    current_chunk_index += 1\n",
+        "\n",
+        "# ============================================================\n",
+        "# 6. READ SOURCE RECORDS, REPAIR IDS/AUTHOR, WRITE NEW JSONL\n",
+        "# ============================================================\n",
+        "\n",
+        "try:\n",
+        "    for source_path in tqdm(source_shards, desc=\"Source shards\"):\n",
+        "        local_source = hf_hub_download(\n",
+        "            repo_id=REPO_ID,\n",
+        "            repo_type=REPO_TYPE,\n",
+        "            filename=source_path,\n",
+        "            revision=BASE_REVISION,\n",
+        "            token=HF_TOKEN,\n",
+        "        )\n",
+        "\n",
+        "        with open(local_source, \"rb\") as source_file:\n",
+        "            for line_number, raw_line in enumerate(source_file, start=1):\n",
+        "                if not raw_line.strip():\n",
+        "                    continue\n",
+        "\n",
+        "                stats[\"source_records\"] += 1\n",
+        "                raw_payload = raw_line.rstrip(b\"\\r\\n\")\n",
+        "\n",
+        "                try:\n",
+        "                    record = json.loads(raw_payload.decode(\"utf-8\"))\n",
+        "                    if not isinstance(record, dict):\n",
+        "                        raise ValueError(\"JSONL value is not an object.\")\n",
+        "\n",
+        "                    required = (\"idx\", \"image\", \"caption\", \"tags\")\n",
+        "                    missing = [k for k in required if k not in record]\n",
+        "                    if missing:\n",
+        "                        raise ValueError(f\"Missing required fields: {missing}\")\n",
+        "\n",
+        "                    # The incoming idx is author-local/legacy metadata.\n",
+        "                    # Validate it, but NEVER reuse it in the repaired dataset.\n",
+        "                    source_idx = record[\"idx\"]\n",
+        "                    if isinstance(source_idx, bool):\n",
+        "                        raise ValueError(\"Source idx cannot be boolean.\")\n",
+        "                    int(source_idx)\n",
+        "\n",
+        "                    if not isinstance(record[\"caption\"], str):\n",
+        "                        raise ValueError(\"caption must be a string.\")\n",
+        "                    prompt = record[\"caption\"]\n",
+        "                    if not prompt.strip():\n",
+        "                        raise ValueError(\"caption is empty or whitespace-only.\")\n",
+        "\n",
+        "                    if not isinstance(record[\"image\"], str) or not record[\"image\"].strip():\n",
+        "                        raise ValueError(\"image must be a non-empty string.\")\n",
+        "\n",
+        "                    if prompt in seen_prompts:\n",
+        "                        stats[\"duplicate_prompts\"] += 1\n",
+        "                        continue\n",
+        "\n",
+        "                    # Apply repaired structure: globally sequential idx and\n",
+        "                    # explicit author field inside every JSONL record.\n",
+        "                    output_record = dict(record)\n",
+        "                    output_record[\"idx\"] = next_idx\n",
+        "                    output_record[\"author\"] = AUTHOR_VALUE\n",
+        "\n",
+        "                    # Compact UTF-8 JSON. The byte offsets below refer to\n",
+        "                    # these exact serialized bytes, not the source line.\n",
+        "                    output_bytes = json.dumps(\n",
+        "                        output_record,\n",
+        "                        ensure_ascii=False,\n",
+        "                        separators=(\",\", \":\"),\n",
+        "                        allow_nan=False,\n",
+        "                    ).encode(\"utf-8\")\n",
+        "                    line_bytes = output_bytes + b\"\\n\"\n",
+        "\n",
+        "                    if current_file is None:\n",
+        "                        open_chunk()\n",
+        "                    elif current_size > 0 and current_size + len(line_bytes) > CHUNK_SIZE_BYTES:\n",
+        "                        open_chunk()\n",
+        "\n",
+        "                    byte_offset = current_size\n",
+        "                    current_file.write(line_bytes)\n",
+        "                    current_size += len(line_bytes)\n",
+        "                    byte_length = len(output_bytes)\n",
+        "\n",
+        "                    tags_value = record[\"tags\"]\n",
+        "                    parquet_tags = None if tags_value is None else str(tags_value)\n",
+        "\n",
+        "                    new_rows.append({\n",
+        "                        \"idx\": next_idx,\n",
+        "                        \"prompt\": prompt,\n",
+        "                        \"tags\": parquet_tags,\n",
+        "                        \"author\": AUTHOR_VALUE,\n",
+        "                        \"json_file\": f\"{DEST_IMAGE_DIR}/{current_path.name}\",\n",
+        "                        \"byte_offset\": int(byte_offset),\n",
+        "                        \"byte_length\": int(byte_length),\n",
+        "                    })\n",
+        "\n",
+        "                    seen_prompts.add(prompt)\n",
+        "                    next_idx += 1\n",
+        "                    stats[\"added_records\"] += 1\n",
+        "\n",
+        "                except Exception as exc:\n",
+        "                    stats[\"invalid_records\"] += 1\n",
+        "                    message = (\n",
+        "                        f\"Invalid source record at {source_path}, \"\n",
+        "                        f\"line {line_number}: {exc}\"\n",
+        "                    )\n",
+        "                    if STRICT_SOURCE_VALIDATION:\n",
+        "                        raise RuntimeError(message) from exc\n",
+        "                    print(\"SKIPPED:\", message)\n",
+        "\n",
+        "finally:\n",
+        "    close_chunk()\n",
+        "\n",
+        "print(\"\\nPreprocessing summary\")\n",
+        "for key, value in stats.items():\n",
+        "    print(f\"{key}: {value}\")\n",
+        "print(\"New JSONL shards:\", len(new_chunk_paths))\n",
+        "\n",
+        "if stats[\"added_records\"] == 0:\n",
+        "    raise RuntimeError(\n",
+        "        \"No new records were appended. No commit was created.\"\n",
+        "    )\n",
+        "\n",
+        "if stats[\"invalid_records\"] and STRICT_SOURCE_VALIDATION:\n",
+        "    raise RuntimeError(\"Invalid source records found; refusing to commit.\")\n",
+        "\n",
+        "# ============================================================\n",
+        "# 7. BUILD UPDATED PARQUET USING THE EXISTING SCHEMA\n",
+        "# ============================================================\n",
+        "\n",
+        "new_table = pa.Table.from_pylist(new_rows, schema=existing_schema)\n",
+        "updated_table = pa.concat_tables([existing_table, new_table])\n",
+        "\n",
+        "updated_parquet_path = temp_dir / DEST_PARQUET\n",
+        "pq.write_table(\n",
+        "    updated_table,\n",
+        "    updated_parquet_path,\n",
+        "    compression=\"zstd\",\n",
+        ")\n",
+        "\n",
+        "# Re-open the actual file that will be uploaded.\n",
+        "check_table = pq.read_table(updated_parquet_path)\n",
+        "\n",
+        "if check_table.schema.names != EXPECTED_COLUMNS:\n",
+        "    raise RuntimeError(\"Written Parquet has incorrect columns.\")\n",
+        "if not check_table.schema.equals(existing_schema, check_metadata=False):\n",
+        "    raise RuntimeError(\n",
+        "        \"Written Parquet schema/types differ from the existing schema.\"\n",
+        "    )\n",
+        "if check_table.num_rows != existing_table.num_rows + len(new_rows):\n",
+        "    raise RuntimeError(\"Written Parquet row count is incorrect.\")\n",
+        "\n",
+        "# Ensure the old rows are byte-for-byte/logically preserved in order.\n",
+        "if not check_table.slice(0, existing_table.num_rows).equals(existing_table):\n",
+        "    raise RuntimeError(\"Existing Parquet rows were changed.\")\n",
+        "\n",
+        "# Ensure all newly added prompts are unique and absent from old data.\n",
+        "new_prompts = [r[\"prompt\"] for r in new_rows]\n",
+        "if len(new_prompts) != len(set(new_prompts)):\n",
+        "    raise RuntimeError(\"Duplicate prompts exist among the new rows.\")\n",
+        "if not set(new_prompts).isdisjoint(existing_prompts):\n",
+        "    raise RuntimeError(\"A new prompt duplicates an existing prompt.\")\n",
+        "\n",
+        "# Global IDs must be sequential for the newly appended image records.\n",
+        "new_ids = [int(r[\"idx\"]) for r in new_rows]\n",
+        "expected_new_ids = list(range(next_global_idx, next_global_idx + len(new_rows)))\n",
+        "if new_ids != expected_new_ids:\n",
+        "    raise RuntimeError(\"New global idx values are not sequential.\")\n",
+        "\n",
+        "# ============================================================\n",
+        "# 8. VALIDATE EVERY NEW JSONL FILE AND PARQUET BYTE REFERENCE\n",
+        "# ============================================================\n",
+        "\n",
+        "chunk_local = {}\n",
+        "chunk_sizes = {}\n",
+        "\n",
+        "for item in new_chunk_paths:\n",
+        "    path = Path(item[\"local_path\"])\n",
+        "    if not path.is_file() or path.stat().st_size == 0:\n",
+        "        raise RuntimeError(f\"Missing or empty output shard: {path}\")\n",
+        "    chunk_local[item[\"repo_path\"]] = path\n",
+        "    chunk_sizes[item[\"repo_path\"]] = path.stat().st_size\n",
+        "\n",
+        "# Parse every output JSONL line, not merely the records referenced below.\n",
+        "for repo_path, local_path in chunk_local.items():\n",
+        "    with open(local_path, \"rb\") as f:\n",
+        "        for line_no, line in enumerate(f, start=1):\n",
+        "            if not line.endswith(b\"\\n\"):\n",
+        "                raise RuntimeError(f\"Missing final newline: {repo_path}:{line_no}\")\n",
+        "            payload = line[:-1]\n",
+        "            if not payload:\n",
+        "                raise RuntimeError(f\"Blank JSONL line: {repo_path}:{line_no}\")\n",
+        "            try:\n",
+        "                parsed = json.loads(payload.decode(\"utf-8\"))\n",
+        "            except Exception as exc:\n",
+        "                raise RuntimeError(\n",
+        "                    f\"Invalid output JSON: {repo_path}:{line_no}: {exc}\"\n",
+        "                ) from exc\n",
+        "            if not isinstance(parsed, dict):\n",
+        "                raise RuntimeError(f\"Output record is not an object: {repo_path}:{line_no}\")\n",
+        "            if parsed.get(\"author\") != AUTHOR_VALUE:\n",
+        "                raise RuntimeError(f\"JSONL author mismatch: {repo_path}:{line_no}\")\n",
+        "\n",
+        "print(\"\\nValidating Parquet -> JSONL byte references...\")\n",
+        "validated = 0\n",
+        "\n",
+        "for row in tqdm(new_rows, desc=\"Byte-reference validation\"):\n",
+        "    repo_path = row[\"json_file\"]\n",
+        "    if repo_path not in chunk_local:\n",
+        "        raise RuntimeError(f\"Parquet points to an unknown new shard: {repo_path}\")\n",
+        "\n",
+        "    offset = int(row[\"byte_offset\"])\n",
+        "    length = int(row[\"byte_length\"])\n",
+        "    size = chunk_sizes[repo_path]\n",
+        "\n",
+        "    if offset < 0 or length <= 0 or offset + length >= size + 1:\n",
+        "        raise RuntimeError(\n",
+        "            f\"Out-of-range byte reference: {repo_path}, \"\n",
+        "            f\"offset={offset}, length={length}, size={size}\"\n",
+        "        )\n",
+        "\n",
+        "    with open(chunk_local[repo_path], \"rb\") as f:\n",
+        "        f.seek(offset)\n",
+        "        payload = f.read(length)\n",
+        "        newline = f.read(1)\n",
+        "\n",
+        "    if len(payload) != length:\n",
+        "        raise RuntimeError(f\"Short read at {repo_path}, offset {offset}.\")\n",
+        "    if newline != b\"\\n\":\n",
+        "        raise RuntimeError(f\"Missing newline at {repo_path}, offset {offset}.\")\n",
+        "\n",
+        "    parsed = json.loads(payload.decode(\"utf-8\"))\n",
+        "\n",
+        "    if int(parsed.get(\"idx\", -1)) != int(row[\"idx\"]):\n",
+        "        raise RuntimeError(f\"idx mismatch at {repo_path}, offset {offset}.\")\n",
+        "    if parsed.get(\"author\") != row[\"author\"]:\n",
+        "        raise RuntimeError(f\"author mismatch at {repo_path}, offset {offset}.\")\n",
+        "    if parsed.get(\"caption\") != row[\"prompt\"]:\n",
+        "        raise RuntimeError(f\"prompt/caption mismatch at {repo_path}, offset {offset}.\")\n",
+        "\n",
+        "    expected_tags = None if parsed.get(\"tags\") is None else str(parsed.get(\"tags\"))\n",
+        "    if expected_tags != row[\"tags\"]:\n",
+        "        raise RuntimeError(f\"tags mismatch at {repo_path}, offset {offset}.\")\n",
+        "\n",
+        "    validated += 1\n",
+        "\n",
+        "if validated != len(new_rows):\n",
+        "    raise RuntimeError(\"Not all newly appended Parquet references were validated.\")\n",
+        "\n",
+        "# Check that all upload targets are unique and no image target already exists.\n",
+        "upload_paths = [DEST_PARQUET] + [x[\"repo_path\"] for x in new_chunk_paths]\n",
+        "if len(upload_paths) != len(set(upload_paths)):\n",
+        "    raise RuntimeError(\"Duplicate paths in commit manifest.\")\n",
+        "\n",
+        "collisions = set(x[\"repo_path\"] for x in new_chunk_paths) & repo_file_set\n",
+        "if collisions:\n",
+        "    raise RuntimeError(f\"Refusing to overwrite existing image shards: {sorted(collisions)}\")\n",
+        "\n",
+        "# Verify the prepared upload files.\n",
+        "upload_local_paths = [updated_parquet_path] + [\n",
+        "    Path(x[\"local_path\"]) for x in new_chunk_paths\n",
+        "]\n",
+        "for path in upload_local_paths:\n",
+        "    if not path.is_file() or path.stat().st_size <= 0:\n",
+        "        raise RuntimeError(f\"Missing or empty upload file: {path}\")\n",
+        "\n",
+        "print(\"\\nPRE-UPLOAD VALIDATION PASSED\")\n",
+        "print(\"Existing Parquet rows preserved:\", existing_table.num_rows)\n",
+        "print(\"New Parquet rows:\", len(new_rows))\n",
+        "print(\"Updated Parquet rows:\", check_table.num_rows)\n",
+        "print(\"New global idx range:\", new_ids[0], \"to\", new_ids[-1])\n",
+        "print(\"New JSONL shards:\", len(new_chunk_paths))\n",
+        "print(\"JSONL byte references validated:\", validated)\n",
+        "print(\"Parquet columns/types preserved:\", True)\n",
+        "\n",
+        "# ============================================================\n",
+        "# 9. BUILD EXACTLY ONE COMMIT\n",
+        "# ============================================================\n",
+        "\n",
+        "operations = [\n",
+        "    CommitOperationAdd(\n",
+        "        path_in_repo=DEST_PARQUET,\n",
+        "        path_or_fileobj=str(updated_parquet_path),\n",
+        "    )\n",
+        "]\n",
+        "\n",
+        "for item in new_chunk_paths:\n",
+        "    operations.append(\n",
+        "        CommitOperationAdd(\n",
+        "            path_in_repo=item[\"repo_path\"],\n",
+        "            path_or_fileobj=str(item[\"local_path\"]),\n",
+        "        )\n",
+        "    )\n",
+        "\n",
+        "print(\"\\nCommit manifest\")\n",
+        "for op in operations:\n",
+        "    print(\"ADD/REPLACE:\", op.path_in_repo)\n",
+        "print(\"Total operations:\", len(operations))\n",
+        "print(\"Parent commit:\", BASE_COMMIT)\n",
+        "print(\"Commit message:\", COMMIT_MESSAGE)\n",
+        "\n",
+        "# Last-moment optimistic concurrency check.\n",
+        "latest_info = api.repo_info(\n",
+        "    repo_id=REPO_ID,\n",
+        "    repo_type=REPO_TYPE,\n",
+        "    revision=BASE_REVISION,\n",
+        ")\n",
+        "if latest_info.sha != BASE_COMMIT:\n",
+        "    raise RuntimeError(\n",
+        "        \"Repository changed while the append was being prepared. \"\n",
+        "        \"Nothing was committed. Re-run from the new repository revision.\"\n",
+        "    )\n",
+        "\n",
+        "# One create_commit call. No automatic retry.\n",
+        "print(\"\\nUploading one commit...\")\n",
+        "try:\n",
+        "    result = api.create_commit(\n",
+        "        repo_id=REPO_ID,\n",
+        "        repo_type=REPO_TYPE,\n",
+        "        revision=BASE_REVISION,\n",
+        "        parent_commit=BASE_COMMIT,\n",
+        "        operations=operations,\n",
+        "        commit_message=COMMIT_MESSAGE,\n",
+        "        num_threads=UPLOAD_THREADS,\n",
+        "    )\n",
+        "    print(\"\\nSUCCESS: one commit created.\")\n",
+        "    print(\"Commit URL:\", getattr(result, \"commit_url\", result))\n",
+        "    print(\"Author:\", AUTHOR_VALUE)\n",
+        "    print(\"Added caption rows:\", len(new_rows))\n",
+        "    print(\"New JSONL shards:\", len(new_chunk_paths))\n",
+        "    print(\"Final Parquet rows:\", check_table.num_rows)\n",
+        "\n",
+        "except Exception as upload_error:\n",
+        "    print(\"\\nUPLOAD ERROR:\", type(upload_error).__name__, str(upload_error))\n",
+        "    print(\"Checking repository state; do not blindly retry...\")\n",
+        "    try:\n",
+        "        current_info = api.repo_info(\n",
+        "            repo_id=REPO_ID,\n",
+        "            repo_type=REPO_TYPE,\n",
+        "            revision=BASE_REVISION,\n",
+        "        )\n",
+        "        if current_info.sha == BASE_COMMIT:\n",
+        "            print(\"Repository revision is unchanged; commit was not finalized on this branch.\")\n",
+        "        else:\n",
+        "            print(\"Repository revision changed.\")\n",
+        "            print(\"Original:\", BASE_COMMIT)\n",
+        "            print(\"Current:\", current_info.sha)\n",
+        "            print(\"Inspect commit history and files before doing anything else.\")\n",
+        "    except Exception as check_error:\n",
+        "        print(\"Could not verify repository state:\", repr(check_error))\n",
+        "        print(\"Inspect the Hugging Face commit history before retrying.\")\n",
+        "    raise\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "name": "append_author_to_repaired_dataset.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}