laudo 0.1.0__py3-none-any.whl

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/__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/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/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/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/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
+    

laudo/filters/filters.py

@@ -0,0 +1,172 @@
+from datetime import date, datetime
+from .helpers_filters import *
+import math
+from pathlib import Path
+
+
+nome_meses = [
+    'janeiro',
+    'fevereiro',
+    'março',
+    'abril',
+    'maio',
+    'junho',
+    'julho',
+    'agosto',
+    'setembro',
+    'outubro',
+    'novembro',
+    'dezembro'
+]
+
+
+class Filters:
+
+    def rgano(self, value: str) -> dict:
+        try:
+            parts = value.split("/")
+            return {"rg": int(parts[0]), "ano": int(parts[1])}
+        except:
+            raise Exception(f"Valor {value} não segue o formato rg/ano")
+
+    def perano(self, value: str) -> int:
+        return self.rgano(value)['ano']
+
+    def perrg(self, value: str) -> int:
+        return self.rgano(value)['rg']
+
+    def br(self, value, loop_):
+        return value if loop_.index == 1 else f"<w:br/>{value}"
+
+    def not_null(self, value):
+        if value is None:
+            return ""
+        return value
+
+    def xxx(self, value):
+        if value is None:
+            return "XXX"
+        return value
+
+    def data_completa(self, value):
+        if not isinstance(value, datetime) and not isinstance(value, date):
+            return ""
+        dia = str(value.day).rjust(2, "0")
+        dia_extenso = get_extenso(value.day)
+        return f"{dia} ({dia_extenso}) dias do mês de {nome_meses[value.month - 1]} do ano de {value.year} ({get_extenso(value.year)})"
+
+    def data_mes_extenso(self, value):
+        if not isinstance(value, datetime) and not isinstance(value, date):
+            return ""
+        value = convert_datetime(value)
+        dia = str(value.day) if value.day > 1 else f"{value.day}°"
+        return f"{dia} de {nome_meses[value.month - 1]} de {value.year}"
+
+    def hora_minuto(self, value):
+        if not isinstance(value, datetime):
+            return "XXX"
+        value = convert_datetime(value)
+        hora = str(value.hour).rjust(2, "0")
+        minuto = str(value.minute).rjust(2, "0")
+        return f"{hora}:{minuto}"
+
+    def dia(self, value):
+        if not isinstance(value, datetime):
+            return "XXX"
+        value = convert_datetime(value)
+        return str(value.day).rjust(2, "0")
+
+    def dia_extenso(self, value):
+        if not isinstance(value, datetime):
+            return "XXX"
+        value = convert_datetime(value)
+        dia = str(value.day).rjust(2, "0")
+        dia_extenso = get_extenso(value.day)
+        return f"{dia} ({dia_extenso})"
+
+    def numero_extenso_masc(self, value):
+        return get_extenso(value)
+
+    def numero_extenso_fem(self, value):
+        return get_extenso(value, feminino=True)
+
+    def mes_extenso(self, value):
+        if not isinstance(value, datetime):
+            return "XXX"
+        return nome_meses[value.month-1]
+
+    def data_simples(self, value):
+        if not value:
+            return ""
+        value = convert_datetime(value)
+        if isinstance(value, datetime):
+            return value.strftime("%d/%m/%Y")
+        try:
+            data = datetime.strptime(value, "%d/%m/%Y")
+            return data.strftime("%d/%m/%Y")
+        except Exception as e:
+            print(e)
+            pass
+
+    def is_male(self, value):
+        if isinstance(value, str):
+            firstname = value.split()[0]
+            return firstname.endswith('o')
+        return False
+
+    def get_extenso(self, value, feminino=False):
+        return get_extenso(value, feminino=feminino)
+
+    def datetime(self, value):
+        try:
+            return datetime.strptime(value, "%d/%m/%Y")
+        except:
+            pass
+
+    def join_enumerate(self, values, with_quotes=False):
+        n = len(values)
+        if n == 0 :
+            return ""
+        if n == 1:
+            return str(values[0])
+        if with_quotes:
+            values = [f"\"{v}\"" for v in values]
+        else:
+            values = [str(v) for v in values]
+        parts1 = values[:-1]
+        text1 = ", ".join(parts1)
+        return f"{text1} e {values[-1]}"
+
+    def moeda_extenso(self, value, prefix="R$ "):
+        value_str = f"{value:.2f}".replace(".", ",")
+        reais = math.floor(value)
+        centavos = int((value%reais + 0.0000000001)*100) if reais > 0 else value*100
+        reais_text = get_extenso(reais)
+        aux1 = "reais" if reais > 1 else "real"
+        aux2 = "centavos" if centavos > 1 else "centavo"
+        centavos_text = get_extenso(centavos)
+
+        middle_text = f"{reais_text} {aux1}"
+        if centavos > 0:
+            middle_text += f" e {centavos_text} {aux2}"
+        text = f"{prefix}{value_str} ({middle_text})"
+        return text
+
+    def file_stem(self, value):
+        try:
+            path = Path(value)
+            return path.stem
+        except:
+            return ""
+
+
+    def str(self, value):
+        return str(value)
+
+    def bookmark(self, value, anyvalue):
+        return value
+
+    def ornow(self, value):
+        if not value:
+            return datetime.now()
+        return value

