groundmark 0.1.0__py3-none-any.whl

groundmark/__init__.py

@@ -0,0 +1,6 @@
+from anchorite import Anchor, BBox, annotate, resolve, strip
+
+from groundmark.markdown import PROMPT
+from groundmark.process import Config, ProcessResult, process
+
+__all__ = ["PROMPT", "Anchor", "BBox", "Config", "ProcessResult", "annotate", "process", "resolve", "strip"]

groundmark/markdown.py

@@ -0,0 +1,104 @@
+"""PDF to Markdown conversion via Pydantic AI (any supported LLM)."""
+
+import re
+import unicodedata
+from typing import Final
+
+from anchorite.document import DocumentChunk
+from pydantic_ai import Agent
+from pydantic_ai.messages import BinaryContent
+
+# Apparently, faithfully analyzing a PDF's complicated layout and transcribing
+# it into well-structured Markdown isn't creative enough for Claude's content
+# filter. Asking the model to add line numbers gives it something "original"
+# to contribute, which satisfies the anti-regurgitation heuristic. We strip
+# them right after.
+# https://privacy.claude.com/en/articles/10023638-why-am-i-receiving-an-output-blocked-by-content-filtering-policy-error
+_LINE_NUM_PREFIX = """
+IMPORTANT: Prefix every output line with its line number followed by a
+pipe character (no trailing space), e.g.:
+  1|# Heading
+  2|
+  3|Some paragraph text here.
+Start numbering at 1. This is required for all output.
+"""
+
+_LINE_NUM_RE = re.compile(r"^\d+\|", re.MULTILINE)
+
+PROMPT: Final[str] = (
+    """
+Carefully transcribe the text for this pdf into a text file with
+markdown annotations.
+"""
+    + _LINE_NUM_PREFIX
+    + """
+**The final output must be formatted as text that visually
+mimics in markdown the layout and hierarchy of the original PDF
+when rendered (ignoring the line-number prefixes).**
+
+* Do not include headers or footers that are repeated on each page.
+* Do not include page numbers.
+* Preserve the reading order of the text as it appears in the PDF.
+* Remove hyphens that break words at the end of lines.
+  * e.g. "uti- lized" -> "utilized"
+* Use Markdown headings (`#`, `##`, `###`) to reflect the size and
+  hierarchy of titles and subtitles in the PDF.
+* Ensure that there are blank lines before and after headings, lists,
+  tables, and images.
+* End each paragraph with a blank line.
+* Do not break lines within paragraphs or headings.
+* Render bullet points and numbered lettered lists as markdown lists.
+  * It is ok to remove brackets and other consistent punctuation around
+    list identifiers
+    * e.g. "a)" -> "a."
+* Use blockquotes for any sidebars or highlighted text.
+* Bold all words and phrases that appear bolded in the original
+  source material. Similarly, italicise all text in italics.
+* Render tables as markdown, paying particular attention to copying
+  identifiers exactly.
+* Break text into paragraphs and lists exactly as they appear in
+  the PDF.
+* Preserve figure/chart captions verbatim — do not paraphrase, extend,
+  or interleave them with descriptions. If useful context is only visible
+  in the image (e.g. axis labels, legend entries, data values), add it
+  as a separate paragraph after the caption.
+* Convert bar charts into markdown tables where possible.
+* Convert tables contained in images into markdown.
+* Keep mathematical expressions as close to the PDF's own characters as
+  possible — use the same Unicode symbols (×, ≥, α, β, etc.) rather than
+  converting to LaTeX commands.
+  * Only use LaTeX (`$...$` / `$$...$$`) for complex display equations
+    with fractions, integrals, summations, or multi-level notation that
+    cannot be represented legibly in plain text.
+* Insert markers at the start of each page of the form `<!--page-->`
+* Surround tables and figure descriptions with markers:
+  * `<!--table-->` ... `<!--end-->`
+  * `<!--figure-->` ... `<!--end-->`
+"""
+)
+
+_agent: Agent[None, str] = Agent(output_type=str)
+
+
+class PydanticAIMarkdownProvider:
+    """MarkdownProvider that converts PDF chunks to Markdown via a vision-capable LLM."""
+
+    def __init__(self, model: str, *, prompt: str | None = None) -> None:
+        self.model = model
+        self._prompt = prompt or PROMPT
+
+    async def generate_markdown(self, chunk: DocumentChunk) -> str:
+        """Convert a document chunk to Markdown.
+
+        Returns:
+            Markdown string with ``<!--page-->`` markers between pages.
+        """
+        result = await _agent.run(
+            [BinaryContent(data=chunk.data, media_type=chunk.mime_type), self._prompt],
+            model=self.model,
+        )
+        # Strip the line-number prefixes added to bypass Claude's content filter.
+        markdown = _LINE_NUM_RE.sub("", result.output)
+        # NFKC-normalize so superscript digits, ligatures, etc. match the
+        # NFKC-normalized anchor text from pdfplumber extraction.
+        return unicodedata.normalize("NFKC", markdown)

