Update TableTex annotations, source metadata, rendering script, and dataset card

.gitattributes

@@ -1,61 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
 sft_train.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -5,6 +5,8 @@ language:
 license: other
 tags:
 - image
+- latex
+- table
 task_categories:
 - image-to-text
 size_categories:
@@ -28,75 +30,86 @@ configs:
 
 ## Dataset Summary
 
-TableTex is a dataset for **table image-to-LaTeX generation**. It contains 19,000 pairs of table images and renderable LaTeX table code collected from scientific articles on arXiv.
+TableTex is a dataset for **table image-to-LaTeX generation**, comprising
+19,000 renderable LaTeX table annotations extracted from scientific articles
+on arXiv. Each annotation corresponds to a table image that can be generated
+locally using the provided `generate_images.py` script. The rendered images
+are not included in the repository, which keeps the distributed dataset
+compact while providing a reproducible image-generation pipeline.
 
-To support complete table generation, each LaTeX sample includes the necessary package declarations for compilation, the table caption, and the table body that preserves the structure, content, and visual formatting of the original table. The source articles span six arXiv subject categories: Computer Science, Mathematics, Economics, Electrical Engineering and Systems Science, Quantitative Finance, and Statistics, covering publications from 2012 to 2025.
+To support complete and compilable table generation, each annotation is
+provided as a standalone LaTeX document containing the required package
+declarations, table caption, and table body. The annotations preserve the
+structure, content, and visual formatting of the source tables.
+
+The source articles cover publications from 2012 to 2025 across six arXiv
+subject categories: Computer Science (`cs`), Mathematics (`math`), Economics
+(`econ`), Electrical Engineering and Systems Science (`eess`), Quantitative
+Finance (`q-fin`), and Statistics (`stat`). Each sample also includes
+source-level attribution, license, and modification metadata.
 
 TableTex is introduced in:
 
 - **CSPO: Alleviating Reward Ambiguity for Structured Table-to-LaTeX Generation**
-- Paper: https://arxiv.org/pdf/2604.10918
+- Paper: https://arxiv.org/abs/2604.10918
 - Code: https://github.com/microsoft/CSPO
 
