exstruct 0.2.80__py3-none-any.whl

exstruct/render/__init__.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+import shutil
+import tempfile
+from types import ModuleType
+from typing import Any, cast
+
+import xlwings as xw
+
+from ..errors import MissingDependencyError, RenderError
+
+logger = logging.getLogger(__name__)
+
+
+def _require_excel_app() -> xw.App:
+    """Ensure Excel COM is available and return an App; otherwise raise."""
+    try:
+        app = xw.App(add_book=False, visible=False)
+        return app
+    except Exception as e:
+        raise RenderError(
+            "Excel (COM) is not available. Rendering (PDF/image) requires a desktop Excel installation."
+        ) from e
+
+
+def export_pdf(excel_path: str | Path, output_pdf: str | Path) -> list[str]:
+    """Export an Excel workbook to PDF via Excel COM and return sheet names in order."""
+    normalized_excel_path = Path(excel_path)
+    normalized_output_pdf = Path(output_pdf)
+    normalized_output_pdf.parent.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory() as td:
+        temp_dir = Path(td)
+        temp_xlsx = temp_dir / "book.xlsx"
+        temp_pdf = temp_dir / "book.pdf"
+        shutil.copy(normalized_excel_path, temp_xlsx)
+
+        app: xw.App | None = None
+        wb: xw.Book | None = None
+        try:
+            app = _require_excel_app()
+            wb = app.books.open(str(temp_xlsx))
+            sheet_names = [s.name for s in wb.sheets]
+            wb.api.ExportAsFixedFormat(0, str(temp_pdf))
+            shutil.copy(temp_pdf, normalized_output_pdf)
+        except RenderError:
+            raise
+        except Exception as exc:
+            raise RenderError(
+                (
+                    "Failed to export PDF for "
+                    f"'{normalized_excel_path}' to '{normalized_output_pdf}'."
+                )
+            ) from exc
+        finally:
+            if wb is not None:
+                wb.close()
+            if app is not None:
+                app.quit()
+        if not normalized_output_pdf.exists():
+            raise RenderError(
+                f"Failed to export PDF to '{normalized_output_pdf}'."
+            )
+    return sheet_names
+
+
+def _require_pdfium() -> ModuleType:
+    """Ensure pypdfium2 is installed; otherwise raise with guidance."""
+    try:
+        import pypdfium2 as pdfium
+    except ImportError as e:
+        raise MissingDependencyError(
+            "Image rendering requires pypdfium2. Install it via `pip install pypdfium2 pillow` or add the 'render' extra."
+        ) from e
+    return cast(ModuleType, pdfium)
+
+
+def export_sheet_images(
+    excel_path: str | Path, output_dir: str | Path, dpi: int = 144
+) -> list[Path]:
+    """Export each sheet as PNG (via PDF then pypdfium2 rasterization) and return paths in sheet order."""
+    pdfium = cast(Any, _require_pdfium())
+    normalized_excel_path = Path(excel_path)
+    normalized_output_dir = Path(output_dir)
+    normalized_output_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_pdf = Path(td) / "book.pdf"
+            sheet_names = export_pdf(normalized_excel_path, tmp_pdf)
+
+            scale = dpi / 72.0
+            written: list[Path] = []
+            with pdfium.PdfDocument(str(tmp_pdf)) as pdf:
+                for i, sheet_name in enumerate(sheet_names):
+                    page = pdf[i]
+                    bitmap = page.render(scale=scale)
+                    pil_image = bitmap.to_pil()
+                    safe_name = _sanitize_sheet_filename(sheet_name)
+                    img_path = normalized_output_dir / f"{i + 1:02d}_{safe_name}.png"
+                    pil_image.save(img_path, format="PNG", dpi=(dpi, dpi))
+                    written.append(img_path)
+            return written
+    except RenderError:
+        raise
+    except Exception as exc:
+        raise RenderError(
+            f"Failed to export sheet images to '{normalized_output_dir}'."
+        ) from exc
+
+
+def _sanitize_sheet_filename(name: str) -> str:
+    return "".join("_" if c in '\\/:*?"<>|' else c for c in name).strip() or "sheet"
+
+
+__all__ = ["export_pdf", "export_sheet_images"]