groundmark/parse.py

@@ -0,0 +1,95 @@
+"""Bounding box extraction from PDFs using pdfplumber."""
+
+import io
+import logging
+import unicodedata
+
+import pdfplumber
+from anchorite import Anchor, BBox
+from anchorite.document import DocumentChunk
+
+
+class PdfplumberAnchorProvider:
+    """AnchorProvider that extracts line-level bounding boxes via pdfplumber.
+
+    Body text lines are emitted individually; table rows are merged into
+    single anchors so that repeated short cell values (e.g. "Pathogenic")
+    become unique when combined with the full row.
+
+    Coordinates are normalized to a 0-1000 scale with top-left origin.
+    """
+
+    async def generate_anchors(self, chunk: DocumentChunk) -> list[Anchor]:
+        pdf = pdfplumber.open(io.BytesIO(chunk.data))
+        anchors: list[Anchor] = []
+
+        for page_offset, page in enumerate(pdf.pages):
+            pw, ph = page.width, page.height
+            if pw <= 0 or ph <= 0:
+                logging.warning(
+                    "Page %d has invalid dimensions (%s x %s), skipping",
+                    chunk.start_page + page_offset,
+                    pw,
+                    ph,
+                )
+                continue
+
+            page_num = chunk.start_page + page_offset
+
+            # Detect table regions on this page.
+            table_bboxes = [table.bbox for table in page.find_tables()]
+
+            lines = page.extract_text_lines(return_chars=False, use_text_flow=True)
+
+            for line in lines:
+                x0, x1 = line["x0"], line["x1"]
+                # pdfplumber's top starts at baseline minus font size,
+                # missing the ascender portion above the glyph. Pad upward
+                # by ~30% of line height to approximate full glyph bounds.
+                line_h = line["bottom"] - line["top"]
+                y0 = line["top"] - 0.3 * line_h
+                y1 = line["bottom"]
+                text = unicodedata.normalize("NFKC", line["text"].strip())
+                if not text:
+                    continue
+
+                in_table = any(_rects_intersect((x0, y0, x1, y1), tb) for tb in table_bboxes)
+
+                if in_table:
+                    # Table lines are already row-level from extract_text_lines.
+                    anchors.append(
+                        Anchor(
+                            page=page_num,
+                            box=_normalize(x0, y0, x1, y1, pw, ph),
+                            text=text,
+                        )
+                    )
+                else:
+                    anchors.append(
+                        Anchor(
+                            page=page_num,
+                            box=_normalize(x0, y0, x1, y1, pw, ph),
+                            text=text,
+                        )
+                    )
+
+        pdf.close()
+        logging.debug("Generated %d bounding boxes", len(anchors))
+        return anchors
+
+
+def _rects_intersect(a: tuple[float, float, float, float], b: tuple[float, float, float, float]) -> bool:
+    """Check if two (x0, y0, x1, y1) rectangles overlap."""
+    ax0, ay0, ax1, ay1 = a
+    bx0, by0, bx1, by1 = b
+    return ax0 < bx1 and ax1 > bx0 and ay0 < by1 and ay1 > by0
+
+
+def _normalize(x0: float, y0: float, x1: float, y1: float, pw: float, ph: float) -> BBox:
+    """Convert PDF coordinates to 0-1000 scale with top-left origin."""
+    return BBox(
+        top=int(y0 / ph * 1000),
+        left=int(x0 / pw * 1000),
+        bottom=int(y1 / ph * 1000),
+        right=int(x1 / pw * 1000),
+    )

