laudo 0.1.0__tar.gz

laudo-0.1.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.3
+Name: laudo
+Version: 0.1.0
+Summary: Generate forensic report using docxtpl templates
+Author: renatormc
+Author-email: renatormc <renatomartinsrmc@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Legal Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Office Suites
+Requires-Dist: beautifulsoup4>=4.14.3
+Requires-Dist: docxtpl[subdoc]>=0.20.2
+Requires-Dist: piexif>=1.1
+Requires-Dist: pillow>=10.0
+Requires-Dist: pyside6>=6.6
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: python-docx-replace>=0.4.4
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/renatormc/laudo
+Project-URL: Repository, https://github.com/renatormc/laudo
+Project-URL: Issues, https://github.com/renatormc/laudo/issues
+Description-Content-Type: text/markdown
+
+# laudo
+
+Convert markdown files to **docx** or **pdf** using `docxtpl` templates and LibreOffice headless.
+
+## Installation
+
+```bash
+pip install laudo
+```
+
+Requires **Python 3.13+** and **LibreOffice** installed system-wide for PDF output.
+
+## Usage
+
+### CLI
+
+```bash
+laudo <folder> <output>
+```
+
+- `<folder>` — directory with your project files.
+- `<output>` — output file (`.docx` or `.pdf`).
+
+### Python API
+
+```python
+from laudo import convert
+
+convert("my_project/", "output.docx")
+convert("my_project/", "output.pdf")
+```
+
+## Input Folder Structure
+
+```
+my_project/
+├── template.docx          # docxtpl template with Jinja2 placeholders
+├── fotos/                 # Images with captions (EXIF)
+│   ├── logo.png
+│   └── photo.jpg
+├── context.txt            # (optional) Variables one per line
+├── intro.md               # One or more .md files
+└── chapter-1.md
+```
+
+### `template.docx`
+
+A standard Word document using [docxtpl](https://github.com/elapouya/python-docxtpl) syntax. Use Jinja2 placeholders like `{{ variable }}` or `{{p intro|markdown }}`.
+
+### `context.txt`
+
+Optional file with variables in `key = value` format, one per line:
+
+```
+author = John Doe
+title = My Document
+```
+
+Lines starting with `#` and empty lines are ignored.
+
+These variables are also available for substitution inside your `.md` files (see below).
+
+### Markdown files
+
+Every `.md` file is read and its content is injected into the template context. The variable name is the filename without extension (whitespace replaced by underscores):
+
+| File | Context key |
+|---|---|
+| `intro.md` | `intro` |
+| `chapter 1.md` | `chapter_1` |
+
+You can use `{{ varname }}` inside `.md` files to reference values from `context.txt`:
+
+**context.txt:**
+```
+name = John Doe
+```
+
+**intro.md:**
+```markdown
+# Hello {{ name }}
+```
+
+The result will be `# Hello John Doe`, then stored in context key `intro`.
+
+Use the `subdoc` global function to embed `.docx` files from the `assets/` folder:
+
+```jinja2
+{{p subdoc("cover.docx") }}
+```
+
+Use the `markdown` filter in your template:
+
+```jinja2
+{{p intro|markdown }}
+```
+
+### Fotos
+
+All image files inside `fotos/` are listed in the `pics` context variable:
+
+```json
+{
+  "logo": {"path": "fotos/logo.png", "caption": "", "thumb": "fotos/.thumbs/logo_thumb.jpg", "reduced": "fotos/.thumbs/logo_reduced.jpg"},
+  "photo": {"path": "fotos/photo.jpg", "caption": "", "thumb": "fotos/.thumbs/photo_thumb.jpg", "reduced": "fotos/.thumbs/photo_reduced.jpg"}
+}
+```
+
+Captions are read from EXIF `ImageDescription` metadata.
+
+## PDF Output
+
+When the output path ends with `.pdf`, a docx is generated first and then converted to PDF via LibreOffice headless:
+
+```bash
+laudo my_project/ output.pdf
+```
+
+The intermediate docx file is automatically removed.
+
+## License
+
+MIT

laudo-0.1.0/README.md

@@ -0,0 +1,123 @@
+# laudo
+
+Convert markdown files to **docx** or **pdf** using `docxtpl` templates and LibreOffice headless.
+
+## Installation
+
+```bash
+pip install laudo
+```
+
+Requires **Python 3.13+** and **LibreOffice** installed system-wide for PDF output.
+
+## Usage
+
+### CLI
+
+```bash
+laudo <folder> <output>
+```
+
+- `<folder>` — directory with your project files.
+- `<output>` — output file (`.docx` or `.pdf`).
+
+### Python API
+
+```python
+from laudo import convert
+
+convert("my_project/", "output.docx")
+convert("my_project/", "output.pdf")
+```
+
+## Input Folder Structure
+
+```
+my_project/
+├── template.docx          # docxtpl template with Jinja2 placeholders
+├── fotos/                 # Images with captions (EXIF)
+│   ├── logo.png
+│   └── photo.jpg
+├── context.txt            # (optional) Variables one per line
+├── intro.md               # One or more .md files
+└── chapter-1.md
+```
+
+### `template.docx`
+
+A standard Word document using [docxtpl](https://github.com/elapouya/python-docxtpl) syntax. Use Jinja2 placeholders like `{{ variable }}` or `{{p intro|markdown }}`.
+
+### `context.txt`
+
+Optional file with variables in `key = value` format, one per line:
+
+```
+author = John Doe
+title = My Document
+```
+
+Lines starting with `#` and empty lines are ignored.
+
+These variables are also available for substitution inside your `.md` files (see below).
+
+### Markdown files
+
+Every `.md` file is read and its content is injected into the template context. The variable name is the filename without extension (whitespace replaced by underscores):
+
+| File | Context key |
+|---|---|
+| `intro.md` | `intro` |
+| `chapter 1.md` | `chapter_1` |
+
+You can use `{{ varname }}` inside `.md` files to reference values from `context.txt`:
+
+**context.txt:**
+```
+name = John Doe
+```
+
+**intro.md:**
+```markdown
+# Hello {{ name }}
+```
+
+The result will be `# Hello John Doe`, then stored in context key `intro`.
+
+Use the `subdoc` global function to embed `.docx` files from the `assets/` folder:
+
+```jinja2
+{{p subdoc("cover.docx") }}
+```
+
+Use the `markdown` filter in your template:
+
+```jinja2
+{{p intro|markdown }}
+```
+
+### Fotos
+
+All image files inside `fotos/` are listed in the `pics` context variable:
+
+```json
+{
+  "logo": {"path": "fotos/logo.png", "caption": "", "thumb": "fotos/.thumbs/logo_thumb.jpg", "reduced": "fotos/.thumbs/logo_reduced.jpg"},
+  "photo": {"path": "fotos/photo.jpg", "caption": "", "thumb": "fotos/.thumbs/photo_thumb.jpg", "reduced": "fotos/.thumbs/photo_reduced.jpg"}
+}
+```
+
+Captions are read from EXIF `ImageDescription` metadata.
+
+## PDF Output
+
+When the output path ends with `.pdf`, a docx is generated first and then converted to PDF via LibreOffice headless:
+
+```bash
+laudo my_project/ output.pdf
+```
+
+The intermediate docx file is automatically removed.
+
+## License
+
+MIT

laudo-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "laudo"
+version = "0.1.0"
+description = "Generate forensic report using docxtpl templates"
+readme = "README.md"
+authors = [
+    { name = "renatormc", email = "renatomartinsrmc@gmail.com" }
+]
+requires-python = ">=3.13"
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Legal Industry",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business :: Office Suites",
+]
+dependencies = [
+    "beautifulsoup4>=4.14.3",
+    "docxtpl[subdoc]>=0.20.2",
+    "PieXif>=1.1",
+    "Pillow>=10.0",
+    "PySide6>=6.6",
+    "python-dateutil>=2.9.0.post0",
+    "python-docx-replace>=0.4.4",
+]
+
+[project.scripts]
+laudo = "laudo.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/renatormc/laudo"
+Repository = "https://github.com/renatormc/laudo"
+Issues = "https://github.com/renatormc/laudo/issues"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.20.2",
+    "pyinstaller>=6.20.0",
+    "pytest>=8.0",
+    "types-beautifulsoup4>=4.12.0.20250516",
+    "types-pillow",
+    "types-python-dateutil>=2.9.0.20260508",
+]
+
+[tool.mypy]
+ignore_missing_imports = true
+
+[build-system]
+requires = ["uv_build>=0.10.8,<0.11.0"]
+build-backend = "uv_build"

