NaviDC-OCR two-stage document parsing demo

.gitattributes

@@ -36,3 +36,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 examples/code.png filter=lfs diff=lfs merge=lfs -text
 examples/layout.jpg filter=lfs diff=lfs merge=lfs -text
 examples/layout_distorted.jpg filter=lfs diff=lfs merge=lfs -text
+examples/crumpled_page.jpg filter=lfs diff=lfs merge=lfs -text
+examples/journal_page.jpg filter=lfs diff=lfs merge=lfs -text

NaviOCR/config.py

@@ -4,8 +4,9 @@
 
 model_path = "StarDoc-AI/NaviDC-OCR"
 
-BACKEND = "vllm-async-engine"
-# [vllm-engine, vllm-async-engine]
+BACKEND = "transformers"
+# [transformers, vllm-engine, vllm-async-engine]
+# This Space uses the transformers backend (ZeroGPU).
 
 
 # =========================

NaviOCR/vlm_utils/__init__.py

@@ -5,7 +5,6 @@ import importlib
 __lazy_attrs__ = {
     "NaviOCRClient": (".NaviOCR_client", "NaviOCRClient"),
     "NaviOCRSamplingParams": (".NaviOCR_client", "NaviOCRSamplingParams"),
-    "NaviOCRLogitsProcessor": (".vlm_client.vllm_v1_no_repeat_ngram", "VllmV1NoRepeatNGramLogitsProcessor"),
 }
 
 

README.md

@@ -6,28 +6,42 @@ colorTo: purple
 sdk: gradio
 sdk_version: 6.24.0
 app_file: app.py
-short_description: Document parsing for digital and camera-captured docs
+short_description: Parse digital & photographed documents into Markdown
 python_version: "3.12"
 startup_duration_timeout: 30m
+license: apache-2.0
+models:
+  - StarDoc-AI/NaviDC-OCR
+pinned: false
 ---
 
 # NaviDC-OCR
 