groundmark/process.py

@@ -0,0 +1,82 @@
+import dataclasses
+
+from anchorite import process_document
+from anchorite.document import DocumentChunk, chunks
+
+from groundmark.markdown import PydanticAIMarkdownProvider
+from groundmark.parse import PdfplumberAnchorProvider
+
+
+@dataclasses.dataclass(frozen=True)
+class Config:
+    """Configuration for the groundmark processing pipeline."""
+
+    model: str
+    """Pydantic AI model string (e.g. "bedrock:au.anthropic.claude-sonnet-4-6")."""
+    uniqueness_threshold: float = 0.5
+    """Minimum score ratio between best and second-best alignment match."""
+    min_overlap: float = 0.9
+    """Minimum overlap fraction required for a valid alignment match."""
+    page_count: int | None = None
+    """Pages per chunk (None = whole PDF in one chunk)."""
+    prompt: str | None = None
+    """Custom LLM prompt (None = use built-in default)."""
+
+
+@dataclasses.dataclass
+class ProcessResult:
+    """Result of processing a PDF into annotated Markdown."""
+
+    annotated_markdown: str
+    """Markdown with <span data-bbox="..." data-page="N"> tags."""
+    coverage_percent: float
+    """Fraction of markdown content covered by aligned bounding boxes."""
+
+
+async def process(
+    pdf_bytes: bytes,
+    config: Config,
+    *,
+    markdown: str | None = None,
+) -> ProcessResult:
+    """Process a PDF into annotated Markdown with bounding box spans.
+
+    Args:
+        pdf_bytes: Raw PDF file bytes.
+        config: Processing configuration.
+        markdown: Optional pre-generated markdown (skips LLM call).
+
+    Returns:
+        ProcessResult with annotated markdown and coverage stats.
+    """
+    md_provider: _CachedMarkdownProvider | PydanticAIMarkdownProvider
+    if markdown is not None:
+        # Cached markdown corresponds to the whole PDF — don't chunk.
+        md_provider = _CachedMarkdownProvider(markdown)
+        doc_chunks = chunks(pdf_bytes)
+    else:
+        md_provider = PydanticAIMarkdownProvider(config.model, prompt=config.prompt)
+        doc_chunks = chunks(pdf_bytes, page_count=config.page_count)
+
+    result = await process_document(
+        doc_chunks,
+        markdown_provider=md_provider,
+        anchor_provider=PdfplumberAnchorProvider(),
+        alignment_uniqueness_threshold=config.uniqueness_threshold,
+        alignment_min_overlap=config.min_overlap,
+    )
+
+    return ProcessResult(
+        annotated_markdown=result.annotate(),
+        coverage_percent=result.coverage_percent,
+    )
+
+
+class _CachedMarkdownProvider:
+    """Returns pre-generated markdown, ignoring the chunk."""
+
+    def __init__(self, markdown: str) -> None:
+        self._markdown = markdown
+
+    async def generate_markdown(self, _chunk: DocumentChunk) -> str:
+        return self._markdown

groundmark/visualize.py