laudo-0.1.0/src/laudo/__init__.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+
+from .core import run
+
+
+def convert(folder: str | Path, output: str | Path, *, debug: bool = False) -> Path:
+    return run(Path(folder), Path(output), debug=debug)

laudo-0.1.0/src/laudo/__main__.py

@@ -0,0 +1,113 @@
+import argparse
+import os
+import stat
+import sys
+from pathlib import Path
+
+from . import convert
+
+
+def _find_project_root() -> Path:
+    candidate = Path(__file__).resolve()
+    for parent in [candidate] + list(candidate.parents):
+        if (parent / "pyproject.toml").is_file():
+            return parent
+    return candidate.parent
+
+
+def _cmd_install() -> None:
+    bindir = Path.home() / ".local" / "bin"
+    bindir.mkdir(parents=True, exist_ok=True)
+    project_root = _find_project_root()
+
+    if os.name == "nt":
+        script = bindir / "laudo-dev.ps1"
+        content = f"& uv run --project {project_root} laudo @args\n"
+        script.write_text(content.lstrip())
+        print(f"Installed laudo wrapper at {script}")
+        path_sep = ";"
+        path_hint = f"$env:Path = \"{bindir};$env:Path\""
+    else:
+        script = bindir / "laudo"
+        content = f"#!/usr/bin/env bash\nexec uv run --project {project_root} laudo \"$@\"\n"
+        script.write_text(content.lstrip())
+        script.chmod(script.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        print(f"Installed laudo wrapper at {script}")
+        path_sep = ":"
+        path_hint = f'export PATH="$PATH:{bindir}"'
+
+    if str(bindir) not in os.environ.get("PATH", "").split(path_sep):
+        print(f"Warning: {bindir} is not in your PATH.", file=sys.stderr)
+        if os.name == "nt":
+            print("Add this to your PowerShell profile:")
+            print(f"  {path_hint}")
+        else:
+            shell = Path(os.environ.get("SHELL", "/bin/bash")).name
+            rc: Path | None = (
+                Path.home() / ".bashrc"
+                if shell == "bash"
+                else Path.home() / ".zshrc"
+                if shell == "zsh"
+                else None
+            )
+            if rc is not None:
+                print(f"Add this line to {rc}:")
+                print(f"  {path_hint}")
+
+
+def _cmd_gen(dir_: Path | None, debug: bool) -> None:
+    if dir_ is not None:
+        os.chdir(str(dir_))
+    folder = Path.cwd()
+    output = folder / "laudo.docx"
+    result = convert(folder, output, debug=debug)
+    print(f"Generated: {result}")
+
+
+def _cmd_captions(dir_: Path | None) -> None:
+    if dir_ is not None:
+        os.chdir(str(dir_))
+    from .gui import run as run_gui
+
+    run_gui(Path.cwd())
+
+
+def _existing_dir(value: str) -> Path:
+    p = Path(value)
+    if not p.is_dir():
+        raise argparse.ArgumentTypeError(f"not a directory: {value}")
+    return p
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Convert markdown files or open the caption editor."
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    gen_p = sub.add_parser("gen", help="Generate docx/pdf from markdown files.")
+    gen_p.add_argument("--dir", type=_existing_dir, default=None, help="Working directory (default: current directory)")
+    gen_p.add_argument("--debug", action="store_true", help="Print the template context before rendering")
+
+    cap_p = sub.add_parser("captions", help="Open the caption editor GUI.")
+    cap_p.add_argument("--dir", type=_existing_dir, default=None, help="Working directory (default: current directory)")
+
+    sub.add_parser("install", help="Install the laudo wrapper script to ~/.local/bin.")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    match args.command:
+        case "install":
+            _cmd_install()
+        case "gen":
+            _cmd_gen(args.dir, args.debug)
+        case "captions":
+            _cmd_captions(args.dir)
+
+
+if __name__ == "__main__":
+    main()

laudo-0.1.0/src/laudo/assets.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from .exif import get_caption
+
+
+def collect_assets(assets_path: Path) -> dict[str, dict]:
+    assets: dict[str, dict] = {}
+    if not assets_path.is_dir():
+        return assets
+    for f in sorted(assets_path.iterdir()):
+        if f.is_file():
+            caption = get_caption(f) if f.suffix.lower() in {".jpg", ".jpeg", ".tiff", ".png"} else ""
+            assets[f.stem] = {"path": f, "caption": caption}
+    return assets

laudo-0.1.0/src/laudo/core.py

@@ -0,0 +1,141 @@
+import os
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+import json
+from docxtpl import DocxTemplate
+from jinja2 import Environment, Template
+
+from laudo.reference_replacer import DocxReferenceReplacer
+
+from .filters import register as register_filters
+from .globals import register as register_globals
+
+
+def _parse_context_txt(folder: Path) -> dict:
+    context: dict = {}
+    ctx_file = folder / "context.txt"
+    if not ctx_file.is_file():
+        return context
+    for line in ctx_file.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        key = key.strip()
+        if not key:
+            continue
+        context[key] = val.strip()
+    return context
+
+
+def _read_context_json(folder: Path) -> dict:
+    ctx: dict = {}
+    for json_file in sorted(folder.glob("*.json")):
+        key = json_file.stem.replace(" ", "_")
+        content = json_file.read_text(encoding="utf-8")
+        ctx[key] = json.loads(content)
+    return ctx
+
+
+def _read_context_markdown(folder: Path, ctx_vars: dict) -> dict:
+    ctx: dict = {}
+    for md_file in sorted(folder.glob("*.md")):
+        key = md_file.stem.replace(" ", "_")
+        content = md_file.read_text(encoding="utf-8")
+        ctx[key] = Template(content).render(ctx_vars)
+    return ctx
+
+
+def _read_context_pics(folder: Path) -> list[dict]:
+    from .exif import get_caption as _get_exif_caption
+    from .images import _IMAGE_EXTENSIONS, get_reduced, get_thumbnail
+
+    fotos = folder / "fotos"
+    if not fotos.is_dir():
+        return []
+
+    cwd = Path.cwd()
+    os.chdir(str(folder))
+    try:
+        pics: list[dict] = []
+        for img in sorted(fotos.iterdir()):
+            if img.is_file() and img.suffix.lower() in _IMAGE_EXTENSIONS:
+                pics.append({
+                    "refname": img.stem,
+                    "path": img,
+                    "caption": _get_exif_caption(img),
+                    "thumb": get_thumbnail(img.stem),
+                    "reduced": get_reduced(img.stem),
+                    "label": "Foto",
+                })
+        return pics
+    finally:
+        os.chdir(str(cwd))
+
+
+def _build_context(folder: Path) -> dict:
+    context_folder = folder / "context"
+    if not context_folder.is_dir():
+        context_folder = folder
+    ctx_vars = _parse_context_txt(context_folder)
+    ctx_vars.update(_read_context_json(context_folder))
+    ctx_vars.update(_read_context_markdown(context_folder, ctx_vars))
+    pics = _read_context_pics(folder)
+    if pics:
+        ctx_vars["pics"] = pics
+    return ctx_vars
+
+@dataclass
+class RenderEnv:
+    tpl: DocxTemplate
+    jinja_env: Environment
+    temp_folder: Path
+    assets_folder: Path
+
+def render_docx(template_path: Path, context: dict, output_path: Path, replace_references=True) -> Path:
+    temp_folder = Path(tempfile.mkdtemp(prefix="laudo_"))
+    renv = RenderEnv(
+        tpl=DocxTemplate(str(template_path)),
+        jinja_env=Environment(),
+        temp_folder=temp_folder,
+        assets_folder=template_path.parent / "assets",
+    )
+    try:
+        register_filters(renv)
+        register_globals(renv)
+        renv.tpl.render(context, jinja_env=renv.jinja_env)
+        if replace_references:
+            dr = DocxReferenceReplacer()
+            dr.replace_in_doc(renv.tpl.docx)
+        renv.tpl.save(str(output_path))
+        return output_path
+    finally:
+        shutil.rmtree(temp_folder, ignore_errors=True)
+
+
+def run(folder: Path, output: Path, *, debug: bool = False) -> Path:
+    template_path = folder / "template.docx"
+    print(template_path)
+    if not template_path.is_file():
+        raise FileNotFoundError(f"template.docx not found in project folder or in package templates")
+
+    
+    context = _build_context(folder)
+    if debug:
+        import pprint
+        print("--- context ---")
+        pprint.pprint(context, indent=2, sort_dicts=False)
+        print("---------------")
+
+    if output.suffix == ".pdf":
+        docx_path = output.with_suffix(".docx")
+        render_docx(template_path, context, docx_path)
+        from .pdf import convert_to_pdf
+
+        result = convert_to_pdf(docx_path, output)
+        # docx_path.unlink()
+        return result
+
+    return render_docx(template_path, context, output)

laudo-0.1.0/src/laudo/exif.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+
+import piexif  # type: ignore[import-untyped]
+from PIL import Image
+
+
+_IMAGE_DESC_TAG = piexif.ImageIFD.ImageDescription
+
+
+def _sanitize(exif_dict: dict) -> dict:
+    """Convert Undefined-type tuples back to bytes for piexif.dump."""
+    for ifd_name in ("0th", "Exif", "GPS", "1st"):
+        ifd = exif_dict.get(ifd_name, {})
+        info = piexif.TAGS.get(ifd_name, {})
+        for tag, value in ifd.items():
+            if isinstance(value, tuple) and info.get(tag, {}).get("type") == 7:
+                ifd[tag] = bytes(value)
+    return exif_dict
+
+
+def get_caption(path: Path) -> str:
+    """Read caption from the EXIF ImageDescription tag."""
+    try:
+        exif_dict = piexif.load(str(path))
+        raw = exif_dict.get("0th", {}).get(_IMAGE_DESC_TAG)
+        if raw is None:
+            return ""
+        if isinstance(raw, bytes):
+            return raw.decode("utf-8", errors="replace")
+        return str(raw)
+    except Exception:
+        return ""
+
+
+def set_caption(path: Path, caption: str) -> None:
+    """Write caption to the EXIF ImageDescription tag (in-place)."""
+    exif_dict = piexif.load(str(path))
+    exif_dict["0th"][_IMAGE_DESC_TAG] = caption.encode("utf-8")
+    exif_bytes = piexif.dump(_sanitize(exif_dict))
+    _save_exif(path, exif_bytes)
+
+
+def clear_caption(path: Path) -> None:
+    """Remove the EXIF ImageDescription tag."""
+    exif_dict = piexif.load(str(path))
+    exif_dict["0th"].pop(_IMAGE_DESC_TAG, None)
+    exif_bytes = piexif.dump(_sanitize(exif_dict))
+    _save_exif(path, exif_bytes)
+
+
+def has_caption(path: Path) -> bool:
+    """Check if the image has a non-empty caption."""
+    return bool(get_caption(path))
+
+
+def _save_exif(path: Path, exif_bytes: bytes) -> None:
+    with Image.open(path) as img:
+        img.save(path, exif=exif_bytes)

laudo-0.1.0/src/laudo/filters/__init__.py

@@ -0,0 +1,17 @@
+from typing import TYPE_CHECKING
+
+from .filters import Filters
+from laudo.filters.markdown_filter import MarkdownFilter
+if TYPE_CHECKING:
+    from laudo.core import RenderEnv
+
+
+def register(rend: 'RenderEnv') -> None:
+    rend.jinja_env.filters["markdown"] = MarkdownFilter(rend)
+    fs = Filters()
+    for name in dir(fs):
+        if not name.startswith("_"):
+            method = getattr(fs, name)
+            if callable(method):
+                rend.jinja_env.filters[name] = method
+