natural-pdf 0.1.28__py3-none-any.whl → 0.1.30__py3-none-any.whl

tools/bad_pdf_eval/eval_suite.py

@@ -0,0 +1,116 @@
+import argparse
+import re
+from pathlib import Path
+from typing import List, Dict
+
+import pandas as pd
+from rich.console import Console
+
+from .utils import find_local_pdf, slugify
+from .analyser import BadPDFAnalyzer, extract_page_hints
+from .reporter import save_json
+
+console = Console()
+
+
+DEFAULT_PAGES = [1, 2, 3]
+
+
+def build_pages_list(row: Dict[str, str]) -> List[int]:
+    pages = DEFAULT_PAGES.copy()
+    text_fields = [
+        row.get("What are we trying to get out of the PDF?", ""),
+        row.get("What do you think makes this PDF bad?", ""),
+    ]
+    for field in text_fields:
+        # Guard against NaN/None or other non-string pandas dtypes
+        if isinstance(field, str) and field:
+            pages += extract_page_hints(field)
+    # deduplicate and sort
+    pages = sorted(set(pages))
+    return pages
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run bad PDF evaluation suite")
+    parser.add_argument(
+        "--csv",
+        default="bad-pdfs/Bad PDF Submission form_Submissions_2025-06-22.csv",
+        help="Path to submissions CSV",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default="eval_results",
+        help="Directory to write results into (will be git-ignored)",
+    )
+    parser.add_argument("--max-row", type=int, default=None, help="debug: process only first n CSV rows")
+    parser.add_argument("--limit", type=int, default=None, help="process at most N PDFs with local files")
+    parser.add_argument("--overwrite", action="store_true", help="re-run analysis even if summary.json exists")
+    args = parser.parse_args()
+
+    csv_path = Path(args.csv)
+    df = pd.read_csv(csv_path)
+    if args.max_row:
+        df = df.head(args.max_row)
+
+    output_root = Path(args.output_dir)
+    output_root.mkdir(exist_ok=True)
+
+    master_records = []
+    processed = 0
+
+    try:
+        for idx, row in df.iterrows():
+            submission_id = row["Submission ID"]
+            pdf_url = row.get("Your bad PDF (one per submission!)", "")
+            pdf_path = find_local_pdf(submission_id, pdf_url)
+            if not pdf_path or not pdf_path.exists():
+                console.print(f"[red]PDF not found for {submission_id}. Skipping.")
+                continue
+
+            # Ignore files that are not .pdf (e.g. ZIPs mistakenly included)
+            if pdf_path.suffix.lower() != ".pdf":
+                console.print(f"[yellow]Not a PDF ({pdf_path.suffix}) for {submission_id}; skipping.")
+                continue
+
+            sub_output = output_root / submission_id
+            summary_path = sub_output / "summary.json"
+
+            # Ensure the original PDF is stored alongside the analysis artefacts
+            try:
+                from shutil import copy2
+
+                sub_output.mkdir(parents=True, exist_ok=True)
+                dest_pdf = sub_output / pdf_path.name
+                if not dest_pdf.exists():
+                    copy2(pdf_path, dest_pdf)
+            except Exception as copy_err:
+                console.print(f"[yellow]Could not copy PDF into results folder: {copy_err}")
+
+            if summary_path.exists() and not args.overwrite:
+                console.print(f"[yellow]Summary exists for {submission_id}; skipping (use --overwrite to refresh)")
+                continue
+
+            pages = build_pages_list(row)
+            try:
+                analyser = BadPDFAnalyzer(pdf_path=pdf_path, output_dir=sub_output, submission_meta=row, pages=pages)
+                summary = analyser.run()
+                master_records.append(summary)
+            except Exception as e:
+                console.print(f"[red]Error processing {submission_id}: {e}. Skipping.")
+                continue
+            processed += 1
+            if args.limit and processed >= args.limit:
+                break
+    except KeyboardInterrupt:
+        console.print("[bold yellow]\nInterrupted by user – saving progress made so far…")
+    finally:
+        # Save master index even on interrupt
+        if master_records:
+            save_json(master_records, output_root / "master_index.json")
+            console.print(f"[bold green]Progress saved to {output_root / 'master_index.json'}")
+        console.print(f"[bold green]Finished. Results in {output_root}")
+
+
+if __name__ == "__main__":
+    main() 

