texsmith 0.0.2.dev0__py3-none-any.whl

texsmith/adapters/latex/engines/latex/runner.py

@@ -0,0 +1,28 @@
+"""Runtime helpers for latexmk builds."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+from rich.console import Console
+
+from .log import LatexStreamResult, stream_latexmk_output
+
+
+def run_latex_engine(
+    argv: Sequence[str],
+    *,
+    workdir: Path,
+    env: Mapping[str, str],
+    console: Console,
+    verbosity: int = 0,
+) -> LatexStreamResult:
+    """Execute a latexmk command and stream structured output."""
+    return stream_latexmk_output(
+        argv,
+        cwd=str(workdir),
+        env=env,
+        console=console,
+        verbosity=verbosity,
+    )

texsmith/adapters/latex/engines/tectonic/__init__.py

@@ -0,0 +1,38 @@
+"""Runtime helpers for invoking the Tectonic engine."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+import subprocess
+
+from rich.console import Console
+
+from ..latex import LatexStreamResult
+
+
+def run_tectonic_engine(
+    argv: Sequence[str],
+    *,
+    workdir: Path,
+    env: Mapping[str, str],
+    console: Console,
+) -> LatexStreamResult:
+    """Execute a tectonic command, streaming plain output."""
+    with subprocess.Popen(
+        argv,
+        cwd=str(workdir),
+        env=dict(env),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        encoding="utf-8",
+        errors="replace",
+    ) as process:
+        assert process.stdout is not None
+        for line in process.stdout:
+            console.print(line.rstrip())
+        returncode = process.wait()
+
+    return LatexStreamResult(returncode=returncode, messages=[])

texsmith/adapters/latex/formatter.py