-For more details, please see the full data card in the GitHub repository: https://github.com/microsoft/CSPO/blob/main/TableTex_Data_Card.md
+For additional details, see the
+[TableTex data card](https://github.com/microsoft/CSPO/blob/main/TableTex_Data_Card.md)
+in the CSPO repository.
 
 ## Dataset Structure
 
-TableTex consists of paired table images and renderable LaTeX table code for table image-to-LaTeX generation. The annotations are provided in three files corresponding to the training and evaluation stages used in the CSPO paper:
-
-- `sft_train.json`: 10,000 samples for supervised fine-tuning
-- `cspo_train.jsonl`: 5,000 samples for reinforcement learning with CSPO
-- `test.jsonl`: 4,000 samples for evaluation
+| Configuration | File | Split | Samples | Purpose |
+| --- | --- | --- | ---: | --- |
+| `sft` | `sft_train.json` | train | 10,000 | Supervised fine-tuning |
+| `cspo` | `cspo_train.jsonl` | train | 5,000 | Reinforcement-learning post-training |
+| `evaluation` | `test.jsonl` | test | 4,000 | Evaluation |
+| **Total** |  |  | **19,000** |  |
 
-The corresponding table images are provided as compressed subject-specific archives. After extraction, the images are organized under six `{subject}/image` directories:
+The distributed files are:
 
 ```text
 tabletex/
-├── README.md
-├── sft_train.json                    # SFT annotations
-├── cspo_train.jsonl                  # CSPO/RL annotations
-├── test.jsonl                        # evaluation annotations
-├── cs/
-│   └── image/
-├── econ/
-│   └── image/
-├── eess/
-│   └── image/
-├── math/
-│   └── image/
-├── q-fin/
-│   └── image/
-└── stat/
-    └── image/
+|-- README.md
+|-- generate_images.py
+|-- sft_train.json
+|-- cspo_train.jsonl
+`-- test.jsonl
 ```
 
-### Extracting Image Archives
-
-The table images are distributed as compressed `.tar.gz` archives to reduce upload and download overhead.
-
-To extract the image folders, run:
+After image generation, PNG files are stored in subject-specific directories,
+and the standalone LaTeX files used for compilation are retained under `tex/`:
 
-```bash
-tar -xzf cs.tar.gz
-tar -xzf econ.tar.gz
-tar -xzf eess.tar.gz
-tar -xzf math.tar.gz
-tar -xzf q-fin.tar.gz
-tar -xzf stat.tar.gz
+```text
+tabletex/
+|-- tex/
+|   |-- cs/image/
+|   |-- econ/image/
+|   |-- eess/image/
+|   |-- math/image/
+|   |-- q-fin/image/
+|   `-- stat/image/
+|-- cs/image/
+|-- econ/image/
+|-- eess/image/
+|-- math/image/
+|-- q-fin/image/
+`-- stat/image/
 ```
 
-After extraction, the dataset directory structure will match the layout illustrated above.
+All image paths in the annotations are relative to the dataset root. Examples:
 
-Image paths referenced in the annotation files are relative to the dataset root. For example:
-
-- `eess/image/2010.13713v2_tex_table3.png`
-- `stat/image/2501.02454v2_tex_table8.png`
+```text
+eess/image/2010.13713v2_tex_table3.png
+stat/image/2501.02454v2_tex_table8.png
+```
 
 ## Data Instances
 
-### `sft` configuration
+### SFT configuration
 
-Each example is stored in a chat-style multimodal format for supervised fine-tuning.
+`sft_train.json` stores samples in a multimodal conversation format:
 
 ```json
 {
@@ -107,76 +120,193 @@ Each example is stored in a chat-style multimodal format for supervised fine-tun
     },
     {
       "role": "assistant",
-      "content": "[LaTeX code here]"
+      "content": "```latex\n\\documentclass{article}\n...\n```"
     }
   ],
   "images": [
     "eess/image/2010.13713v2_tex_table3.png"
-  ]
+  ],
+  "source": {
+    "title": "Self-supervised Human Activity Recognition by Learning to Predict Cross-Dimensional Motion",
+    "authors": [
+      "Setareh Rahimi Taghanaki",
+      "Michael Rainbow",
+      "Ali Etemad"
+    ],
+    "url": "https://arxiv.org/abs/2010.13713v2",
+    "attribution": "\"Self-supervised Human Activity Recognition by Learning to Predict Cross-Dimensional Motion\" by Setareh Rahimi Taghanaki, Michael Rainbow, and Ali Etemad, arXiv:2010.13713v2, licensed under CC BY-SA 4.0. The table was extracted, wrapped as standalone LaTeX, rendered, and cropped by TableTex.",
+    "license": {
+      "name": "CC BY-SA 4.0",
+      "url": "https://creativecommons.org/licenses/by-sa/4.0/"
+    },
+    "modifications": [
+      "Extracted the table LaTeX from the article source.",
+      "Wrapped it as a standalone LaTeX document.",
+      "Rendered and cropped it into a PNG image."
+    ]
+  }
 }
 ```
 
-### `cspo` and `evaluation` configurations
+Fields:
+
+- `messages`: multimodal prompt and target LaTeX response.
+- `images`: list containing the relative output path of the table image.
+- `source`: source and rights metadata for the sample.
+
+### CSPO and evaluation configurations
 
-Each example contains a table image path, the subject category of the source article, and the corresponding LaTeX table code.
+`cspo_train.jsonl` and `test.jsonl` store one JSON object per line:
 
 ```json
 {
   "image_path": "stat/image/2501.02454v2_tex_table8.png",
   "subject": "stat",
-  "tex_code": "\\documentclass{article}\n..."
+  "tex_code": "\\documentclass{article}\n...",
+  "source": {
+    "title": "Finite-Sample Valid Randomization Tests for Monotone Spillover Effects",
+    "authors": [
+      "Shunzhuang Huang",
+      "Xinran Li",
+      "Panos Toulis"
+    ],
+    "url": "https://arxiv.org/abs/2501.02454v2",
+    "attribution": "\"Finite-Sample Valid Randomization Tests for Monotone Spillover Effects\" by Shunzhuang Huang, Xinran Li, and Panos Toulis, arXiv:2501.02454v2, licensed under CC BY-SA 4.0. The table was extracted, wrapped as standalone LaTeX, rendered, and cropped by TableTex.",
+    "license": {
+      "name": "CC BY-SA 4.0",
+      "url": "https://creativecommons.org/licenses/by-sa/4.0/"
+    },
+    "modifications": [
+      "Extracted the table LaTeX from the article source.",
+      "Wrapped it as a standalone LaTeX document.",
+      "Rendered and cropped it into a PNG image."
+    ]
+  }
 }
 ```
 
-## Data Fields
+Fields:
+
+- `image_path`: relative output path of the table image.
+- `subject`: arXiv subject category.
+- `tex_code`: standalone LaTeX code corresponding to the image.
+- `source`: source and rights metadata for the sample.
+
+### Source metadata
+
+Every sample includes:
 
-### `sft`
+- `source.title`: complete title of the source article.
+- `source.authors`: authors of the source article.
+- `source.url`: version-specific arXiv abstract URL.
+- `source.attribution`: attribution statement for the sample.
+- `source.license.name`: exact source-license name.
+- `source.license.url`: URL of the source license.
+- `source.modifications`: transformations performed by TableTex.
 
-- `messages`: conversation-style multimodal input and output used for supervised fine-tuning
-- `images`: relative path to the input table image
+## Generating the Images
 
-### `cspo` and `evaluation`
+### 1. Install Dependencies
 
-- `image_path`: relative path to the input table image
-- `subject`: arXiv subject category of the source article
-- `tex_code`: renderable LaTeX code corresponding to the table image
+TableTex image generation requires:
 
-The subject categories are:
+- Python 3.10 or later
+- `tqdm`
+- TeX Live providing `pdflatex` and `pdfcrop`
+- Poppler providing `pdftoppm`
 
-- `cs`
-- `econ`
-- `eess`
-- `math`
-- `q-fin`
-- `stat`
+Install the Python dependency with:
+
+```bash
+pip install tqdm
+```
+
+Install TeX Live using the official resources:
+
+- **TeX Live:** [Official Website](https://tug.org/texlive/)
+- **Installation Guide:** [TeX Live Documentation](https://tug.org/texlive/doc.html)
+
+We recommend installing the full TeX Live distribution to ensure that all
+LaTeX packages used by the dataset are available.
+
+On Ubuntu/Debian systems, also install the following system dependencies:
+
+```bash
+sudo apt-get update
+sudo apt-get install -y ghostscript poppler-utils
+```
+
+### 2. Run the Script
+
+Run the following commands from the dataset root:
+
+```bash
+python generate_images.py sft_train.json
+python generate_images.py cspo_train.jsonl
+python generate_images.py test.jsonl
+```
+
+The default behavior is to process every record. To process only the first 20
+records:
+
+```bash
+python generate_images.py test.jsonl --limit 20
+```
+
+To use a different output root:
+
+```bash
+python generate_images.py test.jsonl --output-root ./rendered
+```
+
+### 3. Output Files
+
+By default, generated PNG images are written directly to:
+
+```text
+<dataset-root>/<subject>/image/<filename>.png
+```
+
+The standalone LaTeX files used for compilation are written to:
+
+```text
+<dataset-root>/tex/<subject>/image/<filename>.tex
+```
 
 ## Dataset Creation
 
-TableTex was constructed from scientific articles collected from arXiv. Renderable table code was extracted directly from LaTeX source files, and each extracted LaTeX snippet was rendered into a table image, producing paired table image–LaTeX code samples.
+TableTex was constructed from LaTeX sources of scientific articles on arXiv.
+For each sample, the table LaTeX was extracted from an article, wrapped as a
+standalone document, and associated with version-specific source and licensing
+metadata. Images can be generated using the included rendering script.
 
-The collected articles span six arXiv subject categories and cover publications from 2012 to 2025. The source materials were restricted to papers released under the following license families:
+The source articles cover publications from 2012 to 2025 and were selected from
+the following Creative Commons license families:
 
 - CC BY
 - CC BY-SA
 - CC0
 - CC BY-NC
 
-## Split Information
-
-| Configuration | Split | Number of Samples |
-| --- | --- | ---: |
-| `sft` | train | 10,000 |
-| `cspo` | train | 5,000 |
-| `evaluation` | test | 4,000 |
-| **Total** |  | **19,000** |
+The exact license applicable to each sample is recorded in its `source.license`
+object.
 
 ## Intended Use
 
 TableTex is intended for research on table image-to-LaTeX generation, including supervised fine-tuning, reinforcement-learning-based post-training, and evaluation of models that reconstruct tables from images as LaTeX code.
 
-## License
+## Copyright, Attribution, and Licensing
+
+TableTex contains samples derived from arXiv articles released under CC BY,
+CC BY-SA, CC0, or CC BY-NC licenses. Copyright remains with the respective
+authors and/or other rightsholders. The applicable license, attribution, and
+modification information for each sample is recorded in its `source` metadata.
 
-TableTex contains samples derived from arXiv articles released under CC BY, CC BY-SA, CC0, and CC BY-NC licenses. Users are responsible for complying with the original license terms of the source materials when using or redistributing the dataset.
+Users are responsible for complying with the applicable source license when
+using, adapting, or redistributing the LaTeX annotations or generated images,
+including any attribution, share-alike, and non-commercial requirements where
+applicable. Rendering an image locally does not alter the copyright or license
+terms of the source material.
 
 ## Citation
 
@@ -189,4 +319,4 @@ If you use TableTex in your work, please cite:
   journal={arXiv preprint arXiv:2604.10918},
   year={2026}
 }
-```
+```

generate_images.py

@@ -0,0 +1,425 @@
+"""Recompile LaTeX annotations from a dataset file into table images.
+
+Usage examples:
+
+    python generate_images.py test_with.jsonl
+    python generate_images.py cspo_train.jsonl --limit 0
+    python generate_images.py sft_train.json --limit 0
+
+The generated files follow the annotation paths directly under ``tabletex``:
+
+    <subject>/image/<arxiv_id>_tex_table<n>.png
+
+The corresponding LaTeX sources are kept under:
+
+    tex/<subject>/image/<arxiv_id>_tex_table<n>.tex
+
+The LaTeX/PDF/PNG conversion pipeline is implemented directly in this file.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import subprocess
+from pathlib import Path, PurePosixPath
+
+from tqdm import tqdm
+
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+DEFAULT_OUTPUT = PROJECT_ROOT
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Write dataset LaTeX to .tex files and compile them to PNG."
+    )
+    parser.add_argument(
+        "input_file",
+        type=Path,
+        help=(
+            "Input dataset filename or path. Relative filenames are resolved "
+            f"under {PROJECT_ROOT}."
+        ),
+    )
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        default=DEFAULT_OUTPUT,
+        help=f"Root for generated files (default: {DEFAULT_OUTPUT})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=0,
+        help="Only process the first N records; use 0 for all records (default: 0).",
+    )
+    return parser.parse_args()
+
+
+def print_process_error(tool_name: str, error: BaseException) -> None:
+    """Print subprocess diagnostics without aborting the remaining files."""
+    print(f"{tool_name} details:")
+    if isinstance(error, subprocess.CalledProcessError):
+        details = (error.stdout or "") + (error.stderr or "")
+        if details.strip():
+            print(details.rstrip())
+            return
+    print(str(error))
+
+
+def remove_intermediate_files(*paths: Path) -> None:
+    """Remove compilation intermediates when present."""
+    for path in paths:
+        if path.is_file():
+            path.unlink()
+
+
+def generate_image(input_base_dir: str, output_base_dir: str) -> None:
+    """Compile all .tex files one directory below input_base_dir into PNGs."""
+    input_root = Path(input_base_dir)
+    output_root = Path(output_base_dir)
+    output_root.mkdir(parents=True, exist_ok=True)
+
+    tex_files: list[tuple[Path, Path, Path]] = []
+    for folder_path in sorted(input_root.iterdir()):
+        if not folder_path.is_dir():
+            continue
+        print(folder_path)
+        output_folder = output_root / folder_path.name
+        output_folder.mkdir(parents=True, exist_ok=True)
+        for tex_path in sorted(folder_path.glob("*.tex")):
+            tex_files.append((folder_path, tex_path, output_folder))
+
+    total = len(tex_files)
+    failures = 0
+    for folder_path, tex_path, output_folder in tqdm(
+        tex_files, desc="Processing .tex files"
+    ):
+        pdf_path = tex_path.with_suffix(".pdf")
+        cropped_pdf = pdf_path.with_name(
+            f"{pdf_path.stem}.pdfcrop-{os.getpid()}.pdf"
+        )
+        image_path = output_folder / tex_path.with_suffix(".png").name
+        aux_path = tex_path.with_suffix(".aux")
+        log_path = tex_path.with_suffix(".log")
+        out_path = tex_path.with_suffix(".out")
+
+        try:
+            subprocess.run(
+                ["pdflatex", "-interaction=nonstopmode", str(tex_path)],
+                cwd=folder_path,
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=60,
+            )
+        except (OSError, subprocess.SubprocessError) as error:
+            failures += 1
+            print(f"ERROR 1 pdflatex failed: {tex_path}")
+            print_process_error("pdflatex", error)
+            remove_intermediate_files(
+                pdf_path, cropped_pdf, aux_path, log_path, out_path
+            )
+            continue
+
+        try:
+            # pdfcrop creates tmp-pdfcrop-*.tex in its current directory.
+            # Keep the project/output path ASCII-only on Windows.
+            subprocess.run(
+                [
+                    "pdfcrop",
+                    "--margins",
+                    "5 5 5 5",
+                    str(pdf_path).replace("\\", "/"),
+                    str(cropped_pdf).replace("\\", "/"),
+                ],
+                cwd=folder_path,
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                errors="replace",
+            )
+            os.replace(cropped_pdf, pdf_path)
+        except (OSError, subprocess.SubprocessError) as error:
+            failures += 1
+            print(f"ERROR 2 pdfcrop failed: {tex_path}")
+            print_process_error("pdfcrop", error)
+            remove_intermediate_files(
+                pdf_path, cropped_pdf, aux_path, log_path, out_path
+            )
+            continue
+
+        try:
+            subprocess.run(
+                [
+                    "pdftoppm",
+                    "-png",
+                    "-r",
+                    "300",
+                    str(pdf_path).replace("\\", "/"),
+                    str(image_path),
+                ],
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                errors="replace",
+            )
+            normalize_pdftoppm_outputs(image_path)
+        except (OSError, subprocess.SubprocessError) as error:
+            failures += 1
+            print(f"ERROR 3 pdftoppm failed: {tex_path}")
+            print_process_error("pdftoppm", error)
+        finally:
+            remove_intermediate_files(
+                pdf_path, cropped_pdf, aux_path, log_path, out_path
+            )
+
+    print(f"Success: {total - failures}/{total} tables.")
+
+
+def extract_sft_tex(record: dict[str, object], record_number: int) -> str:
+    """Extract the assistant's fenced LaTeX response from an SFT record."""
+    messages = record.get("messages")
+    if not isinstance(messages, list):
+        raise ValueError(f"Record {record_number}: missing messages list")
+
+    assistant_content: str | None = None
+    for message in messages:
+        if (
+            isinstance(message, dict)
+            and message.get("role") == "assistant"
+            and isinstance(message.get("content"), str)
+        ):
+            assistant_content = message["content"]
+            break
+
+    if assistant_content is None:
+        raise ValueError(
+            f"Record {record_number}: missing assistant message with string content"
+        )
+
+    fenced = re.fullmatch(
+        r"\s*```(?:latex|tex)?\s*\n?(.*?)\n?```\s*",
+        assistant_content,
+        flags=re.IGNORECASE | re.DOTALL,
+    )
+    return (fenced.group(1) if fenced else assistant_content).strip()
+
+
+def preprocess_tex_code(tex_code: str) -> str:
+    """Add adjustbox support and constrain unwrapped tabular environments."""
+    package_pattern = re.compile(
+        r"\\usepackage(?:\s*\[[^\]]*\])?\s*\{[^}]*\badjustbox\b[^}]*\}"
+    )
+    if not package_pattern.search(tex_code):
+        package_line = "\\usepackage{adjustbox}\n"
+        documentclass = re.search(
+            r"\\documentclass(?:\s*\[[^\]]*\])?\s*\{[^}]+\}[^\r\n]*(?:\r?\n)?",
+            tex_code,
+        )
+        if documentclass:
+            insert_at = documentclass.end()
+            tex_code = tex_code[:insert_at] + package_line + tex_code[insert_at:]
+        else:
+            begin_document = tex_code.find(r"\begin{document}")
+            if begin_document >= 0:
+                tex_code = (
+                    tex_code[:begin_document]
+                    + package_line
+                    + tex_code[begin_document:]
+                )
+            else:
+                tex_code = package_line + tex_code
+
+    # Existing samples may already wrap their table correctly. Avoid nesting a
+    # second adjustbox around those environments.
+    if r"\begin{adjustbox}" not in tex_code:
+        adjustbox_begin = (
+            "\\begin{adjustbox}{max width=\\textwidth, "
+            "max height=0.8\\textheight, keepaspectratio}\n"
+        )
+        adjustbox_end = "\\end{adjustbox}\n"
+        tex_code = tex_code.replace(
+            r"\begin{tabular}",
+            adjustbox_begin + r"\begin{tabular}",
+        )
+        tex_code = tex_code.replace(
+            r"\end{tabular}",
+            r"\end{tabular}" + "\n" + adjustbox_end,
+        )
+
+    return tex_code
+
+
+def normalize_record(
+    record: object, record_number: int
+) -> dict[str, str]:
+    """Normalize JSONL and SFT schemas to image_path/tex_code."""
+    if not isinstance(record, dict):
+        raise ValueError(f"Record {record_number}: expected a JSON object")
+
+    image_path = record.get("image_path")
+    tex_code = record.get("tex_code")
+
+    if isinstance(image_path, str) and isinstance(tex_code, str):
+        return {
+            "image_path": image_path,
+            "tex_code": preprocess_tex_code(tex_code),
+        }
+
+    images = record.get("images")
+    if (
+        isinstance(images, list)
+        and len(images) == 1
+        and isinstance(images[0], str)
+    ):
+        return {
+            "image_path": images[0],
+            "tex_code": preprocess_tex_code(
+                extract_sft_tex(record, record_number)
+            ),
+        }
+
+    raise ValueError(
+        f"Record {record_number}: expected image_path/tex_code strings, "
+        "or one images entry plus an assistant message"
+    )
+
+
+def read_records(input_path: Path, limit: int) -> list[dict[str, str]]:
+    """Read and normalize records from a JSONL file or JSON array."""
+    if limit < 0:
+        raise ValueError("--limit must be non-negative")
+    if not input_path.is_file():
+        raise FileNotFoundError(f"Input dataset not found: {input_path}")
+
+    records: list[dict[str, str]] = []
+    if input_path.suffix.lower() == ".json":
+        with input_path.open("r", encoding="utf-8") as input_file:
+            data = json.load(input_file)
+        if not isinstance(data, list):
+            raise ValueError(f"Expected a JSON array in: {input_path}")
+        selected = data[:limit] if limit else data
+        for record_number, record in enumerate(selected, start=1):
+            records.append(normalize_record(record, record_number))
+    else:
+        with input_path.open("r", encoding="utf-8") as input_file:
+            for line_number, line in enumerate(input_file, start=1):
+                if not line.strip():
+                    continue
+                record = json.loads(line)
+                records.append(normalize_record(record, line_number))
+                if limit and len(records) >= limit:
+                    break
+    return records
+
+
+def validated_image_path(raw_path: str) -> PurePosixPath:
+    """Return a safe dataset-relative PNG path."""
+    image_path = PurePosixPath(raw_path.replace("\\", "/"))
+    if image_path.is_absolute() or ".." in image_path.parts:
+        raise ValueError(f"image_path must be relative and cannot contain '..': {raw_path}")
+    if len(image_path.parts) != 3 or image_path.parts[1] != "image":
+        raise ValueError(
+            "Expected image_path in '<subject>/image/<filename>.png' form, "
+            f"got: {raw_path}"
+        )
+    if image_path.suffix.lower() != ".png":
+        raise ValueError(f"Expected a .png image_path, got: {raw_path}")
+    return image_path
+
+
+def write_tex_files(
+    records: list[dict[str, str]], output_root: Path
+) -> tuple[set[str], list[tuple[PurePosixPath, Path]]]:
+    """Write one .tex file per annotation and return subjects/output mappings."""
+    subjects: set[str] = set()
+    outputs: list[tuple[PurePosixPath, Path]] = []
+    tex_root = output_root / "tex"
+
+    for record in records:
+        image_path = validated_image_path(record["image_path"])
+        subject = image_path.parts[0]
+        tex_path = tex_root.joinpath(*image_path.with_suffix(".tex").parts)
+        final_png = output_root.joinpath(*image_path.parts)
+
+        tex_path.parent.mkdir(parents=True, exist_ok=True)
+        with tex_path.open("w", encoding="utf-8", newline="\n") as out_file:
+            out_file.write(record["tex_code"])
+            if not record["tex_code"].endswith("\n"):
+                out_file.write("\n")
+
+        subjects.add(subject)
+        outputs.append((image_path, final_png))
+
+    return subjects, outputs
+
+
+def normalize_pdftoppm_outputs(final_png: Path) -> None:
+    """Normalize pdftoppm's '<name>.png-1.png' output to '<name>.png'."""
+    generated_first_page = final_png.with_name(final_png.name + "-1.png")
+    if generated_first_page.is_file():
+        final_png.parent.mkdir(parents=True, exist_ok=True)
+        os.replace(generated_first_page, final_png)
+
+    # Preserve unexpected additional pages with readable, deterministic names.
+    pattern = re.compile(re.escape(final_png.name) + r"-(\d+)\.png$")
+    for generated_page in final_png.parent.glob(final_png.name + "-*.png"):
+        match = pattern.fullmatch(generated_page.name)
+        if not match or match.group(1) == "1":
+            continue
+        page_output = final_png.with_name(
+            f"{final_png.stem}_page{match.group(1)}{final_png.suffix}"
+        )
+        os.replace(generated_page, page_output)
+
+
+def compile_images_directly(
+    subjects: set[str],
+    output_root: Path,
+) -> None:
+    """Compile stored TEX files directly into their final image directories."""
+    tex_root = output_root / "tex"
+
+    for subject in sorted(subjects):
+        generate_image(
+            str(tex_root / subject),
+            str(output_root / subject),
+        )
+
+
+def main() -> int:
+    args = parse_args()
+    input_path = args.input_file
+    if not input_path.is_absolute():
+        input_path = PROJECT_ROOT / input_path
+    input_path = input_path.resolve()
+    output_root = args.output_root.resolve()
+
+    records = read_records(input_path, args.limit)
+    if not records:
+        print("No records found; nothing to do.")
+        return 0
+
+    subjects, outputs = write_tex_files(records, output_root)
+    print(f"Wrote {len(records)} TEX files under: {output_root / 'tex'}")
+
+    compile_images_directly(subjects, output_root)
+
+    succeeded = [(path, png) for path, png in outputs if png.is_file()]
+    failed = [(path, png) for path, png in outputs if not png.is_file()]
+    print(f"Reproduced images: {len(succeeded)}/{len(outputs)}")
+    for image_path, png_path in failed:
+        print(f"FAILED: {image_path} -> {png_path}")
+
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sft_train.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:00b7c90bfcf4fd24658e3913de21bc9455de5120a30046f867bc3325c3bc1597
-size 14808288
+oid sha256:ace4a459b5e717db3294ad0e40152ecfd55533d7474805d1964fb2facb93fece
+size 24063731