markitup-py 0.3.1__tar.gz

markitup_py-0.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Timmy
+
+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.

markitup_py-0.3.1/PKG-INFO

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: markitup-py
+Version: 0.3.1
+Summary: The reverse of MarkItDown: turn Markdown into clean, themeable DOCX and PDF documents.
+Author: Timmy
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/markitup
+Project-URL: Source, https://github.com/yourname/markitup
+Project-URL: Issues, https://github.com/yourname/markitup/issues
+Keywords: markdown,docx,pdf,document-generation,markitdown,report
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Office/Business :: Office Suites
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: markdown-it-py>=3.0
+Requires-Dist: python-docx>=1.1
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: pdf
+Requires-Dist: weasyprint>=60; extra == "pdf"
+Requires-Dist: pypdf>=4.0; extra == "pdf"
+Requires-Dist: reportlab>=4.0; extra == "pdf"
+Requires-Dist: Pillow>=10; extra == "pdf"
+Provides-Extra: chromium
+Requires-Dist: playwright>=1.40; extra == "chromium"
+Provides-Extra: all
+Requires-Dist: weasyprint>=60; extra == "all"
+Requires-Dist: pypdf>=4.0; extra == "all"
+Requires-Dist: reportlab>=4.0; extra == "all"
+Requires-Dist: Pillow>=10; extra == "all"
+Requires-Dist: playwright>=1.40; extra == "all"
+Dynamic: license-file
+
+# MarkItUp
+
+The reverse of Microsoft's **MarkItDown**: feed it Markdown, get back clean,
+well-designed `.docx` and `.pdf` (and `.html`).
+
+Unlike an LLM that "codes and executes" a document on every request, MarkItUp is
+a **deterministic pipeline**. The same Markdown + same theme always produces the
+same document. All design decisions are front-loaded into a theme, once — they
+are never re-derived per document.
+
+```
+markdown ──parse──▶ IR ──render──┬──▶ .docx   (python-docx → OOXML)
+                                 ├──▶ .html   (theme → CSS)
+                                 └──▶ .pdf    (IR → themed HTML → print engine)
+```
+
+PDF uses a **pluggable engine**: `weasyprint` (pure-Python, default) or
+`chromium` (headless, highest fidelity). Both consume the same HTML.
+
+## Install
+
+```bash
+pip install markitup-py            # docx only (lightweight)
+pip install "markitup-py[pdf]"     # + PDF and existing-file watermarking
+```
+
+The import name is `markitup`. PDF needs system libs for WeasyPrint
+(pango, cairo, gdk-pixbuf).
+
+## Quick start (Python)
+
+```python
+from markitup import MarkItUp
+
+m = MarkItUp(theme="report")
+m.convert("doc.md", "doc.pdf")
+m.convert("doc.md")                 # -> ./doc.docx (current directory)
+```
+
+Configure once, convert many. Every knob overrides the theme:
+
+```python
+from markitup import MarkItUp, Watermark
+
+m = MarkItUp(
+    theme="report",
+    body_font="Georgia",
+    heading_font="Calibri",
+    text_color="#222222",
+    heading_color="#0B3D2E",
+    heading_colors={1: "#0B3D2E", 2: "#1F6FEB"},   # per-level overrides
+    accent_color="#1F6FEB",
+    base_size=11, scale=1.2, line_height=1.45,
+    page_size="A4", margin_cm=2.54,
+    banner="CONFIDENTIAL — INTERNAL USE ONLY",
+    watermark=Watermark(enabled=True, text="DRAFT", opacity=0.08, position="center"),
+)
+m.convert("doc.md", "doc.pdf")
+```
+
+## Fonts
+
+DOCX stores font *names* and the reader substitutes what they have installed, so
+prefer cross-platform families. PDF is rendered here, so a font must be installed
+on this machine to appear.
+
+```python
+from markitup import list_fonts, is_available
+info = list_fonts()
+info["installed"]   # families available for PDF rendering on this machine
+info["safe"]        # curated cross-platform families for .docx
+is_available("Georgia")
+```
+
+```bash
+markitup fonts
+```
+
+## Watermarks
+
+A watermark is a theme token, applied identically to docx and PDF — text or image,
+with `opacity`, `rotation`, `position` (`center`/`top`/`bottom`).
+
+```python
+m = MarkItUp(watermark={"text": "DRAFT", "opacity": 0.1, "rotation": -45})
+m = MarkItUp(watermark={"image": "logo.png", "opacity": 0.12})
+```
+
+### Stamp an EXISTING file
+
+Add a watermark to a `.pdf` or `.docx` you already have — no re-rendering. It's an
+overlay/append, so the document's content is left intact.
+
+```python
+from markitup import stamp
+
+stamp("report.pdf", "stamped.pdf", "CONFIDENTIAL",
+      position="top", opacity=0.12, pages="1-3", behind=True)
+stamp("report.docx", "stamped.docx", {"image": "logo.png", "opacity": 0.1})
+# encrypted PDF: pass password=...
+```
+
+```bash
+markitup stamp report.pdf -o stamped.pdf --watermark CONFIDENTIAL --position top
+markitup stamp report.docx -o stamped.docx --watermark-image logo.png
+```
+
+Encrypted PDFs are refused unless you supply a password. Scanned/image PDFs are
+fine — the overlay lands on top.
+
+## Banners
+
+A short notice rendered in-flow at the very top of a generated document:
+
+```python
+from markitup import Banner
+m = MarkItUp(banner=Banner(text="RESTRICTED", color="#FFFFFF", bg="#B00020"))
+```
+
+## Templates (`base_docx`)
+
+Hand MarkItUp a Word file you designed — brand fonts, colors, a header/footer with
+your logo. It opens the file, clears the body, and maps your Markdown onto *its*
+named styles. The template owns the design; Markdown just fills it. (This is the
+Pandoc `reference.docx` model.)
+
+```python
+m = MarkItUp(base_docx="brand-template.docx")
+m.convert("doc.md", "out.docx")
+```
+
+## CLI
+
+```bash
+markitup convert in.md -o out.pdf --theme report --font Georgia
+markitup convert in.md --banner "CONFIDENTIAL" --watermark DRAFT
+markitup fonts
+markitup stamp in.pdf -o out.pdf --watermark "DO NOT COPY" --position bottom --pages 1-2
+```
+
+## Supported Markdown
+
+Headings, paragraphs, **bold**/*italic*/~~strike~~/`code`, links, ordered &
+unordered lists (nested), blockquotes, fenced code blocks, GFM tables (with
+column alignment and clean wrapping), and thematic breaks.
+
+## Architecture
+
+| Module                    | Responsibility                                        |
+|---------------------------|-------------------------------------------------------|
+| `markitup/ir.py`          | Intermediate Representation — structure & intent only |
+| `markitup/theme.py`       | Design tokens; computed type scale; watermark/banner  |
+| `markitup/parse.py`       | markdown-it-py token stream → IR                       |
+| `markitup/render_docx.py` | IR + Theme → `.docx`                                   |
+| `markitup/render_html.py` | IR + Theme → HTML/CSS (PDF intermediate)              |
+| `markitup/render_pdf.py`  | HTML → PDF (pluggable engine)                          |
+| `markitup/stamp.py`       | Watermark existing `.pdf`/`.docx`                      |
+| `markitup/fonts.py`       | Font discovery                                         |
+| `markitup/api.py`         | The `MarkItUp` class                                   |
+| `markitup/themes/*.yaml`  | Named themes                                           |
+
+## License
+
+MIT.

