dot-parser 2.0.0__py3-none-any.whl

dot_parser/pricing.py

@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: Kannon For Deep Tech
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Per-backend pricing helpers.
+
+Exposes ``cost_per_1k_pages`` and ``estimate_cost``. Name-based so callers
+can query pricing without instantiating a backend (no API key needed).
+
+Sources: https://mistral.ai/news/ocr-4/ and the LlamaCloud pricing page.
+"""
+
+from typing import Literal
+
+BackendName = Literal["pymu", "docling", "mistral", "llama"]
+LlamaTier = Literal["fast", "cost_effective", "agentic", "agentic_plus"]
+
+_MISTRAL_SYNC = 4.0
+_MISTRAL_BATCH = 2.0
+
+# LlamaCloud bills in credits; rates below are $/1k pages assuming
+# $0.001/credit (the public list price at the time of writing).
+_LLAMA_PER_TIER: dict[str, float] = {
+    "fast": 1.0,
+    "cost_effective": 3.0,
+    "agentic": 10.0,
+    "agentic_plus": 45.0,
+}
+
+
+def cost_per_1k_pages(
+    name: BackendName,
+    *,
+    tier: LlamaTier = "cost_effective",
+    batch: bool = False,
+) -> float:
+    """Return USD cost per 1k pages for a backend.
+
+    ``tier`` applies only to ``llama``; ``batch=True`` applies only to
+    ``mistral`` (Batch API, 50% off sync). Both are ignored otherwise.
+    """
+    if name in ("pymu", "docling"):
+        return 0.0
+    if name == "mistral":
+        return _MISTRAL_BATCH if batch else _MISTRAL_SYNC
+    if name == "llama":
+        return _LLAMA_PER_TIER[tier]
+    raise ValueError(f"unknown backend: {name}")
+
+
+def estimate_cost(
+    name: BackendName,
+    pages: int,
+    *,
+    tier: LlamaTier = "cost_effective",
+    batch: bool = False,
+) -> float:
+    """Return total USD cost for ``pages`` pages on ``name``."""
+    return pages * cost_per_1k_pages(name, tier=tier, batch=batch) / 1000

dot_parser/tokens.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: Kannon For Deep Tech
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+
+def count_tokens(text: str) -> int:
+    return max(1, len(text) // 4)

dot_parser/vlms.py

@@ -0,0 +1,203 @@
+# SPDX-FileCopyrightText: Kannon For Deep Tech
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Ready-made `VLM` implementations.
+
+`MistralVLM` is the implementation used for the DOCX image-extraction
+path: it sends each image to Mistral's chat-completion API with a
+short, deterministic prompt and returns a description string.
+
+Kept separate from the Mistral OCR backend (`backends/mistral.py`)
+because the two use different Mistral endpoints (`ocr.process` vs.
+`chat.complete`) and have independent install/model requirements.
+"""
+
+import os
+
+from pydantic import BaseModel, Field
+
+from dot_parser.image_utils import parse_image_annotation
+from dot_parser.images import VLM, ImageDescription
+
+# Per-call ceiling for a single image description. The Mistral SDK's own
+# default is 300_000 ms, which is longer than most callers' entire
+# request budget — one stuck image could consume all of it and starve
+# every image behind it. Measured descriptions land at 0.7-8.5 s, so 60 s
+# is roughly 7x the slowest observed call: generous enough never to cut
+# off a legitimately slow one, short enough to fail fast. Pass
+# ``timeout_ms=None`` to restore the SDK default.
+DEFAULT_VLM_TIMEOUT_MS = 60_000
+
+_DEFAULT_PROMPT = (
+    "Describe this image for a downstream RAG system. Populate the two "
+    "fields of the structured response as follows.\n\n"
+    "title: a short kebab-case slug (3-8 words, lowercase, "
+    "hyphen-separated, no file extension) naming what the image "
+    'depicts (e.g. "system-architecture-diagram", '
+    '"exploded-gear-assembly-view", "monthly-revenue-bar-chart").\n\n'
+    "description: let image complexity set the length — do not pad "
+    "simple images and do not compress complex ones.\n"
+    "  - Simple imagery (logo, photo, icon, single screenshot): 2-3 "
+    "concrete sentences.\n"
+    "  - Diagrams, schematics, architecture views, flowcharts, "
+    "process maps: a structured paragraph that (a) names every "
+    "labeled node/block/component, (b) describes each connection/"
+    "arrow/flow (source -> target, with relationship label if any), "
+    "and (c) transcribes all visible text verbatim.\n"
+    "  - Charts and plots: state the chart type, axes (with units), "
+    "series, and the notable values, trends, or extrema. Transcribe "
+    "the title, legend, and axis labels verbatim.\n"
+    "  - Tables: transcribe the header row verbatim and summarize the "
+    "rows; if the table is small (<= 15 rows), transcribe it in full "
+    "as markdown inside the description.\n"
+    "  - Screenshots of UI or code: transcribe all readable text "
+    "verbatim and name the visible UI elements or code constructs.\n\n"
+    "Always: be concrete, transcribe text exactly as it appears, do "
+    "not speculate about anything not visible."
+)
+
+
+def _language_directive(language: str) -> str:
+    """Instruction appended to a description prompt to fix the output language.
+
+    Only the model's own prose (``description``, and the ``title`` slug)
+    is forced into ``language``; text the model transcribes from the image
+    must stay in whatever language it appears in, so quoted labels and
+    captions are not silently translated.
+    """
+    return (
+        f"\n\nWrite the description and the title slug in {language}. "
+        "Text you transcribe verbatim from the image must stay in its "
+        "original language — only your own prose description is in "
+        f"{language}."
+    )
+
+
+class _ImageDescriptionSchema(BaseModel):
+    """Structured-output schema for `chat.parse`.
+
+    Sending this class as `response_format=` puts the model in
+    constrained-decoding mode, so the emitted JSON is guaranteed to be
+    syntactically valid (newlines escaped) and to contain both keys
+    with string values. This is what prevents the long-description
+    failure mode where unescaped newlines broke `json.loads`.
+    """
+
+    title: str = Field(
+        description=(
+            "Short kebab-case slug, 3-8 words, lowercase, "
+            "hyphen-separated, no file extension. "
+            'Example: "system-architecture-diagram".'
+        )
+    )
+    description: str = Field(
+        description=(
+            "Interpretation of the image content; length scales with "
+            "image complexity per the user prompt."
+        )
+    )
+
+
+class MistralVLM(VLM):
+    """Vision-language model backed by Mistral's chat-completion API.
+
+    Used by `parse_with_images(format="docx", vlm=MistralVLM())` to
+    interpret each embedded image. PDF parsing through the Mistral OCR
+    backend does not need this — annotations there come back inline
+    from the OCR call itself.
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        model: str = "mistral-medium-2604",
+        prompt: str = _DEFAULT_PROMPT,
+        language: str | None = None,
+        timeout_ms: int | None = DEFAULT_VLM_TIMEOUT_MS,
+        reasoning_effort: str | None = None,
+    ) -> None:
+        try:
+            from mistralai.client import Mistral as _Mistral
+            from mistralai.extra.utils.response_format import (
+                response_format_from_pydantic_model,
+            )
+        except ImportError as e:
+            raise ImportError(
+                "MistralVLM requires `mistralai`. Install with: pip install dot-parser[mistral]"
+            ) from e
+
+        key = api_key or os.environ.get("MISTRAL_API_KEY")
+        if not key:
+            raise ValueError(
+                "MistralVLM requires an API key. Set MISTRAL_API_KEY or pass api_key=..."
+            )
+        self._client = _Mistral(api_key=key)
+        self._model = model
+        self._timeout_ms = timeout_ms
+        # Only sent when set: the accepted values are per-model (reasoning
+        # models such as magistral/mistral-small-latest take "none" or
+        # "high" and reject "minimal"/"low"/"medium"; non-reasoning models
+        # reject the field outright), so an unconditional default would
+        # 400 on some models. None keeps the model's own default.
+        self._reasoning_effort = reasoning_effort
+        # `language`, when set, fixes the output language of the
+        # description (e.g. "French"); appended once here so it survives
+        # whether or not the caller also overrode `prompt`.
+        self._prompt = prompt + (_language_directive(language) if language else "")
+        # Precomputed JSON-schema response_format. Sending this on every
+        # chat.complete call asks the API for constrained decoding so the
+        # model emits a JSON object matching _ImageDescriptionSchema.
+        self._response_format = response_format_from_pydantic_model(_ImageDescriptionSchema)
+
+    def describe_image(
+        self,
+        image_base64: str,
+        *,
+        mime_type: str = "image/png",
+        context: str | None = None,
+    ) -> ImageDescription:
+        prompt = self._prompt
+        if context:
+            prompt = (
+                f"{prompt}\n\nThe image appears in a document near the "
+                f"following text (use it only to ground your description, "
+                f"do not repeat it):\n\n{context}"
+            )
+
+        data_url = f"data:{mime_type};base64,{image_base64}"
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {"type": "image_url", "image_url": data_url},
+                ],
+            }
+        ]
+
+        # Constrained decoding: chat.complete with a json_schema
+        # response_format derived from _ImageDescriptionSchema. This is
+        # what chat.parse does internally, minus the Pydantic-coercion
+        # wrapper that was raising silently and dropping us into an
+        # unconstrained fallback. We parse the JSON ourselves so a
+        # slightly malformed payload can still yield a usable title.
+        optional: dict = {}
+        if self._reasoning_effort is not None:
+            optional["reasoning_effort"] = self._reasoning_effort
+        resp = self._client.chat.complete(
+            model=self._model,
+            messages=messages,
+            response_format=self._response_format,
+            timeout_ms=self._timeout_ms,
+            **optional,
+        )
+        content = resp.choices[0].message.content
+        if isinstance(content, list):
+            # Defensive: chat models occasionally return a list of chunks.
+            raw = "".join(
+                c.get("text", "") if isinstance(c, dict) else str(c) for c in content
+            ).strip()
+        else:
+            raw = (content or "").strip()
+        return parse_image_annotation(raw)

dot_parser-2.0.0.dist-info/METADATA

@@ -0,0 +1,274 @@
+Metadata-Version: 2.5
+Name: dot-parser
+Version: 2.0.0
+Summary: Document-to-markdown parser and chunker for RAG pipelines
+Project-URL: Homepage, https://gitlab.com/deepika6190303/deepika-open-toolbox/dot-parser
+Project-URL: Repository, https://gitlab.com/deepika6190303/deepika-open-toolbox/dot-parser
+Project-URL: Issues, https://gitlab.com/deepika6190303/deepika-open-toolbox/dot-parser/-/issues
+Author-email: Kannon For Deep Tech <louis.letarnec@deepika.ai>
+License-Expression: AGPL-3.0-or-later
+License-File: LICENSE.md
+Keywords: chunking,deepika,markdown,open-toolbox,parser,rag
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.12
+Requires-Dist: markitdown[all]>=0.1
+Requires-Dist: pillow>=10.0
+Requires-Dist: pydantic>=2
+Requires-Dist: pymupdf4llm>=1.27.2.2
+Requires-Dist: python-docx>=1.2.0
+Requires-Dist: semchunk>=3.0
+Requires-Dist: typing-extensions>=4.16
+Provides-Extra: all
+Requires-Dist: docling>=2.0; extra == 'all'
+Requires-Dist: llama-cloud>=2.4; extra == 'all'
+Requires-Dist: mistralai>=2.0; extra == 'all'
+Provides-Extra: docling
+Requires-Dist: docling>=2.0; extra == 'docling'
+Provides-Extra: llama
+Requires-Dist: llama-cloud>=2.4; extra == 'llama'
+Provides-Extra: mistral
+Requires-Dist: mistralai>=2.0; extra == 'mistral'
+Description-Content-Type: text/markdown
+
+# dot-parser
+
+[![PyPI](https://img.shields.io/pypi/v/dot-parser)](https://pypi.org/project/dot-parser/)
+![Python Version](https://img.shields.io/badge/python-3.12%2B-blue)
+[![Licence: AGPL v3](https://img.shields.io/badge/licence-AGPL--3.0--or--later-blue)](LICENSE.md)
+[![Pipeline](https://gitlab.com/deepika6190303/deepika-open-toolbox/dot-parser/badges/main/pipeline.svg)](https://gitlab.com/deepika6190303/deepika-open-toolbox/dot-parser/-/pipelines)
+
+**Turn documents into clean Markdown, then into retrieval-ready chunks.**
+
+```python
+from dot_parser import parse, chunk
+
+markdown = parse("report.pdf")
+chunks = chunk(markdown)
+
+for c in chunks:
+    print(c.section_path, len(c.content))
+    # ['# Report', '## Methods', '### Analysis'] 842
+```
+
+## Why dot-parser
+
+A RAG pipeline needs two things from a document: faithful text, and chunks that
+keep their place in the document's structure. Most tools give you one or the
+other — parsers stop at raw text, splitters assume you already have Markdown and
+cut it blind to headings.
+
+dot-parser does both in one step. It converts PDF, DOCX, PPTX, HTML, XLSX, CSV,
+Markdown and plain text into clean Markdown, then splits that Markdown into
+chunks carrying their heading hierarchy in `section_path` — so a chunk still
+knows it came from *Report › Methods › Analysis*.
+
+The default install stays light: heavy backends are optional extras, and you pick
+per document whether to run locally or through a cloud OCR. See
+[docs/DESIGN.md](docs/DESIGN.md) for how it compares to Docling, MarkItDown and
+LangChain splitters.
+
+## Features
+
+- One `parse()` call for PDF, DOCX, PPTX, HTML, XLSX, CSV, Markdown and text
+- Swappable PDF backends: local and fast, local and layout-aware, or cloud OCR
+- Heading-aware chunking with `section_path` metadata
+- Image extraction with per-image descriptions, from a VLM or from OCR annotations
+- Batch PDF parsing through the Mistral Batch API (50% cheaper)
+- Cost estimation before you send anything
+- Light by default — heavy backends live behind extras
+
+## Installation
+
+```bash
+pip install dot-parser
+
+# With optional PDF backends (each ~50 MB - 1 GB):
+pip install 'dot-parser[docling]'
+pip install 'dot-parser[mistral]'
+pip install 'dot-parser[llama]'
+pip install 'dot-parser[all]'
+```
+
+Requires Python 3.12+.
+
+## Quick start
+
+```python
+from dot_parser import parse, chunk
+
+markdown: str = parse("report.pdf")
+chunks: list[Chunk] = chunk(markdown)
+
+for c in chunks:
+    print(c.section_path, c.heading, len(c.content))
+    # ["# Report", "## Methods", "### Analysis"], "### Analysis", 842
+```
+
+For a different PDF backend:
+
+```python
+from dot_parser import parse, parse_pdfs, Mistral, Docling
+
+# single PDF, cloud OCR
+md = parse("scanned.pdf", backend=Mistral())
+
+# many PDFs, batched (50% off via Mistral Batch API)
+mds = parse_pdfs(["a.pdf", "b.pdf", "c.pdf"], backend=Mistral())
+
+# local layout-aware ML pipeline
+md = parse("paper.pdf", backend=Docling())
+```
+
+## API
+
+### `parse(source, format=None, backend=None) -> str`
+
+Converts a document to Markdown.
+
+- **source** -- file path (`str` or `Path`) or raw `bytes`
+- **format** -- explicit format hint (e.g. `"pdf"`, `"docx"`). Required when source is `bytes`, otherwise inferred from the file extension.
+- **backend** -- optional PDF backend (`Pymu`, `Docling`, `Mistral`, `Llama`). Defaults to `Pymu()`. Backends only apply to PDF input.
+
+Supported formats: `.pdf`, `.md`, `.txt`, `.docx`, `.pptx`, `.html`, `.xhtml`, `.htm`, `.xlsx`, `.csv`
+
+Raises `ParseError` on unsupported formats or conversion failures.
+
+### `parse_pdfs(sources, backend=None) -> list[str | None]`
+
+Converts a list of PDFs to Markdown, in input order. Backends that implement a `parse_pdfs` method (e.g. `Mistral` via the Batch API, 50% off) handle the whole list in a single optimized call. Otherwise falls back to looping `parse()` per source. Failed items are returned as `None` (no exception raised).
+
+### `parse_with_images(source, format=None, *, backend=None, vlm=None, annotate_images=True, include_tables=True) -> ParseResult`
+
+Converts a `.pdf`, `.docx` or `.pptx` and extracts its images alongside the
+Markdown, keeping `![name](name)` anchors at each image's position. Each image is
+described either by a VLM or by OCR annotations from the same call. See
+[docs/IMAGE_EXTRACTION.md](docs/IMAGE_EXTRACTION.md) for the two available paths per format.
+
+### Backends
+
+- **`Pymu(ocr_fallback=True)`** -- pymupdf4llm, default. Fast and CPU-only. The built-in OCR fallback kicks in when an OCR engine (tesseract, rapidocr, paddleocr) is available. Set `ocr_fallback=False` to force the no-OCR code path (matches a runtime image without OCR shipped).
+- **`Docling(force_full_page_ocr=True)`** -- IBM Docling, layout-aware ML pipeline + Tesseract OCR. Robust on image-only and broken-encoding PDFs. Install with `pip install dot-parser[docling]`.
+- **`Mistral(api_key=None, model="mistral-ocr-4-0")`** -- Mistral OCR cloud API. Reads `MISTRAL_API_KEY` from env. Implements `parse_pdfs` via the Batch API. Install with `pip install dot-parser[mistral]`.
+- **`Llama(api_key=None, tier="cost_effective")`** -- LlamaCloud parsing API. Reads `LLAMA_CLOUD_API_KEY` from env. Tiers: `fast`, `cost_effective`, `agentic`, `agentic_plus`. Install with `pip install dot-parser[llama]`.
+
+#### Mistral OCR enrichments
+
+Three optional extras on the `Mistral(...)` constructor, applying to the `*_with_images` methods. All default to off, so existing callers see no change:
+
+```python
+from dot_parser import parse_with_images, Mistral
+
+result = parse_with_images(
+    "spec.pdf",
+    backend=Mistral(
+        extract_headers_footers=True,  # page furniture -> result.pages[i].header/.footer
+        confidence_scores="page",  # or "word"   -> result.pages[i].*_confidence
+        extract_captions=True,  # figure captions -> image.original_caption
+    ),
+)
+
+for page in result.pages:
+    print(page.page, page.average_confidence, page.minimum_confidence)
+```
+
+- `extract_headers_footers` moves running headers/footers out of the markdown and into `ParseResult.pages`, so repeated "page 4 of 27" noise stays out of retrieval chunks. It **removes that text from the markdown** -- the only one of the three that changes `result.markdown`.
+- `confidence_scores` surfaces OCR's self-reported quality. **Calibrate any threshold on your own corpus -- absolute cutoffs do not transfer.** Measured over the 39 pages of the benchmark corpus (`native_simple`, `image_only`, `broken_encoding`), `average_confidence` sat at 0.985-0.989 and `minimum_confidence` at 0.23-0.46 on *every* document regardless of quality. `minimum_confidence` is the single worst region on the page, so it is low even on clean pages and is not a page-quality alarm by itself.
+- `extract_captions` fills `ExtractedImage.original_caption` from the figure caption printed beside each image. Needs OCR 4+ **and** `mistralai>=2.8`; on older SDKs it logs a warning and leaves captions `None` rather than failing.
+
+If the OCR model rejects any of these parameters, the call is retried once without them -- you get the markdown and images, minus the enrichments.
+
+#### Caption-grounded image interpretation
+
+Mistral OCR's inline annotations (`annotate_images=True`) are produced from the cropped image alone -- the annotating model sees no caption and no page text, which on domain-specific figures yields confidently wrong descriptions. `interpret_images()` replaces that pass with client-side VLM calls grounded in each figure's own caption and surrounding markdown:
+
+```python
+from dot_parser import parse_with_images, interpret_images, Mistral, MistralVLM
+
+result = parse_with_images(
+    "paper.pdf",
+    backend=Mistral(extract_captions=True),
+    annotate_images=False,  # skip the ungrounded inline pass
+)
+result = interpret_images(result, MistralVLM())
+```
+
+Same number of VLM calls as `annotate_images=True`, but each one carries the caption. On a figure-heavy biomechanics paper this turned "magnetic field components" / "fluid flow through a curved pipe" into accurate descriptions of the actual rib diagrams.
+
+### `chunk(markdown, max_tokens=None, merge=True) -> list[Chunk]`
+
+Splits Markdown into chunks with heading-hierarchy metadata.
+
+- **markdown** -- Markdown string (typically output of `parse()`)
+- **max_tokens** -- maximum tokens per chunk. Auto-computed from the 95th percentile of section sizes (clamped 64-512) when `None`.
+- **merge** -- when `True` (default), merges small adjacent sections sharing the same parent heading to reduce fragmentation.
+
+The chunking algorithm is described in [docs/DESIGN.md](docs/DESIGN.md).
+
+### `Chunk`
+
+```python
+@dataclass(frozen=True)
+class Chunk:
+    content: str  # full text of the chunk (heading + body)
+    heading: str | None  # the heading line, if any
+    section_path: list[str]  # hierarchy of headings leading to this chunk
+```
+
+### `ParseError`
+
+Raised by `parse()` when a document cannot be converted.
+
+### Cost estimation
+
+`cost_per_1k_pages(backend)` and `estimate_cost(backend, pages, batch=False)`
+report what a cloud backend will cost, without instantiating it or needing an
+API key.
+
+## Stability
+
+`dot-parser` follows semantic versioning: everything exported from the top-level
+package is covered, anything underscore-prefixed is internal and may change in
+any release. Public names are never removed without a deprecation period.
+
+```toml
+dependencies = ["dot-parser>=1.0,<2"]
+```
+
+See [docs/VERSIONING.md](docs/VERSIONING.md) for the full policy.
+
+## Roadmap
+
+- [ ] Table extraction as structured data, not just Markdown
+- [ ] Streaming parse for very large documents
+- [ ] Additional cloud OCR backends
+
+## Documentation
+
+| Document | Contents |
+|---|---|
+| [docs/DESIGN.md](docs/DESIGN.md) | Design rationale, backend choices, chunking algorithm |
+| [docs/IMAGE_EXTRACTION.md](docs/IMAGE_EXTRACTION.md) | Image-extraction paths per format |
+| [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) | Environment setup, tests, code style |
+| [docs/VERSIONING.md](docs/VERSIONING.md) | Versioning, deprecation policy, how to depend on this package |
+| [docs/PUBLISHING.md](docs/PUBLISHING.md) | Cutting a release |
+| [CHANGELOG.md](CHANGELOG.md) | Release history |
+
+## Contributing
+
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for the DCO
+sign-off requirement, the licensing terms that apply to contributions, and how to
+submit a change.
+
+## Licence
+
+Copyright (C) 2026 Kannon For Deep Tech (deepika)
+
+This software is distributed under the GNU Affero General Public License,
+version 3 or later — see [LICENSE.md](LICENSE.md).
+
+A commercial licence is available for use in proprietary environments.
+Contact: louis.letarnec@deepika.ai

dot_parser-2.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+dot_parser/__init__.py,sha256=oAWCCkbHhoTSbhilZwVM66GBBcGkUq0wwVlZHD1thnQ,1052
+dot_parser/chunking.py,sha256=nvLyCZz8h3EVEsbR4oFu_kE58CLBvWbcYQkwzZD-xKQ,8208
+dot_parser/docx_images.py,sha256=tXBl8OiKazHt_1wbOtlaOTlBXu4gIZ-2zwEcG9xxdTM,26018
+dot_parser/image_utils.py,sha256=26uiRuz6j-ZLWvGshHKbfvRJWQxoh2DfiKLX33k-XHY,6037
+dot_parser/images.py,sha256=OQ64cbn2-nFn9hKjPLM8cO5gBTDzkcBVL0ArFThnbGA,4651
+dot_parser/markdown_utils.py,sha256=KXjLtneqDzPLbiMfND1TEmEHum1oRk0vym0h4qgf9K0,1789
+dot_parser/models.py,sha256=OMiCL7XqLki0iie0K3TrLw0iDTvt0BjeWnopLGYu004,561
+dot_parser/parsers.py,sha256=UurXUTU_Za5DSZat07tQB9fSm5IfSbhLgN2XHICQlmI,12286
+dot_parser/pricing.py,sha256=cjqM-gaZ-GQyGibbUQwWpqIECv33j4OJ3_Shvp33OXc,1684
+dot_parser/tokens.py,sha256=LIERtlBVtN_loTOMUyuDDxuUr_p4q8YSdmxIEI_Uhts,164
+dot_parser/vlms.py,sha256=cACc_Psy8tJggNXPdHXZ3NY9kneg_oCtNmtGYljNh-w,8636
+dot_parser/backends/__init__.py,sha256=nmJciV1nfu8__4Ls37xwh1kvc1yrhpscHoInMaO7c-o,583
+dot_parser/backends/_base.py,sha256=rYmdLAJOoZKpVbm9njGJ-PjjNl8Sp2hi65AiCP_7CW8,2257
+dot_parser/backends/docling.py,sha256=0OoucXeY0AqwRFk1aEbSzP7g9z7s8OuAfUzOz7AHwMw,1976
+dot_parser/backends/llama.py,sha256=5vlGbTr8jJB_ms1ZXp0HGAR59MvM-iNLU67Cq3neHg8,2634
+dot_parser/backends/mistral.py,sha256=cRg_g5szAGtzFNT3mC3KFSfpjKPJJpzBROCWcjxl1_c,25801
+dot_parser/backends/pymu.py,sha256=EIg4JWwyNdjkbKOlzxWLxERmyZAMIUNxulQu-2AsxAw,2253
+dot_parser-2.0.0.dist-info/METADATA,sha256=yvMawlilJPvxb2_VMM_syz5i30mgxudIT2oRPe2B3lk,12199
+dot_parser-2.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+dot_parser-2.0.0.dist-info/licenses/LICENSE.md,sha256=ADUqsZhl4juwq34PRTMiBqumpm11s_PMli_dZQjWPqQ,34260
+dot_parser-2.0.0.dist-info/RECORD,,

dot_parser-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any