@@ -0,0 +1,201 @@
+"""Debug visualizer: overlay bounding boxes from annotated Markdown onto the source PDF."""
+
+import asyncio
+import io
+import logging
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from anchorite import Anchor, align, annotate
+from anchorite.document import chunks
+from pypdf import PdfReader, PdfWriter
+from pypdf.annotations import Highlight
+from pypdf.generic import ArrayObject, FloatObject
+
+from groundmark.markdown import PydanticAIMarkdownProvider
+from groundmark.parse import PdfplumberAnchorProvider
+
+_SPAN_RE = re.compile(
+    r'<span\s+data-bbox="(\d+),(\d+),(\d+),(\d+)"\s+data-page="(\d+)">(.*?)</span>',
+    re.DOTALL,
+)
+
+app = typer.Typer()
+
+
+def _log(msg: str) -> None:
+    print(msg, file=sys.stderr)
+
+
+def _add_highlight(
+    writer: PdfWriter,
+    page_num: int,
+    bbox: tuple[int, int, int, int],
+    page_width: float,
+    page_height: float,
+    *,
+    color: tuple[float, float, float],
+) -> None:
+    top, left, bottom, right = bbox
+    # Convert from 0-1000 scale to PDF coordinates (bottom-left origin).
+    x0 = left / 1000 * page_width
+    x1 = right / 1000 * page_width
+    y0 = page_height - bottom / 1000 * page_height
+    y1 = page_height - top / 1000 * page_height
+
+    hex_color = "".join(f"{int(c * 255):02x}" for c in color)
+    quad_points = ArrayObject(
+        [
+            FloatObject(x0),
+            FloatObject(y1),  # top-left
+            FloatObject(x1),
+            FloatObject(y1),  # top-right
+            FloatObject(x0),
+            FloatObject(y0),  # bottom-left
+            FloatObject(x1),
+            FloatObject(y0),  # bottom-right
+        ]
+    )
+    annotation = Highlight(
+        rect=(x0, y0, x1, y1),
+        quad_points=quad_points,
+        highlight_color=hex_color,
+    )
+    writer.add_annotation(page_number=page_num, annotation=annotation)
+
+
+def _overlay_bboxes(
+    pdf_bytes: bytes,
+    annotated_markdown: str,
+    raw_anchors: list[Anchor],
+) -> bytes:
+    """Draw bounding box highlights onto the PDF.
+
+    Blue = raw extracted boxes, Red = aligned (from annotated Markdown).
+    """
+    reader = PdfReader(io.BytesIO(pdf_bytes))
+    writer = PdfWriter()
+    writer.append_pages_from_reader(reader)
+
+    # Blue: raw extracted boxes.
+    for anchor in raw_anchors:
+        if anchor.page >= len(reader.pages):
+            continue
+        page = reader.pages[anchor.page]
+        pw = float(page.mediabox.width)
+        ph = float(page.mediabox.height)
+        box = anchor.box
+        _add_highlight(writer, anchor.page, (box.top, box.left, box.bottom, box.right), pw, ph, color=(0.8, 0.9, 1))
+
+    # Red: aligned boxes from annotated Markdown.
+    for match in _SPAN_RE.finditer(annotated_markdown):
+        top, left, bottom, right = int(match[1]), int(match[2]), int(match[3]), int(match[4])
+        page_num = int(match[5])
+        if page_num >= len(reader.pages):
+            continue
+        page = reader.pages[page_num]
+        pw = float(page.mediabox.width)
+        ph = float(page.mediabox.height)
+        _add_highlight(writer, page_num, (top, left, bottom, right), pw, ph, color=(1, 0.85, 0.85))
+
+    buf = io.BytesIO()
+    writer.write(buf)
+    return buf.getvalue()
+
+
+@app.command()
+def visualize(
+    input_pdf: Annotated[Path, typer.Argument(help="Path to the source PDF.")],
+    output_pdf: Annotated[Path, typer.Argument(help="Path for the output PDF with bbox overlays.")],
+    model: Annotated[str, typer.Option(help="Pydantic AI model string.")] = "",
+    markdown_file: Annotated[Path | None, typer.Option("--markdown", "-m", help="Cached Markdown file.")] = None,
+    uniqueness_threshold: Annotated[float, typer.Option("--threshold", "-t")] = 0.5,
+    min_overlap: Annotated[float, typer.Option("--overlap", "-o")] = 0.9,
+    page_count: Annotated[int | None, typer.Option("--page-count", "-p", help="Pages per chunk.")] = None,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Enable debug logging.")] = False,
+) -> None:
+    """Run the groundmark pipeline on a PDF and overlay bounding boxes."""
+    if verbose:
+        logging.basicConfig(level=logging.DEBUG, stream=sys.stderr)
+
+    if not markdown_file and not model:
+        _log("Error: provide --model or --markdown")
+        raise SystemExit(1)
+
+    asyncio.run(
+        _run(
+            input_pdf,
+            output_pdf,
+            model,
+            markdown_file,
+            uniqueness_threshold,
+            min_overlap,
+            page_count,
+        )
+    )
+
+
+async def _run(
+    input_pdf: Path,
+    output_pdf: Path,
+    model: str,
+    markdown_file: Path | None,
+    uniqueness_threshold: float,
+    min_overlap: float,
+    page_count: int | None,
+) -> None:
+    pdf_bytes = input_pdf.read_bytes()
+    doc_chunks = list(chunks(pdf_bytes, page_count=page_count))
+    t0 = time.perf_counter()
+
+    # Extract anchors (bounding boxes) from the PDF.
+    _log("Extracting bounding boxes...")
+    t = time.perf_counter()
+    provider = PdfplumberAnchorProvider()
+    all_anchors = await asyncio.gather(*(provider.generate_anchors(c) for c in doc_chunks))
+    flat_anchors = [a for chunk_anchors in all_anchors for a in chunk_anchors]
+    _log(f"  {len(flat_anchors)} bounding boxes ({time.perf_counter() - t:.1f}s)")
+
+    # Generate or load Markdown.
+    if markdown_file:
+        markdown = markdown_file.read_text()
+        _log(f"  Loaded cached Markdown from {markdown_file}")
+    else:
+        _log("Generating Markdown...")
+        t = time.perf_counter()
+        md_provider = PydanticAIMarkdownProvider(model)
+        md_chunks = await asyncio.gather(*(md_provider.generate_markdown(c) for c in doc_chunks))
+        markdown = "\n\n<!--page-->\n\n".join(md_chunks)
+        _log(f"  {len(markdown)} chars ({time.perf_counter() - t:.1f}s)")
+
+    # Write plain markdown before alignment so it's available even if alignment hangs.
+    if not markdown_file:
+        md_path = output_pdf.with_suffix(".md")
+        md_path.write_text(markdown)
+        _log(f"  Markdown written to {md_path}")
+
+    # Align anchors to Markdown.
+    _log("Aligning...")
+    t = time.perf_counter()
+    alignment = align(
+        flat_anchors,
+        markdown,
+        uniqueness_threshold=uniqueness_threshold,
+        min_overlap=min_overlap,
+    )
+    annotated_markdown = annotate(markdown, alignment)
+    coverage = sum(e - s for s, e in alignment.values()) / len(markdown) if markdown else 0.0
+    _log(f"  {coverage:.1%} coverage ({time.perf_counter() - t:.1f}s)")
+
+    output_bytes = _overlay_bboxes(pdf_bytes, annotated_markdown, flat_anchors)
+    output_pdf.write_bytes(output_bytes)
+    _log(f"  Output written to {output_pdf}")
+    _log(f"Total: {time.perf_counter() - t0:.1f}s")
+
+
+if __name__ == "__main__":
+    app()

