simple-resume 0.1.9__py3-none-any.whl

simple_resume/shell/render/latex.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""Render resumes as LaTeX documents (shell layer with I/O operations)."""
+
+from __future__ import annotations
+
+import shutil
+
+# Bandit: subprocess usage is confined to vetted TeX commands.
+import subprocess  # nosec B404
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from simple_resume.core.latex import (
+    LatexRenderResult,
+    build_latex_context_pure,
+    fontawesome_support_block,
+)
+from simple_resume.core.paths import Paths
+from simple_resume.shell import config
+from simple_resume.shell.runtime.content import get_content
+
+
+class LatexCompilationError(RuntimeError):
+    """Raise when LaTeX compilation fails."""
+
+    def __init__(self, message: str, *, log: str | None = None) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            log: The compilation log.
+
+        """
+        super().__init__(message)
+        self.log = log
+
+
+def _jinja_environment(template_root: Path) -> Environment:
+    """Return a Jinja2 environment for LaTeX templates.
+
+    This is an I/O operation that loads templates from the file system.
+
+    Args:
+        template_root: Path to template directory.
+
+    Returns:
+        Configured Jinja2 environment.
+
+    """
+    loader = FileSystemLoader(str(template_root))
+    env = Environment(loader=loader, autoescape=select_autoescape(("html", "xml")))
+    return env
+
+
+def build_latex_context(
+    data: dict[str, Any],
+    *,
+    static_dir: Path | None = None,
+) -> dict[str, Any]:
+    """Prepare the LaTeX template context from raw resume data (with I/O).
+
+    This shell function wraps the pure core function and adds file system
+    operations for FontAwesome font detection.
+
+    Args:
+        data: Raw resume data dictionary.
+        static_dir: Path to static assets directory for font detection.
+
+    Returns:
+        Dictionary of context variables for LaTeX template rendering.
+
+    """
+    # Get pure context from core
+    context = build_latex_context_pure(data)
+
+    # Add fontawesome_block with file system check (I/O operation)
+    fontawesome_dir: str | None = None
+    if static_dir is not None:
+        candidate = Path(static_dir) / "fonts" / "fontawesome"
+        if candidate.is_dir():  # I/O: file system check
+            fontawesome_dir = f"{candidate.resolve().as_posix()}/"
+
+    context["fontawesome_block"] = fontawesome_support_block(fontawesome_dir)
+
+    return context
+
+
+def render_resume_latex_from_data(
+    data: dict[str, Any],
+    *,
+    paths: Paths | None = None,
+    template_name: str = "latex/basic.tex",
+) -> LatexRenderResult:
+    """Render a LaTeX template with the prepared context.
+
+    This function performs I/O operations: template loading and rendering.
+
+    Args:
+        data: Resume data dictionary.
+        paths: Path configuration (resolved if not provided).
+        template_name: Template file name to render.
+
+    Returns:
+        LatexRenderResult with rendered tex and context.
+
+    """
+    resolved_paths = paths or config.resolve_paths()
+    context = build_latex_context(data, static_dir=resolved_paths.static)
+
+    # I/O operations: load and render template
+    env = _jinja_environment(resolved_paths.templates)
+    template = env.get_template(template_name)
+    tex = template.render(**context)
+
+    return LatexRenderResult(tex=tex, context=context)
+
+
+def render_resume_latex(
+    name: str,
+    *,
+    paths: Paths | None = None,
+    template_name: str = "latex/basic.tex",
+) -> LatexRenderResult:
+    """Read resume data and render it to a LaTeX string.
+
+    This function performs I/O operations: reading resume data from file system.
+
+    Args:
+        name: Resume name to load.
+        paths: Path configuration (resolved if not provided).
+        template_name: Template file name to render.
+
+    Returns:
+        LatexRenderResult with rendered tex and context.
+
+    """
+    resolved_paths = paths or config.resolve_paths()
+
+    # I/O operation: read resume data
+    data = get_content(name, paths=resolved_paths, transform_markdown=False)
+
+    return render_resume_latex_from_data(
+        data, paths=resolved_paths, template_name=template_name
+    )
+
+
+def compile_tex_to_pdf(
+    tex_path: Path,
+    *,
+    engines: Iterable[str] = ("xelatex", "pdflatex"),
+) -> Path:
+    """Compile a `.tex` file to PDF using an available LaTeX engine.
+
+    This function performs I/O operations: subprocess execution and file system access.
+
+    Args:
+        tex_path: Path to .tex file to compile.
+        engines: LaTeX engines to try (in order).
+
+    Returns:
+        Path to generated PDF file.
+
+    Raises:
+        LatexCompilationError: If compilation fails.
+
+    """
+    # I/O: Check which LaTeX engine is available
+    available_engine = None
+    for engine in engines:
+        if shutil.which(engine):
+            available_engine = engine
+            break
+
+    if available_engine is None:
+        raise LatexCompilationError(
+            "No LaTeX engine found. Install xelatex or pdflatex to render PDFs."
+        )
+
+    tex_argument = str(tex_path) if tex_path.is_absolute() else tex_path.name
+
+    command = [
+        available_engine,
+        "-interaction=nonstopmode",
+        "-halt-on-error",
+        "-output-directory",
+        str(tex_path.parent.resolve()),
+        tex_argument,
+    ]
+
+    # I/O: Execute subprocess
+    # Bandit: command arguments are constructed from vetted engine names and paths.
+    result = subprocess.run(  # noqa: S603  # nosec B603
+        command,
+        cwd=str(tex_path.parent),
+        capture_output=True,
+        check=False,
+    )
+
+    if result.returncode != 0:
+        log = (result.stdout or b"") + b"\n" + (result.stderr or b"")
+        message = f"LaTeX compilation failed with exit code {result.returncode}"
+        raise LatexCompilationError(
+            message,
+            log=log.decode("utf-8", errors="ignore"),
+        )
+
+    pdf_path = tex_path.with_suffix(".pdf")
+    return pdf_path
+
+
+def compile_tex_to_html(
+    tex_path: Path,
+    *,
+    tools: Iterable[str] = ("pandoc", "htlatex"),
+) -> Path:
+    """Compile a `.tex` file to HTML using an available tool.
+
+    This function performs I/O operations: subprocess execution and file system access.
+
+    Args:
+        tex_path: Path to .tex file to compile.
+        tools: Conversion tools to try (in order).
+
+    Returns:
+        Path to generated HTML file.
+
+    Raises:
+        LatexCompilationError: If compilation fails.
+
+    """
+    html_path = tex_path.with_suffix(".html")
+    tex_argument = str(tex_path) if tex_path.is_absolute() else tex_path.name
+
+    last_error: LatexCompilationError | None = None
+
+    # I/O: Try each tool
+    for tool in tools:
+        if shutil.which(tool) is None:
+            continue
+
+        if tool == "pandoc":
+            command = [
+                tool,
+                tex_argument,
+                "-f",
+                "latex",
+                "-t",
+                "html5",
+                "-s",
+                "-o",
+                str(html_path),
+            ]
+        elif tool == "htlatex":
+            command = [
+                tool,
+                tex_argument,
+                "html",
+            ]
+        else:
+            continue
+
+        # I/O: Execute subprocess
+        # Bandit: conversion command uses whitelisted tool names and the
+        # rendered tex path.
+        result = subprocess.run(  # noqa: S603  # nosec B603
+            command,
+            cwd=str(tex_path.parent),
+            capture_output=True,
+            check=False,
+        )
+
+        if result.returncode == 0:
+            # I/O: Check/rename generated file
+            if tool == "htlatex":
+                generated = tex_path.with_suffix(".html")
+                if generated.exists():
+                    generated.rename(html_path)
+            if not html_path.exists():
+                html_path.write_text("", encoding="utf-8")
+            return html_path
+
+        log = (result.stdout or b"") + b"\n" + (result.stderr or b"")
+        last_error = LatexCompilationError(
+            f"LaTeX to HTML conversion via {tool} "
+            f"failed with exit code {result.returncode}",
+            log=log.decode("utf-8", errors="ignore"),
+        )
+        continue
+
+    if last_error is not None:
+        raise last_error
+    raise LatexCompilationError(
+        "No LaTeX-to-HTML tool found. Install pandoc or htlatex to render HTML output."
+    )
+
+
+__all__ = [
+    "LatexCompilationError",
+    "LatexRenderResult",
+    "build_latex_context",
+    "compile_tex_to_html",
+    "compile_tex_to_pdf",
+    "render_resume_latex",
+    "render_resume_latex_from_data",
+]