exstruct-0.2.80.dist-info/METADATA

@@ -0,0 +1,435 @@
+Metadata-Version: 2.3
+Name: exstruct
+Version: 0.2.80
+Summary: Excel to structured JSON (tables, shapes, charts) for LLM/RAG pipelines
+Keywords: excel,structure,data,exstruct
+Author: harumiWeb
+License: BSD 3-Clause License
+         
+         Copyright (c) 2025, ExStruct Contributors
+         All rights reserved.
+         
+         Redistribution and use in source and binary forms, with or without
+         modification, are permitted provided that the following conditions are met:
+         
+         1. Redistributions of source code must retain the above copyright notice, this
+            list of conditions and the following disclaimer.
+         
+         2. Redistributions in binary form must reproduce the above copyright notice,
+            this list of conditions and the following disclaimer in the documentation
+            and/or other materials provided with the distribution.
+         
+         3. Neither the name of the copyright holder nor the names of its
+            contributors may be used to endorse or promote products derived from
+            this software without specific prior written permission.
+         
+         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+         AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+         IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+         DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+         FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+         DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+         SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+         CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+         OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Requires-Dist: numpy>=2.3.5
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: scipy>=1.16.3
+Requires-Dist: xlwings>=0.33.16
+Requires-Dist: pypdfium2>=5.1.0 ; extra == 'render'
+Requires-Dist: pillow>=12.0.0 ; extra == 'render'
+Requires-Dist: python-toon>=0.1.3 ; extra == 'toon'
+Requires-Dist: pyyaml>=6.0.3 ; extra == 'yaml'
+Requires-Python: >=3.11
+Project-URL: Documentation, https://harumiweb.github.io/exstruct/
+Project-URL: Homepage, https://harumiweb.github.io/exstruct/
+Project-URL: Issues, https://github.com/harumiWeb/exstruct/issues
+Project-URL: Repository, https://github.com/harumiWeb/exstruct
+Provides-Extra: render
+Provides-Extra: toon
+Provides-Extra: yaml
+Description-Content-Type: text/markdown
+
+# ExStruct — Excel Structured Extraction Engine
+
+[![PyPI version](https://badge.fury.io/py/exstruct.svg)](https://pypi.org/project/exstruct/) [![PyPI Downloads](https://static.pepy.tech/personalized-badge/exstruct?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/exstruct) ![Licence: BSD-3-Clause](https://img.shields.io/badge/license-BSD--3--Clause-blue?style=flat-square) [![pytest](https://github.com/harumiWeb/exstruct/actions/workflows/pytest.yml/badge.svg)](https://github.com/harumiWeb/exstruct/actions/workflows/pytest.yml) [![Codacy Badge](https://app.codacy.com/project/badge/Grade/e081cb4f634e4175b259eb7c34f54f60)](https://app.codacy.com/gh/harumiWeb/exstruct/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+
+![ExStruct Image](/docs/assets/icon.webp)
+
+ExStruct reads Excel workbooks and outputs structured data (cells, table candidates, shapes, charts, print areas/views, auto page-break areas, hyperlinks) as JSON by default, with optional YAML/TOON formats. It targets both COM/Excel environments (rich extraction) and non-COM environments (cells + table candidates + print areas), with tunable detection heuristics and multiple output modes to fit LLM/RAG pipelines.
+
+[日本版README](README.ja.md)
+
+## Features
+
+- **Excel → Structured JSON**: cells, shapes, charts, table candidates, print areas/views, and auto page-break areas per sheet.
+- **Output modes**: `light` (cells + table candidates + print areas; no COM, shapes/charts empty), `standard` (texted shapes + arrows, charts, print areas), `verbose` (all shapes with width/height, charts with size, print areas). Verbose also emits cell hyperlinks. Size output is flag-controlled.
+- **Auto page-break export (COM only)**: capture Excel-computed auto page breaks and write per-area JSON/YAML/TOON when requested (CLI option appears only when COM is available).
+- **Formats**: JSON (compact by default, `--pretty` available), YAML, TOON (optional dependencies).
+- **Table detection tuning**: adjust heuristics at runtime via API.
+- **CLI rendering** (Excel required): optional PDF and per-sheet PNGs.
+- **Graceful fallback**: if Excel COM is unavailable, extraction falls back to cells + table candidates without crashing.
+
+## Installation
+
+```bash
+pip install exstruct
+```
+
+Optional extras:
+
+- YAML: `pip install pyyaml`
+- TOON: `pip install python-toon`
+- Rendering (PDF/PNG): Excel + `pip install pypdfium2 pillow`
+- All extras at once: `pip install exstruct[yaml,toon,render]`
+
+Platform note:
+
+- Full extraction (shapes/charts) targets Windows + Excel (COM via xlwings). On other platforms, use `mode=light` to get cells + `table_candidates`.
+
+## Quick Start (CLI)
+
+```bash
+exstruct input.xlsx > output.json          # compact JSON to stdout (default)
+exstruct input.xlsx -o out.json --pretty   # pretty JSON to a file
+exstruct input.xlsx --format yaml          # YAML (needs pyyaml)
+exstruct input.xlsx --format toon          # TOON (needs python-toon)
+exstruct input.xlsx --sheets-dir sheets/   # split per sheet in chosen format
+exstruct input.xlsx --print-areas-dir areas/  # split per print area (if any)
+exstruct input.xlsx --auto-page-breaks-dir auto_areas/  # COM only; option appears when available
+exstruct input.xlsx --mode light           # cells + table candidates only
+exstruct input.xlsx --pdf --image          # PDF and PNGs (Excel required)
+```
+
+Auto page-break exports are available via API and CLI when Excel/COM is available; the CLI exposes `--auto-page-breaks-dir` only in COM-capable environments.
+
+## Quick Start (Python)
+
+```python
+from pathlib import Path
+from exstruct import extract, export, set_table_detection_params
+
+# Tune table detection (optional)
+set_table_detection_params(table_score_threshold=0.3, density_min=0.04)
+
+# Extract with modes: "light", "standard", "verbose"
+wb = extract("input.xlsx", mode="standard")
+export(wb, Path("out.json"), pretty=False)  # compact JSON
+
+# Model helpers: iterate, index, and serialize directly
+first_sheet = wb["Sheet1"]           # __getitem__ access
+for name, sheet in wb:               # __iter__ yields (name, SheetData)
+    print(name, len(sheet.rows))
+wb.save("out.json", pretty=True)     # WorkbookData → file (by extension)
+first_sheet.save("sheet.json")       # SheetData → file (by extension)
+print(first_sheet.to_yaml())         # YAML text (requires pyyaml)
+
+# ExStructEngine: per-instance options (nested configs)
+from exstruct import (
+    DestinationOptions,
+    ExStructEngine,
+    FilterOptions,
+    FormatOptions,
+    OutputOptions,
+    StructOptions,
+    export_auto_page_breaks,
+)
+
+engine = ExStructEngine(
+    options=StructOptions(mode="verbose"),  # verbose includes hyperlinks by default
+    output=OutputOptions(
+        format=FormatOptions(pretty=True),
+        filters=FilterOptions(include_shapes=False),  # drop shapes in output
+        destinations=DestinationOptions(sheets_dir=Path("out_sheets")),  # also write per-sheet files
+    ),
+)
+wb2 = engine.extract("input.xlsx")
+engine.export(wb2, Path("out_filtered.json"))  # drops shapes via filters
+
+# Enable hyperlinks in other modes
+engine_links = ExStructEngine(options=StructOptions(mode="standard", include_cell_links=True))
+with_links = engine_links.extract("input.xlsx")
+
+# Export per print area (if print areas exist)
+from exstruct import export_print_areas_as
+export_print_areas_as(wb, "areas", fmt="json", pretty=True)
+
+# Auto page-break extraction/output (COM only; raises if no auto breaks exist)
+engine_auto = ExStructEngine(
+    output=OutputOptions(
+        destinations=DestinationOptions(auto_page_breaks_dir=Path("auto_areas"))
+    )
+)
+wb_auto = engine_auto.extract("input.xlsx")  # includes SheetData.auto_print_areas
+engine_auto.export(wb_auto, Path("out_with_auto.json"))  # also writes auto_areas/*
+export_auto_page_breaks(wb_auto, "auto_areas", fmt="json", pretty=True)  # manual writer
+```
+
+**Note (non-COM environments):** If Excel COM is unavailable, extraction still runs and returns cells + `table_candidates`; `shapes`/`charts` will be empty.
+
+## Table Detection Tuning
+
+```python
+from exstruct import set_table_detection_params
+
+set_table_detection_params(
+    table_score_threshold=0.35,  # increase to be stricter
+    density_min=0.05,
+    coverage_min=0.2,
+    min_nonempty_cells=3,
+)
+```
+
+Use higher thresholds to reduce false positives; lower them if true tables are missed.
+
+## Output Modes
+
+- **light**: cells + table candidates (no COM needed).
+- **standard**: texted shapes + arrows, charts (COM if available), table candidates. Hyperlinks are off unless `include_cell_links=True`.
+- **verbose**: all shapes (with width/height), charts, table candidates, and cell hyperlinks.
+
+## Error Handling / Fallbacks
+
+- Excel COM unavailable → falls back to cells + table candidates; shapes/charts empty.
+- Shape extraction failure → logs warning, still returns cells + table candidates.
+- CLI prints errors to stdout/stderr and returns non-zero on failures.
+
+## Optional Rendering
+
+Requires Excel and `pypdfium2`.
+
+```bash
+exstruct input.xlsx --pdf --image --dpi 144
+```
+
+Creates `<output>.pdf` and `<output>_images/` PNGs per sheet.
+
+## Benchmark: Excel Structuring Demo
+
+To show how well exstruct can structure Excel, we parse a workbook that combines three elements on one sheet and share an AI reasoning benchmark that uses the JSON output.
+
+- Table (sales data)
+- Line chart
+- Flowchart built only with shapes
+
+(Screenshot below is the actual sample Excel sheet)
+![Sample Excel](/docs/assets/demo_sheet.png)
+Sample workbook: `sample/sample.xlsx`
+Sample workbook: `sample/sample.xlsx`
+
+### 1. Input: Excel Sheet Overview
+
+This sample Excel contains:
+
+### ① Table (Sales Data)
+
+| Month  | Product A | Product B | Product C |
+| ------ | --------- | --------- | --------- |
+| Jan-25 | 120       | 80        | 60        |
+| Feb-25 | 135       | 90        | 64        |
+| Mar-25 | 150       | 100       | 70        |
+| Apr-25 | 170       | 110       | 72        |
+| May-25 | 160       | 120       | 75        |
+| Jun-25 | 180       | 130       | 80        |
+
+### ② Chart (Line Chart)
+
+- Title: Sales Data
+- Series: Product A / Product B / Product C (six months)
+- Y axis: 0–200
+
+### ③ Flowchart built with shapes
+
+The sheet includes this flow:
+
+- Start / End
+- Format check
+- Loop (items remaining?)
+- Error handling
+- Yes/No decision for sending email
+
+### 2. Output: Structured JSON produced by exstruct (excerpt)
+
+Below is a **shortened JSON output example** from parsing this Excel workbook.
+
+```json
+{
+  "book_name": "sample.xlsx",
+  "sheets": {
+    "Sheet1": {
+      "rows": [
+        {
+          "r": 3,
+          "c": {
+            "1": "月",
+            "2": "製品A",
+            "3": "製品B",
+            "4": "製品C"
+          }
+        },
+        ...
+      ],
+      "shapes": [
+        {
+          "text": "開始",
+          "l": 148,
+          "t": 220,
+          "type": "AutoShape-FlowchartProcess"
+        },
+        {
+          "text": "入力データ読み込み",
+          "l": 132,
+          "t": 282,
+          "type": "AutoShape-FlowchartProcess"
+        },
+        {
+          "l": 193,
+          "t": 246,
+          "type": "AutoShape-Mixed",
+          "begin_arrow_style": 1,
+          "end_arrow_style": 2,
+          "direction": "N"
+        },
+        ...
+      ],
+      "charts": [
+        {
+          "name": "Chart 1",
+          "chart_type": "Line",
+          "title": "売上データ",
+          "y_axis_range": [
+            0.0,
+            200.0
+          ],
+          "series": [
+            {
+              "name": "製品A",
+              "name_range": "Sheet1!$C$3",
+              "x_range": "Sheet1!$B$4:$B$9",
+              "y_range": "Sheet1!$C$4:$C$9"
+            },
+            ...
+          ],
+          "l": 377,
+          "t": 25
+        }
+      ],
+      "table_candidates": [
+        "B3:E9"
+      ]
+    }
+  }
+}
+```
+
+### 3. How AI (Copilot / LLM) interprets the JSON
+
+````md
+Below is the Markdown reconstruction of the Excel workbook. The table, chart, and flowchart are all represented.
+
+---
+
+## 📊 Sales Data Table
+
+| Month      | Product A | Product B | Product C |
+| ---------- | --------- | --------- | --------- |
+| 2025-01-01 | 120       | 80        | 60        |
+| 2025-02-01 | 135       | 90        | 64        |
+| 2025-03-01 | 150       | 100       | 70        |
+| 2025-04-01 | 170       | 110       | 72        |
+| 2025-05-01 | 160       | 120       | 75        |
+| 2025-06-01 | 180       | 130       | 80        |
+
+---
+
+## 📈 Sales Data (Line Chart)
+
+- Chart title: **売上データ (Sales Data)**
+- Chart type: Line
+- Y-axis range: 0 to 200
+- Data series:
+  - Product A: 120 → 135 → 150 → 170 → 160 → 180
+  - Product B: 80 → 90 → 100 → 110 → 120 → 130
+  - Product C: 60 → 64 → 70 → 72 → 75 → 80
+
+---
+
+## 🔄 Process Flow (Mermaid Flowchart)
+
+```mermaid
+flowchart TD
+    A[Start]
+    B[Load input data]
+    C{Is format valid?}
+    D[Show error]
+    E[Process one item]
+    F{Items remaining?}
+    G[Generate output]
+    H{Send email?}
+    I[Send email]
+    J[Finish]
+
+    A --> B
+    B --> C
+    C -- no --> D
+    C -- yes --> E
+    E --> F
+    F -- yes --> E
+    F -- no --> G
+    G --> H
+    H -- yes --> I
+    H -- no --> J
+    I --> J
+```
+````
+
+From this we can see:
+
+**exstruct's JSON is already in a format that AI can read and reason over directly.**
+
+### 4. Summary
+
+This benchmark confirms exstruct can:
+
+- **Parse tables, charts, and shapes (flowcharts) simultaneously**
+- Convert the semantic structure of Excel into JSON
+- Let AI/LLMs read that JSON directly and reconstruct the workbook contents
+
+In short, **exstruct = “an engine that converts Excel into a format AI can understand.”**
+
+## Notes
+
+- Default JSON is compact to reduce tokens; use `--pretty` or `pretty=True` when readability matters.
+- Field `table_candidates` replaces `tables`; adjust downstream consumers accordingly.
+
+## Enterprise Use
+
+ExStruct is used primarily as a **library**, not a service.
+
+- No official support or SLA is provided
+- Long-term stability is prioritized over rapid feature growth
+- Forking and internal modification are expected in enterprise use
+
+This project is suitable for teams that:
+- need transparency over black-box tools
+- are comfortable maintaining internal forks if necessary
+
+## Print Areas and Auto Page Breaks (PrintArea / PrintAreaView)
+
+- `SheetData.print_areas` holds print areas (cell coordinates) in light/standard/verbose.
+- `SheetData.auto_print_areas` holds Excel COM-computed auto page-break areas when auto page-break extraction is enabled (COM only).
+- Use `export_print_areas_as(...)` or CLI `--print-areas-dir` to write one file per print area (nothing is written if none exist).
+- Use CLI `--auto-page-breaks-dir` (COM only), `DestinationOptions.auto_page_breaks_dir` (preferred), or `export_auto_page_breaks(...)` to write per-auto-page-break files; the API raises `ValueError` if no auto page breaks exist.
+- `PrintAreaView` includes rows and table candidates inside the area, plus shapes/charts that overlap the area (size-less shapes are treated as points). `normalize=True` rebases row/col indices to the area origin.
+
+## License
+
+BSD-3-Clause. See `LICENSE` for details.
+
+## Documentation
+
+- API Reference (GitHub Pages): https://harumiweb.github.io/exstruct/
+- JSON Schemas: see `schemas/` (one file per model); regenerate via `python scripts/gen_json_schema.py`.

exstruct-0.2.80.dist-info/RECORD

@@ -0,0 +1,20 @@
+exstruct/__init__.py,sha256=649fea37d359a9c994790c0256de70adace62647809547b3567ab9d1c4ba0e63,12122
+exstruct/cli/availability.py,sha256=29b79cc084e9d4d314626f56e2745c5c1238f51c984f1c97a7115c1c2fbe79ca,1410
+exstruct/cli/main.py,sha256=63d299d9032522ab9b29032aa77d17700815f752f024d49ab5de7a5068e64751,3830
+exstruct/core/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+exstruct/core/cells.py,sha256=e38266674e621ddd815fdea017d4b9ede833147933a80cd56f462f7db882f0a8,35930
+exstruct/core/charts.py,sha256=e7962eebb32dbd58165825639f0b5a32da2bf0a9880d4a57687c8a265f1e76e7,7777
+exstruct/core/integrate.py,sha256=da216a4f864bb0a3111aa9d8b2d7cbd3ef8c26d30a32a3425e0fb90b31eb1c1a,14037
+exstruct/core/shapes.py,sha256=f2913c5134b1c82be066e805a24cc3e21c3e5afef880dbab57987fa18c58c8bf,11069
+exstruct/engine.py,sha256=8027aa9e9bc8d2f23c42c230fdd935b7685f4eb8b51613ed7a2d7fce2236e5a7,25543
+exstruct/errors.py,sha256=9be81f7e93df84642fd2db4591bfbff1d5440d715287b582da113e7b0a5549ac,1002
+exstruct/io/__init__.py,sha256=8cb00dd3e1fed186ab79f80948b241ff72a76e95b79fd9c4d4746829b61bf5ee,19267
+exstruct/models/__init__.py,sha256=c502e877ce9bdbc899de6f6a95583282c95f9ef81d6a69296f2fef827dc3b7e3,11924
+exstruct/models/maps.py,sha256=9ebb0e67e4d80b771b2ec3babba488cb84fa4a56681906990fff733273e73f52,12930
+exstruct/models/types.py,sha256=4226f75035fc144bfaf88fe29bdeaa6a986924f18b3b3a048502187d27339d2a,278
+exstruct/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+exstruct/render/__init__.py,sha256=e2c16904003c6fd28f96ff2ff13b2ac677465a48f732e93627544644b4dc37d9,4242
+exstruct-0.2.80.dist-info/WHEEL,sha256=b6dc288e80aa2d1b1518ddb3502fd5b53e8fd6cb507ed2a4f932e9e6088b264a,78
+exstruct-0.2.80.dist-info/entry_points.txt,sha256=3429e73dd9d41bb977b49a34914dddd7ec70352b79882bb937a3999e8e8bce9c,53
+exstruct-0.2.80.dist-info/METADATA,sha256=d162e1003f843a4912e9dbfc82c298614068832b6506a23034fb11948ef790fe,16635
+exstruct-0.2.80.dist-info/RECORD,,

exstruct-0.2.80.dist-info/WHEEL

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

exstruct-0.2.80.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+exstruct = exstruct.cli.main:main
+