#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# File: src/scitex_writer/migration/_parsing.py
"""LaTeX parsing helpers for Overleaf migration."""
import re
from pathlib import Path
from typing import Optional
# Image extensions recognised as figures
IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".pdf", ".eps", ".svg", ".tif", ".tiff"}
# Table data extensions
TABLE_EXTS = {".csv", ".tsv"}
# Priority names for detecting the main .tex file
MAIN_TEX_PRIORITY = ["main.tex", "paper.tex", "manuscript.tex", "article.tex"]
# IMRAD section patterns (filename or \section{} heading match)
SECTION_PATTERNS = {
"abstract": [r"abstract", r"summary"],
"introduction": [r"intro", r"background"],
"methods": [r"method", r"material", r"experimental", r"procedure"],
"results": [r"result", r"finding", r"observation"],
"discussion": [r"discuss", r"conclu", r"implication"],
}
# Canonical scitex-writer section filenames
IMRAD_SECTIONS = ["abstract", "introduction", "methods", "results", "discussion"]
def read_tex(path: Path) -> str:
"""Read a .tex file with encoding fallback."""
for enc in ("utf-8", "latin-1"):
try:
return path.read_text(encoding=enc)
except UnicodeDecodeError:
continue
return ""
def detect_main_tex(extracted_dir: Path) -> Optional[Path]:
"""Find the root .tex file containing \\documentclass.
Strategy:
1. Scan all .tex files for \\documentclass (not in comments)
2. If exactly one found, return it
3. If multiple: prefer main.tex > paper.tex > manuscript.tex > article.tex
4. If still ambiguous, prefer shallowest directory depth
"""
candidates = []
for tex_file in extracted_dir.rglob("*.tex"):
content = read_tex(tex_file)
if re.search(r"^[^%]*\\documentclass", content, re.MULTILINE):
candidates.append(tex_file)
if not candidates:
return None
if len(candidates) == 1:
return candidates[0]
for name in MAIN_TEX_PRIORITY:
matches = [c for c in candidates if c.name == name]
if matches:
return matches[0]
return min(candidates, key=lambda p: len(p.relative_to(extracted_dir).parts))
def parse_inputs(main_tex_path: Path, base_dir: Path, _depth: int = 0) -> list[dict]:
"""Parse \\input{} and \\include{} directives from a .tex file.
Recursively follows nested \\input up to depth 10.
"""
if _depth > 10:
return []
content = read_tex(main_tex_path)
results = []
pattern = re.compile(r"^[^%\n]*\\(input|include)\{([^}]+)\}", re.MULTILINE)
for match in pattern.finditer(content):
cmd = match.group(1)
arg = match.group(2).strip()
rel_path = Path(arg)
if not rel_path.suffix:
rel_path = rel_path.with_suffix(".tex")
resolved = (main_tex_path.parent / rel_path).resolve()
if not resolved.exists():
resolved = (base_dir / rel_path).resolve()
entry = {
"command": cmd,
"arg": arg,
"resolved_path": resolved,
"exists": resolved.exists(),
}
results.append(entry)
if resolved.exists() and resolved.suffix == ".tex":
nested = parse_inputs(resolved, base_dir, _depth + 1)
results.extend(nested)
return results
def extract_metadata(content: str) -> dict:
"""Extract \\title{}, \\author{}, keywords from main .tex content."""
metadata = {"title": None, "authors_block": None, "keywords": None}
title_match = re.search(r"\\title\{([^}]+)\}", content)
if title_match:
metadata["title"] = title_match.group(1).strip()
author_match = re.search(r"\\author\{([^}]+)\}", content)
if author_match:
metadata["authors_block"] = author_match.group(1).strip()
kw_match = re.search(
r"\\begin\{keyword[s]?\}(.*?)\\end\{keyword[s]?\}", content, re.DOTALL
)
if not kw_match:
kw_match = re.search(r"\\keywords\{([^}]+)\}", content)
if kw_match:
metadata["keywords"] = kw_match.group(1).strip()
return metadata
def classify_section(tex_path: Path, content: str) -> Optional[str]:
"""Map a .tex file to an IMRAD section name."""
name = tex_path.stem.lower()
for section, patterns in SECTION_PATTERNS.items():
if any(re.search(p, name) for p in patterns):
return section
section_cmd = re.search(r"\\section\*?\{([^}]+)\}", content)
if section_cmd:
heading = section_cmd.group(1).lower()
for section, patterns in SECTION_PATTERNS.items():
if any(re.search(p, heading) for p in patterns):
return section
return None
def split_inline_sections(content: str) -> dict[str, str]:
"""Split monolithic main.tex body into IMRAD sections by \\section{} boundaries."""
pattern = re.compile(r"\\section\*?\{([^}]+)\}")
matches = list(pattern.finditer(content))
if not matches:
return {}
sections = {}
for i, match in enumerate(matches):
heading = match.group(1).strip()
start = match.start()
end = matches[i + 1].start() if i + 1 < len(matches) else len(content)
section_content = content[start:end].strip()
heading_lower = heading.lower()
section_name = None
for name, pats in SECTION_PATTERNS.items():
if any(re.search(p, heading_lower) for p in pats):
section_name = name
break
if section_name:
if section_name in sections:
sections[section_name] += "\n\n" + section_content
else:
sections[section_name] = section_content
return sections
def find_bib_files(d: Path) -> list[Path]:
"""Find all .bib files."""
return sorted(d.rglob("*.bib"))
def find_image_files(d: Path) -> list[Path]:
"""Find all image files, excluding compiled-looking PDFs."""
images = []
skip_stems = {"main", "output", "manuscript", "paper"}
for f in d.rglob("*"):
if f.suffix.lower() in IMAGE_EXTS and f.is_file():
if f.suffix.lower() == ".pdf" and f.stem in skip_stems:
continue
images.append(f)
return sorted(images)
def find_table_files(d: Path) -> list[Path]:
"""Find CSV and TSV files."""
return sorted(f for f in d.rglob("*") if f.suffix.lower() in TABLE_EXTS)
def find_style_files(d: Path) -> list[Path]:
"""Find custom .cls, .sty, and .bst files."""
styles = []
for ext in ("*.cls", "*.sty", "*.bst"):
styles.extend(d.rglob(ext))
return sorted(styles)
def unique_dest(dest: Path) -> Path:
"""Return dest if it doesn't exist; otherwise append _N suffix."""
if not dest.exists():
return dest
stem, suffix = dest.stem, dest.suffix
n = 1
while True:
candidate = dest.parent / f"{stem}_{n}{suffix}"
if not candidate.exists():
return candidate
n += 1
# EOF
/