exstruct 0.1.0__py3-none-any.whl

exstruct/__init__.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal, Optional
+
+from .core.integrate import extract_workbook
+from .core.cells import set_table_detection_params
+from .io import save_as_json, save_as_toon, save_as_yaml, save_sheets
+from .models import CellRow, Chart, ChartSeries, Shape, SheetData, WorkbookData
+from .render import export_pdf, export_sheet_images
+
+__all__ = [
+    "extract",
+    "export",
+    "export_sheets",
+    "export_pdf",
+    "export_sheet_images",
+    "process_excel",
+    "ExtractionMode",
+    "CellRow",
+    "Shape",
+    "ChartSeries",
+    "Chart",
+    "SheetData",
+    "WorkbookData",
+    "set_table_detection_params",
+]
+
+
+ExtractionMode = Literal["light", "standard", "verbose"]
+
+
+def extract(file_path: str | Path, mode: ExtractionMode = "standard") -> WorkbookData:
+    """Extract workbook semantic structure and return WorkbookData."""
+    if mode not in ("light", "standard", "verbose"):
+        raise ValueError(f"Unsupported mode: {mode}")
+    return extract_workbook(Path(file_path), mode=mode)
+
+
+def export(
+    data: WorkbookData,
+    path: str | Path,
+    fmt: Optional[Literal["json", "yaml", "yml", "toon"]] = None,
+    *,
+    pretty: bool = False,
+    indent: int | None = None,
+) -> None:
+    """Export WorkbookData to supported file formats (json/yaml/toon)."""
+    dest = Path(path)
+    format_hint = (fmt or dest.suffix.lstrip(".") or "json").lower()
+    match format_hint:
+        case "json":
+            save_as_json(data, dest, pretty=pretty, indent=indent)
+        case "yaml" | "yml":
+            save_as_yaml(data, dest)
+        case "toon":
+            save_as_toon(data, dest)
+        case _:
+            raise ValueError(f"Unsupported export format: {format_hint}")
+
+
+def export_sheets(data: WorkbookData, dir_path: str | Path) -> dict[str, Path]:
+    """
+    Export each sheet as a JSON file (book_name + SheetData) into a directory.
+    Returns a mapping of sheet name to written path.
+    """
+    return save_sheets(data, Path(dir_path), fmt="json")
+
+
+def export_sheets_as(
+    data: WorkbookData,
+    dir_path: str | Path,
+    fmt: Literal["json", "yaml", "yml", "toon"] = "json",
+    *,
+    pretty: bool = False,
+    indent: int | None = None,
+) -> dict[str, Path]:
+    """
+    Export each sheet in the given format (json/yaml/toon), including book_name and SheetData; returns sheet name → path map.
+    """
+    return save_sheets(data, Path(dir_path), fmt=fmt, pretty=pretty, indent=indent)
+
+
+def process_excel(
+    file_path: Path,
+    output_path: Path,
+    out_fmt: str = "json",
+    image: bool = False,
+    pdf: bool = False,
+    dpi: int = 72,
+    mode: ExtractionMode = "standard",
+    pretty: bool = False,
+    indent: int | None = None,
+) -> None:
+    """Convenience wrapper for CLI: export workbook and optionally PDF/PNG images (Excel required for rendering)."""
+    if mode not in ("light", "standard", "verbose"):
+        raise ValueError(f"Unsupported mode: {mode}")
+    workbook_model = extract(file_path, mode=mode)
+    match out_fmt:
+        case "json":
+            save_as_json(workbook_model, output_path, pretty=pretty, indent=indent)
+        case "yaml" | "yml":
+            save_as_yaml(workbook_model, output_path)
+        case "toon":
+            save_as_toon(workbook_model, output_path)
+        case _:
+            raise ValueError(f"Unsupported export format: {out_fmt}")
+
+    if pdf or image:
+        pdf_path = output_path.with_suffix(".pdf")
+        export_pdf(file_path, pdf_path)
+        if image:
+            images_dir = output_path.parent / f"{output_path.stem}_images"
+            export_sheet_images(file_path, images_dir, dpi=dpi)
+
+    print(f"{file_path.name} -> {output_path} completed.")

exstruct/cli/main.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from exstruct import process_excel
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Dev-only CLI stub for ExStruct extraction."
+    )
+    parser.add_argument("input", type=Path, help="Excel file (.xlsx/.xlsm/.xls)")
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        help="Output path (defaults to <input>.json)",
+    )
+    parser.add_argument(
+        "-f",
+        "--format",
+        default="json",
+        choices=["json", "yaml", "yml", "toon"],
+        help="Export format",
+    )
+    parser.add_argument(
+        "--image",
+        action="store_true",
+        help="(placeholder) Render PNG alongside JSON",
+    )
+    parser.add_argument(
+        "--pdf",
+        action="store_true",
+        help="(placeholder) Render PDF alongside JSON",
+    )
+    parser.add_argument(
+        "--dpi",
+        type=int,
+        default=144,
+        help="DPI for image rendering (placeholder)",
+    )
+    parser.add_argument(
+        "-m",
+        "--mode",
+        default="standard",
+        choices=["light", "standard", "verbose"],
+        help="Extraction detail level",
+    )
+    parser.add_argument(
+        "--pretty",
+        action="store_true",
+        help="Pretty-print JSON output (indent=2). Default is compact JSON.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    input_path: Path = args.input
+    if not input_path.exists():
+        print(f"File not found: {input_path}")
+        return 0
+
+    suffix = ".json"
+    if args.format in ("yaml", "yml"):
+        suffix = ".yaml"
+    elif args.format == "toon":
+        suffix = ".toon"
+
+    output_path: Path = args.output or input_path.with_suffix(suffix)
+
+    try:
+        process_excel(
+            file_path=input_path,
+            output_path=output_path,
+            out_fmt=args.format,
+            image=args.image,
+            pdf=args.pdf,
+            dpi=args.dpi,
+            mode=args.mode,
+            pretty=args.pretty,
+        )
+        return 0
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())