simple-resume 0.1.9__py3-none-any.whl

simple_resume/shell/effect_executor.py

@@ -0,0 +1,211 @@
+"""Effect executor for the shell layer.
+
+The EffectExecutor performs actual I/O operations
+described by Effect objects.
+This is the "imperative shell" that executes
+side effects created by the "functional core".
+
+Usage:
+    executor = EffectExecutor()
+    effects = [
+        MakeDirectory(path=Path("/tmp/output")),
+        WriteFile(path=Path("/tmp/output/file.txt"), content="data"),
+    ]
+    executor.execute_many(effects)
+"""
+
+import shutil
+import subprocess  # nosec B404
+import webbrowser
+from pathlib import Path
+from typing import Any, Callable
+
+import weasyprint
+
+from simple_resume.core.effects import (
+    CopyFile,
+    DeleteFile,
+    Effect,
+    MakeDirectory,
+    OpenBrowser,
+    RenderPdf,
+    RunCommand,
+    WriteFile,
+)
+
+
+class EffectExecutor:
+    """Executes effects in the shell layer.
+
+    This class performs actual I/O operations based on Effect descriptions.
+    It implements the "imperative shell" pattern, isolating all side effects
+    from the functional core.
+    """
+
+    def execute(self, effect: Effect) -> Any:
+        """Execute a single effect.
+
+        Args:
+            effect: The effect to execute
+
+        Returns:
+            Result of the operation (type depends on effect)
+
+        Raises:
+            ValueError: If effect type is unknown
+            Various I/O exceptions: Depending on the operation
+
+        """
+        # Dispatch table for effect types
+        handlers: dict[type[Effect], Callable[[Any], Any]] = {
+            WriteFile: lambda e: self._write_file(e.path, e.content, e.encoding),
+            MakeDirectory: lambda e: self._make_directory(e.path, e.parents),
+            DeleteFile: lambda e: self._delete_file(e.path),
+            CopyFile: lambda e: self._copy_file(e.source, e.destination),
+            OpenBrowser: lambda e: self._open_browser(e.url),
+            RunCommand: lambda e: self._run_command(e.command, e.cwd),
+            RenderPdf: lambda e: self._render_pdf(
+                e.html, e.css, e.output_path, e.base_url
+            ),
+        }
+
+        handler = handlers.get(type(effect))
+        if handler is None:
+            raise ValueError(f"Unknown effect type: {type(effect)}")
+        return handler(effect)
+
+    def execute_many(self, effects: list[Effect]) -> None:
+        """Execute multiple effects in sequence.
+
+        Effects are executed in order. If any effect fails, execution stops
+        and the exception is propagated.
+
+        Args:
+            effects: List of effects to execute
+
+        """
+        for effect in effects:
+            self.execute(effect)
+
+    def _write_file(self, path: Path, content: str | bytes, encoding: str) -> None:
+        """Write content to a file.
+
+        Creates parent directories if they don't exist.
+        Overwrites existing file content.
+
+        Args:
+            path: Target file path
+            content: Content to write (string or bytes)
+            encoding: Text encoding (used only for string content)
+
+        """
+        # Ensure parent directories exist
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write content based on type
+        if isinstance(content, bytes):
+            path.write_bytes(content)
+        else:
+            path.write_text(content, encoding=encoding)
+
+    def _make_directory(self, path: Path, parents: bool) -> None:
+        """Create a directory.
+
+        Args:
+            path: Directory path to create
+            parents: If True, create parent directories as needed
+
+        Raises:
+            FileNotFoundError: If parents=False and parent directory doesn't exist
+
+        """
+        path.mkdir(parents=parents, exist_ok=True)
+
+    def _delete_file(self, path: Path) -> None:
+        """Delete a file.
+
+        Does not raise an error if the file doesn't exist.
+
+        Args:
+            path: File path to delete
+
+        """
+        path.unlink(missing_ok=True)
+
+    def _copy_file(self, source: Path, destination: Path) -> None:
+        """Copy a file from source to destination.
+
+        Creates parent directories if they don't exist.
+
+        Args:
+            source: Source file path
+            destination: Destination file path
+
+        """
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, destination)
+
+    def _open_browser(self, url: str) -> None:
+        """Open a URL in the default web browser.
+
+        Args:
+            url: URL to open (http://, https://, or file://)
+
+        """
+        webbrowser.open(url)
+
+    def _run_command(
+        self, command: list[str], cwd: Path | None
+    ) -> subprocess.CompletedProcess[bytes]:
+        """Execute a shell command.
+
+        Args:
+            command: Command to run as a list of arguments
+            cwd: Working directory for command execution
+
+        Returns:
+            CompletedProcess object with execution results
+
+        Raises:
+            CalledProcessError: If command exits with non-zero status
+
+        """
+        # Validate command for security
+        if isinstance(command, (list, tuple)):
+            unsafe_chars = [";", "|", "&"]
+            if any(any(char in str(arg) for char in unsafe_chars) for arg in command):
+                raise ValueError("Unsafe command detected")
+        elif isinstance(command, str):
+            if ";" in command or "|" in command or "&" in command:
+                raise ValueError("Unsafe command detected")
+
+        return subprocess.run(command, cwd=cwd, check=True)  # noqa: S603  # nosec B603
+
+    def _render_pdf(
+        self, html: str, css: str, output_path: Path, base_url: str | None
+    ) -> int | None:
+        """Render HTML+CSS to PDF using WeasyPrint."""
+        html_doc = weasyprint.HTML(string=html, base_url=base_url)
+        css_obj = weasyprint.CSS(string=css)
+        document = html_doc.render(stylesheets=[css_obj])
+        pdf_bytes = document.write_pdf()
+        if not isinstance(pdf_bytes, (bytes, bytearray)):
+            # Guard against test doubles returning non-bytes payloads.
+            try:
+                pdf_bytes = bytes(pdf_bytes)
+            except Exception as exc:
+                raise RuntimeError(
+                    "WeasyPrint returned invalid output (not bytes)"
+                ) from exc
+
+        if not pdf_bytes:
+            raise RuntimeError("WeasyPrint returned empty PDF output")
+
+        # Ensure parent directories and write file
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_bytes(pdf_bytes)
+
+        try:
+            return len(document.pages)
+        except Exception:  # pragma: no cover - defensive
+            return None