groundmark-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: groundmark
+Version: 0.1.0
+Summary: PDF to grounded Markdown with bounding box annotations
+Project-URL: Homepage, https://github.com/populationgenomics/groundmark
+Project-URL: Bug Tracker, https://github.com/populationgenomics/groundmark/issues
+Author-email: Tobias Sargeant <tobias.sargeant@gmail.com>
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: anchorite>=0.1.1
+Requires-Dist: pdfplumber>=0.11.9
+Requires-Dist: pydantic-ai-slim[anthropic,bedrock,google,openai]>=1.67.0
+Requires-Dist: pypdf>=6.8.0
+Description-Content-Type: text/markdown
+
+# groundmark
+
+<img src="groundmark.webp" alt="groundmark" width="200">
+
+## Grounded Markdown for PDFs
+
+**groundmark is a thin, batteries-included wrapper around [anchorite](https://github.com/populationgenomics/anchorite).** It provides concrete implementations of anchorite's provider protocols — [Pydantic AI](https://ai.pydantic.dev/) for LLM-based Markdown generation and [pdfplumber](https://github.com/jsvine/pdfplumber) for bounding box extraction — so you can go from PDF bytes to annotated Markdown in a single call. All the heavy lifting (Smith-Waterman alignment, annotation, stripping, quote resolution) lives in anchorite.
+
+Give it a PDF and a model string, get back Markdown with embedded bounding box coordinates that trace every text span back to its location in the source PDF.
+
+## Architecture
+
+The library processes documents in two streams that are then merged:
+
+1. **Semantic Stream**: The PDF is sent to an LLM (via Pydantic AI) to produce clean Markdown with `<!--page-->` markers between pages.
+2. **Positional Stream**: The PDF is parsed locally by pdfplumber to extract line-level text segments and their bounding boxes.
+3. **Alignment**: Smith-Waterman alignment (via anchorite) maps each parsed line to its position in the Markdown, constrained by page boundaries.
+4. **Annotation**: Bounding box coordinates are injected as HTML span attributes:
+
+   ```html
+   <span data-bbox="120,45,180,890" data-page="3">The patient presented with</span>
+   ```
+
+## Quick Start
+
+```python
+import asyncio
+import groundmark as gm
+
+async def main():
+    pdf_bytes = open("document.pdf", "rb").read()
+
+    config = gm.Config(model="bedrock:au.anthropic.claude-sonnet-4-6")
+
+    # PDF -> annotated Markdown (one call)
+    result = await gm.process(pdf_bytes, config)
+    print(f"Coverage: {result.coverage_percent:.2%}")
+    print(result.annotated_markdown[:500])
+
+    # Strip for LLM consumption
+    stripped = gm.strip(result.annotated_markdown)
+    # stripped.plain_text: clean Markdown with spans removed
+    # stripped.validation_map: list of (start, end, Anchor) ranges
+
+    # Resolve verbatim quotes to PDF coordinates
+    resolved = gm.resolve(result.annotated_markdown, ["the patient presented with"])
+    # -> {"the patient presented with": [(page, BBox), ...]}
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Debug Visualizer
+
+The included visualizer overlays extracted bounding boxes onto the source PDF, useful for diagnosing alignment issues. Blue highlights show raw extracted boxes from pdfplumber; red highlights show aligned boxes from the annotated Markdown.
+
+```bash
+python -m groundmark.visualize input.pdf output.pdf --model "bedrock:au.anthropic.claude-sonnet-4-6"
+
+# Or with cached Markdown:
+python -m groundmark.visualize input.pdf output.pdf --markdown cached.md
+```
+
+![Visualizer output showing blue (raw) and red (aligned) bounding box overlays](visualize_example.jpg)
+
+*Screenshot from Santoro et al., "Health outcomes and drug utilisation in children with Noonan syndrome: a European cohort study," Orphanet J Rare Dis 20:76 (2025). [doi:10.1186/s13023-025-03594-7](https://doi.org/10.1186/s13023-025-03594-7). CC-BY 4.0.*
+
+## Configuration
+
+### Timeouts
+
+The LLM call for PDF-to-Markdown conversion can take several minutes for large documents, especially with Opus on Bedrock. Timeout defaults by provider:
+
+| Provider | Default | Environment Variable |
+|----------|---------|---------------------|
+| Bedrock (boto3) | 300s | `AWS_READ_TIMEOUT` |
+| Anthropic (httpx) | 600s | — (use `ModelSettings(timeout=...)`) |
+
+For Bedrock with Opus, 300s may not be enough. Set a higher timeout:
+
+```bash
+export AWS_READ_TIMEOUT=600
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

groundmark-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+groundmark/__init__.py,sha256=nuEYgTIqO-5cTZ7XpWzmnKt01EKpuRsqKC_eDHaolM0,273
+groundmark/markdown.py,sha256=v_zBQyL7ArWqmdYrjBuj2nXlXMRHHEYm9kd9bfwC5IY,4407
+groundmark/parse.py,sha256=sw91PbgskQiGzgU3A1N5HTly7yfEvBPqotazRnhwfD0,3460
+groundmark/process.py,sha256=PHCNAwIyS6JgIYCQM094uJmYiOnGRODGEbAFXuiqb7w,2696
+groundmark/visualize.py,sha256=BfvirOZyYSD__VqDuF_kZW9cAzT1AMjZ741gpJsFyOo,6755
+groundmark-0.1.0.dist-info/METADATA,sha256=hIjcRwYGxhhVXav93h0bb3oi4M9Z35blwYkuMIiiNEQ,4690
+groundmark-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+groundmark-0.1.0.dist-info/licenses/LICENSE,sha256=lwIanGu698z5WiBedbwEOdUJLQb_G4FOFgucqExVIS0,1087
+groundmark-0.1.0.dist-info/RECORD,,

groundmark-0.1.0.dist-info/WHEEL

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

groundmark-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Centre for Population Genomics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.