| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| import tempfile |
| from pathlib import Path |
| from typing import Any |
|
|
| import fitz |
|
|
| ROOT_DIR = Path(__file__).resolve().parent.parent |
| if str(ROOT_DIR) not in sys.path: |
| sys.path.insert(0, str(ROOT_DIR)) |
|
|
| from scripts.benchmark_ocr import benchmark_engine |
| from scripts.benchmark_voices import DEFAULT_VOICES, benchmark_voices as benchmark_voice_set |
| from scripts.dry_run_pdf import dry_run_pdf |
| from scripts.select_test_pages import build_test_pdf |
| from scripts.verify_pipeline import verify_pipeline |
| from app import main |
|
|
|
|
| ENGINE_PRESETS: dict[str, list[str]] = { |
| "practical": ["arabic", "paddleocr", "tesseract"], |
| "balanced": [ |
| "arabic-max", |
| "arabic", |
| "tawkeed-ocr", |
| "katib-ocr", |
| "arabic-qwen-ocr", |
| "arabic-glm-ocr", |
| "baseer-ocr", |
| "paddleocr", |
| "tesseract", |
| ], |
| "maximum": [ |
| "arabic-max", |
| "arabic", |
| "tawkeed-ocr", |
| "katib-ocr", |
| "arabic-qwen-ocr", |
| "arabic-glm-ocr", |
| "baseer-ocr", |
| "qari-ocr", |
| "paddleocr-vl", |
| "paddleocr", |
| "tesseract", |
| ], |
| } |
|
|
|
|
| def choose_best_result(results: list[dict[str, Any]]) -> dict[str, Any] | None: |
| successful = [item for item in results if item.get("ok")] |
| if not successful: |
| return None |
| return max(successful, key=lambda item: (item.get("qualityScore", 0), item.get("arabicWords", 0), -item.get("seconds", 0))) |
|
|
|
|
| def env_text(env: dict[str, str]) -> str: |
| return " ".join(f"{key}={value}" for key, value in env.items()) |
|
|
|
|
| def quote_arg(value: str | Path) -> str: |
| text = str(value) |
| if not text: |
| return '""' |
| if any(char.isspace() for char in text): |
| return f'"{text}"' |
| return text |
|
|
|
|
| def build_commands( |
| pdf_path: Path, |
| extraction: str, |
| voice_id: str, |
| audio_max_chars: int, |
| audio_out: Path | None = None, |
| env_file: Path | None = None, |
| external_tts_out_dir: Path | None = None, |
| external_ocr_out_dir: Path | None = None, |
| ) -> dict[str, str]: |
| pdf = quote_arg(pdf_path) |
| extraction_arg = quote_arg(extraction) |
| settings_arg = f"--env-file {quote_arg(env_file)}" if env_file else f"--from-extraction {extraction_arg}" |
| smoke_out = quote_arg(audio_out or (ROOT_DIR / "outputs" / f"{pdf_path.stem}-sample-smoke.wav")) |
| tts_sample_out = quote_arg(external_tts_out_dir or (ROOT_DIR / "outputs" / "external-tts-sample")) |
| ocr_sample_out = quote_arg(external_ocr_out_dir or (ROOT_DIR / "outputs" / "external-ocr-sample")) |
| return { |
| "dryRunRecommended": f"python scripts\\dry_run_pdf.py {pdf} {settings_arg}", |
| "audioSmokeRecommended": ( |
| f"python scripts\\verify_pipeline.py --pdf {pdf} {settings_arg} " |
| f"--voice-id {voice_id} --max-speech-chars {audio_max_chars} --out {smoke_out}" |
| ), |
| "externalTtsSample": f"python scripts\\export_tts_sample.py {pdf} {settings_arg} --out-dir {tts_sample_out}", |
| "externalOcrSample": f"python scripts\\export_ocr_sample_images.py {pdf} --out-dir {ocr_sample_out}", |
| "fullPipelineRecommended": ( |
| f"python scripts\\verify_pipeline.py --pdf {pdf} {settings_arg} " |
| f"--voice-id {voice_id} --out outputs\\full-book-smoke.wav" |
| ), |
| } |
|
|
|
|
| def seconds_label(seconds: float | None) -> str: |
| if seconds is None: |
| return "unknown" |
| if seconds < 60: |
| return f"{round(seconds, 1)} seconds" |
| minutes = seconds / 60 |
| if minutes < 60: |
| return f"{round(minutes, 1)} minutes" |
| return f"{round(minutes / 60, 1)} hours" |
|
|
|
|
| def estimate_full_book( |
| total_pages: int, |
| sample_page_count: int, |
| selected: dict[str, Any], |
| dry_run: dict[str, Any], |
| audio_smoke: dict[str, Any] | None = None, |
| ) -> dict[str, Any]: |
| sample_page_count = max(sample_page_count, 1) |
| pages_multiplier = total_pages / sample_page_count if total_pages else 0 |
| ocr_seconds_per_page = float(selected.get("seconds") or 0) / sample_page_count |
| speech_chars_per_page = float(dry_run.get("speechCharacters") or 0) / sample_page_count |
| estimated_ocr_seconds = round(ocr_seconds_per_page * total_pages, 2) if total_pages else None |
| estimated_speech_chars = int(round(speech_chars_per_page * total_pages)) if total_pages else None |
|
|
| tts_seconds_per_char = None |
| estimated_tts_seconds = None |
| if audio_smoke: |
| audio_chars = int(audio_smoke.get("audioSpeechCharacters") or 0) |
| elapsed = float(audio_smoke.get("elapsedSeconds") or 0) |
| if audio_chars > 0 and elapsed > 0 and estimated_speech_chars is not None: |
| tts_seconds_per_char = elapsed / audio_chars |
| estimated_tts_seconds = round(tts_seconds_per_char * estimated_speech_chars, 2) |
|
|
| estimated_total_seconds = None |
| if estimated_ocr_seconds is not None: |
| estimated_total_seconds = estimated_ocr_seconds + (estimated_tts_seconds or 0) |
|
|
| return { |
| "basis": "sample", |
| "totalPages": total_pages, |
| "samplePages": sample_page_count, |
| "pagesMultiplier": round(pages_multiplier, 2), |
| "ocrSecondsPerPage": round(ocr_seconds_per_page, 2), |
| "estimatedOcrSeconds": estimated_ocr_seconds, |
| "estimatedOcrTime": seconds_label(estimated_ocr_seconds), |
| "speechCharactersPerPage": round(speech_chars_per_page, 2), |
| "estimatedSpeechCharacters": estimated_speech_chars, |
| "ttsSecondsPerCharacter": round(tts_seconds_per_char, 5) if tts_seconds_per_char is not None else None, |
| "estimatedTtsSeconds": estimated_tts_seconds, |
| "estimatedTtsTime": seconds_label(estimated_tts_seconds), |
| "estimatedTotalSeconds": round(estimated_total_seconds, 2) if estimated_total_seconds is not None else None, |
| "estimatedTotalTime": seconds_label(estimated_total_seconds), |
| "note": "Estimate is based on selected sample pages; dense or scanned pages can vary a lot.", |
| } |
|
|
|
|
| def build_next_steps(result: dict[str, Any]) -> list[str]: |
| steps: list[str] = [] |
| dry_run = result.get("dryRun") or {} |
| estimate = result.get("estimateFullBook") or {} |
| env = result.get("recommendedEnvText") or "" |
| audio = result.get("audioSmoke") |
|
|
| if not dry_run.get("readyForTts"): |
| steps.append("OCR text is not ready for TTS. Try more sample pages, another OCR engine, or higher render zoom before creating audio.") |
| return steps |
|
|
| if dry_run.get("quality") == "warning": |
| reasons = "; ".join(dry_run.get("qualityReasons") or []) |
| detail = f" Warning reasons: {reasons}." if reasons else "" |
| steps.append(f"OCR is usable but should be checked before full-book TTS.{detail}") |
| else: |
| steps.append("OCR quality is usable for TTS on the selected sample.") |
| if env: |
| steps.append(f"Apply these OCR settings for the full book: {env}.") |
| if audio: |
| steps.append("Listen to the audio smoke file before processing the full book.") |
| else: |
| steps.append("Run again with --verify-audio to check pronunciation before processing the full book.") |
| voice_benchmark = result.get("voiceBenchmark") or {} |
| if voice_benchmark.get("ready"): |
| steps.append("Listen to the voice benchmark files and choose the most natural Arabic voice before the full-book run.") |
| elif result.get("voiceBenchmarkRequested"): |
| steps.append("Voice benchmarking did not produce audio. Run scripts/preflight_check.py and install the missing local voice setup.") |
| commands = result.get("commands") or {} |
| if commands.get("dryRunRecommended"): |
| steps.append(f"Recommended dry run command: {commands['dryRunRecommended']}") |
| if commands.get("externalTtsSample"): |
| steps.append(f"External voice comparison sample: {commands['externalTtsSample']}") |
| if commands.get("externalOcrSample"): |
| steps.append(f"External OCR model image sample: {commands['externalOcrSample']}") |
|
|
| total_seconds = estimate.get("estimatedTotalSeconds") |
| tts_seconds = estimate.get("estimatedTtsSeconds") |
| if isinstance(total_seconds, (int, float)) and total_seconds >= 3600: |
| steps.append("Estimated runtime is long. Use the Docker worker or an always-on computer, and process a small sample first.") |
| elif isinstance(total_seconds, (int, float)) and total_seconds >= 600: |
| steps.append("Estimated runtime is more than a few minutes. Keep the browser open or use the worker path for the full book.") |
| if isinstance(tts_seconds, (int, float)) and result.get("smokeVoiceId") == "silma-local" and tts_seconds >= 1800: |
| steps.append("SILMA sounds better but may be slow for the full book. Use --voice-id espeak-ar-clear for a faster fallback smoke test.") |
| return steps |
|
|
|
|
| def resolve_smoke_voice(voice_id: str | None = None) -> str: |
| if voice_id and voice_id != "auto": |
| return voice_id |
| if main.find_silma_python() is not None or main.importlib.util.find_spec("silma_tts") is not None: |
| return "silma-local" |
| if main.find_habibi_python() is not None: |
| return "habibi-msa" |
| if main.find_supertonic_python() is not None or main.importlib.util.find_spec("supertonic") is not None: |
| return "supertonic-ar" |
| if main.find_espeak_ng() is not None: |
| return "espeak-ar-clear" |
| return "silma-local" |
|
|
|
|
| def write_env_snippet(path: Path, result: dict[str, Any]) -> None: |
| env = result.get("recommendedEnv") or {} |
| path.parent.mkdir(parents=True, exist_ok=True) |
| lines = [ |
| "# Arabic PDF Reader OCR settings", |
| "# Generated by scripts/prepare_book_workflow.py", |
| f"# Source PDF: {result.get('pdf', '')}", |
| f"# Sample PDF: {result.get('sample', {}).get('output', '')}", |
| "", |
| ] |
| if not env: |
| lines.append("# No OCR settings were needed for this sample.") |
| else: |
| for key in sorted(env): |
| lines.append(f"{key}={env[key]}") |
| path.write_text("\n".join(lines) + "\n", encoding="utf-8") |
|
|
|
|
| def markdown_value(value: Any) -> str: |
| if value is None or value == "": |
| return "-" |
| if isinstance(value, bool): |
| return "yes" if value else "no" |
| return str(value) |
|
|
|
|
| def fenced_block(language: str, text: str) -> list[str]: |
| return [f"```{language}", text.strip() or "-", "```"] |
|
|
|
|
| def write_markdown_report(path: Path, result: dict[str, Any]) -> None: |
| selected = result.get("selected") or {} |
| sample = result.get("sample") or {} |
| dry_run = result.get("dryRun") or {} |
| audio = result.get("audioSmoke") or {} |
| voice_benchmark = result.get("voiceBenchmark") or {} |
| estimate = result.get("estimateFullBook") or {} |
| commands = result.get("commands") or {} |
| next_steps = result.get("nextSteps") or [] |
|
|
| selected_pages = ", ".join(str(page) for page in sample.get("pages", [])) or "-" |
| command_text = "\n".join(command for command in commands.values() if command) |
| benchmark_lines = [ |
| "| Engine | Quality | Score | Arabic words | Fragment ratio | Extraction | Notes |", |
| "| --- | --- | --- | --- | --- | --- | --- |", |
| ] |
| for item in result.get("benchmark") or []: |
| notes = "; ".join(item.get("qualityReasons") or []) |
| if not item.get("ok"): |
| notes = item.get("error") or "failed" |
| benchmark_lines.append( |
| "| " |
| + " | ".join( |
| [ |
| markdown_value(item.get("engine")), |
| markdown_value(item.get("quality") if item.get("ok") else "failed"), |
| markdown_value(item.get("qualityScore")), |
| markdown_value(item.get("arabicWords")), |
| markdown_value(item.get("fragmentLineRatio")), |
| markdown_value(item.get("extraction")), |
| markdown_value(notes), |
| ] |
| ) |
| + " |" |
| ) |
| lines = [ |
| "# Arabic Audio Preparation Report", |
| "", |
| "## Book", |
| "", |
| f"- PDF: {markdown_value(result.get('pdf'))}", |
| f"- Total pages: {markdown_value(result.get('totalPages'))}", |
| f"- Sample PDF: {markdown_value(sample.get('output'))}", |
| f"- Sample pages: {selected_pages}", |
| f"- Engine preset: {markdown_value(result.get('enginePreset'))}", |
| "", |
| "## Benchmark Results", |
| "", |
| *benchmark_lines, |
| "", |
| "## Selected OCR", |
| "", |
| f"- Extraction: {markdown_value(selected.get('extraction'))}", |
| f"- Engine: {markdown_value(selected.get('engine'))}", |
| f"- Quality score: {markdown_value(selected.get('qualityScore'))}", |
| f"- Arabic words: {markdown_value(selected.get('arabicWords'))}", |
| f"- Sample OCR time: {markdown_value(selected.get('seconds'))} seconds", |
| "", |
| "## Recommended OCR Settings", |
| "", |
| *fenced_block("text", result.get("recommendedEnvText") or "No OCR settings were needed for this sample."), |
| "", |
| "## Dry Run", |
| "", |
| f"- Quality: {markdown_value(dry_run.get('quality'))}", |
| f"- Quality reasons: {markdown_value('; '.join(dry_run.get('qualityReasons') or []))}", |
| f"- Ready for TTS: {markdown_value(dry_run.get('readyForTts'))}", |
| f"- Speech characters: {markdown_value(dry_run.get('speechCharacters'))}", |
| f"- One-letter Arabic word ratio: {markdown_value(dry_run.get('singleArabicWordRatio'))}", |
| f"- Low-information line ratio: {markdown_value(dry_run.get('fragmentLineRatio'))}", |
| f"- Chunks: {markdown_value(dry_run.get('chunks'))}", |
| f"- Extraction: {markdown_value(dry_run.get('extraction'))}", |
| "", |
| ] |
|
|
| if audio: |
| lines.extend( |
| [ |
| "## Audio Smoke", |
| "", |
| f"- Voice: {markdown_value(result.get('smokeVoiceId') or audio.get('voiceId'))}", |
| f"- Engine: {markdown_value(audio.get('engine'))}", |
| f"- Speech characters synthesized: {markdown_value(audio.get('audioSpeechCharacters'))}", |
| f"- Audio seconds: {markdown_value(audio.get('seconds'))}", |
| f"- Output: {markdown_value(audio.get('path'))}", |
| "", |
| ] |
| ) |
| else: |
| lines.extend(["## Audio Smoke", "", "- Not run. Use `--verify-audio` to create a short pronunciation sample.", ""]) |
|
|
| if voice_benchmark: |
| lines.extend( |
| [ |
| "## Voice Benchmark", |
| "", |
| f"- Output directory: {markdown_value(voice_benchmark.get('outputDir'))}", |
| f"- Text characters: {markdown_value(voice_benchmark.get('textCharacters'))}", |
| f"- Audio format: {markdown_value(voice_benchmark.get('audioFormat'))}", |
| f"- Recommended starting voice: {markdown_value((voice_benchmark.get('recommended') or {}).get('voiceId'))}", |
| f"- Fastest successful voice: {markdown_value((voice_benchmark.get('fastest') or {}).get('voiceId'))}", |
| "", |
| "| Voice | Label | Engine | Status | Time | Audio | Notes |", |
| "| --- | --- | --- | --- | ---: | --- | --- |", |
| ] |
| ) |
| for item in voice_benchmark.get("results", []): |
| status = "ok" if item.get("ok") else "failed" |
| elapsed = item.get("elapsedSeconds", "-") |
| audio_path = item.get("path", "-") |
| notes = item.get("error", "") |
| lines.append( |
| f"| {markdown_value(item.get('voiceId'))} | {markdown_value(item.get('label'))} | " |
| f"{markdown_value(item.get('engine'))} | {status} | {elapsed} | {audio_path} | {notes} |" |
| ) |
| lines.append("") |
| elif result.get("voiceBenchmarkRequested"): |
| lines.extend(["## Voice Benchmark", "", "- Not run because no usable cleaned OCR sample was available.", ""]) |
|
|
| lines.extend( |
| [ |
| "## Full Book Estimate", |
| "", |
| f"- Estimated OCR time: {markdown_value(estimate.get('estimatedOcrTime'))}", |
| f"- Estimated TTS time: {markdown_value(estimate.get('estimatedTtsTime'))}", |
| f"- Estimated total time: {markdown_value(estimate.get('estimatedTotalTime'))}", |
| f"- Estimated speech characters: {markdown_value(estimate.get('estimatedSpeechCharacters'))}", |
| f"- Basis: {markdown_value(estimate.get('basis'))}", |
| "", |
| "> Estimates are based on the selected sample pages. Dense scanned pages, marginal scans, and different fonts can change runtime and quality.", |
| "", |
| "## Commands", |
| "", |
| *fenced_block("powershell", command_text), |
| "", |
| "## Next Steps", |
| "", |
| ] |
| ) |
| if next_steps: |
| lines.extend(f"- {step}" for step in next_steps) |
| else: |
| lines.append("- No next steps were generated.") |
| lines.append("") |
|
|
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text("\n".join(lines), encoding="utf-8") |
|
|
|
|
| def prepare_book_workflow( |
| pdf_path: Path, |
| sample_pages: int = 1, |
| skip_first: int = 0, |
| engines: list[str] | None = None, |
| engine_preset: str = "balanced", |
| chunk_size: int = 900, |
| verify_audio: bool = False, |
| voice_id: str | None = "auto", |
| audio_out: Path | None = None, |
| audio_max_chars: int = 1200, |
| benchmark_voices: bool = False, |
| voice_ids: list[str] | None = None, |
| voice_benchmark_out_dir: Path | None = None, |
| voice_benchmark_format: str = "wav", |
| voice_benchmark_max_chars: int | None = None, |
| ) -> dict[str, Any]: |
| if not pdf_path.exists(): |
| raise FileNotFoundError(f"PDF not found: {pdf_path}") |
| if pdf_path.suffix.lower() != ".pdf": |
| raise ValueError("Input must be a PDF file.") |
|
|
| with fitz.open(pdf_path) as document: |
| total_pages = document.page_count |
| if engine_preset not in ENGINE_PRESETS: |
| raise ValueError(f"Unknown engine preset: {engine_preset}") |
| engines = engines or ENGINE_PRESETS[engine_preset] |
| sample_pdf = Path(tempfile.gettempdir()) / f"{pdf_path.stem}-arabic-audio-sample-{sample_pages}.pdf" |
| sample_info = build_test_pdf(pdf_path, sample_pdf, count=sample_pages, skip_first=skip_first) |
|
|
| benchmark_results = [benchmark_engine(sample_pdf, engine) for engine in engines] |
| best = choose_best_result(benchmark_results) |
| if best is None: |
| return { |
| "pdf": str(pdf_path), |
| "sample": sample_info, |
| "benchmark": benchmark_results, |
| "ready": False, |
| "error": "No OCR engine produced usable Arabic text on the sample.", |
| } |
|
|
| extraction = str(best.get("extraction") or "") |
| recommendation = best.get("recommendation") |
| speech_sample_chars = voice_benchmark_max_chars if voice_benchmark_max_chars is not None else audio_max_chars |
| dry_run = dry_run_pdf( |
| sample_pdf, |
| chunk_size=chunk_size, |
| from_extraction=extraction, |
| speech_sample_chars=speech_sample_chars, |
| ) |
| audio_result = None |
| voice_benchmark_result = None |
| resolved_voice_id = resolve_smoke_voice(voice_id) |
| if verify_audio: |
| output = audio_out or (ROOT_DIR / "outputs" / f"{pdf_path.stem}-sample-smoke.wav") |
| audio_result = verify_pipeline( |
| sample_pdf, |
| resolved_voice_id, |
| output, |
| from_extraction=extraction, |
| max_speech_chars=audio_max_chars, |
| ) |
| if benchmark_voices and dry_run.get("readyForTts"): |
| sample_text = str(dry_run.get("speechSampleText") or dry_run.get("speechPreview") or "").strip() |
| if sample_text: |
| output_dir = voice_benchmark_out_dir or (ROOT_DIR / "outputs" / f"{pdf_path.stem}-voice-benchmark") |
| selected_voices = voice_ids or DEFAULT_VOICES |
| voice_benchmark_result = benchmark_voice_set( |
| voices=selected_voices, |
| text=sample_text, |
| output_dir=output_dir, |
| audio_format=voice_benchmark_format, |
| ) |
| estimate = estimate_full_book( |
| total_pages=total_pages, |
| sample_page_count=len(sample_info.get("pages", [])) or sample_pages, |
| selected=best, |
| dry_run=dry_run, |
| audio_smoke=audio_result, |
| ) |
| commands = build_commands( |
| pdf_path=pdf_path, |
| extraction=extraction, |
| voice_id=resolved_voice_id, |
| audio_max_chars=audio_max_chars, |
| audio_out=audio_out, |
| ) |
|
|
| result = { |
| "pdf": str(pdf_path), |
| "totalPages": total_pages, |
| "sample": sample_info, |
| "benchmark": benchmark_results, |
| "enginePreset": engine_preset if engines == ENGINE_PRESETS[engine_preset] else "custom", |
| "selected": best, |
| "recommendation": recommendation, |
| "recommendedEnv": recommendation.get("env", {}) if recommendation else {}, |
| "recommendedEnvText": env_text(recommendation.get("env", {})) if recommendation else "", |
| "dryRun": dry_run, |
| "audioSmoke": audio_result, |
| "smokeVoiceId": resolved_voice_id, |
| "voiceBenchmark": voice_benchmark_result, |
| "voiceBenchmarkRequested": benchmark_voices, |
| "estimateFullBook": estimate, |
| "commands": commands, |
| "ready": bool(dry_run.get("readyForTts") and (audio_result is not None if verify_audio else True)), |
| } |
| result["nextSteps"] = build_next_steps(result) |
| return result |
|
|
|
|
| def print_summary(result: dict[str, Any]) -> None: |
| selected = result.get("selected") or {} |
| recommendation = result.get("recommendation") or {} |
| dry_run = result.get("dryRun") or {} |
| print("Arabic book preparation") |
| print(f"Sample: {result.get('sample', {}).get('output', '-')}") |
| print(f"Selected OCR: {selected.get('extraction', '-')} score={selected.get('qualityScore', '-')}") |
| if recommendation: |
| print(f"Full-book settings: {recommendation.get('summary')}") |
| print( |
| f"Dry run: quality={dry_run.get('quality', '-')} readyForTts={dry_run.get('readyForTts', False)} " |
| f"speechChars={dry_run.get('speechCharacters', 0)}" |
| ) |
| audio = result.get("audioSmoke") |
| if audio: |
| print(f"Audio smoke: {audio.get('path')} {audio.get('seconds')}s {audio.get('bytes')} bytes") |
| voice_benchmark = result.get("voiceBenchmark") or {} |
| if voice_benchmark: |
| successful = [item for item in voice_benchmark.get("results", []) if item.get("ok")] |
| print(f"Voice benchmark: {len(successful)}/{len(voice_benchmark.get('results', []))} voices wrote to {voice_benchmark.get('outputDir')}") |
| estimate = result.get("estimateFullBook") or {} |
| if estimate: |
| print( |
| f"Estimate: OCR {estimate.get('estimatedOcrTime')} " |
| f"TTS {estimate.get('estimatedTtsTime')} total {estimate.get('estimatedTotalTime')}" |
| ) |
| steps = result.get("nextSteps") or [] |
| if steps: |
| print("Next steps:") |
| for step in steps: |
| print(f"- {step}") |
| print(f"Ready: {'yes' if result.get('ready') else 'no'}") |
|
|
|
|
| def main_cli() -> None: |
| if hasattr(sys.stdout, "reconfigure"): |
| sys.stdout.reconfigure(encoding="utf-8", errors="replace") |
| parser = argparse.ArgumentParser(description="Benchmark, dry-run, and optionally audio-smoke an Arabic PDF sample.") |
| parser.add_argument("pdf", type=Path, help="Arabic PDF to prepare") |
| parser.add_argument("--sample-pages", type=int, default=1, help="Number of informative pages to sample.") |
| parser.add_argument("--skip-first", type=int, default=0, help="Ignore the first N pages when selecting sample pages.") |
| parser.add_argument( |
| "--engine-preset", |
| choices=sorted(ENGINE_PRESETS), |
| default="balanced", |
| help="OCR engine preset to use when --engines is not provided. balanced is the recommended free Arabic-trained stack.", |
| ) |
| parser.add_argument( |
| "--engines", |
| nargs="+", |
| default=None, |
| choices=[ |
| "arabic", |
| "arabic-max", |
| "qari-ocr", |
| "tawkeed-ocr", |
| "katib-ocr", |
| "arabic-qwen-ocr", |
| "arabic-glm-ocr", |
| "baseer-ocr", |
| "easyocr", |
| "paddleocr", |
| "paddleocr-vl", |
| "surya", |
| "tesseract", |
| "auto", |
| "best", |
| ], |
| help="OCR engines to benchmark on the sample.", |
| ) |
| parser.add_argument("--chunk-size", type=int, default=900, help="Dry-run chunk size.") |
| parser.add_argument("--verify-audio", action="store_true", help="Also create a short audio smoke test from the sample.") |
| parser.add_argument("--voice-id", default="auto", help="Local voice id for --verify-audio. Use auto to prefer SILMA when installed.") |
| parser.add_argument("--audio-out", type=Path, help="Audio output path for --verify-audio.") |
| parser.add_argument( |
| "--audio-max-chars", |
| type=int, |
| default=1200, |
| help="Maximum cleaned characters to synthesize for --verify-audio.", |
| ) |
| parser.add_argument( |
| "--benchmark-voices", |
| action="store_true", |
| help="Compare local voices using the cleaned OCR sample text.", |
| ) |
| parser.add_argument( |
| "--voices", |
| nargs="+", |
| choices=list(main.LOCAL_VOICES), |
| help="Voice ids to compare with --benchmark-voices.", |
| ) |
| parser.add_argument( |
| "--voice-benchmark-out-dir", |
| type=Path, |
| help="Output directory for --benchmark-voices audio files.", |
| ) |
| parser.add_argument( |
| "--voice-benchmark-format", |
| choices=["wav", "mp3"], |
| default="wav", |
| help="Audio format for --benchmark-voices.", |
| ) |
| parser.add_argument( |
| "--voice-benchmark-max-chars", |
| type=int, |
| help="Maximum cleaned OCR characters to use for --benchmark-voices. Defaults to --audio-max-chars.", |
| ) |
| parser.add_argument("--json", action="store_true", help="Print JSON instead of a compact summary.") |
| parser.add_argument( |
| "--write-env", |
| type=Path, |
| help="Write recommended OCR settings to a small .env snippet. Secrets are never written.", |
| ) |
| parser.add_argument( |
| "--write-report", |
| type=Path, |
| help="Write a readable Markdown report with OCR settings, estimates, commands, and next steps.", |
| ) |
| args = parser.parse_args() |
|
|
| result = prepare_book_workflow( |
| args.pdf, |
| sample_pages=args.sample_pages, |
| skip_first=args.skip_first, |
| engines=args.engines, |
| engine_preset=args.engine_preset, |
| chunk_size=args.chunk_size, |
| verify_audio=args.verify_audio, |
| voice_id=args.voice_id, |
| audio_out=args.audio_out, |
| audio_max_chars=args.audio_max_chars, |
| benchmark_voices=args.benchmark_voices, |
| voice_ids=args.voices, |
| voice_benchmark_out_dir=args.voice_benchmark_out_dir, |
| voice_benchmark_format=args.voice_benchmark_format, |
| voice_benchmark_max_chars=args.voice_benchmark_max_chars, |
| ) |
| if args.write_env: |
| write_env_snippet(args.write_env, result) |
| result["writtenEnv"] = str(args.write_env) |
| result["commands"] = build_commands( |
| pdf_path=args.pdf, |
| extraction=str(result.get("selected", {}).get("extraction") or ""), |
| voice_id=str(result.get("smokeVoiceId") or args.voice_id), |
| audio_max_chars=args.audio_max_chars, |
| audio_out=args.audio_out, |
| env_file=args.write_env, |
| ) |
| result["nextSteps"] = build_next_steps(result) |
| if args.write_report: |
| write_markdown_report(args.write_report, result) |
| result["writtenReport"] = str(args.write_report) |
| if args.json: |
| print(json.dumps(result, ensure_ascii=False, indent=2)) |
| else: |
| print_summary(result) |
| if not result.get("ready"): |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main_cli() |
|
|
