emboss-pdf 0.1.0__py3-none-any.whl

emboss/__init__.py

@@ -0,0 +1,77 @@
+"""Emboss - constraint-driven PDF generation.
+
+Describe a document; the engine handles layout, typography, and the
+PDF/UA structure tree. Output is deterministic: identical input always
+produces identical bytes.
+
+    from emboss import Document
+
+    doc = Document(title="Quarterly Report", style="finance")
+    doc.heading("Revenue Analysis", level=1)
+    doc.paragraph("Revenue increased 12% year over year.")
+    doc.table(headers=["Region", "Q3"], rows=[["North", "$2.4M"]])
+    doc.save("report.pdf")
+"""
+
+from .constraints import (
+    ConstraintValidator, Issue, ValidationError, ValidationResult,
+)
+from .spec import (
+    BibliographyBlock, BulletList, Callout, Chart, Citation, CodeBlock,
+    Document, Footnote, HeaderFooter, Heading, HorizontalRule, Image,
+    LegalFeatures, MathBlock, NumberedList, PageBreak, PageSpec, Paragraph,
+    SvgBlock, Table, TableCell, TextRun,
+)
+from .bibliography import format_citation, format_bibliography
+from .code_highlight import tokenize, colorize, THEMES as CODE_THEMES, LANGUAGES
+from .math_render import parse_math, MathExpression, render_math
+from .colors import (
+    ColorTheme, resolve_color, PALETTES,
+    CmykColor, SpotColor, rgb_to_cmyk, parse_cmyk,
+)
+from .crossref import CrossReferenceIndex
+from .svg import SvgImage, parse_svg, render_svg
+from .numbering import NumberingContext
+from .styles import PRESETS, Style, StyleSheet, resolve_preset
+from .typography.font_metrics import FontMetrics, FontRegistry
+from .typography.hyphenation import Hyphenator
+from .typography.line_breaking import LineBreaker
+from .intelligence import (
+    ContentAnalyzer, QualityScorer, SmartTypography, TableIntelligence,
+    DocumentTypeDetector,
+)
+from .slides import slide_document, SlideConfig, SLIDE_16_9, SLIDE_4_3
+from .templates import (
+    memo, report, letter, invoice, academic_paper, legal_brief,
+    slide_deck, data_sheet,
+)
+from .markdown import parse_markdown
+from .generate import spec_prompt, generate, parse_spec_json
+from .writer import RenderResult, render_document
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Document", "PageSpec", "Heading", "Paragraph", "BulletList",
+    "NumberedList", "Table", "TableCell", "TextRun", "Image", "Chart",
+    "Footnote", "Callout", "CodeBlock", "MathBlock", "BibliographyBlock",
+    "Citation", "SvgBlock", "PageBreak", "HorizontalRule", "LegalFeatures",
+    "HeaderFooter", "SvgImage", "parse_svg", "render_svg", "NumberingContext",
+    "format_citation", "format_bibliography",
+    "tokenize", "colorize", "CODE_THEMES", "LANGUAGES",
+    "parse_math", "MathExpression", "render_math",
+    "ColorTheme", "resolve_color", "PALETTES",
+    "CmykColor", "SpotColor", "rgb_to_cmyk", "parse_cmyk",
+    "CrossReferenceIndex",
+    "Style", "StyleSheet", "PRESETS", "resolve_preset",
+    "FontRegistry", "FontMetrics", "Hyphenator", "LineBreaker",
+    "ConstraintValidator", "ValidationResult", "ValidationError", "Issue",
+    "slide_document", "SlideConfig", "SLIDE_16_9", "SLIDE_4_3",
+    "memo", "report", "letter", "invoice", "academic_paper",
+    "legal_brief", "slide_deck", "data_sheet",
+    "render_document", "RenderResult",
+    "parse_markdown", "spec_prompt", "generate", "parse_spec_json",
+    "ContentAnalyzer", "QualityScorer", "SmartTypography",
+    "TableIntelligence", "DocumentTypeDetector",
+    "__version__",
+]

emboss/__main__.py