markitup_py-0.3.1/README.md

@@ -0,0 +1,164 @@
+# MarkItUp
+
+The reverse of Microsoft's **MarkItDown**: feed it Markdown, get back clean,
+well-designed `.docx` and `.pdf` (and `.html`).
+
+Unlike an LLM that "codes and executes" a document on every request, MarkItUp is
+a **deterministic pipeline**. The same Markdown + same theme always produces the
+same document. All design decisions are front-loaded into a theme, once — they
+are never re-derived per document.
+
+```
+markdown ──parse──▶ IR ──render──┬──▶ .docx   (python-docx → OOXML)
+                                 ├──▶ .html   (theme → CSS)
+                                 └──▶ .pdf    (IR → themed HTML → print engine)
+```
+
+PDF uses a **pluggable engine**: `weasyprint` (pure-Python, default) or
+`chromium` (headless, highest fidelity). Both consume the same HTML.
+
+## Install
+
+```bash
+pip install markitup-py            # docx only (lightweight)
+pip install "markitup-py[pdf]"     # + PDF and existing-file watermarking
+```
+
+The import name is `markitup`. PDF needs system libs for WeasyPrint
+(pango, cairo, gdk-pixbuf).
+
+## Quick start (Python)
+
+```python
+from markitup import MarkItUp
+
+m = MarkItUp(theme="report")
+m.convert("doc.md", "doc.pdf")
+m.convert("doc.md")                 # -> ./doc.docx (current directory)
+```
+
+Configure once, convert many. Every knob overrides the theme:
+
+```python
+from markitup import MarkItUp, Watermark
+
+m = MarkItUp(
+    theme="report",
+    body_font="Georgia",
+    heading_font="Calibri",
+    text_color="#222222",
+    heading_color="#0B3D2E",
+    heading_colors={1: "#0B3D2E", 2: "#1F6FEB"},   # per-level overrides
+    accent_color="#1F6FEB",
+    base_size=11, scale=1.2, line_height=1.45,
+    page_size="A4", margin_cm=2.54,
+    banner="CONFIDENTIAL — INTERNAL USE ONLY",
+    watermark=Watermark(enabled=True, text="DRAFT", opacity=0.08, position="center"),
+)
+m.convert("doc.md", "doc.pdf")
+```
+
+## Fonts
+
+DOCX stores font *names* and the reader substitutes what they have installed, so
+prefer cross-platform families. PDF is rendered here, so a font must be installed
+on this machine to appear.
+
+```python
+from markitup import list_fonts, is_available
+info = list_fonts()
+info["installed"]   # families available for PDF rendering on this machine
+info["safe"]        # curated cross-platform families for .docx
+is_available("Georgia")
+```
+
+```bash
+markitup fonts
+```
+
+## Watermarks
+
+A watermark is a theme token, applied identically to docx and PDF — text or image,
+with `opacity`, `rotation`, `position` (`center`/`top`/`bottom`).
+
+```python
+m = MarkItUp(watermark={"text": "DRAFT", "opacity": 0.1, "rotation": -45})
+m = MarkItUp(watermark={"image": "logo.png", "opacity": 0.12})
+```
+
+### Stamp an EXISTING file
+
+Add a watermark to a `.pdf` or `.docx` you already have — no re-rendering. It's an
+overlay/append, so the document's content is left intact.
+
+```python
+from markitup import stamp
+
+stamp("report.pdf", "stamped.pdf", "CONFIDENTIAL",
+      position="top", opacity=0.12, pages="1-3", behind=True)
+stamp("report.docx", "stamped.docx", {"image": "logo.png", "opacity": 0.1})
+# encrypted PDF: pass password=...
+```
+
+```bash
+markitup stamp report.pdf -o stamped.pdf --watermark CONFIDENTIAL --position top
+markitup stamp report.docx -o stamped.docx --watermark-image logo.png
+```
+
+Encrypted PDFs are refused unless you supply a password. Scanned/image PDFs are
+fine — the overlay lands on top.
+
+## Banners
+
+A short notice rendered in-flow at the very top of a generated document:
+
+```python
+from markitup import Banner
+m = MarkItUp(banner=Banner(text="RESTRICTED", color="#FFFFFF", bg="#B00020"))
+```
+
+## Templates (`base_docx`)
+
+Hand MarkItUp a Word file you designed — brand fonts, colors, a header/footer with
+your logo. It opens the file, clears the body, and maps your Markdown onto *its*
+named styles. The template owns the design; Markdown just fills it. (This is the
+Pandoc `reference.docx` model.)
+
+```python
+m = MarkItUp(base_docx="brand-template.docx")
+m.convert("doc.md", "out.docx")
+```
+
+## CLI
+
+```bash
+markitup convert in.md -o out.pdf --theme report --font Georgia
+markitup convert in.md --banner "CONFIDENTIAL" --watermark DRAFT
+markitup fonts
+markitup stamp in.pdf -o out.pdf --watermark "DO NOT COPY" --position bottom --pages 1-2
+```
+
+## Supported Markdown
+
+Headings, paragraphs, **bold**/*italic*/~~strike~~/`code`, links, ordered &
+unordered lists (nested), blockquotes, fenced code blocks, GFM tables (with
+column alignment and clean wrapping), and thematic breaks.
+
+## Architecture
+
+| Module                    | Responsibility                                        |
+|---------------------------|-------------------------------------------------------|
+| `markitup/ir.py`          | Intermediate Representation — structure & intent only |
+| `markitup/theme.py`       | Design tokens; computed type scale; watermark/banner  |
+| `markitup/parse.py`       | markdown-it-py token stream → IR                       |
+| `markitup/render_docx.py` | IR + Theme → `.docx`                                   |
+| `markitup/render_html.py` | IR + Theme → HTML/CSS (PDF intermediate)              |
+| `markitup/render_pdf.py`  | HTML → PDF (pluggable engine)                          |
+| `markitup/stamp.py`       | Watermark existing `.pdf`/`.docx`                      |
+| `markitup/fonts.py`       | Font discovery                                         |
+| `markitup/api.py`         | The `MarkItUp` class                                   |
+| `markitup/themes/*.yaml`  | Named themes                                           |
+
+## License
+
+MIT.