tools/bad_pdf_eval/export_enrichment_csv.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+"""Export enrichment data (id, thought_process, code_suggestion) to a CSV.
+
+Usage
+-----
+python -m tools.bad_pdf_eval.export_enrichment_csv --out eval_results/enrichment.csv
+"""
+
+import argparse
+import csv
+import json
+from pathlib import Path
+from typing import List, Dict
+
+ROOT = Path(__file__).resolve().parent.parent.parent  # repo root
+EVAL_DIR = ROOT / "eval_results"
+
+
+def collect_records() -> List[Dict[str, str]]:
+    records: List[Dict[str, str]] = []
+    for summary_path in EVAL_DIR.glob("*/summary.json"):
+        try:
+            data = json.loads(summary_path.read_text())
+        except Exception:
+            continue
+        tp = data.get("thought_process", "").strip()
+        cs = data.get("code_suggestion", "").strip()
+        if not tp and not cs:
+            # Skip summaries without enrichment at doc level
+            continue
+        records.append({
+            "id": data.get("submission_id", summary_path.parent.name),
+            "thought_process": tp.replace("\n", " ").strip(),
+            "code_suggestion": cs.replace("\n", " ").strip(),
+        })
+    return records
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Export enriched summaries to CSV.")
+    ap.add_argument("--out", default=str(EVAL_DIR / "enrichment_export.csv"), help="Output CSV path")
+    args = ap.parse_args()
+
+    records = collect_records()
+    if not records:
+        print("No enriched summaries found.")
+        return
+
+    out_path = Path(args.out)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with out_path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=["id", "thought_process", "code_suggestion"])
+        writer.writeheader()
+        for rec in records:
+            writer.writerow(rec)
+
+    print(f"Wrote {len(records)} records to {out_path}")
+
+
+if __name__ == "__main__":
+    main() 

tools/bad_pdf_eval/llm_enrich.py