simple_resume/shell/file_opener.py

@@ -0,0 +1,308 @@
+"""File opener for the shell layer.
+
+This module handles platform-specific file opening operations.
+All I/O operations for opening files in external applications
+are consolidated here, following the functional core / imperative shell pattern.
+
+The core layer should never import this module directly.
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+import subprocess  # nosec B404
+import sys
+import webbrowser
+from pathlib import Path
+
+from simple_resume.core.exceptions import FileSystemError
+
+
+class FileOpener:
+    """Platform-aware file opener for generated artifacts.
+
+    This class consolidates all file-opening logic in one place,
+    handling PDF, HTML, and generic file types across platforms.
+    """
+
+    @staticmethod
+    def open_file(path: Path, format_type: str | None = None) -> bool:
+        """Open a file using the appropriate system application.
+
+        Args:
+            path: Path to the file to open
+            format_type: Optional format hint ('pdf', 'html', or None for generic)
+
+        Returns:
+            True if file was opened successfully
+
+        Raises:
+            FileSystemError: If file doesn't exist or cannot be opened
+
+        """
+        if not path.exists():
+            raise FileSystemError(
+                f"File doesn't exist: {path}",
+                path=str(path),
+                operation="open",
+            )
+
+        if not path.is_file():
+            raise FileSystemError(
+                f"Path is not a file: {path}",
+                path=str(path),
+                operation="open",
+            )
+
+        # Determine format from extension if not provided
+        if format_type is None:
+            suffix = path.suffix.lower()
+            if suffix == ".pdf":
+                format_type = "pdf"
+            elif suffix in (".html", ".htm"):
+                format_type = "html"
+
+        try:
+            if format_type == "pdf":
+                return FileOpener._open_pdf(path)
+            elif format_type == "html":
+                return FileOpener._open_html(path)
+            else:
+                return FileOpener._open_generic(path)
+        except Exception as exc:
+            raise FileSystemError(
+                f"Failed to open file: {exc}",
+                path=str(path),
+                operation="open",
+            ) from exc
+
+    @staticmethod
+    def _validate_path(path: Path) -> str:
+        """Validate path for security and return string representation.
+
+        Args:
+            path: Path to validate
+
+        Returns:
+            String representation of the path
+
+        Raises:
+            ValueError: If path contains unsafe characters
+
+        """
+        path_str = str(path.resolve() if not path.is_absolute() else path)
+
+        # Check for command injection characters
+        unsafe_patterns = ["..", ";", "|", "&", "`", "$", "(", ")"]
+        if any(pattern in path_str for pattern in unsafe_patterns):
+            raise ValueError(f"Unsafe path detected: {path_str}")
+
+        return path_str
+
+    # PDF opening methods
+
+    @staticmethod
+    def _open_pdf(path: Path) -> bool:
+        """Open PDF file using system's PDF viewer."""
+        if sys.platform == "darwin":
+            return FileOpener._open_pdf_macos(path)
+        elif sys.platform.startswith("linux"):
+            return FileOpener._open_pdf_linux(path)
+        else:
+            return FileOpener._open_pdf_windows(path)
+
+    @staticmethod
+    def _open_pdf_macos(path: Path) -> bool:
+        """Open PDF file on macOS."""
+        path_str = FileOpener._validate_path(path)
+        subprocess.run(  # noqa: S603  # nosec B603
+            ["/usr/bin/open", path_str],
+            check=True,
+            capture_output=True,
+        )
+        return True
+
+    @staticmethod
+    def _open_pdf_linux(path: Path) -> bool:
+        """Open PDF file on Linux."""
+        path_str = FileOpener._validate_path(path)
+
+        # Try xdg-open first
+        xdg_open = shutil.which("xdg-open")
+        if xdg_open:
+            result = subprocess.run(  # noqa: S603  # nosec B603
+                [xdg_open, path_str],
+                check=False,
+                capture_output=True,
+            )
+            if result.returncode == 0:
+                return True
+
+        # Fallback to common PDF viewers
+        for viewer in ["evince", "okular", "acroread"]:
+            viewer_path = shutil.which(viewer)
+            if viewer_path:
+                try:
+                    subprocess.run(  # noqa: S603  # nosec B603
+                        [viewer_path, path_str],
+                        check=True,
+                        capture_output=True,
+                    )
+                    return True
+                except (subprocess.CalledProcessError, FileNotFoundError):
+                    continue
+
+        return False
+
+    @staticmethod
+    def _open_pdf_windows(path: Path) -> bool:
+        """Open PDF file on Windows."""
+        path_str = FileOpener._validate_path(path)
+        cmd_path = shutil.which("cmd") or "cmd"
+
+        subprocess.run(  # noqa: S603  # nosec B603
+            [cmd_path, "/c", "start", "", path_str],
+            check=True,
+            shell=False,
+            capture_output=True,
+        )
+        return True
+
+    # HTML opening methods
+
+    @staticmethod
+    def _open_html(path: Path) -> bool:
+        """Open HTML file using system's web browser."""
+        path_str = FileOpener._validate_path(path)
+
+        # Try webbrowser module first (cross-platform)
+        try:
+            if webbrowser.open(f"file://{path_str}"):
+                return True
+        except Exception:  # noqa: BLE001
+            logging.debug("Failed to open browser with webbrowser module")
+            pass
+
+        # Platform-specific fallbacks
+        if sys.platform == "darwin":
+            return FileOpener._open_html_macos(path)
+        elif sys.platform.startswith("linux"):
+            return FileOpener._open_html_linux(path)
+        else:
+            return FileOpener._open_html_windows(path)
+
+    @staticmethod
+    def _open_html_macos(path: Path) -> bool:
+        """Open HTML file on macOS."""
+        path_str = FileOpener._validate_path(path)
+        result = subprocess.run(  # noqa: S603  # nosec B603
+            ["/usr/bin/open", path_str],
+            check=False,
+            capture_output=True,
+        )
+        return result.returncode == 0
+
+    @staticmethod
+    def _open_html_linux(path: Path) -> bool:
+        """Open HTML file on Linux."""
+        path_str = FileOpener._validate_path(path)
+
+        xdg_open = shutil.which("xdg-open")
+        if xdg_open:
+            result = subprocess.run(  # noqa: S603  # nosec B603
+                [xdg_open, path_str],
+                check=False,
+                capture_output=True,
+            )
+            return result.returncode == 0
+
+        return False
+
+    @staticmethod
+    def _open_html_windows(path: Path) -> bool:
+        """Open HTML file on Windows."""
+        path_str = FileOpener._validate_path(path)
+        cmd_path = shutil.which("cmd") or "cmd"
+
+        result = subprocess.run(  # noqa: S603  # nosec B603
+            [cmd_path, "/c", "start", "", path_str],
+            check=False,
+            shell=False,
+            capture_output=True,
+        )
+        return result.returncode == 0
+
+    # Generic file opening
+
+    @staticmethod
+    def _open_generic(path: Path) -> bool:
+        """Open file using system's default application."""
+        if sys.platform == "darwin":
+            return FileOpener._open_generic_macos(path)
+        elif sys.platform.startswith("linux"):
+            return FileOpener._open_generic_linux(path)
+        else:
+            return FileOpener._open_generic_windows(path)
+
+    @staticmethod
+    def _open_generic_macos(path: Path) -> bool:
+        """Open file on macOS."""
+        path_str = FileOpener._validate_path(path)
+        result = subprocess.run(  # noqa: S603  # nosec B603
+            ["/usr/bin/open", path_str],
+            check=False,
+            capture_output=True,
+        )
+        return result.returncode == 0
+
+    @staticmethod
+    def _open_generic_linux(path: Path) -> bool:
+        """Open file on Linux."""
+        path_str = FileOpener._validate_path(path)
+
+        xdg_open = shutil.which("xdg-open")
+        if xdg_open is None:
+            return False
+
+        try:
+            result = subprocess.run(  # noqa: S603  # nosec B603
+                [xdg_open, path_str],
+                check=False,
+                capture_output=True,
+                timeout=10,
+            )
+            return result.returncode == 0
+        except subprocess.TimeoutExpired:
+            return False
+
+    @staticmethod
+    def _open_generic_windows(path: Path) -> bool:
+        """Open file on Windows."""
+        path_str = FileOpener._validate_path(path)
+        cmd_path = shutil.which("cmd") or "cmd"
+
+        result = subprocess.run(  # noqa: S603  # nosec B603
+            [cmd_path, "/c", "start", "", path_str],
+            check=False,
+            shell=False,
+            capture_output=True,
+        )
+        return result.returncode == 0
+
+
+def open_file(path: Path, format_type: str | None = None) -> bool:
+    """Open a file using the system default application.
+
+    Args:
+        path: Path to the file to open
+        format_type: Optional format hint ('pdf', 'html', or None for generic)
+
+    Returns:
+        True if file was opened successfully
+
+    """
+    return FileOpener.open_file(path, format_type)
+
+
+__all__ = ["FileOpener", "open_file"]

simple_resume/shell/generate/__init__.py

@@ -0,0 +1,37 @@
+"""High-level resume generation module in shell layer.
+
+This module provides a clean, organized interface for generating resumes
+in various formats. It offers both standard (eager) and lazy-loading
+implementations to optimize for different use cases.
+
+.. versionadded:: 0.1.0
+
+"""
+
+# Direct imports from core generation modules
+from simple_resume.core.generate.html import (
+    HtmlGeneratorFactory,
+    create_html_generator_factory,
+)
+from simple_resume.core.generate.pdf import (
+    PdfGeneratorFactory,
+)
+
+# Re-export lazy loading versions for backward compatibility
+from simple_resume.shell.generate.lazy import (
+    generate,
+    generate_all,
+    generate_html,
+    generate_pdf,
+    generate_resume,
+    preview,
+)
+
+__all__ = [
+    "generate",
+    "generate_all",
+    "generate_html",
+    "generate_pdf",
+    "generate_resume",
+    "preview",
+]