-NaviDC-OCR is a lightweight (~1.2B parameters) Vision-Language Model for unified document parsing across digital and camera-captured documents. It extracts structured text, tables, formulas, and layout from document images.
-
-## How it works
-
-1. **Layout Detection**: The model first analyzes the document layout, identifying regions like text, tables, formulas, images, and code blocks.
-2. **Content Extraction**: Each detected region is then individually parsed to extract the content (text, LaTeX formulas, OTSL tables, code, etc.).
-
-The model is based on the Qwen2.5-VL architecture and uses a two-step extraction pipeline.
-
-## Links
-
-- [Paper (arXiv:2608.12898)](https://arxiv.org/abs/2608.12898)
-- [Model on Hugging Face](https://huggingface.co/StarDoc-AI/NaviDC-OCR)
-- [GitHub Repository](https://github.com/caipeng328/NaviDC-OCR)
-
-## License
-
-Apache-2.0
+Demo of [StarDoc-AI/NaviDC-OCR](https://huggingface.co/StarDoc-AI/NaviDC-OCR), a 1.2B
+document-parsing vision-language model that unifies **digital** and
+**camera-captured** documents
+([paper](https://huggingface.co/papers/2608.12898) ·
+[code](https://github.com/caipeng328/NaviDC-OCR)).
+
+The app follows the authors' two-stage pipeline:
+
+1. **Layout** — the page is resized to 1036×1036 and the model emits
+   reading-ordered regions. `Detection` mode returns axis-aligned boxes (digital
+   pages, flat scans); `Segmentation` mode returns multi-point polygons, which is
+   the paper's geometry-aware path for photographed, curved or crumpled pages.
+2. **Recognition** — each region is cropped (polygon-masked and de-rotated where
+   needed) and recognized with the block-type-specific prompt and sampling
+   parameters from the reference implementation. Tables come back as OTSL and are
+   converted to HTML, equations to LaTeX, using the authors' post-processors
+   (vendored under `NaviOCR/`).
+
+Outputs: rendered document, Markdown source, layout overlay, and the raw block
+list as JSON.
+
+## Credits
+
+Example pages are the official assets from the
+[NaviDC-OCR model card](https://huggingface.co/StarDoc-AI/NaviDC-OCR/tree/main/assets)
+(Apache-2.0). The `NaviOCR/` package is a trimmed copy of the authors'
+[reference implementation](https://github.com/caipeng328/NaviDC-OCR) (Apache-2.0),
+limited to the modules needed for the transformers backend.

app.py

@@ -1,150 +1,404 @@
-import os
+"""NaviDC-OCR — document parsing across digital and camera-captured documents.
 
-os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+Two-stage pipeline, faithful to the authors' reference implementation
+(https://github.com/caipeng328/NaviDC-OCR):
 
-import spaces  # MUST come before any CUDA-touching import
-import torch
-import gradio as gr
+1. Layout stage — the page is resized to 1036x1036 and the model predicts
+   reading-ordered blocks as `<box:...><label:...><angle>` (boxes in
+   "Detection" mode, multi-point polygons in "Segmentation" mode, which is what
+   the paper uses for curved / camera-captured pages).
+2. Recognition stage — every block is cropped (polygon-masked when needed),
+   de-rotated, and recognized with the block-type-specific prompt and sampling
+   parameters from `NaviOCR/vlm_utils/NaviOCR_client.py`, then post-processed
+   (OTSL tables -> HTML, LaTeX equation fixes) with the authors' post-processors.
+"""
+
+import base64
+import io
+import json
+import os
+import tempfile
 import time
-from PIL import Image
+from dataclasses import asdict
+from typing import Any
 
-import NaviOCR.config as CONFIG
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
 
-# Force transformers backend (vLLM is not available on ZeroGPU)
-CONFIG.BACKEND = "transformers"
+import spaces  # noqa: F401  (must precede torch / transformers)
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image, ImageDraw, ImageFont
+from transformers import AutoModelForImageTextToText, AutoProcessor
 
-from transformers import AutoProcessor, AutoModelForImageTextToText
-from NaviOCR.vlm_utils.NaviOCR_client import NaviOCRClient
+from NaviOCR.vlm_utils.NaviOCR_client import (
+    DEFAULT_PROMPTS,
+    DEFAULT_SAMPLING_PARAMS,
+    LAYOUT_PROMPTS,
+    NaviOCRClient,
+)
+from NaviOCR.vlm_utils.post_process.otsl2html import convert_otsl_to_html
+from NaviOCR.vlm_utils.vlm_client import SamplingParams
 
 MODEL_ID = "StarDoc-AI/NaviDC-OCR"
 
-# Load model eagerly at module scope (ZeroGPU rule #2)
-print(f"Loading {MODEL_ID} ...")
-processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)
+processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True, use_fast=True)
 model = AutoModelForImageTextToText.from_pretrained(
     MODEL_ID,
     trust_remote_code=True,
     torch_dtype=torch.bfloat16,
     attn_implementation="sdpa",
-).to("cuda").eval()
+)
+model = model.eval().to("cuda")
 
-# Initialize the NaviOCR client with transformers backend directly
-predictor = NaviOCRClient(
+client = NaviOCRClient(
     backend="transformers",
     model=model,
     processor=processor,
-    use_tqdm=False,
+    prompts=DEFAULT_PROMPTS,
+    sampling_params=DEFAULT_SAMPLING_PARAMS,
+    batch_size=0,  # the authors' transformers backend default: one region at a time
+    use_tqdm=True,
 )
 
-print("Model loaded successfully.")
+PARATEXT_TYPES = {"header", "footer", "page_number", "aside_text", "page_footnote", "unknown"}
+CAPTION_TYPES = {
+    "table_caption",
+    "image_caption",
+    "code_caption",
+    "table_footnote",
+    "image_footnote",
+}
+BLOCK_COLORS = {
+    "title": (216, 27, 96),
+    "text": (30, 136, 229),
+    "table": (0, 137, 123),
+    "table_caption": (0, 172, 193),
+    "table_footnote": (0, 172, 193),
+    "image": (245, 124, 0),
+    "image_caption": (251, 192, 45),
+    "image_footnote": (251, 192, 45),
+    "equation": (142, 36, 170),
+    "equation_block": (142, 36, 170),
+    "code": (94, 53, 177),
+    "code_caption": (121, 85, 72),
+    "algorithm": (94, 53, 177),
+    "list": (57, 73, 171),
+    "ref_text": (109, 76, 65),
+    "seal": (211, 47, 47),
+    "char": (0, 121, 107),
+}
+DEFAULT_COLOR = (117, 117, 117)
+
+
+def _sampling_params(task: str, max_new_tokens: int) -> SamplingParams:
+    """Authors' per-task sampling params, with a bounded generation length."""
+    base = DEFAULT_SAMPLING_PARAMS.get(task) or DEFAULT_SAMPLING_PARAMS["default"]
+    fields = asdict(base)
+    fields["max_new_tokens"] = int(max_new_tokens)
+    return SamplingParams(**fields)
+
+
+def _points(bbox, width: int, height: int) -> np.ndarray:
+    pts = np.array(bbox, dtype=np.float32).reshape(-1, 2)
+    pts[:, 0] *= width
+    pts[:, 1] *= height
+    return pts.astype(np.int32)
+
+
+def _crop(image: Image.Image, bbox) -> Image.Image:
+    pts = _points(bbox, image.width, image.height)
+    x1, y1 = int(pts[:, 0].min()), int(pts[:, 1].min())
+    x2, y2 = int(pts[:, 0].max()), int(pts[:, 1].max())
+    x1, y1 = max(0, x1), max(0, y1)
+    x2, y2 = min(image.width, max(x2, x1 + 1)), min(image.height, max(y2, y1 + 1))
+    return image.crop((x1, y1, x2, y2))
+
+
+def _data_uri(image: Image.Image, max_width: int = 900) -> str:
+    if image.width > max_width:
+        ratio = max_width / image.width
+        image = image.resize((max_width, max(1, int(image.height * ratio))), Image.Resampling.LANCZOS)
+    buffer = io.BytesIO()
+    image.convert("RGB").save(buffer, format="JPEG", quality=88)
+    return "data:image/jpeg;base64," + base64.b64encode(buffer.getvalue()).decode()
+
+
+def _font(size: int):
+    try:
+        return ImageFont.load_default(size=size)
+    except TypeError:  # very old Pillow
+        return ImageFont.load_default()
+
+
+def draw_layout(image: Image.Image, blocks: list) -> Image.Image:
+    """Overlay the predicted blocks, numbered in predicted reading order."""
+    canvas = image.convert("RGB").copy()
+    overlay = Image.new("RGBA", canvas.size, (0, 0, 0, 0))
+    draw = ImageDraw.Draw(overlay)
+    line_width = max(2, round(min(canvas.size) / 400))
+    font = _font(max(13, round(min(canvas.size) / 55)))
+
+    for order, block in enumerate(blocks, start=1):
+        color = BLOCK_COLORS.get(block.type, DEFAULT_COLOR)
+        pts = _points(block.bbox, canvas.width, canvas.height)
+        if len(pts) == 2:
+            xy = [(int(pts[0][0]), int(pts[0][1])), (int(pts[1][0]), int(pts[1][1]))]
+            draw.rectangle(xy, outline=color + (255,), width=line_width)
+            anchor = xy[0]
+        else:
+            polygon = [(int(x), int(y)) for x, y in pts]
+            draw.polygon(polygon, outline=color + (255,), fill=color + (28,), width=line_width)
+            anchor = min(polygon, key=lambda p: (p[1], p[0]))
+
+        label = f"{order} {block.type}"
+        if block.angle:
+            label += f" {block.angle}\u00b0"
+        tx, ty = anchor[0], max(0, anchor[1] - font.size - 4)
+        text_box = draw.textbbox((tx, ty), label, font=font)
+        draw.rectangle(
+            (text_box[0] - 2, text_box[1] - 2, text_box[2] + 2, text_box[3] + 2),
+            fill=color + (235,),
+        )
+        draw.text((tx, ty), label, fill=(255, 255, 255, 255), font=font)
+
+    return Image.alpha_composite(canvas.convert("RGBA"), overlay).convert("RGB")
 
 
-def blocks_to_markdown(blocks):
-    """Convert NaviOCR ContentBlock list to markdown string."""
-    md_parts = []
+def blocks_to_markdown(image: Image.Image, blocks: list, drop_paratext: bool):
+    """Assemble reading-ordered blocks into Markdown (raw + display variants)."""
+    parts: list[str] = []
+    figures: dict[str, Image.Image] = {}
+
     for block in blocks:
-        btype = block.get("type", "text")
-        content = block.get("content")
-        if content is None:
+        block_type = block.type
+        content = (block.content or "").strip()
+
+        if drop_paratext and block_type in PARATEXT_TYPES:
+            continue
+
+        if block_type == "image":
+            key = f"figure_{len(figures) + 1}.jpg"
+            figures[key] = _crop(image, block.bbox)
+            parts.append(f"![{key}]({key})")
             continue
-        content = content.strip()
+
         if not content:
             continue
-        if btype == "title":
-            md_parts.append(f"## {content}\n")
-        elif btype == "table":
-            md_parts.append(f"{content}\n")
-        elif btype == "equation":
-            md_parts.append(f"{content}\n")
-        elif btype == "code":
-            md_parts.append(f"```\n{content}\n```\n")
-        elif btype == "image":
-            md_parts.append(f"![image]({content})\n")
-        elif btype == "list":
-            md_parts.append(f"{content}\n")
-        else:
-            md_parts.append(f"{content}\n")
-    return "\n".join(md_parts)
 
+        if block_type == "title":
+            parts.append(f"## {content}")
+        elif block_type == "table":
+            parts.append(content)  # already OTSL -> HTML in post-processing
+        elif block_type == "char":
+            parts.append(convert_otsl_to_html(content) or content)
+        elif block_type in {"code", "algorithm"}:
+            parts.append(f"```\n{content}\n```")
+        elif block_type in CAPTION_TYPES:
+            parts.append(f"*{content}*")
+        elif block_type == "seal":
+            parts.append(f"**[seal]** {content}")
+        else:  # text, list, ref_text, equation, phonetic, header/footer, ...
+            parts.append(content)
 
-@spaces.GPU(duration=120)
-def parse_document(image: Image.Image, progress=gr.Progress(track_tqdm=True)):
-    """Parse a document image and extract structured text, tables, formulas, and layout.
+    raw_markdown = "\n\n".join(parts).strip()
+    display_markdown = raw_markdown
+    for key, crop in figures.items():
+        display_markdown = display_markdown.replace(
+            f"![{key}]({key})",
+            f'<img src="{_data_uri(crop)}" style="max-width:100%;border-radius:6px" />',
+        )
+    return raw_markdown, display_markdown
+
+
+def _write_markdown(markdown: str) -> str:
+    directory = tempfile.mkdtemp(prefix="navidc_ocr_")
+    path = os.path.join(directory, "navidc_ocr.md")
+    with open(path, "w", encoding="utf-8") as handle:
+        handle.write(markdown)
+    return path
+
+
+@spaces.GPU(duration=150)
+def parse_document(
+    image: Image.Image,
+    layout_mode: str = "Detection",
+    drop_paratext: bool = True,
+    max_new_tokens: int = 2048,
+    progress=gr.Progress(track_tqdm=True),
+) -> tuple[Image.Image, str, str, list[dict[str, Any]], str, str]:
+    """Parse a document page into Markdown with NaviDC-OCR.
 
     Args:
-        image: A document image (digital or camera-captured).
+        image: A document page — a digital page, a scan, or a camera photo.
+        layout_mode: "Detection" for axis-aligned boxes (digital pages, flat
+            scans) or "Segmentation" for multi-point polygons (camera-captured,
+            curved or crumpled pages).
+        drop_paratext: Drop headers, footers, page numbers and margin notes.
+        max_new_tokens: Generation cap per region.
 
     Returns:
-        Markdown-formatted structured text with layout, tables, formulas, and code blocks.
+        The layout overlay, rendered Markdown, raw Markdown, the block list as
+        JSON, a downloadable .md file, and a short run report.
     """
     if image is None:
-        return "Please upload an image first."
+        raise gr.Error("Please provide a document image first.")
+
+    started = time.time()
+    page = image.convert("RGB") if isinstance(image, Image.Image) else Image.open(image).convert("RGB")
+    helper = client.helper
+    mode = layout_mode if layout_mode in LAYOUT_PROMPTS else "Detection"
+
+    # ---- stage 1: layout ------------------------------------------------
+    layout_image = helper.prepare_for_layout(page)  # resized to 1036x1036
+    raw_layout = client.client.predict(
+        layout_image,
+        LAYOUT_PROMPTS[mode],
+        _sampling_params("layout", max(1024, int(max_new_tokens))),
+    )
+    blocks = helper.parse_layout_output(raw_layout)
+    layout_seconds = time.time() - started
 
-    if image.mode != "RGB":
-        image = image.convert("RGB")
+    if not blocks:
+        report = (
+            f"No layout blocks were parsed in **{mode}** mode "
+            f"({layout_seconds:.1f}s). Raw layout output is in the *Blocks* tab."
+        )
+        return (
+            page,
+            "",
+            "",
+            [{"raw_layout_output": raw_layout}],
+            _write_markdown(""),
+            report,
+        )
 
-    start = time.time()
-    # The NaviOCR two-step extract: layout detection → content extraction per block
-    results = predictor.batch_two_step_extract(images=[image])
-    elapsed = time.time() - start
+    # ---- stage 2: per-region recognition --------------------------------
+    block_images, prompts, params, indices = helper.prepare_for_extract(page, blocks)
+    params = [
+        _sampling_params(blocks[idx].type, max_new_tokens) for idx in indices
+    ]
+    if block_images:
+        outputs = client.client.batch_predict(block_images, prompts, params)
+        for idx, output in zip(indices, outputs):
+            blocks[idx].content = output
 
-    blocks = results[0]
-    markdown = blocks_to_markdown(blocks)
+    blocks = helper.post_process(blocks)
 
-    # Append timing info
-    markdown += f"\n\n---\n*Parsed in {elapsed:.1f}s*"
+    raw_markdown, display_markdown = blocks_to_markdown(page, blocks, drop_paratext)
+    overlay = draw_layout(page, blocks)
+    total_seconds = time.time() - started
 
-    return markdown
+    counts: dict[str, int] = {}
+    for block in blocks:
+        counts[block.type] = counts.get(block.type, 0) + 1
+    summary = ", ".join(f"{count}\u00d7{name}" for name, count in sorted(counts.items()))
+    report = (
+        f"**{len(blocks)} regions** in `{mode}` mode \u2014 {summary}.  \n"
+        f"Layout {layout_seconds:.1f}s \u00b7 total {total_seconds:.1f}s."
+    )
+
+    return (
+        overlay,
+        display_markdown,
+        raw_markdown,
+        [dict(block) for block in blocks],
+        _write_markdown(raw_markdown),
+        report,
+    )
 
 
 CSS = """
-#col-container { max-width: 1100px; margin: 0 auto; }
+#col-container { max-width: 1400px; margin: 0 auto; }
 .dark .gradio-container { color: var(--body-text-color); }
+#doc-md { overflow-x: auto; }
+#doc-md table { border-collapse: collapse; }
+#doc-md td, #doc-md th { border: 1px solid var(--border-color-primary); padding: 4px 8px; }
 """
 
-with gr.Blocks(theme=gr.themes.Citrus(), css=CSS) as demo:
-    gr.Markdown(
-        """
-        # NaviDC-OCR: Document Parsing Across Digital and Camera-Captured Documents
+LATEX = [
+    {"left": "$$", "right": "$$", "display": True},
+    {"left": "$", "right": "$", "display": False},
+    {"left": "\\(", "right": "\\)", "display": False},
+    {"left": "\\[", "right": "\\]", "display": True},
+]
 
-        Upload a document image (digital or camera-captured) to extract structured text,
-        tables, formulas, and layout as Markdown.
+with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title="NaviDC-OCR") as demo:
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown(
+            """
+# NaviDC-OCR — document parsing, digital *and* camera-captured
 
-        [Paper](https://arxiv.org/abs/2608.12898) · [Model](https://huggingface.co/StarDoc-AI/NaviDC-OCR) · [GitHub](https://github.com/caipeng328/NaviDC-OCR)
-        """
-    )
-    with gr.Row():
-        image_in = gr.Image(
-            label="Document Image",
-            type="pil",
-            sources=["upload", "clipboard"],
-            height=500,
-        )
+A 1.2B document-parsing VLM that reads layout, text, tables, formulas and code
+off flat scans **and** photographed / crumpled pages, and returns Markdown.
 
-    run_btn = gr.Button("Parse Document", variant="primary")
+[model](https://huggingface.co/StarDoc-AI/NaviDC-OCR) ·
+[paper](https://huggingface.co/papers/2608.12898) ·
+[code](https://github.com/caipeng328/NaviDC-OCR)
+"""
+        )
+        with gr.Row():
+            with gr.Column(scale=4):
+                image = gr.Image(label="Document page", type="pil", height=460)
+                layout_mode = gr.Radio(
+                    choices=[
+                        ("Boxes — digital pages & flat scans", "Detection"),
+                        ("Multi-point — photos, curved or crumpled pages", "Segmentation"),
+                    ],
+                    value="Detection",
+                    label="Layout mode",
+                )
+                run_button = gr.Button("Parse document", variant="primary")
+                report = gr.Markdown()
+                with gr.Accordion("Advanced settings", open=False):
+                    drop_paratext = gr.Checkbox(
+                        value=True,
+                        label="Drop headers, footers, page numbers and margin notes",
+                    )
+                    max_new_tokens = gr.Slider(
+                        256, 4096, value=2048, step=128, label="Max new tokens per region"
+                    )
+            with gr.Column(scale=6):
+                with gr.Tabs():
+                    with gr.Tab("Document"):
+                        document = gr.Markdown(
+                            latex_delimiters=LATEX,
+                            elem_id="doc-md",
+                            show_copy_button=True,
+                        )
+                    with gr.Tab("Markdown source"):
+                        markdown_source = gr.Code(
+                            language="markdown", lines=28, interactive=False, label=None
+                        )
+                    with gr.Tab("Layout"):
+                        overlay = gr.Image(label="Predicted regions (reading order)", height=620)
+                    with gr.Tab("Blocks"):
+                        blocks_json = gr.JSON(label="Blocks")
+                markdown_file = gr.DownloadButton("Download Markdown")
 
-    output_md = gr.Markdown(
-        label="Parsed Result",
-        value="Upload an image and click **Parse Document** to see results here.",
-    )
+        gr.Examples(
+            examples=[
+                ["examples/journal_page.jpg", "Detection"],
+                ["examples/crumpled_page.jpg", "Segmentation"],
+                ["examples/table.png", "Detection"],
+                ["examples/formula.png", "Detection"],
+                ["examples/code.png", "Detection"],
+                ["examples/scientific_figure.png", "Detection"],
+            ],
+            inputs=[image, layout_mode],
+            outputs=[overlay, document, markdown_source, blocks_json, markdown_file, report],
+            fn=parse_document,
+            cache_examples=True,
+            cache_mode="lazy",
+            label="Examples from the NaviDC-OCR model card",
+        )
 
-    run_btn.click(fn=parse_document, inputs=[image_in], outputs=[output_md], api_name="parse")
-
-    gr.Examples(
-        examples=[
-            "examples/text.png",
-            "examples/table.png",
-            "examples/formula.png",
-            "examples/code.png",
-            "examples/layout.jpg",
-            "examples/layout_distorted.jpg",
-            "examples/scientific_figure.png",
-        ],
-        inputs=[image_in],
-        outputs=[output_md],
+    gr.on(
+        triggers=[run_button.click],
         fn=parse_document,
-        cache_examples=True,
-        cache_mode="lazy",
+        inputs=[image, layout_mode, drop_paratext, max_new_tokens],
+        outputs=[overlay, document, markdown_source, blocks_json, markdown_file, report],
     )
 
-demo.launch(mcp_server=True)
+if __name__ == "__main__":
+    demo.queue(max_size=16).launch(mcp_server=True)

requirements.txt

@@ -1,20 +1,9 @@
-torch
+transformers==4.57.1
 torchvision
-transformers
 accelerate
-sentencepiece
-safetensors
-qwen-vl-utils
-pillow>=11,<12
 numpy
-opencv-python-headless>=4.12,<5
+pillow
+opencv-python-headless
+pydantic
 loguru
 tqdm
-pyclipper
-shapely
-fast-langdetect
-beautifulsoup4
-pydantic
-json-repair
-aiofiles
-httpx