simple_resume/shell/render/operations.py

@@ -0,0 +1,240 @@
+"""Shell layer for rendering operations with external dependencies.
+
+This module contains all the external dependencies and rendering logic
+that should be isolated from the pure core functionality.
+"""
+
+from __future__ import annotations
+
+import subprocess  # nosec B404
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+# Import internal modules that will receive injected dependencies
+from simple_resume.core.effects import CopyFile, MakeDirectory
+from simple_resume.core.generate import html as _html_generation
+from simple_resume.core.generate import pdf as _pdf_generation
+from simple_resume.core.generate.html import create_html_generator_factory
+from simple_resume.core.generate.pdf import PdfGenerationConfig
+from simple_resume.core.models import RenderPlan
+from simple_resume.core.protocols import EffectExecutor as EffectExecutorProtocol
+from simple_resume.core.protocols import TemplateLocator
+from simple_resume.core.render import get_template_environment
+from simple_resume.core.result import GenerationMetadata, GenerationResult
+from simple_resume.shell.config import ASSETS_ROOT, TEMPLATE_LOC
+from simple_resume.shell.effect_executor import EffectExecutor
+
+
+def create_backend_injector(module: ModuleType, **overrides: Any) -> Any:
+    """Create a context manager for temporarily overriding module attributes.
+
+    This is a factory function that returns a context manager, keeping the
+    core module pure while allowing dependency injection in the shell layer.
+    """
+
+    class _BackendInjector:
+        def __init__(self, module: ModuleType, **overrides: Any) -> None:
+            self.module = module
+            self.overrides = overrides
+            self.originals: dict[str, Any] = {}
+
+        def __enter__(self) -> None:
+            for name, value in self.overrides.items():
+                self.originals[name] = getattr(self.module, name, None)
+                setattr(self.module, name, value)
+
+        def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: object,
+        ) -> None:
+            for name, original in self.originals.items():
+                setattr(self.module, name, original)
+
+    return _BackendInjector(module, **overrides)
+
+
+def generate_pdf_with_weasyprint(
+    render_plan: RenderPlan,
+    output_path: Path,
+    resume_name: str,
+    filename: str | None = None,
+    effect_executor: EffectExecutorProtocol | None = None,
+) -> tuple[GenerationResult, int | None]:
+    """Delegate to the HTML-to-PDF backend with patchable dependencies."""
+
+    class _TemplateLocator(TemplateLocator):
+        def get_template_location(self) -> Path:
+            return TEMPLATE_LOC
+
+    locator = _TemplateLocator()
+    executor = effect_executor or EffectExecutor()
+
+    backend_injector = create_backend_injector(
+        _pdf_generation,
+        get_template_environment=get_template_environment,
+    )
+
+    with backend_injector:
+        config = PdfGenerationConfig(
+            resume_name=resume_name,
+            filename=filename,
+            template_locator=locator,
+            effect_executor=executor,
+        )
+        return _pdf_generation.generate_pdf_with_weasyprint(
+            render_plan,
+            output_path,
+            config,
+        )
+
+
+def _get_asset_copy_effects(output_dir: Path) -> list[CopyFile | MakeDirectory]:
+    """Generate effects to copy CSS and font files to output directory.
+
+    This ensures HTML files work standalone without needing a base tag
+    or server. Assets are copied to output_dir/static/css/ and output_dir/static/fonts/.
+
+    Args:
+        output_dir: The directory where HTML output is being written
+
+    Returns:
+        List of effects to create directories and copy files
+
+    """
+    effects: list[CopyFile | MakeDirectory] = []
+    static_src = ASSETS_ROOT / "static"
+
+    # CSS files
+    css_src = static_src / "css"
+    css_dest = output_dir / "static" / "css"
+    effects.append(MakeDirectory(path=css_dest, parents=True))
+
+    for css_file in css_src.glob("*.css"):
+        effects.append(CopyFile(source=css_file, destination=css_dest / css_file.name))
+
+    # Font files
+    fonts_src = static_src / "fonts"
+    fonts_dest = output_dir / "static" / "fonts"
+    if fonts_src.exists():
+        effects.append(MakeDirectory(path=fonts_dest, parents=True))
+        for font_file in fonts_src.glob("*"):
+            if font_file.is_file():
+                effects.append(
+                    CopyFile(source=font_file, destination=fonts_dest / font_file.name)
+                )
+
+    return effects
+
+
+def generate_html_with_jinja(
+    render_plan: RenderPlan,
+    output_path: Path,
+    filename: str | None = None,
+    effect_executor: EffectExecutorProtocol | None = None,
+) -> GenerationResult:
+    """Render HTML via Jinja with injectable template environment."""
+
+    class _TemplateLocator(TemplateLocator):
+        def get_template_location(self) -> Path:
+            return TEMPLATE_LOC
+
+    locator = _TemplateLocator()
+
+    # Create HTML generator factory with explicit locator
+    html_factory = create_html_generator_factory(default_template_locator=locator)
+    prepare_html_func = html_factory.create_prepare_html_function()
+
+    backend_injector = create_backend_injector(
+        _html_generation,
+        get_template_environment=get_template_environment,
+    )
+
+    with backend_injector:
+        html_content, effects, metadata = prepare_html_func(
+            render_plan=render_plan,
+            output_path=output_path,
+            resume_name=filename or "resume",
+            filename=filename,
+            template_locator=locator,
+        )
+
+        # Add effects to copy static assets (CSS, fonts) to output directory
+        output_dir = output_path.parent
+        asset_effects = _get_asset_copy_effects(output_dir)
+        all_effects = list(effects) + asset_effects
+
+        # Execute the effects to actually create the files
+        executor = effect_executor or EffectExecutor()
+        executor.execute_many(all_effects)
+
+        # Create and return GenerationResult
+        return GenerationResult(
+            output_path=output_path,
+            format_type="html",
+            metadata=metadata,
+        )
+
+
+def open_file_in_browser(
+    file_path: Path,
+    browser: str | None = None,
+) -> None:
+    """Open a file in the default or specified browser.
+
+    Args:
+        file_path: Path to the file to open.
+        browser: Optional browser command.
+
+    Returns:
+        None
+
+    """
+    if browser:
+        # Use specified browser command for opening the file
+        subprocess.Popen(  # noqa: S603  # nosec B603
+            [browser, str(file_path)],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    else:
+        # Use default system opener
+        subprocess.run(  # noqa: S603  # nosec B603
+            ["xdg-open", str(file_path)]
+            if Path("/usr/bin/xdg-open").exists()
+            else ["open", str(file_path)]
+            if Path("/usr/bin/open").exists()
+            else ["start", str(file_path)],
+            check=False,
+        )
+
+
+def create_generation_result(
+    output_path: Path,
+    format_type: str,
+    generation_time: float,
+    **metadata_kwargs: Any,
+) -> GenerationResult:
+    """Create a GenerationResult with metadata."""
+    # Explicitly construct metadata with proper types to satisfy type checkers
+    metadata = GenerationMetadata(
+        format_type=format_type,
+        template_name=str(metadata_kwargs.get("template_name", "unknown")),
+        generation_time=generation_time,
+        file_size=int(metadata_kwargs.get("file_size", 0)),
+        resume_name=str(metadata_kwargs.get("resume_name", "resume")),
+        palette_info=metadata_kwargs.get("palette_info"),
+        page_count=metadata_kwargs.get("page_count"),
+    )
+    return GenerationResult(output_path, format_type, metadata)
+
+
+__all__ = [
+    "create_backend_injector",
+    "generate_pdf_with_weasyprint",
+    "generate_html_with_jinja",
+    "open_file_in_browser",
+    "create_generation_result",
+]