laudo/filters/helpers_filters.py

@@ -0,0 +1,166 @@
+from datetime import datetime
+from dateutil import parser
+
+class NumeroExtenso():
+    trioextenso = ()
+    classextenso = ()
+
+    def __init__(self):
+        self.trioextenso_masculino = (
+            ("dummy", "um", "dois", "três", "quatro", "cinco", "seis", "sete",
+                      "oito", "nove"),
+            ("dez", "onze", "doze", "treze", "quatorze", "quinze", "dezesseis",
+             "dezessete", "dezoito", "dezenove"),
+            ("dummy", "dummy", "vinte", "trinta", "quarenta", "cinquenta",
+                      "sessenta", "setenta", "oitenta", "noventa"),
+            ("dummy", "cento", "duzentos", "trezentos", "quatrocentos",
+                      "quinhentos", "seiscentos", "setecentos", "oitocentos",
+                      "novecentos"))
+        self.trioextenso_feminino = (
+            ("dummy", "uma", "duas", "três", "quatro", "cinco", "seis", "sete",
+                      "oito", "nove"),
+            ("dez", "onze", "doze", "treze", "quatorze", "quinze", "dezesseis",
+             "dezessete", "dezoito", "dezenove"),
+            ("dummy", "dummy", "vinte", "trinta", "quarenta", "cinquenta",
+                      "sessenta", "setenta", "oitenta", "noventa"),
+            ("dummy", "cento", "duzentas", "trezentas", "quatrocentas",
+                      "quinhentas", "seiscentas", "setecentas", "oitocentas",
+                      "novecentas"))
+        self.classextenso = (
+            "dummy", "mil", "milh", "bilh", "trilh", "quatrilh",
+            "quintilh", "sextilh", "septilh", "octilh",
+            "nonilh", "decilh", "undecilh", "duodecilh",
+                      "tredecilh", "quatordecilh", "quindecilh",
+                      "sexdecilh", "setedecilh", "octodecilh",
+                      "novedecilh", "vigesilh")
+        self.trioextenso = self.trioextenso_masculino
+        
+
+    def escrever_trio_extenso(self, trio):
+        """
+        Retorna um trio por extenso.
+
+        Entrada: trio na forma de string.
+
+        Retorno: trio em extenso.
+        """
+        saida = []
+
+        if trio == '100':
+            # Erro antigo aqui. Consertado usando "return"
+            return 'cem'
+        elif trio == '000':
+            return 'zero'
+        else:
+            c, d, u = trio
+            c, d, u = int(c), int(d), int(u)
+
+            if c != 0:
+                saida.append(self.trioextenso[3][c])
+            if d == 1:
+                saida.append(self.trioextenso[1][u])
+            else:
+                if d != 0:
+                    saida.append(self.trioextenso[2][d])
+                if u != 0:
+                    saida.append(self.trioextenso[0][u])
+        return ' e '.join(saida)
+
+    def nao_e_ultimo_trio(self, totalTrios, contador):
+        """
+        Retorna verdadeiro se o trio indicado pelo contador
+        não é o último (isso é, não é o mais à direita).
+
+        Entrada: Número total de trios e o contador.
+
+        Retorno: Verdadeiro se o trio NÃO é o último e
+        falso caso contrário.
+        """
+        return contador < (totalTrios - 1)
+
+    def trio_a_esquerda_eq_zero(self, trioLista, contador):
+        """
+        Retorna verdadeiro se o trio à esquerda do trio
+        indicado pelo contador é igual a zero.
+
+        Entrada: Os trios em forma de Lista e o contador.
+
+        Retorno: Verdadeiro se o trio à esquerda do contador
+        for zero e falso caso contrário.
+        """
+
+        # Contador igual a zero indexa o elemento mais à direita,
+        # por isso devemos acrescentar tamanho da lista.
+        t = len(trioLista)-1
+        return trioLista[t-contador-1] == '000'
+
+    def getExtenso(self, num, quebradelinhas=0, feminino=False):
+        """
+        Algoritmo principal. Recebe um número na forma de
+        string e retorna sua escrita em extenso.
+
+        Entrada: Número na forma de string e uma flag que, se
+        tiver o valor 0 (zero), o extenso é retornado em uma
+        só linha. Um valor 1 (um) faz o extenso ser quebrado
+        em várias linhas.
+
+        Retorno: O número de entrada em extenso na forma de
+        string.
+        """
+        self.trioextenso = self.trioextenso_feminino if feminino else self.trioextenso_masculino
+        # Remove os zeros iniciais e faz padding
+        # para números com quantidade de algarismos
+        # não múltipla de 3
+        num = num.lstrip('0')
+        pad = 3 - len(num) % 3
+        if pad < 3:
+            num = '0'*pad + num
+
+        it = iter(num)
+        trioLista = [''.join([a, b, c]) for a, b, c in zip(it, it, it)]
+
+        if len(trioLista) > len(self.classextenso):
+            raise IndexError('Número muito grande')
+
+        contador = 0
+        saida = ''
+        extensofinal = ''
+
+        for trio in reversed(trioLista):
+            trioInt = int(trio)
+
+            if trioInt > 0:
+                saida = self.escrever_trio_extenso(trio)
+                if contador > 0:
+                    saida = saida + ' ' + self.classextenso[contador]
+                if contador > 1:
+                    if trioInt > 1:
+                        saida = saida + 'ões'
+                    else:
+                        saida = saida + 'ão'
+                if quebradelinhas == 0:
+                    if self.nao_e_ultimo_trio(len(trioLista), contador):
+                        if self.trio_a_esquerda_eq_zero(trioLista, contador):
+                            saida = ' e ' + saida
+                        elif trioInt >= 100:
+                            saida = ', ' + saida
+                        else:
+                            saida = ' e ' + saida
+                else:
+                    saida = saida + '\n'
+
+                extensofinal = saida + extensofinal
+            contador = contador + 1
+        return extensofinal.rstrip('\n')
+
+
+def get_extenso(num, feminino=False):
+    if not isinstance(num, str):
+        num = str(num)
+    n = NumeroExtenso()
+    return n.getExtenso(num, quebradelinhas=0, feminino=feminino)
+
+def convert_datetime(value: str | datetime) -> datetime:
+    if isinstance(value, str):
+        return parser.parse(value)
+    return value