simple-resume 0.1.9__py3-none-any.whl

simple_resume/core/effects.py

@@ -0,0 +1,154 @@
+"""Effect types for the functional core.
+
+Effects represent side effects (I/O operations) that should be
+executed by the shell layer. Core functions return effects instead
+of performing I/O directly, enabling pure testing.
+
+This implements the "Effect System" pattern where:
+- Core functions are pure and return descriptions of side effects (Effects)
+- Shell layer executes these effects, performing actual I/O
+
+All effects are immutable (frozen dataclasses) and hashable.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class Effect(ABC):
+    """Base class for all side effects.
+
+    Effects describe I/O operations without performing them.
+    They are created by core logic and executed by the shell layer.
+    """
+
+    @abstractmethod
+    def describe(self) -> str:
+        """Return human-readable description of this effect."""
+        pass
+
+
+@dataclass(frozen=True)
+class WriteFile(Effect):
+    """Effect: Write content to a file.
+
+    Attributes:
+        path: Target file path
+        content: Content to write (string or bytes)
+        encoding: Text encoding (used only for string content)
+
+    """
+
+    path: Path
+    content: str | bytes
+    encoding: str = "utf-8"
+
+    def describe(self) -> str:
+        """Return human-readable description."""
+        return f"Write file: {self.path}"
+
+
+@dataclass(frozen=True)
+class MakeDirectory(Effect):
+    """Effect: Create a directory.
+
+    Attributes:
+        path: Directory path to create
+        parents: If True, create parent directories as needed
+
+    """
+
+    path: Path
+    parents: bool = True
+
+    def describe(self) -> str:
+        """Return human-readable description."""
+        return f"Create directory: {self.path}"
+
+
+@dataclass(frozen=True)
+class DeleteFile(Effect):
+    """Effect: Delete a file.
+
+    Attributes:
+        path: File path to delete
+
+    """
+
+    path: Path
+
+    def describe(self) -> str:
+        """Return human-readable description."""
+        return f"Delete file: {self.path}"
+
+
+@dataclass(frozen=True)
+class OpenBrowser(Effect):
+    """Effect: Open a URL in the default web browser.
+
+    Attributes:
+        url: URL to open (can be http://, https://, or file://)
+
+    """
+
+    url: str
+
+    def describe(self) -> str:
+        """Return human-readable description."""
+        return f"Open browser: {self.url}"
+
+
+@dataclass(frozen=True)
+class RunCommand(Effect):
+    """Effect: Execute a shell command.
+
+    Attributes:
+        command: Command to run as a list of arguments
+        cwd: Working directory for command execution (None for current dir)
+
+    """
+
+    command: list[str]
+    cwd: Path | None = None
+
+    def describe(self) -> str:
+        """Return human-readable description."""
+        command_str = " ".join(self.command)
+        return f"Run command: {command_str}"
+
+
+@dataclass(frozen=True)
+class CopyFile(Effect):
+    """Effect: Copy a file from source to destination.
+
+    Attributes:
+        source: Source file path
+        destination: Destination file path
+
+    """
+
+    source: Path
+    destination: Path
+
+    def describe(self) -> str:
+        """Return human-readable description."""
+        return f"Copy file: {self.source} -> {self.destination}"
+
+
+@dataclass(frozen=True)
+class RenderPdf(Effect):
+    """Effect: Render HTML+CSS to PDF at the target path.
+
+    The shell layer is responsible for providing the rendering engine
+    (e.g., WeasyPrint).
+    """
+
+    html: str
+    css: str
+    output_path: Path
+    base_url: str | None = None
+
+    def describe(self) -> str:
+        """Return human-readable description."""
+        return f"Render PDF to: {self.output_path}"

simple_resume/core/exceptions.py

@@ -0,0 +1,261 @@
+"""Core exception types for simple-resume."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class SimpleResumeError(Exception):
+    """Raise for any simple-resume specific error."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        context: dict[str, Any] | None = None,
+        filename: str | None = None,
+    ) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            context: Optional context for the error.
+            filename: The name of the file being processed.
+
+        """
+        super().__init__(message)
+        self.message = message
+        self.context = context or {}
+        self.filename = filename
+
+    def __str__(self) -> str:
+        """Return a formatted error message."""
+        base_msg = self.message
+        if self.filename:
+            base_msg = f"{self.filename}: {base_msg}"
+        if self.context:
+            context_str = ", ".join(f"{k}={v}" for k, v in self.context.items())
+            base_msg = f"{base_msg} (context: {context_str})"
+        return base_msg
+
+
+class ValidationError(SimpleResumeError, ValueError):
+    """Raise when resume data validation fails."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        errors: list[str] | None = None,
+        warnings: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+        filename: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            errors: A list of validation errors.
+            warnings: A list of validation warnings.
+            context: Optional context for the error.
+            filename: The name of the file being processed.
+            **kwargs: Additional context (will be filtered).
+
+        """
+        # Filter out parameters that should be passed to parent
+        filtered_kwargs = {
+            k: v for k, v in kwargs.items() if k not in ["context", "filename"]
+        }
+
+        super().__init__(message, context=context, filename=filename, **filtered_kwargs)
+        self.errors = errors or []
+        self.warnings = warnings or []
+
+
+class ConfigurationError(SimpleResumeError):
+    """Raise when configuration is invalid."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        config_key: str | None = None,
+        config_value: Any | None = None,
+        context: dict[str, Any] | None = None,
+        filename: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            config_key: The configuration key that caused the error.
+            config_value: The value of the configuration key.
+            context: Optional context for the error.
+            filename: The name of the file being processed.
+            **kwargs: Additional context (will be filtered).
+
+        """
+        # Filter out parameters that should be passed to parent
+        filtered_kwargs = {
+            k: v for k, v in kwargs.items() if k not in ["context", "filename"]
+        }
+
+        super().__init__(message, context=context, filename=filename, **filtered_kwargs)
+        self.config_key = config_key
+        self.config_value = config_value
+
+    def __str__(self) -> str:
+        """Return a formatted error message."""
+        base_msg = super().__str__()
+        if self.config_key:
+            base_msg = f"{base_msg} (config_key={self.config_key})"
+        return base_msg
+
+
+class PaletteError(SimpleResumeError):
+    """Raise when color palette operations fail."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        palette_name: str | None = None,
+        color_values: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+        filename: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            palette_name: The name of the palette.
+            color_values: The color values that caused the error.
+            context: Optional context for the error.
+            filename: The name of the file being processed.
+            **kwargs: Additional context (will be filtered).
+
+        """
+        # Filter out parameters that should be passed to parent
+        filtered_kwargs = {
+            k: v for k, v in kwargs.items() if k not in ["context", "filename"]
+        }
+
+        super().__init__(message, context=context, filename=filename, **filtered_kwargs)
+        self.palette_name = palette_name
+        self.color_values = color_values
+
+
+class FileSystemError(SimpleResumeError):
+    """Raise when file system operations fail."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        path: str | None = None,
+        operation: str | None = None,
+        **kwargs: Any,
+    ):
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            path: The file path.
+            operation: The file system operation that failed.
+            **kwargs: Additional context.
+
+        """
+        super().__init__(message, **kwargs)
+        self.path = path
+        self.operation = operation
+
+
+class SessionError(SimpleResumeError):
+    """Raise when session operations fail."""
+
+    def __init__(
+        self, message: str, *, session_id: str | None = None, **kwargs: Any
+    ) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            session_id: The ID of the session.
+            **kwargs: Additional context.
+
+        """
+        super().__init__(message, **kwargs)
+        self.session_id = session_id
+
+
+class GenerationError(SimpleResumeError):
+    """Raise when PDF/HTML generation fails."""
+
+    def __init__(self, message: str, **metadata: Any) -> None:
+        """Initialize the exception with optional metadata.
+
+        Args:
+            message: The error message.
+            **metadata: Optional metadata such as ``output_path``, ``format_type``,
+                ``resume_name``, ``context`` and ``filename``.
+
+        """
+        output_path = metadata.pop("output_path", None)
+        format_type = metadata.pop("format_type", None)
+        resume_name = metadata.pop("resume_name", None)
+        context = metadata.pop("context", None)
+        filename = metadata.pop("filename", None)
+
+        if filename is None and resume_name is not None:
+            filename = resume_name
+
+        super().__init__(message, context=context, filename=filename, **metadata)
+        self.output_path = str(output_path) if output_path is not None else None
+        self.format_type = format_type
+        self.resume_name = resume_name
+
+    def __str__(self) -> str:
+        """Return a formatted error message."""
+        base_msg = super().__str__()
+        if self.format_type:
+            base_msg = f"{base_msg} (format={self.format_type})"
+        return base_msg
+
+
+class TemplateError(SimpleResumeError):
+    """Raise when template processing fails."""
+
+    def __init__(self, message: str, **metadata: Any) -> None:
+        """Initialize the exception with optional metadata.
+
+        Args:
+            message: The error message.
+            **metadata: Optional metadata such as ``template_name``,
+                ``template_path``, ``context`` and ``filename``.
+
+        """
+        template_name = metadata.pop("template_name", None)
+        template_path = metadata.pop("template_path", None)
+        context = metadata.pop("context", None)
+        filename = metadata.pop("filename", None)
+
+        super().__init__(message, context=context, filename=filename, **metadata)
+        self.template_name = template_name
+        self.template_path = template_path
+
+
+__all__ = [
+    # Base exception
+    "SimpleResumeError",
+    # Specific exception types
+    "ConfigurationError",
+    "FileSystemError",
+    "GenerationError",
+    "PaletteError",
+    "SessionError",
+    "TemplateError",
+    "ValidationError",
+]

simple_resume/core/file_operations.py

@@ -0,0 +1,68 @@
+"""Core file operations for resume management.
+
+Pure functions for file discovery and path operations without external dependencies.
+"""
+
+from collections.abc import Generator
+from pathlib import Path
+
+
+def find_yaml_files(input_dir: Path, pattern: str = "*") -> list[Path]:
+    """Find resume input files matching the given pattern.
+
+    Args:
+        input_dir: Directory to search for YAML files.
+        pattern: Glob pattern for matching files.
+
+    Returns:
+        List of matching YAML file paths.
+
+    """
+    if not input_dir.exists():
+        return []
+
+    yaml_files = []
+
+    # Find files matching pattern with .yaml/.yml/.json extension
+    for ext in ("yaml", "yml", "json"):
+        for file_path in input_dir.glob(f"{pattern}.{ext}"):
+            if file_path.is_file():
+                yaml_files.append(file_path)
+
+    return sorted(yaml_files)
+
+
+def iterate_yaml_files(
+    input_dir: Path, pattern: str = "*"
+) -> Generator[Path, None, None]:
+    """Iterate over YAML files matching the given pattern.
+
+    Args:
+        input_dir: Directory to search for YAML files.
+        pattern: Glob pattern for matching files.
+
+    Yields:
+        YAML file paths.
+
+    """
+    yield from find_yaml_files(input_dir, pattern)
+
+
+def get_resume_name_from_path(file_path: Path) -> str:
+    """Extract resume name from file path.
+
+    Args:
+        file_path: Path to YAML file.
+
+    Returns:
+        Resume name (filename without extension).
+
+    """
+    return file_path.stem
+
+
+__all__ = [
+    "find_yaml_files",
+    "iterate_yaml_files",
+    "get_resume_name_from_path",
+]

simple_resume/core/generate/__init__.py

@@ -0,0 +1,21 @@
+"""Core generation functionality for resumes.
+
+This module provides pure functions for generating different output formats
+from resume data without any I/O side effects.
+"""
+
+from __future__ import annotations
+
+from simple_resume.core.generate.html import create_html_generator_factory
+from simple_resume.core.generate.pdf import (
+    prepare_pdf_with_latex,
+    prepare_pdf_with_weasyprint,
+)
+from simple_resume.core.generate.plan import build_generation_plan
+
+__all__ = [
+    "build_generation_plan",
+    "create_html_generator_factory",
+    "prepare_pdf_with_latex",
+    "prepare_pdf_with_weasyprint",
+]

simple_resume/core/generate/exceptions.py

@@ -0,0 +1,69 @@
+"""Exception types used by the generation subsystem."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from simple_resume.core.exceptions import SimpleResumeError
+
+
+class GenerationError(SimpleResumeError):
+    """Raise when PDF/HTML generation fails."""
+
+    def __init__(self, message: str, **metadata: Any) -> None:
+        """Initialize the exception with optional metadata.
+
+        Args:
+            message: The error message.
+            **metadata: Optional metadata such as ``output_path``, ``format_type``,
+                ``resume_name``, ``context`` and ``filename``.
+
+        """
+        output_path = metadata.pop("output_path", None)
+        format_type = metadata.pop("format_type", None)
+        resume_name = metadata.pop("resume_name", None)
+        context = metadata.pop("context", None)
+        filename = metadata.pop("filename", None)
+
+        if filename is None and resume_name is not None:
+            filename = resume_name
+
+        super().__init__(message, context=context, filename=filename, **metadata)
+        self.output_path = str(output_path) if output_path is not None else None
+        self.format_type = format_type
+        self.resume_name = resume_name
+
+    def __str__(self) -> str:
+        """Return a formatted error message."""
+        base_msg = super().__str__()
+        if self.format_type:
+            base_msg = f"{base_msg} (format={self.format_type})"
+        return base_msg
+
+
+class TemplateError(SimpleResumeError):
+    """Raise when template processing fails."""
+
+    def __init__(self, message: str, **metadata: Any) -> None:
+        """Initialize the exception with optional metadata.
+
+        Args:
+            message: The error message.
+            **metadata: Optional metadata such as ``template_name``,
+                ``template_path``, ``context`` and ``filename``.
+
+        """
+        template_name = metadata.pop("template_name", None)
+        template_path = metadata.pop("template_path", None)
+        context = metadata.pop("context", None)
+        filename = metadata.pop("filename", None)
+
+        super().__init__(message, context=context, filename=filename, **metadata)
+        self.template_name = template_name
+        self.template_path = template_path
+
+
+__all__ = [
+    "GenerationError",
+    "TemplateError",
+]