@@ -0,0 +1,273 @@
+"""Enrich evaluation summaries with LLM-generated thought_process and code_suggestion.
+
+Usage
+-----
+python -m tools.bad_pdf_eval.llm_enrich --submission ja6EqV1 --model o3
+
+Environment
+-----------
+OPENAI_API_KEY must be set or passed via --api-key.
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+import textwrap
+from pathlib import Path
+from typing import Dict, Any, List
+
+from openai import OpenAI
+from pydantic import BaseModel, Field
+from PIL import Image
+
+ROOT = Path(__file__).resolve().parent.parent.parent  # repo root
+EVAL_DIR = ROOT / "eval_results"
+CHEATSHEET_PATH = ROOT / "tools" / "bad_pdf_eval" / "LLM_NaturalPDF_CheatSheet.md"
+WORKFLOWS_PATH = ROOT / "tools" / "bad_pdf_eval" / "LLM_NaturalPDF_Workflows.md"
+
+
+def read_md(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def img_to_b64_jpeg(path: Path, max_px: int = 1024) -> str:
+    """Return base64-encoded tiny JPEG thumbnail."""
+    with Image.open(path) as im:
+        im.thumbnail((max_px, max_px))
+        buffered = BytesIO()
+        im.convert("RGB").save(buffered, format="JPEG", quality=40, optimize=True)
+        return base64.b64encode(buffered.getvalue()).decode()
+
+
+from io import BytesIO
+
+def build_prompt(page: Dict[str, Any]) -> List[Dict[str, str]]:
+    """Return OpenAI chat prompt messages list."""
+    cheatsheet = read_md(CHEATSHEET_PATH)
+    workflows = read_md(WORKFLOWS_PATH)
+
+    image_section = None
+    if page.get("image") and Path(page["image"]).exists():
+        try:
+            b64 = img_to_b64_jpeg(Path(page["image"]))
+            image_section = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}", "detail": "low"}}
+        except Exception:
+            pass
+
+    context_json = {
+        "describe": page.get("describe", ""),
+        "inspect": page.get("inspect", ""),
+        "layout_yolo_regions": page.get("layout_yolo_regions", []),
+        "layout_tatr_regions": page.get("layout_tatr_regions", []),
+        "blob_sample": page.get("blobs_sample", []),
+        "ocr_sample": page.get("ocr_sample", []),
+    }
+
+    sys_msg = textwrap.dedent(
+        f"""
+        You are an expert Natural-PDF engineer. Use the cheat-sheet and workflows to craft bespoke extraction code.
+        Return JSON with two keys: thought_process (concise reasoning) and code_suggestion (Python code). Do not add extra keys.
+        """
+    )
+
+    messages = [
+        {"role": "system", "content": sys_msg},
+        {"role": "system", "content": "CHEATSHEET:\n" + cheatsheet},
+        {"role": "system", "content": "WORKFLOWS:\n" + workflows},
+    ]
+
+    user_parts = [
+        f"Goal: {page.get('goal_tag') or 'generic_extraction'} — {page.get('goal', '') or 'Extract the most useful information (text, tables, key/value pairs) from the page.'}",
+        f"Page number: {page['page_number']}",
+        "Context JSON:" + json.dumps(context_json),
+        "Provide your JSON response now.",
+    ]
+    if image_section:
+        user_parts.insert(2, image_section)
+    messages.append({"role": "user", "content": "\n\n".join(user_parts)})
+    return messages
+
+
+def build_pdf_prompt(summary: Dict[str, Any]) -> List[Dict[str, Any]]:
+    cheatsheet = read_md(CHEATSHEET_PATH)
+    workflows = read_md(WORKFLOWS_PATH)
+
+    pdf_overview = [
+        f"PDF: {Path(summary['pdf']).name}",
+        f"Goal: {summary.get('goal') or 'Extract useful information from the document'}",
+        f"Total pages analysed: {len(summary['pages'])}",
+    ]
+
+    per_page_sections = []
+    for page in summary["pages"]:
+        image_section = None
+        if page.get("image") and Path(page["image"]).exists():
+            try:
+                b64 = img_to_b64_jpeg(Path(page["image"]))
+                image_section = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}", "detail": "low"}}
+            except Exception:
+                pass
+        context_json = {
+            "describe": page.get("describe", ""),
+            "inspect": page.get("inspect", ""),
+            "layout_yolo_regions": page.get("layout_yolo_regions", []),
+            "layout_tatr_regions": page.get("layout_tatr_regions", []),
+            "blob_sample": page.get("blobs_sample", []),
+            "ocr_sample": page.get("ocr_sample", []),
+        }
+        per_page_sections.append({
+            "page_number": page["page_number"],
+            "goal_tag": page.get("goal_tag") or "generic_extraction",
+            "image": image_section,
+            "context": context_json,
+        })
+
+    sys_msg = textwrap.dedent(
+        """
+        You are a Natural-PDF engineer with full access to the provided evidence
+        (describe/inspect text, YOLO & TATR regions, blob samples, OCR snippets, images).
+
+        Rely on these artefacts—not on generic heuristics. Avoid phrases like "try" or "usually this works".
+        If the evidence is genuinely insufficient, state exactly what is missing.
+
+        Extraction strategy:
+          1. Start with the text layer: `page.extract_text()`, `page.extract_table()`, or region selectors.
+          2. Use **anchor-based region selection**: locate a stable header/label/line/rect and select the area
+             between anchors via `.find()`, `.below()`, `.above()`, `.until()`, `.expand()`, etc.
+             Example: `page.find('text:contains(Violations)').below(until='text:bold')`.
+          3. Strongly prefer until= to find a specific ending point as opposed to a pixel-based approach,
+             as this allows your code to work on potentially other similar pages of the document.
+          3. Fall back to TATR or other vision models only if the text layer is unusable.
+             • Blanket advice like "run analyze_layout('tatr') on every page" is discouraged—
+               only invoke a layout model when anchor-based text extraction genuinely fails
+               or evidence shows complex unruled tables that require cell-grid inference.
+
+        Handle tables, key-value forms, and free-form paragraphs with the same anchor-driven approach. Key-value
+        forms might be easily extracted with .ask(...) or .extract(), feel free to mention as an option
+        but try to not rely on it.
+
+        Use Natural PDF Flows to access multi-page or columnar content, falling back on loops when necessary.
+
+        If it seems like the approach is not ideal, or that additional features would be useful in
+        this use case, outline the specifics of the issues and what additional information/approaches/code/etc
+        would allow you to more easily extract the information.
+
+        When working with pages or elements, try to use .apply and .filter. Natural PDF stresses
+        a fluent API, and for loops are discouraged.
+
+        Return ONE JSON object with exactly these keys:
+          • thought_process – concise reasoning and feature/enhancement requests (≤4 short paragraphs)
+          • code_suggestion – executable Python snippet using natural_pdf
+          • difficult_elements – bullet list of page features that are *hard* for any extraction engine **and that you can _prove_ from the supplied evidence** (tiny fonts in `describe`, scanned_image flag, missing text layer, no ruling lines inferred from `layout_*` arrays, etc.).  If no difficult element is evident, return an empty list.  Do *not* speculate.
+          • test_case – short description of how this PDF/page could be turned into an automated regression test (e.g. "assert tbl.df.shape == (12, 5)")
+
+        Code-style expectations:
+          • Use **real sample text** from the page as anchors — never placeholders such as
+            "AnchorText", "Texts", or "Also".  If no stable anchor is visible, state that
+            fact in the *thought_process* and leave a TODO rather than shipping a placeholder.
+          • When a page is flagged as *scanned_image* (or no text layer exists) your code
+            MUST call `page.apply_ocr()` *before* any `.find()` or `.extract_text()` calls.
+          • Prefer `header_el.parent('table')` (up-tree navigation) over a global
+            `page.find('table')[i]` positional index — this is more robust when multiple tables
+            are present.
+          • For tables, assume Natural-PDF returns a `TableResult`; use `tbl.df` or
+            `tbl.to_df(header='first')` instead of manually building a DataFrame unless you
+            need custom header/skiprows logic.
+          • Explicitly name the extractor (`analyze_layout('tatr')`, `analyze_layout('detectron')`)
+            instead of vague comments like "YOLO fallback".
+        """
+    )
+
+    messages = [
+        {"role": "system", "content": sys_msg},
+        {"role": "system", "content": "CHEATSHEET:\n" + cheatsheet},
+        {"role": "system", "content": "WORKFLOWS:\n" + workflows},
+    ]
+
+    user_content: List[Dict[str, Any]] = [{"type": "text", "text": "\n".join(pdf_overview)}]
+    for sec in per_page_sections:
+        txt = json.dumps({k: sec[k] for k in ("page_number", "goal_tag", "context")})
+        user_content.append({"type": "text", "text": txt})
+        if sec["image"]:
+            user_content.append(sec["image"])
+
+    messages.append({"role": "user", "content": user_content})
+    return messages
+
+
+# -------------------------------------------------
+# Structured output via Pydantic model + function call
+# -------------------------------------------------
+
+
+class DocOutput(BaseModel):
+    """LLM enrichment for a whole PDF (single object)."""
+
+    thought_process: str = Field(..., description="Overall reasoning about the PDF and extraction plan")
+    code_suggestion: str = Field(..., description="Python snippet using natural_pdf to achieve the user goal for this PDF")
+    difficult_elements: List[str] = Field(..., description="Bullet list of page features that are *hard* for any extraction engine")
+    test_case: str = Field(..., description="Short description of how this PDF/page could be turned into an automated regression test")
+
+
+def enrich_summary(summary_path: Path, api_key: str, model: str = "o3"):
+    summary = json.loads(summary_path.read_text())
+
+    # Decide whether to re-enrich
+    if not FORCE and summary.get("thought_process") and summary.get("code_suggestion"):
+        print(f"[skip] {summary_path.parent.name}: already enriched (use --force to overwrite)")
+        return
+
+    print(f"[send] {summary_path.parent.name}: requesting enrichment for entire document")
+
+    client = OpenAI(api_key=api_key)
+    msgs = build_pdf_prompt(summary)
+
+    completion = client.beta.chat.completions.parse(
+        model=model,
+        messages=msgs,
+        response_format=DocOutput
+    )
+
+    # Expect exactly one function call in the first choice
+    doc_out = completion.choices[0].message.parsed
+
+    summary["thought_process"] = doc_out.thought_process
+    summary["code_suggestion"] = doc_out.code_suggestion
+    summary["difficult_elements"] = doc_out.difficult_elements
+    summary["test_case"] = doc_out.test_case
+
+    print("** Code suggestion:\n", doc_out.code_suggestion)
+    print("** Thought process:\n", doc_out.thought_process)
+
+    summary_path.write_text(json.dumps(summary, indent=2, ensure_ascii=False))
+    print(f"[update] Wrote enriched data to {summary_path}")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--submission", help="Submission ID to enrich (folder name)")
+    ap.add_argument("--model", default="o3")
+    ap.add_argument("--api-key", default=os.getenv("OPENAI_API_KEY"), help="OpenAI key if not in env")
+    ap.add_argument("--force", action="store_true", help="overwrite existing enrichment")
+    args = ap.parse_args()
+    
+    if not args.api_key:
+        raise SystemExit("OPENAI_API_KEY not provided")
+
+    global FORCE
+    FORCE = args.force
+
+    if args.submission:
+        summary_path = EVAL_DIR / args.submission / "summary.json"
+        if not summary_path.exists():
+            raise SystemExit("summary.json not found for submission")
+        enrich_summary(summary_path, args.api_key, args.model)
+    else:
+        for summary_path in EVAL_DIR.glob("*/summary.json"):
+            enrich_summary(summary_path, args.api_key, args.model)
+
+
+if __name__ == "__main__":
+    main() 

tools/bad_pdf_eval/reporter.py

@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+from typing import Any, Dict
+
+from rich.console import Console
+
+console = Console()
+
+
+def save_json(data: Dict[str, Any], path: Path):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+
+def log_section(title: str):
+    console.rule(f"[bold cyan]{title}") 

tools/bad_pdf_eval/utils.py

@@ -0,0 +1,127 @@
+import re
+from pathlib import Path
+from typing import Optional
+import urllib.request
+import ssl
+from rich.console import Console
+
+ROOT_DIR = Path(__file__).resolve().parent.parent.parent  # project root
+BAD_PDF_DIR = ROOT_DIR / "bad_pdf_analysis"
+SUBMISSIONS_DIR = ROOT_DIR / "bad-pdfs" / "submissions"
+
+console = Console()
+
+
+def slugify(value: str, max_length: int = 50) -> str:
+    """Make a filesystem-safe filename from arbitrary text."""
+    value = re.sub(r"[^\w\-\. ]+", "_", value)
+    value = value.strip().replace(" ", "_")
+    return value[:max_length]
+
+
+def _search_directory(directory: Path, pattern: str, predicate) -> Optional[Path]:
+    """Utility: recursively search *directory* using glob *pattern*; return first match passing *predicate*."""
+    for p in directory.glob(pattern):
+        try:
+            if predicate(p):
+                return p
+        except Exception:
+            # Just in case of any weird permission/path errors – skip
+            continue
+    return None
+
+
+def find_local_pdf(submission_id: str, pdf_url: Optional[str] = None) -> Optional[Path]:
+    """Return the local path to the PDF for *submission_id*.
+
+    Search strategy (in order):
+    1. Inside ``bad_pdf_analysis`` where early analyses live – matching *submission_id* in filename.
+    2. Inside ``bad-pdfs/submissions`` where raw downloads reside – matching *submission_id*.
+    3. If *pdf_url* is supplied, also try the basename of the URL in ``bad-pdfs/submissions``.
+    4. As a last resort – try to download the PDF to the submissions folder
+    """
+
+    submission_id_lower = submission_id.lower()
+
+    # 1) Search the processed-analysis folder (legacy path)
+    path = _search_directory(
+        BAD_PDF_DIR,
+        f"**/{submission_id}*.pdf",
+        lambda p: submission_id_lower in p.stem.lower(),
+    )
+    if path:
+        return path
+
+    # 2) Search the raw submissions folder by id substring
+    path = _search_directory(
+        SUBMISSIONS_DIR,
+        f"**/*{submission_id}*.pdf",
+        lambda p: submission_id_lower in p.stem.lower(),
+    )
+    if path:
+        return path
+
+    # 3) Use basename from URL, if provided
+    if pdf_url:
+        # Extract filename portion before any query string
+        from urllib.parse import urlparse
+
+        parsed = urlparse(pdf_url)
+        filename = Path(parsed.path).name
+        if filename:
+            candidate = SUBMISSIONS_DIR / filename
+            if candidate.exists():
+                return candidate
+            # fallback: case-insensitive glob match on stem
+            stem = Path(filename).stem.lower()
+            path = _search_directory(
+                SUBMISSIONS_DIR,
+                f"**/{stem}*.pdf",
+                lambda p: stem in p.stem.lower(),
+            )
+            if path:
+                return path
+
+    # 4) As a last resort – try to download the PDF to the submissions folder
+    if pdf_url:
+        try:
+            SUBMISSIONS_DIR.mkdir(parents=True, exist_ok=True)
+            from urllib.parse import urlparse
+
+            parsed = urlparse(pdf_url)
+            filename = Path(parsed.path).name or f"{submission_id}.pdf"
+            # Sanitise filename a bit – avoid query strings leaking in
+            filename = slugify(filename, max_length=100)
+            if not filename.lower().endswith(".pdf"):
+                filename += ".pdf"
+
+            dest_path = SUBMISSIONS_DIR / filename
+            if not dest_path.exists():
+                # Retrieve the file (no progress bar – keep it simple and robust)
+                try:
+                    # Some hosts reject default Python user-agent; set one.
+                    req = urllib.request.Request(pdf_url, headers={"User-Agent": "Mozilla/5.0"})
+                    # Disable SSL verification edge-cases the storage host sometimes triggers
+                    ctx = ssl.create_default_context()
+                    with urllib.request.urlopen(req, context=ctx, timeout=30) as resp, open(dest_path, "wb") as f:
+                        f.write(resp.read())
+                except Exception as e:
+                    # Fallback: try requests if available (venv usually has it)
+                    try:
+                        import requests
+
+                        r = requests.get(pdf_url, timeout=30)
+                        r.raise_for_status()
+                        with open(dest_path, "wb") as f:
+                            f.write(r.content)
+                    except Exception as e2:
+                        console.print(f"[red]Download failed for {submission_id}: {e2}")
+                        return None
+            if dest_path.exists():
+                return dest_path
+        except Exception:
+            # Networking problems, permissions, etc. – silently give up; caller will log
+            return None
+
+    # None found
+    return None 

tools/rtl_smoke_test.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""RTL pipeline smoke-test for natural-pdf.
+
+Run it from the repository root:
+
+    python tools/rtl_smoke_test.py
+
+It loads *pdfs/arabic.pdf* and performs a handful of checks that cover the
+most common break-points we identified for RTL handling:
+    1. char ingestion / word grouping
+    2. selector finds on logical Arabic tokens
+    3. bracket mirroring
+    4. number directionality inside RTL lines
+
+Exit code is **0** when all checks pass, **1** otherwise.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from bidi.algorithm import get_display  # type: ignore
+
+from natural_pdf import PDF
+from natural_pdf.utils.bidi_mirror import mirror_brackets
+
+
+PDF_PATH = Path("pdfs/arabic.pdf")
+
+if not PDF_PATH.exists():
+    print(f"❗  PDF not found: {PDF_PATH.resolve()}")
+    sys.exit(1)
+
+# ────────────────────────────────────────────────────────────────
+# Helpers
+# ────────────────────────────────────────────────────────────────
+
+failures: list[str] = []
+
+def check(cond: bool, msg: str):
+    """Collect failures but keep running to show full report."""
+    if cond:
+        print(f"✓ {msg}")
+    else:
+        print(f"✗ {msg}")
+        failures.append(msg)
+
+
+# ────────────────────────────────────────────────────────────────
+# Load page
+# ────────────────────────────────────────────────────────────────
+
+pdf = PDF(str(PDF_PATH))
+page = pdf.pages[0]
+
+# Basic char/word counts (should be non-zero)
+check(len(page.chars) > 0, "chars were ingested")
+check(len(page.words) > 0, "words were grouped")
+
+# First line logical text
+logical_first_line = page.extract_text().split("\n")[0]
+print("First logical line:")
+print("  ", logical_first_line)
+
+# 1. Arabic keyword should be findable
+check(page.find(text="مكرر") is not None, "page.find works for Arabic token 'مكرر'")
+
+# 2. Reversed token should NOT match
+check(page.find(text="مكرر"[::-1]) is None, "reverse token does not match (logical order stored)")
+
+# 3. Extracted line should already show the bracket pair in correct orientation
+check("(مكرر)" in logical_first_line, "parentheses orientation is correct in extract_text")
+
+# 4. Western numbers must stay LTR inside RTL
+#    After visual re-order, the line should end with 2022 (year on the left visually → last in logical string)
+check(logical_first_line.rstrip().endswith("2022"), "Western number '2022' kept logical placement")
+
+print("\nSummary: {} passed, {} failed".format(4 - len(failures), len(failures)))
+
+sys.exit(0 if not failures else 1) 

natural_pdf-0.1.28.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-natural_pdf
-pdfs