@@ -0,0 +1,311 @@
+"""CLI entry point: emboss render spec.json -o output.pdf
+
+Supports JSON input from files or stdin, so an LLM can pipe its output
+directly into PDF generation:
+
+    llm "Generate a financial report" --json | emboss render - -o report.pdf
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+def _render(args: argparse.Namespace) -> int:
+    try:
+        from .adapters.pydantic_schema import DocumentSpec
+    except ImportError:
+        print(
+            "error: pydantic is required for JSON-to-PDF conversion.\n"
+            "  pip install emboss-pdf[llm]",
+            file=sys.stderr,
+        )
+        return 1
+
+    if args.input == "-":
+        raw = sys.stdin.read()
+    else:
+        path = Path(args.input)
+        if not path.exists():
+            print(f"error: file not found: {path}", file=sys.stderr)
+            return 1
+        raw = path.read_text(encoding="utf-8")
+
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        print(f"error: invalid JSON: {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        spec = DocumentSpec.model_validate(data)
+    except Exception as exc:
+        print(f"error: invalid document spec:\n  {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        doc = spec.to_document()
+        pdf_bytes = doc.render()
+    except Exception as exc:
+        print(f"error: rendering failed: {exc}", file=sys.stderr)
+        return 1
+
+    output = Path(args.output)
+    output.write_bytes(pdf_bytes)
+
+    if not args.quiet:
+        from .pdf.verify import verify_pdf
+
+        report = verify_pdf(pdf_bytes)
+        print(
+            f"{output} — {len(pdf_bytes):,} bytes, "
+            f"{report.page_count} page{'s' if report.page_count != 1 else ''}, "
+            f"tagged={report.has_struct_tree}",
+        )
+        if not report.ok:
+            for problem in report.problems:
+                print(f"  warning: {problem}", file=sys.stderr)
+    return 0
+
+
+def _schema(args: argparse.Namespace) -> int:
+    try:
+        from .adapters.pydantic_schema import generate_json_schema
+    except ImportError:
+        print(
+            "error: pydantic is required for schema generation.\n"
+            "  pip install emboss-pdf[llm]",
+            file=sys.stderr,
+        )
+        return 1
+
+    output = generate_json_schema(indent=2)
+
+    if args.output:
+        Path(args.output).write_text(output, encoding="utf-8")
+        if not args.quiet:
+            print(f"Schema written to {args.output}")
+    else:
+        print(output)
+    return 0
+
+
+def _verify(args: argparse.Namespace) -> int:
+    from .pdf.verify import verify_pdf
+
+    path = Path(args.input)
+    if not path.exists():
+        print(f"error: file not found: {path}", file=sys.stderr)
+        return 1
+
+    data = path.read_bytes()
+    report = verify_pdf(data)
+    print(report)
+    return 0 if report.ok else 1
+
+
+def _export(args: argparse.Namespace) -> int:
+    try:
+        from .adapters.pydantic_schema import DocumentSpec
+    except ImportError:
+        print(
+            "error: pydantic is required.\n  pip install emboss-pdf[llm]",
+            file=sys.stderr,
+        )
+        return 1
+
+    if args.input == "-":
+        raw = sys.stdin.read()
+    else:
+        path = Path(args.input)
+        if not path.exists():
+            print(f"error: file not found: {path}", file=sys.stderr)
+            return 1
+        raw = path.read_text(encoding="utf-8")
+
+    try:
+        spec = DocumentSpec.model_validate_json(raw)
+    except Exception as exc:
+        print(f"error: invalid document spec:\n  {exc}", file=sys.stderr)
+        return 1
+
+    doc = spec.to_document()
+    fmt = args.format
+
+    if fmt == "html":
+        from .adapters.html_export import to_html
+
+        output = to_html(doc, standalone=True)
+    elif fmt == "markdown":
+        from .adapters.markdown_export import to_markdown
+
+        output = to_markdown(doc)
+    elif fmt == "office-json":
+        from .adapters.docx_export import to_office_dict
+
+        output = json.dumps(to_office_dict(doc), indent=2, ensure_ascii=False)
+    else:
+        print(f"error: unknown format: {fmt}", file=sys.stderr)
+        return 1
+
+    if args.output:
+        Path(args.output).write_text(output, encoding="utf-8")
+        if not args.quiet:
+            print(f"Exported {fmt} to {args.output}")
+    else:
+        print(output)
+    return 0
+
+
+def _analyze(args: argparse.Namespace) -> int:
+    from .intelligence import ContentAnalyzer
+
+    if args.input == "-":
+        raw = sys.stdin.read()
+    else:
+        path = Path(args.input)
+        if not path.exists():
+            print(f"error: file not found: {path}", file=sys.stderr)
+            return 1
+        raw = path.read_text(encoding="utf-8")
+
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        print(f"error: invalid JSON: {exc}", file=sys.stderr)
+        return 1
+
+    analyzer = ContentAnalyzer()
+    analysis = analyzer.analyze_spec(data)
+    print(analysis.summary)
+    return 0
+
+
+def _validate(args: argparse.Namespace) -> int:
+    try:
+        from .adapters.pydantic_schema import DocumentSpec
+    except ImportError:
+        print(
+            "error: pydantic is required.\n  pip install emboss-pdf[llm]",
+            file=sys.stderr,
+        )
+        return 1
+
+    if args.input == "-":
+        raw = sys.stdin.read()
+    else:
+        raw = Path(args.input).read_text(encoding="utf-8")
+
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        print(f"error: invalid JSON: {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        spec = DocumentSpec.model_validate(data)
+    except Exception as exc:
+        print(f"invalid: {exc}", file=sys.stderr)
+        return 1
+
+    print(
+        f"valid: {spec.title!r}, "
+        f"{len(spec.content)} blocks, "
+        f"style={spec.style}"
+    )
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="emboss",
+        description="Emboss — constraint-driven PDF generation for LLM pipelines",
+    )
+    parser.add_argument(
+        "--version", action="version",
+        version=f"%(prog)s {_get_version()}",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    render_p = sub.add_parser(
+        "render",
+        help="Render a JSON document spec to PDF",
+        description="Convert a JSON document specification to a professionally typeset PDF.",
+    )
+    render_p.add_argument("input", help="JSON spec file path, or '-' for stdin")
+    render_p.add_argument("-o", "--output", default="output.pdf", help="Output PDF path (default: output.pdf)")
+    render_p.add_argument("-q", "--quiet", action="store_true", help="Suppress status output")
+
+    schema_p = sub.add_parser(
+        "schema",
+        help="Export the JSON Schema for LLM prompt engineering",
+        description="Generate the JSON Schema that LLMs use to produce valid document specs.",
+    )
+    schema_p.add_argument("-o", "--output", default=None, help="Write to file instead of stdout")
+    schema_p.add_argument("-q", "--quiet", action="store_true")
+
+    verify_p = sub.add_parser(
+        "verify",
+        help="Verify an existing PDF's structural integrity",
+    )
+    verify_p.add_argument("input", help="PDF file path")
+
+    export_p = sub.add_parser(
+        "export",
+        help="Export a JSON spec to HTML, Markdown, or Office-ready JSON",
+        description="Convert a document spec to alternative formats for preview, editing, or PPTX/DOCX conversion.",
+    )
+    export_p.add_argument("input", help="JSON spec file path, or '-' for stdin")
+    export_p.add_argument(
+        "-f", "--format",
+        choices=["html", "markdown", "office-json"],
+        default="html",
+        help="Output format (default: html)",
+    )
+    export_p.add_argument("-o", "--output", default=None, help="Write to file instead of stdout")
+    export_p.add_argument("-q", "--quiet", action="store_true")
+
+    analyze_p = sub.add_parser(
+        "analyze",
+        help="Run content intelligence analysis on a document spec",
+        description="Detect document type, classify table columns, and report content intelligence.",
+    )
+    analyze_p.add_argument("input", help="JSON spec file, or '-' for stdin")
+
+    validate_p = sub.add_parser(
+        "validate",
+        help="Validate a JSON document spec without rendering",
+    )
+    validate_p.add_argument("input", help="JSON spec file, or '-' for stdin")
+
+    args = parser.parse_args(argv)
+
+    if args.command is None:
+        parser.print_help()
+        return 0
+
+    handlers = {
+        "render": _render,
+        "schema": _schema,
+        "verify": _verify,
+        "export": _export,
+        "analyze": _analyze,
+        "validate": _validate,
+    }
+    return handlers[args.command](args)
+
+
+def _get_version() -> str:
+    try:
+        from . import __version__
+
+        return __version__
+    except Exception:
+        return "0.1.0"
+
+
+if __name__ == "__main__":
+    sys.exit(main())

emboss/adapters/__init__.py

@@ -0,0 +1,7 @@
+"""Adapters for external systems and format conversion.
+
+  pydantic_schema  - Pydantic v2 models for LLM structured output
+  html_export      - Semantic HTML for preview and interchange
+  markdown_export  - Markdown for LLM round-trips and pandoc conversion
+  docx_export      - Structured dict for DOCX/PPTX conversion
+"""

emboss/adapters/docx_export.py

@@ -0,0 +1,221 @@
+"""Export a Document to a structured representation for DOCX/PPTX conversion.
+
+Rather than depending on python-docx or python-pptx directly (which would
+add heavy dependencies), this module exports a clean intermediate dict
+that any conversion tool can consume:
+
+    from emboss.adapters.docx_export import to_office_dict
+    data = to_office_dict(document)
+    # Feed to python-docx, pandoc, or any converter
+
+The dict mirrors the Open XML structure closely enough that conversion
+is mechanical, but uses plain Python types so no Office libraries are
+required at export time.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..spec import Document
+
+__all__ = ["to_office_dict"]
+
+
+def to_office_dict(document: "Document") -> dict:
+    """Convert a Document to a structured dict for Office format conversion.
+
+    Returns a dict with:
+      - metadata: title, author, subject, keywords, language
+      - styles: resolved style presets as CSS-like properties
+      - content: ordered list of typed blocks with full formatting
+    """
+    from ..spec import (
+        BibliographyBlock,
+        BulletList,
+        Callout,
+        Chart,
+        CodeBlock,
+        Footnote,
+        Heading,
+        HorizontalRule,
+        Image,
+        MathBlock,
+        PageBreak,
+        Paragraph,
+        Table,
+    )
+
+    sheet = document.stylesheet
+    blocks = []
+
+    for element in document.content:
+        if isinstance(element, Heading):
+            blocks.append({
+                "type": "heading",
+                "level": element.level,
+                "text": element.text,
+                "numbering": element.numbering,
+                "runs": _serialize_runs(element.runs),
+            })
+
+        elif isinstance(element, Paragraph):
+            style = sheet.resolved(sheet.body, element.style)
+            blocks.append({
+                "type": "paragraph",
+                "runs": _serialize_runs(element.runs),
+                "align": style.require("align"),
+                "indent_first": style.indent_first or 0,
+            })
+
+        elif isinstance(element, BulletList):
+            items = []
+            for item_runs in element.item_runs:
+                items.append({"runs": _serialize_runs(item_runs)})
+            blocks.append({
+                "type": "list",
+                "bullet": element.bullet,
+                "items": items,
+            })
+
+        elif isinstance(element, Table):
+            blocks.append(_serialize_table(element))
+
+        elif isinstance(element, Image):
+            blocks.append({
+                "type": "image",
+                "source": element.source if isinstance(element.source, str) else "<bytes>",
+                "alt_text": element.alt_text,
+                "width": element.width,
+                "height": element.height,
+                "caption": element.caption,
+                "align": element.align,
+            })
+
+        elif isinstance(element, Chart):
+            blocks.append({
+                "type": "chart",
+                "chart_type": element.chart_type,
+                "labels": list(element.labels),
+                "values": list(element.values),
+                "title": element.title,
+                "width": element.width,
+                "height": element.height,
+            })
+
+        elif isinstance(element, Footnote):
+            blocks.append({
+                "type": "footnote",
+                "marker": element.marker,
+                "runs": _serialize_runs(element.runs),
+            })
+
+        elif isinstance(element, Callout):
+            blocks.append({
+                "type": "callout",
+                "variant": element.variant,
+                "title": element.title,
+                "runs": _serialize_runs(element.runs),
+                "background": element.background,
+                "border_color": element.border_color,
+            })
+
+        elif isinstance(element, CodeBlock):
+            blocks.append({
+                "type": "code_block",
+                "code": element.code,
+                "language": element.language,
+                "line_numbers": element.line_numbers,
+                "caption": element.caption,
+            })
+
+        elif isinstance(element, MathBlock):
+            blocks.append({
+                "type": "math",
+                "source": element.source,
+                "display": element.display,
+                "caption": element.caption,
+            })
+
+        elif isinstance(element, BibliographyBlock):
+            from ..bibliography import format_bibliography
+            blocks.append({
+                "type": "bibliography",
+                "title": element.title,
+                "heading_level": element.heading_level,
+                "entries": format_bibliography(
+                    element.citations, element.bib_style
+                ),
+            })
+
+        elif isinstance(element, HorizontalRule):
+            blocks.append({"type": "horizontal_rule"})
+
+        elif isinstance(element, PageBreak):
+            blocks.append({"type": "page_break"})
+
+    page = document.page
+    return {
+        "metadata": {
+            "title": document.title,
+            "author": document.author,
+            "subject": document.subject,
+            "keywords": document.keywords,
+            "language": document.language,
+        },
+        "page": {
+            "width_pt": page.width,
+            "height_pt": page.height,
+            "margin_top_pt": page.margin_top,
+            "margin_right_pt": page.margin_right,
+            "margin_bottom_pt": page.margin_bottom,
+            "margin_left_pt": page.margin_left,
+        },
+        "content": blocks,
+    }
+
+
+def _serialize_runs(runs: list) -> list[dict]:
+    return [
+        {
+            "text": run.text,
+            "bold": run.bold,
+            "italic": run.italic,
+            "font_size": run.font_size,
+            "font_family": run.font_family,
+            "color": run.color,
+            "link": run.link,
+        }
+        for run in runs
+    ]
+
+
+def _serialize_table(table) -> dict:
+    headers = []
+    for cell in table.header_cells:
+        headers.append({
+            "text": cell.plain_text,
+            "align": cell.align,
+            "bold": cell.bold,
+        })
+
+    rows = []
+    for row in table.body_rows:
+        cells = []
+        for cell in row:
+            cells.append({
+                "text": cell.plain_text,
+                "align": cell.align,
+                "bold": cell.bold,
+                "background": cell.background,
+            })
+        rows.append(cells)
+
+    return {
+        "type": "table",
+        "headers": headers,
+        "rows": rows,
+        "caption": table.caption,
+        "stripe": table.stripe,
+    }