markitup_py-0.3.1/markitup/__init__.py

@@ -0,0 +1,45 @@
+"""MarkItUp — markdown -> docx/pdf/html, the reverse of Microsoft's MarkItDown.
+
+Quick start:
+
+    from markitup import MarkItUp
+    MarkItUp(theme="report").convert("doc.md", "doc.pdf")
+
+Pipeline:  markdown --parse--> IR --render--> .docx / .pdf / .html
+All visual decisions live in a Theme; the renderers are mechanical.
+"""
+import os
+
+from .api import MarkItUp
+from .theme import Theme, Watermark, Banner, Table, make_watermark
+from .parse import parse
+from .render_docx import render as render_docx
+from .render_html import render_html
+from .render_pdf import render_pdf
+from .stamp import stamp
+from .fonts import list_fonts, available_fonts, is_available, SAFE_FONTS
+
+__version__ = "0.3.1"
+__all__ = [
+    "MarkItUp", "Theme", "Watermark", "Banner", "Table",
+    "parse", "render_docx", "render_html", "render_pdf",
+    "stamp", "convert",
+    "list_fonts", "available_fonts", "is_available", "SAFE_FONTS",
+]
+
+
+def convert(markdown_text: str, out_path: str, theme="report",
+            base_url: str = ".", pdf_engine: str = "weasyprint") -> str:
+    """One-shot helper: markdown string -> file (format from extension)."""
+    doc = parse(markdown_text)
+    th = theme if isinstance(theme, Theme) else Theme.load(theme)
+    ext = os.path.splitext(out_path)[1].lower()
+    if ext == ".docx":
+        return render_docx(doc, th, out_path)
+    if ext == ".pdf":
+        return render_pdf(doc, th, out_path, engine=pdf_engine, base_url=base_url)
+    if ext in (".html", ".htm"):
+        with open(out_path, "w", encoding="utf-8") as fh:
+            fh.write(render_html(doc, th))
+        return out_path
+    raise ValueError(f"unsupported output extension: {ext!r}")