@@ -0,0 +1,297 @@
+"""Utilities for rendering LaTeX partials (snippets)."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from jinja2 import Environment, FileSystemLoader, Template
+from requests.utils import requote_uri as requote_url
+
+from .pygments import PygmentsLatexHighlighter
+from .utils import escape_latex_chars
+
+
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    from texsmith.core.context import DocumentState
+
+
+TEMPLATE_DIR = Path(__file__).resolve().parent / "partials"
+
+
+def optimize_list(numbers: Iterable[int]) -> list[str]:
+    """Merge consecutive integers into human-readable ranges."""
+    values = sorted(numbers)
+    if not values:
+        return []
+
+    optimized: list[str] = []
+    start = end = values[0]
+
+    for num in values[1:]:
+        if num == end + 1:
+            end = num
+        else:
+            optimized.append(f"{start}-{end}" if start != end else str(start))
+            start = end = num
+
+    optimized.append(f"{start}-{end}" if start != end else str(start))
+    return optimized
+
+
+class LaTeXFormatter:
+    """Render LaTeX templates using Jinja2 with custom delimiters."""
+
+    def __init__(self, template_dir: Path = TEMPLATE_DIR) -> None:
+        self.env = Environment(
+            block_start_string=r"\BLOCK{",
+            block_end_string=r"}",
+            variable_start_string=r"\VAR{",
+            variable_end_string=r"}",
+            comment_start_string=r"\COMMENT{",
+            comment_end_string=r"}",
+            loader=FileSystemLoader(template_dir),
+        )
+        self.legacy_latex_accents: bool = False
+        self.env.filters.setdefault("latex_escape", self._escape_latex)
+        self.env.filters.setdefault("escape_latex", self._escape_latex)
+
+        template_paths: list[Path] = []
+        for ext in (".tex", ".cls"):
+            template_paths.extend(template_dir.glob(f"**/*{ext}"))
+
+        self._template_names: dict[str, str] = {}
+        for path in template_paths:
+            relative = path.relative_to(template_dir)
+            key = self._normalise_key(relative.with_suffix("").as_posix())
+            self._template_names[key] = relative.as_posix()
+
+        self.templates: dict[str, Template] = {}
+        self.default_code_engine = "pygments"
+        self.default_code_style = "bw"
+        self._pygments: PygmentsLatexHighlighter | None = None
+
+    @staticmethod
+    def _normalise_key(name: str) -> str:
+        """Normalise template identifiers to align with loader expectations."""
+        return name.replace("/", "_")
+
+    @classmethod
+    def normalise_key(cls, name: str) -> str:
+        """Public wrapper for normalising template identifiers."""
+        return cls._normalise_key(name)
+
+    @property
+    def template_names(self) -> set[str]:
+        """Return the set of available template identifiers."""
+        return set(self._template_names)
+
+    def _get_template(self, key: str) -> Template:
+        """Return a cached template instance loading it on demand."""
+        normalised = self._normalise_key(key)
+        template = self.templates.get(normalised)
+        if template is not None:
+            return template
+
+        template_name = self._template_names.get(normalised)
+        if template_name is None:
+            raise KeyError(key)
+
+        template = self.env.get_template(template_name)
+        self.templates[normalised] = template
+        return template
+
+    def __getattr__(self, method: str) -> Callable[..., str]:
+        """Proxy calls to templates or custom handlers."""
+        mangled = f"handle_{method}"
+        try:
+            handler = object.__getattribute__(self, mangled)
+        except AttributeError:
+            handler = None
+        if handler is not None:
+            return handler  # type: ignore[return-value]
+
+        try:
+            template = self._get_template(method)
+        except KeyError:
+            raise AttributeError(f"Object has no template for '{method}'") from None
+
+        def render_template(*args: Any, **kwargs: Any) -> str:
+            """Render the template with optional positional shorthand."""
+            if len(args) > 1:
+                msg = f"Expected at most 1 argument, got {len(args)}, use keyword arguments instead"
+                raise ValueError(msg)
+            if args:
+                kwargs["text"] = args[0]
+            return template.render(**kwargs)
+
+        return render_template
+
+    def __getitem__(self, key: str) -> Callable[..., str]:
+        return self._get_template(key).render
+
+    def _escape_url(self, url: str) -> str:
+        """Escape a URL for safe use in LaTeX commands."""
+        return escape_latex_chars(requote_url(url), legacy_accents=self.legacy_latex_accents)
+
+    def handle_codeinlinett(self, text: str) -> str:
+        """Render plain inline code inside \\texttt."""
+        escaped = escape_latex_chars(text, legacy_accents=self.legacy_latex_accents)
+        escaped = escaped.replace("-", "-\\allowbreak{}")
+        return self._get_template("codeinlinett").render(text=escaped)
+
+    def handle_codeblock(
+        self,
+        code: str,
+        language: str = "text",
+        filename: str | None = None,
+        lineno: bool = False,
+        highlight: Iterable[int] | None = None,
+        baselinestretch: float | None = None,
+        engine: str | None = None,
+        state: DocumentState | None = None,
+        **_: Any,
+    ) -> str:
+        """Render code blocks with optional line numbers and highlights."""
+        highlight = list(highlight or [])
+        optimized_highlight = optimize_list(highlight)
+        normalized_engine = (engine or self.default_code_engine or "pygments").lower()
+        if normalized_engine not in {"minted", "listings", "verbatim", "pygments"}:
+            normalized_engine = "pygments"
+
+        if normalized_engine == "pygments":
+            style_name = str(self.default_code_style or "bw").strip() or "bw"
+            if self._pygments is None or self._pygments.style != style_name:
+                self._pygments = PygmentsLatexHighlighter(style=style_name)
+            latex_code, style_defs = self._pygments.render(
+                code,
+                language,
+                linenos=lineno,
+                highlight_lines=highlight,
+            )
+            if state is not None and style_defs:
+                state.pygments_styles.setdefault(self._pygments.style_key, style_defs)
+            return self._get_template("codeblock_pygments").render(
+                code=latex_code,
+                language=language,
+                linenos=lineno,
+                filename=filename,
+                baselinestretch=baselinestretch,
+                highlight=optimized_highlight,
+            )
+
+        if normalized_engine == "listings":
+            return self._get_template("codeblock_listings").render(
+                code=code,
+                language=language,
+                linenos=lineno,
+                filename=filename,
+                baselinestretch=baselinestretch,
+                highlight=optimized_highlight,
+            )
+
+        if normalized_engine == "verbatim":
+            return self._get_template("codeblock_verbatim").render(
+                code=code,
+                language=language,
+                linenos=lineno,
+                filename=filename,
+                baselinestretch=baselinestretch,
+                highlight=optimized_highlight,
+            )
+
+        return self._get_template("codeblock").render(
+            code=code,
+            language=language,
+            linenos=lineno,
+            filename=filename,
+            baselinestretch=baselinestretch,
+            highlight=optimized_highlight,
+        )
+
+    def url(self, text: str, url: str) -> str:
+        """Render a URL, escaping special LaTeX characters."""
+        safe_url = self._escape_url(url)
+        return self._get_template("url").render(text=text, url=safe_url)
+
+    def handle_href(self, text: str, url: str) -> str:
+        """Render \\href links with escaped URLs."""
+        return self._get_template("href").render(text=text, url=self._escape_url(url))
+
+    def handle_regex(self, text: str, url: str) -> str:
+        """Render regex helper links with escaped URLs."""
+        return self._get_template("regex").render(text=text, url=self._escape_url(url))
+
+    def handle_codeinline(
+        self,
+        *,
+        language: str = "text",
+        text: str,
+        engine: str | None = None,
+        state: DocumentState | None = None,
+        delimiter: str | None = None,
+    ) -> str:
+        """Render inline code with engine-specific highlighting."""
+        normalized_engine = (engine or self.default_code_engine or "pygments").lower()
+        if normalized_engine == "minted":
+            delimiter = delimiter or "|"
+            return self._get_template("codeinline").render(
+                language=language or "text",
+                text=text,
+                delimiter=delimiter,
+            )
+
+        if normalized_engine == "pygments":
+            style_name = str(self.default_code_style or "bw").strip() or "bw"
+            if self._pygments is None or self._pygments.style != style_name:
+                self._pygments = PygmentsLatexHighlighter(style=style_name)
+            latex_code, style_defs = self._pygments.render_inline(text, language)
+            if state is not None and style_defs:
+                state.pygments_styles.setdefault(self._pygments.style_key, style_defs)
+            return r"{\ttfamily " + latex_code + "}"
+
+        # listings/verbatim fallback to plain typewriter
+        return self.handle_codeinlinett(text)
+
+    def _escape_latex(self, value: str) -> str:
+        """Escape helper that honours the formatter legacy accent setting."""
+        return escape_latex_chars(value, legacy_accents=self.legacy_latex_accents)
+
+    def svg(self, svg: str | Path) -> str:
+        """Render an SVG image by converting it to PDF first."""
+        from ..transformers import svg2pdf
+
+        pdfpath = svg2pdf(svg, self.output_path)  # type: ignore[attr-defined]
+        return f"\\includegraphics[width=1em]{{{pdfpath}}}"
+
+    def get_cover(self, name: str, **kwargs: Any) -> str:
+        """Render a named cover template populated with book metadata."""
+        template = self._get_template(f"cover/{name}")
+        return template.render(
+            title=self.config.title,  # type: ignore[attr-defined]
+            author=self.config.author,  # type: ignore[attr-defined]
+            subtitle=self.config.subtitle,  # type: ignore[attr-defined]
+            email=self.config.email,  # type: ignore[attr-defined]
+            year=self.config.year,  # type: ignore[attr-defined]
+            **self.config.cover.model_dump(),  # type: ignore[attr-defined]
+            **kwargs,
+        )
+
+    def override_template(self, name: str, source: str | Path) -> None:
+        """Override a built-in template snippet using an external payload."""
+        if isinstance(source, Path):
+            template_source = source.read_text(encoding="utf-8")
+            template_name = source.as_posix()
+        else:
+            template_source = source
+            template_name = name
+
+        template = self.env.from_string(template_source)
+        template.name = template_name
+        normalised = self._normalise_key(name)
+        self.templates[normalised] = template
+        self._template_names[normalised] = template_name
+
+
+__all__ = ["LaTeXFormatter", "optimize_list"]

texsmith/adapters/latex/latexmk.py

@@ -0,0 +1,148 @@
+"""Helpers for configuring latexmk commands and RC files."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import shlex
+import shutil
+from typing import Any
+
+from texsmith.adapters.latex import pyxindy
+
+
+@dataclass(slots=True)
+class LatexmkEngine:
+    """Normalised latexmk engine invocation."""
+
+    command: list[str]
+    pdf_mode: int
+
+
+def _perl_escape(value: str) -> str:
+    return value.replace("\\", "\\\\").replace("'", "\\'")
+
+
+def _pdf_mode_from_command(command: str) -> int:
+    lowered = Path(command).name.lower()
+    if lowered.endswith("xelatex"):
+        return 5
+    if lowered.endswith("lualatex"):
+        return 4
+    return 1
+
+
+def normalise_engine_command(engine: str | None, *, shell_escape: bool) -> LatexmkEngine:
+    """Return latexmk engine tokens and pdf mode derived from the provided string."""
+    tokens = shlex.split(engine.strip()) if engine else []
+    if not tokens:
+        tokens = ["pdflatex"]
+
+    if shell_escape and not any(token in {"-shell-escape", "--shell-escape"} for token in tokens):
+        tokens.append("--shell-escape")
+
+    pdf_mode = _pdf_mode_from_command(tokens[0])
+    return LatexmkEngine(command=tokens, pdf_mode=pdf_mode)
+
+
+def latexmk_pdf_flag(pdf_mode: int) -> str:
+    """Return the latexmk flag required for the requested pdf mode."""
+    if pdf_mode == 4:
+        return "-pdflua"
+    if pdf_mode == 5:
+        return "-pdfxe"
+    return "-pdf"
+
+
+def build_engine_command(engine: LatexmkEngine) -> str:
+    """Construct the pdflatex command string used by latexmk."""
+    return shlex.join([*engine.command, "%O", "%S"])
+
+
+def normalise_index_engine(candidate: Any) -> str:
+    """Resolve the effective index engine from template context or availability."""
+    if isinstance(candidate, str):
+        stripped = candidate.strip().lower()
+        if stripped in {"pyxindy", "texindy", "makeindex"}:
+            if stripped == "pyxindy" and not pyxindy.is_available():
+                stripped = "texindy" if shutil.which("texindy") else "makeindex"
+            return stripped
+    if pyxindy.is_available():
+        return "pyxindy"
+    return "texindy" if shutil.which("texindy") else "makeindex"
+
+
+def _engine_variable(pdf_mode: int) -> str:
+    if pdf_mode == 5:
+        return "xelatex"
+    if pdf_mode == 4:
+        return "lualatex"
+    return "pdflatex"
+
+
+def build_latexmkrc_content(
+    *,
+    root_filename: str,
+    engine: str | None,
+    requires_shell_escape: bool,
+    bibliography: bool,
+    index_engine: str | None = None,
+    has_index: bool = False,
+    has_glossary: bool = False,
+) -> str:
+    """Produce a latexmkrc payload matching the selected template features."""
+    engine_config = normalise_engine_command(engine, shell_escape=requires_shell_escape)
+    command_string = build_engine_command(engine_config)
+    engine_var = _engine_variable(engine_config.pdf_mode)
+    safe_root = _perl_escape(root_filename or "texsmith-output")
+
+    lines = [
+        "# Auto-generated by texsmith\n",
+        f"$root_filename = '{safe_root}';\n",
+        f"$pdf_mode = {engine_config.pdf_mode};\n",
+        f"${engine_var} = '{_perl_escape(command_string)}';\n",
+    ]
+
+    if bibliography:
+        lines.extend(
+            [
+                "$bibtex_use = 2;\n",
+                "$biber = 'biber %O %B';\n",
+                "$clean_ext .= ' %R.run.xml %R.blg';\n",
+            ]
+        )
+
+    if has_index:
+        index_var = normalise_index_engine(index_engine)
+        if index_var == "pyxindy":
+            makeindex = pyxindy.latexmk_makeindex_command()
+        else:
+            makeindex = "texindy %O -o %D %S" if index_var == "texindy" else "makeindex %O -o %D %S"
+        lines.append(f"$makeindex = '{_perl_escape(makeindex)}';\n")
+
+    if has_glossary:
+        glossaries_cmd = pyxindy.latexmk_makeglossaries_command()
+        lines.extend(
+            [
+                "add_cus_dep('glo', 'gls', 0, 'run_makeglossaries');\n",
+                "add_cus_dep('acn', 'acr', 0, 'run_makeglossaries');\n",
+                "\n",
+                "sub run_makeglossaries {\n",
+                "  my ($base) = @_;\n",
+                f'  my $cmd = "{_perl_escape(glossaries_cmd)}";\n',
+                "  return system($cmd);\n",
+                "}\n",
+            ]
+        )
+
+    return "".join(lines)
+
+
+__all__ = [
+    "LatexmkEngine",
+    "build_engine_command",
+    "build_latexmkrc_content",
+    "latexmk_pdf_flag",
+    "normalise_engine_command",
+    "normalise_index_engine",
+]

texsmith/adapters/latex/partials/acronym.tex

@@ -0,0 +1 @@
+\gls{\VAR{text}}

texsmith/adapters/latex/partials/add.tex

@@ -0,0 +1 @@
+\begin{goodbox}\uline{\VAR{text}}\end{goodbox}

texsmith/adapters/latex/partials/addition.tex

@@ -0,0 +1 @@
+\begin{goodbox}\uline{\VAR{text}}\end{goodbox}

texsmith/adapters/latex/partials/blockquote.tex

@@ -0,0 +1,3 @@
+\begin{displayquote}
+\VAR{text|safe}
+\end{displayquote}

texsmith/adapters/latex/partials/callout.tex

@@ -0,0 +1,3 @@
+\begin{callout}[callout \VAR{type}]{\VAR{title}}
+\VAR{text}
+\end{callout}

texsmith/adapters/latex/partials/choices.tex

@@ -0,0 +1,5 @@
+\begin{todolist}
+\BLOCK{for checked, item in items -}
+    \item\BLOCK{if checked}[\done]\BLOCK{endif} \VAR{item}
+\BLOCK{endfor}
+\end{todolist}

texsmith/adapters/latex/partials/citation.tex

@@ -0,0 +1 @@
+\cite{\VAR{key}}

texsmith/adapters/latex/partials/codeblock.tex