markitup_py-0.3.1/markitup/api.py

@@ -0,0 +1,145 @@
+"""The public, configured entry point: the MarkItUp class.
+
+Mirrors the ergonomics of Microsoft's MarkItDown — construct once with your
+preferences, then convert many files:
+
+    from markitup import MarkItUp, Watermark
+    m = MarkItUp(theme="report", body_font="Georgia", text_color="#222")
+    m.convert("doc.md", "doc.pdf")
+    m.convert("doc.md")            # -> ./doc.docx (current working directory)
+
+Every visual knob is optional and overrides the chosen theme.
+"""
+from __future__ import annotations
+
+import os
+from typing import Dict, Optional, Union
+
+from .theme import Theme, Banner, Watermark, make_watermark, norm_hex
+from .parse import parse
+from .render_docx import render as _render_docx
+from .render_html import render_html as _render_html
+from .render_pdf import render_pdf as _render_pdf
+from . import stamp as _stamp_mod
+
+
+class MarkItUp:
+    def __init__(
+        self,
+        theme: Union[str, Theme] = "report",
+        *,
+        # fonts
+        body_font: Optional[str] = None,
+        heading_font: Optional[str] = None,
+        mono_font: Optional[str] = None,
+        # colors (accept '#RRGGBB' or 'RRGGBB')
+        text_color: Optional[str] = None,
+        heading_color: Optional[str] = None,
+        heading_colors: Optional[Dict[int, str]] = None,
+        accent_color: Optional[str] = None,
+        link_color: Optional[str] = None,
+        # type & page
+        base_size: Optional[float] = None,
+        line_height: Optional[float] = None,
+        scale: Optional[float] = None,
+        page_size: Optional[str] = None,
+        margin_cm: Optional[float] = None,
+        # structure & marks
+        base_docx: Optional[str] = None,
+        watermark: Union[Watermark, str, dict, None] = None,
+        banner: Union[Banner, str, dict, None] = None,
+        # pdf
+        pdf_engine: str = "weasyprint",
+    ):
+        th = theme if isinstance(theme, Theme) else Theme.load(theme)
+
+        if body_font:
+            th.fonts.body = body_font
+        if heading_font:
+            th.fonts.heading = heading_font
+        if mono_font:
+            th.fonts.mono = mono_font
+
+        if text_color:
+            th.colors.text = norm_hex(text_color)
+        if heading_color:
+            th.colors.heading = norm_hex(heading_color)
+        if accent_color:
+            th.colors.accent = norm_hex(accent_color)
+        if link_color:
+            th.colors.link = norm_hex(link_color)
+        if heading_colors:
+            th.colors.headings.update({int(k): norm_hex(v) for k, v in heading_colors.items()})
+
+        if base_size is not None:
+            th.type.base_size = base_size
+        if line_height is not None:
+            th.type.line_height = line_height
+        if scale is not None:
+            th.type.ratio = scale
+        if page_size:
+            th.page.size = page_size
+        if margin_cm is not None:
+            th.page.margin_cm = margin_cm
+
+        if base_docx:
+            th.base_docx = base_docx
+        if watermark is not None:
+            th.watermark = make_watermark(watermark)
+        if banner is not None:
+            th.banner = _coerce_banner(banner)
+
+        self.theme = th
+        self.pdf_engine = pdf_engine
+
+    # ---- conversion -------------------------------------------------------
+    def convert(self, input_path: str, output_path: Optional[str] = None,
+                *, to: str = "docx") -> str:
+        """Convert a markdown file. If `output_path` is omitted, the output is
+        written to the current working directory as <input-stem>.<to>."""
+        with open(input_path, "r", encoding="utf-8") as fh:
+            md = fh.read()
+        if output_path is None:
+            stem = os.path.splitext(os.path.basename(input_path))[0]
+            output_path = os.path.join(os.getcwd(), f"{stem}.{to.lstrip('.')}")
+        base_url = os.path.dirname(os.path.abspath(input_path)) or "."
+        return self.convert_text(md, output_path, base_url=base_url)
+
+    def convert_text(self, markdown_text: str, output_path: str,
+                     *, base_url: str = ".") -> str:
+        """Convert a markdown string to the file at output_path (format from ext)."""
+        doc = parse(markdown_text)
+        ext = os.path.splitext(output_path)[1].lower()
+        if ext == ".docx":
+            return _render_docx(doc, self.theme, output_path)
+        if ext == ".pdf":
+            return _render_pdf(doc, self.theme, output_path,
+                               engine=self.pdf_engine, base_url=base_url)
+        if ext in (".html", ".htm"):
+            with open(output_path, "w", encoding="utf-8") as fh:
+                fh.write(_render_html(doc, self.theme))
+            return output_path
+        raise ValueError(f"unsupported output extension: {ext!r}")
+
+    # ---- existing-file watermarking --------------------------------------
+    @staticmethod
+    def stamp(input_path: str, output_path: str, watermark, **kwargs) -> str:
+        """Watermark an existing .pdf/.docx. See markitup.stamp for options."""
+        return _stamp_mod.stamp(input_path, output_path, watermark, **kwargs)
+
+
+def _coerce_banner(value) -> Optional[Banner]:
+    if value is None:
+        return None
+    if isinstance(value, Banner):
+        b = value
+    elif isinstance(value, str):
+        b = Banner(text=value)
+    elif isinstance(value, dict):
+        b = Banner(**value)
+    else:
+        raise TypeError(f"banner must be Banner | str | dict | None, got {type(value)!r}")
+    b.color = norm_hex(b.color)
+    if b.bg:
+        b.bg = norm_hex(b.bg)
+    return b