@@ -0,0 +1,7 @@
+%\leavevmode % Required to avoid a bug in the tcolorbox package
+\begin{code}{\VAR{language|default('text')}}{\BLOCK{if filename}\VAR{filename}\BLOCK{endif}}{
+    \BLOCK{- if baselinestretch}baselinestretch=\VAR{baselinestretch}, \BLOCK{endif}
+    \BLOCK{- if linenos}linenos, \BLOCK{endif -}
+    \BLOCK{- if highlight }, highlightlines={\VAR{','.join(highlight)}}\BLOCK{endif -}
+}
+\VAR{code}\end{code}

texsmith/adapters/latex/partials/codeblock_listings.tex

@@ -0,0 +1,5 @@
+\begin{code}{\VAR{language|default('text')}}{\BLOCK{if filename}\VAR{filename}\BLOCK{endif}}{
+    \BLOCK{- if linenos},numbers=left, firstnumber=1, stepnumber=1\BLOCK{endif -}
+    \BLOCK{- if highlight }, highlightlines={\VAR{','.join(highlight)}}\BLOCK{endif -}
+}
+\VAR{code}\end{code}

texsmith/adapters/latex/partials/codeblock_pygments.tex

@@ -0,0 +1,5 @@
+\begin{code}{\VAR{language|default('text')}}{\BLOCK{if filename}\VAR{filename}\BLOCK{endif}}{
+    \BLOCK{- if baselinestretch}baselinestretch=\VAR{baselinestretch}, \BLOCK{endif}
+    \BLOCK{- if linenos}linenos, \BLOCK{endif -}
+}
+\VAR{code}\end{code}

texsmith/adapters/latex/partials/codeblock_verbatim.tex

@@ -0,0 +1,12 @@
+\begin{code}{\VAR{language|default('text')}}{\BLOCK{if filename}\VAR{filename}\BLOCK{endif}}{
+    \BLOCK{- if baselinestretch}baselinestretch=\VAR{baselinestretch}, \BLOCK{endif}
+}
+\begin{Verbatim}[
+    breaklines,
+    breakanywhere,
+    commandchars=\\\{\},
+    \BLOCK{- if linenos}numbers=left, firstnumber=1, stepnumber=1,\BLOCK{endif -}
+    \BLOCK{- if highlight }highlightlines={\VAR{','.join(highlight)}}\BLOCK{endif}
+]
+\VAR{code}\end{Verbatim}
+\end{code}

texsmith/adapters/latex/partials/codeinline.tex

@@ -0,0 +1 @@
+\mintinline[breaklines=true]{\BLOCK{if language}\VAR{language}\BLOCK{else}text\BLOCK{endif}}\VAR{delimiter}\VAR{text}\VAR{delimiter}

texsmith/adapters/latex/partials/codeinlinett.tex

@@ -0,0 +1 @@
+\texttt{\VAR{text}}

texsmith/adapters/latex/partials/comment.tex

@@ -0,0 +1 @@
+\begin{commentbox}/* \VAR{text} */\end{commentbox}

texsmith/adapters/latex/partials/del.tex

@@ -0,0 +1 @@
+\xout{\VAR{text}}

texsmith/adapters/latex/partials/deletion.tex

@@ -0,0 +1 @@
+\xout{\VAR{text}}

texsmith/adapters/latex/partials/description_list.tex

@@ -0,0 +1,5 @@
+\begin{description}
+\BLOCK{for title, item in items -}
+    \item[{ \VAR{title} }] \VAR{item}
+\BLOCK{endfor}
+\end{description}

texsmith/adapters/latex/partials/enquote.tex

@@ -0,0 +1 @@
+\enquote{\VAR{text}}

texsmith/adapters/latex/partials/epigraph.tex

@@ -0,0 +1 @@
+\epigraph{\itshape ``\VAR{text}''}{--- \textit{\VAR{source}}}

texsmith/adapters/latex/partials/exercises_solutions.tex

@@ -0,0 +1,7 @@
+\chapter{Solution des exercices}
+
+\BLOCK{for id, title, label, solution in text}
+\par
+\textbf{Exercice \VAR{id}. \hyperref[\VAR{label}]{\VAR{title}}}\par
+\VAR{solution}
+\BLOCK{endfor}

texsmith/adapters/latex/partials/figure.tex

@@ -0,0 +1,33 @@
+\begin{figure}[H]
+    \centering
+    \BLOCK{-if label}\label{\VAR{label}}\BLOCK{endif}
+    \BLOCK{if width}\BLOCK{set width_value = width.rstrip('%') if width.endswith('%') else width}\BLOCK{endif}
+    \BLOCK{if adjustbox}
+    \ifdefined\adjustbox
+        \BLOCK{if link}\href{\VAR{link}}{%
+        \adjustbox{max width=\textwidth}{%
+            \includegraphics[width=\BLOCK{if width}\BLOCK{if width.endswith('%')}\VAR{(width_value|float) / 100}\linewidth\BLOCK{else}\VAR{width}\BLOCK{endif}\BLOCK{else}\linewidth\BLOCK{endif}]{\VAR{path}}
+        }
+        }\BLOCK{else}
+        \adjustbox{max width=\textwidth}{%
+            \includegraphics[width=\BLOCK{if width}\BLOCK{if width.endswith('%')}\VAR{(width_value|float) / 100}\linewidth\BLOCK{else}\VAR{width}\BLOCK{endif}\BLOCK{else}\linewidth\BLOCK{endif}]{\VAR{path}}
+        }
+        \BLOCK{endif}
+    \else
+        \BLOCK{if link}\href{\VAR{link}}{%
+        \includegraphics[width=\BLOCK{if width}\BLOCK{if width.endswith('%')}\VAR{(width_value|float) / 100}\linewidth\BLOCK{else}\VAR{width}\BLOCK{endif}\BLOCK{else}\linewidth\BLOCK{endif}]{\VAR{path}}
+        }\BLOCK{else}
+        \includegraphics[width=\BLOCK{if width}\BLOCK{if width.endswith('%')}\VAR{(width_value|float) / 100}\linewidth\BLOCK{else}\VAR{width}\BLOCK{endif}\BLOCK{else}\linewidth\BLOCK{endif}]{\VAR{path}}
+        \BLOCK{endif}
+    \fi
+    \BLOCK{else}
+    \BLOCK{if link}\href{\VAR{link}}{%
+    \includegraphics[width=\BLOCK{if width}\BLOCK{if width.endswith('%')}\VAR{(width_value|float) / 100}\linewidth\BLOCK{else}\VAR{width}\BLOCK{endif}\BLOCK{else}\linewidth\BLOCK{endif}]{\VAR{path}}
+    }\BLOCK{else}
+    \includegraphics[width=\BLOCK{if width}\BLOCK{if width.endswith('%')}\VAR{(width_value|float) / 100}\linewidth\BLOCK{else}\VAR{width}\BLOCK{endif}\BLOCK{else}\linewidth\BLOCK{endif}]{\VAR{path}}
+    \BLOCK{endif}
+    \BLOCK{endif}
+    \BLOCK{-if caption}
+    \caption\BLOCK{if shortcaption}[\VAR{shortcaption}]\BLOCK{endif}{\VAR{caption}}
+    \BLOCK{-endif}
+\end{figure}

texsmith/adapters/latex/partials/figure_tcolorbox.tex

@@ -0,0 +1,15 @@
+\begin{center}
+\BLOCK{-if label}\label{\VAR{label}}
+\BLOCK{endif-}
+\BLOCK{if width}\BLOCK{set width_value = width.rstrip('%') if width.endswith('%') else width}\BLOCK{endif}
+\BLOCK{-if caption}\captionsetup{type=figure}\BLOCK{endif}
+\BLOCK{if link}\href{\VAR{link}}{%
+\includegraphics[width=\BLOCK{if width}\BLOCK{if width.endswith('%')}\VAR{(width_value|float) / 100}\linewidth\BLOCK{else}\VAR{width}\BLOCK{endif}\BLOCK{else}\linewidth\BLOCK{endif}]{\VAR{path}}
+}
+\BLOCK{else}
+\includegraphics[width=\BLOCK{if width}\BLOCK{if width.endswith('%')}\VAR{(width_value|float) / 100}\linewidth\BLOCK{else}\VAR{width}\BLOCK{endif}\BLOCK{else}\linewidth\BLOCK{endif}]{\VAR{path}}
+\BLOCK{endif}
+\BLOCK{-if caption}
+\captionof{figure}\BLOCK{if shortcaption}[\VAR{shortcaption}]\BLOCK{endif}{\VAR{caption}}
+\BLOCK{-endif}
+\end{center}

texsmith/adapters/latex/partials/footnote.tex

@@ -0,0 +1,3 @@
+\footnote\BLOCK{if id}[\VAR{id}]\BLOCK{endif}{\BLOCK{if "\n" in text}%
+\VAR{text}
+\BLOCK{else}\VAR{text}\BLOCK{endif}}%