simple-resume 0.1.9__py3-none-any.whl

simple_resume/core/constants/__init__.py

@@ -0,0 +1,207 @@
+"""Centralized constants for simple-resume.
+
+This package contains core constants and enums for resume generation.
+Domain-specific constants are organized in separate submodules.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Final
+
+# =============================================================================
+# CLI Exit Codes
+# =============================================================================
+
+EXIT_SUCCESS: Final[int] = 0
+EXIT_SIGINT: Final[int] = 130  # Ctrl+C cancellation
+EXIT_FILE_SYSTEM_ERROR: Final[int] = 2
+EXIT_INTERNAL_ERROR: Final[int] = 3
+EXIT_RESOURCE_ERROR: Final[int] = 4
+EXIT_INPUT_ERROR: Final[int] = 5
+EXIT_GENERIC_ERROR: Final[int] = 1
+
+# =============================================================================
+# Error Messages
+# =============================================================================
+
+ERROR_UNKNOWN_COMMAND: Final[str] = "Unknown command"
+ERROR_FILE_NOT_FOUND: Final[str] = "Resume file not found"
+ERROR_INVALID_FORMAT: Final[str] = "Invalid format"
+ERROR_PERMISSION_DENIED: Final[str] = "Permission denied"
+
+# =============================================================================
+# Process and Resource Limits
+# =============================================================================
+
+DEFAULT_PROCESS_TIMEOUT_SECONDS: Final[int] = 30
+MAX_RESUME_SIZE_MB: Final[int] = 10
+MAX_PALETTE_SIZE_MB: Final[int] = 1
+
+# =============================================================================
+# File Extensions
+# =============================================================================
+
+PDF_EXTENSION: Final[str] = ".pdf"
+HTML_EXTENSION: Final[str] = ".html"
+TEX_EXTENSION: Final[str] = ".tex"
+MARKDOWN_EXTENSION: Final[str] = ".md"
+
+# =============================================================================
+# Default Values
+# =============================================================================
+
+# Default values will be set after enum definitions
+DEFAULT_FORMAT: str
+DEFAULT_TEMPLATE: str
+
+# =============================================================================
+# Configuration
+# =============================================================================
+
+MIN_FILENAME_PARTS: Final[int] = 2
+ALLOWED_PATH_OVERRIDES: Final[set[str]] = {"content_dir", "templates_dir", "static_dir"}
+
+# =============================================================================
+# Validation
+# =============================================================================
+
+MAX_FILE_SIZE_MB: Final[int] = 50
+
+
+class OutputFormat(str, Enum):
+    """Define supported output formats for resume generation.
+
+    Final formats (require rendering):
+        PDF: Portable Document Format
+        HTML: HyperText Markup Language
+
+    Intermediate formats (editable before final render):
+        MARKDOWN: Markdown intermediate (for HTML path)
+        TEX: LaTeX intermediate (for PDF path)
+        LATEX: Alias for TEX (deprecated, use TEX)
+    """
+
+    PDF = "pdf"
+    HTML = "html"
+    MARKDOWN = "markdown"
+    TEX = "tex"
+    LATEX = "latex"  # Alias for TEX, kept for backwards compatibility
+
+    @classmethod
+    def values(cls) -> set[str]:
+        """Return a set of all format values including aliases."""
+        return {
+            cls.PDF.value,
+            cls.HTML.value,
+            cls.MARKDOWN.value,
+            cls.TEX.value,
+            cls.LATEX.value,
+        }
+
+    @classmethod
+    def intermediate_formats(cls) -> set[OutputFormat]:
+        """Return the set of intermediate (non-final) output formats."""
+        return {cls.MARKDOWN, cls.TEX}
+
+    @classmethod
+    def is_intermediate(cls, fmt: OutputFormat) -> bool:
+        """Check if a format is an intermediate format."""
+        return fmt in cls.intermediate_formats()
+
+    @classmethod
+    def is_valid(cls, format_str: str) -> bool:
+        """Check if a format string is valid."""
+        return format_str.lower() in cls.values()
+
+    @classmethod
+    def normalize(
+        cls, value: str | OutputFormat, *, param_name: str | None = None
+    ) -> OutputFormat:
+        """Convert arbitrary input into an `OutputFormat` enum member."""
+        if isinstance(value, cls):
+            return value
+        if not isinstance(value, str):
+            raise TypeError(
+                "Output format must be provided as string or OutputFormat, "
+                f"got {type(value)}"
+            )
+
+        normalized = value.strip().lower()
+        try:
+            return cls(normalized)
+        except ValueError as exc:  # pragma: no cover - defensive path
+            label = f"{param_name} " if param_name else ""
+            raise ValueError(
+                f"Unsupported {label}format: {value}. "
+                f"Supported formats: {', '.join(sorted(cls.values()))}"
+            ) from exc
+
+
+class TemplateType(str, Enum):
+    """Define available resume templates."""
+
+    NO_BARS = "resume_no_bars"
+    WITH_BARS = "resume_with_bars"
+
+    @classmethod
+    def values(cls) -> set[str]:
+        """Return a set of all template values."""
+        return {cls.NO_BARS.value, cls.WITH_BARS.value}
+
+    @classmethod
+    def is_valid(cls, template_str: str) -> bool:
+        """Check if a template string is valid."""
+        return template_str in cls.values()
+
+
+class RenderMode(str, Enum):
+    """Define rendering modes for resume generation."""
+
+    HTML = "html"
+    LATEX = "latex"
+
+
+# Set defaults using enum values
+DEFAULT_FORMAT = OutputFormat.PDF.value
+DEFAULT_TEMPLATE = TemplateType.NO_BARS.value
+SUPPORTED_FORMATS: Final[set[str]] = OutputFormat.values()
+SUPPORTED_TEMPLATES: Final[set[str]] = TemplateType.values()
+
+
+__all__ = [
+    # Exit codes
+    "EXIT_SUCCESS",
+    "EXIT_SIGINT",
+    "EXIT_FILE_SYSTEM_ERROR",
+    "EXIT_INTERNAL_ERROR",
+    "EXIT_RESOURCE_ERROR",
+    "EXIT_INPUT_ERROR",
+    "EXIT_GENERIC_ERROR",
+    # Error messages
+    "ERROR_UNKNOWN_COMMAND",
+    "ERROR_FILE_NOT_FOUND",
+    "ERROR_INVALID_FORMAT",
+    "ERROR_PERMISSION_DENIED",
+    # Process and resource limits
+    "DEFAULT_PROCESS_TIMEOUT_SECONDS",
+    "MAX_RESUME_SIZE_MB",
+    "MAX_PALETTE_SIZE_MB",
+    "MAX_FILE_SIZE_MB",
+    # File extensions
+    "PDF_EXTENSION",
+    "HTML_EXTENSION",
+    "TEX_EXTENSION",
+    "MARKDOWN_EXTENSION",
+    # Defaults and configuration
+    "DEFAULT_FORMAT",
+    "DEFAULT_TEMPLATE",
+    "MIN_FILENAME_PARTS",
+    "ALLOWED_PATH_OVERRIDES",
+    "SUPPORTED_FORMATS",
+    "SUPPORTED_TEMPLATES",
+    # Enums
+    "OutputFormat",
+    "TemplateType",
+    "RenderMode",
+]

simple_resume/core/constants/colors.py

@@ -0,0 +1,98 @@
+"""Color-related constants for simple-resume."""
+
+from __future__ import annotations
+
+from typing import Final
+
+DEFAULT_COLOR_SCHEME: Final[dict[str, str]] = {
+    "theme_color": "#0395DE",
+    "sidebar_color": "#F6F6F6",
+    "sidebar_text_color": "#000000",
+    "bar_background_color": "#DFDFDF",
+    "date2_color": "#616161",
+    "frame_color": "#757575",
+    "heading_icon_color": "#0395DE",
+    "bold_color": "#585858",
+}
+
+# WCAG 2.1 relative luminance formula constants
+# Reference: https://www.w3.org/TR/WCAG21/#dfn-relative-luminance
+# These constants implement the standard relative luminance calculation
+# for determining color contrast and accessibility compliance.
+WCAG_LINEARIZATION_THRESHOLD: Final[float] = 0.03928
+WCAG_LINEARIZATION_DIVISOR: Final[float] = 12.92
+WCAG_LINEARIZATION_EXPONENT: Final[float] = 2.4
+WCAG_LINEARIZATION_OFFSET: Final[float] = 0.055
+
+# Color manipulation constants
+BOLD_DARKEN_FACTOR: Final[float] = 0.75
+SIDEBAR_BOLD_DARKEN_FACTOR: Final[float] = 0.8
+
+# Luminance thresholds for color contrast calculations
+LUMINANCE_VERY_DARK: Final[float] = 0.15
+LUMINANCE_DARK: Final[float] = 0.5
+LUMINANCE_VERY_LIGHT: Final[float] = 0.8
+ICON_CONTRAST_THRESHOLD: Final[float] = 3.0
+
+# Color Format Constants
+HEX_COLOR_SHORT_LENGTH: Final[int] = 3
+HEX_COLOR_FULL_LENGTH: Final[int] = 6
+
+# UI Element Constants
+DEFAULT_BOLD_COLOR: Final[str] = "#585858"
+
+# Define color field ordering for palette application
+COLOR_FIELD_ORDER: Final[tuple[str, ...]] = (
+    "accent_color",
+    "sidebar_color",
+    "text_color",
+    "emphasis_color",
+    "link_color",
+)
+
+# Direct color keys that can be specified in configuration
+DIRECT_COLOR_KEYS: Final[set[str]] = {
+    "accent_color",
+    "sidebar_color",
+    "text_color",
+    "emphasis_color",
+    "link_color",
+    "sidebar_text_color",
+}
+
+# Resume configuration color ordering (used by palette normalization)
+CONFIG_COLOR_FIELDS: Final[tuple[str, ...]] = (
+    "theme_color",
+    "sidebar_color",
+    "sidebar_text_color",
+    "bar_background_color",
+    "date2_color",
+    "frame_color",
+    "heading_icon_color",
+)
+
+CONFIG_DIRECT_COLOR_KEYS: Final[tuple[str, ...]] = CONFIG_COLOR_FIELDS + (
+    "bold_color",
+    "sidebar_bold_color",
+)
+
+__all__ = [
+    "DEFAULT_COLOR_SCHEME",
+    "WCAG_LINEARIZATION_THRESHOLD",
+    "WCAG_LINEARIZATION_DIVISOR",
+    "WCAG_LINEARIZATION_EXPONENT",
+    "WCAG_LINEARIZATION_OFFSET",
+    "BOLD_DARKEN_FACTOR",
+    "SIDEBAR_BOLD_DARKEN_FACTOR",
+    "LUMINANCE_VERY_DARK",
+    "LUMINANCE_DARK",
+    "LUMINANCE_VERY_LIGHT",
+    "ICON_CONTRAST_THRESHOLD",
+    "HEX_COLOR_SHORT_LENGTH",
+    "HEX_COLOR_FULL_LENGTH",
+    "DEFAULT_BOLD_COLOR",
+    "COLOR_FIELD_ORDER",
+    "DIRECT_COLOR_KEYS",
+    "CONFIG_COLOR_FIELDS",
+    "CONFIG_DIRECT_COLOR_KEYS",
+]

simple_resume/core/constants/files.py

@@ -0,0 +1,28 @@
+"""Filesystem and file-format constants for simple-resume."""
+
+from __future__ import annotations
+
+from typing import Final
+
+# Supported file extensions
+SUPPORTED_YAML_EXTENSIONS: Final[set[str]] = {".yaml", ".yml"}
+SUPPORTED_YAML_EXTENSIONS_STR: Final[str] = "yaml"  # For CLI usage
+
+# Default template paths
+DEFAULT_LATEX_TEMPLATE: Final[str] = "latex/basic.tex"
+
+# Font scaling constants
+FONTAWESOME_DEFAULT_SCALE: Final[float] = 0.72
+
+# Byte conversion constants
+BYTES_PER_KB: Final[int] = 1024
+BYTES_PER_MB: Final[int] = 1024 * 1024
+
+__all__ = [
+    "SUPPORTED_YAML_EXTENSIONS",
+    "SUPPORTED_YAML_EXTENSIONS_STR",
+    "DEFAULT_LATEX_TEMPLATE",
+    "FONTAWESOME_DEFAULT_SCALE",
+    "BYTES_PER_KB",
+    "BYTES_PER_MB",
+]

simple_resume/core/constants/layout.py

@@ -0,0 +1,58 @@
+"""Layout and measurement constants for simple-resume."""
+
+from __future__ import annotations
+
+from typing import Final
+
+# Default page dimensions in millimeters (A4 paper: 210x297mm)
+DEFAULT_PAGE_WIDTH_MM: Final[int] = 210
+DEFAULT_PAGE_HEIGHT_MM: Final[int] = 297
+
+# Default sidebar width in millimeters (A4 standard layout)
+DEFAULT_SIDEBAR_WIDTH_MM: Final[int] = 65
+
+# Default padding values in points/millimeters
+DEFAULT_PADDING: Final[int] = 12
+DEFAULT_SIDEBAR_PADDING_ADJUSTMENT: Final[int] = -2
+DEFAULT_SIDEBAR_PADDING: Final[int] = 12
+
+# Frame padding values
+DEFAULT_FRAME_PADDING: Final[int] = 10
+
+# Cover letter specific padding
+DEFAULT_COVER_PADDING_TOP: Final[int] = 10
+DEFAULT_COVER_PADDING_BOTTOM: Final[int] = 20
+DEFAULT_COVER_PADDING_HORIZONTAL: Final[int] = 25
+
+# Validation constraints
+MIN_PAGE_WIDTH_MM: Final[int] = 100
+MAX_PAGE_WIDTH_MM: Final[int] = 300
+MIN_PAGE_HEIGHT_MM: Final[int] = 150
+MAX_PAGE_HEIGHT_MM: Final[int] = 400
+
+MIN_SIDEBAR_WIDTH_MM: Final[int] = 30
+MAX_SIDEBAR_WIDTH_MM: Final[int] = 100
+
+MIN_PADDING: Final[int] = 0
+MAX_PADDING: Final[int] = 50
+
+__all__ = [
+    "DEFAULT_PAGE_WIDTH_MM",
+    "DEFAULT_PAGE_HEIGHT_MM",
+    "DEFAULT_SIDEBAR_WIDTH_MM",
+    "DEFAULT_PADDING",
+    "DEFAULT_SIDEBAR_PADDING_ADJUSTMENT",
+    "DEFAULT_SIDEBAR_PADDING",
+    "DEFAULT_FRAME_PADDING",
+    "DEFAULT_COVER_PADDING_TOP",
+    "DEFAULT_COVER_PADDING_BOTTOM",
+    "DEFAULT_COVER_PADDING_HORIZONTAL",
+    "MIN_PAGE_WIDTH_MM",
+    "MAX_PAGE_WIDTH_MM",
+    "MIN_PAGE_HEIGHT_MM",
+    "MAX_PAGE_HEIGHT_MM",
+    "MIN_SIDEBAR_WIDTH_MM",
+    "MAX_SIDEBAR_WIDTH_MM",
+    "MIN_PADDING",
+    "MAX_PADDING",
+]

simple_resume/core/dependencies.py

@@ -0,0 +1,258 @@
+"""Dependency injection container and interfaces for improved testability.
+
+This module introduces dependency injection patterns to reduce coupling between
+Session and Resume classes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+from simple_resume.core.paths import Paths
+from simple_resume.core.resume import Resume
+
+
+class SessionConfigProtocol(Protocol):
+    """Minimal session config contract needed by the core."""
+
+    default_template: str | None
+    default_palette: str | None
+    preview_mode: bool
+
+
+class NullSessionConfig:
+    """Fallback config used when no SessionConfig is supplied."""
+
+    default_template: str | None = None
+    default_palette: str | None = None
+    preview_mode: bool = False
+
+
+class ResumeLoader(Protocol):
+    """Protocol for loading resume instances."""
+
+    def load_resume(
+        self,
+        name: str,
+        *,
+        paths: Paths | None = None,
+        transform_markdown: bool = True,
+    ) -> Resume:
+        """Load a resume by name with given configuration."""
+        ...
+
+
+class ResumeCache(Protocol):
+    """Protocol for caching resume instances."""
+
+    def get_resume(self, key: str) -> Resume | None:
+        """Get a resume from cache."""
+        ...
+
+    def put_resume(self, key: str, resume: Resume) -> None:
+        """Put a resume into cache."""
+        ...
+
+    def invalidate_resume(self, key: str | None = None) -> None:
+        """Invalidate cached resume(s)."""
+        ...
+
+    def clear_cache(self) -> None:
+        """Clear all cached resumes."""
+        ...
+
+    def get_cache_keys(self) -> list[str]:
+        """Get list of cached resume keys."""
+        ...
+
+    def get_cache_size(self) -> int:
+        """Get number of cached resumes."""
+        ...
+
+    def get_memory_usage(self) -> int:
+        """Get estimated memory usage of cached resumes in bytes."""
+        ...
+
+
+class ResumeConfigurator(Protocol):
+    """Protocol for configuring resume instances."""
+
+    def configure_resume(self, resume: Resume, config: SessionConfigProtocol) -> Resume:
+        """Apply session configuration to a resume."""
+        ...
+
+
+class DefaultResumeLoader:
+    """Default implementation of ResumeLoader using Resume.read_yaml."""
+
+    def load_resume(
+        self,
+        name: str,
+        *,
+        paths: Paths | None = None,
+        transform_markdown: bool = True,
+    ) -> Resume:
+        """Load resume using Resume.read_yaml method."""
+        return Resume.read_yaml(
+            name=name,
+            paths=paths,
+            transform_markdown=transform_markdown,
+        )
+
+
+class MemoryResumeCache:
+    """In-memory implementation of ResumeCache."""
+
+    def __init__(self) -> None:
+        """Initialize an empty in-memory cache."""
+        self._cache: dict[str, Resume] = {}
+
+    def get_resume(self, key: str) -> Resume | None:
+        """Get a resume from cache."""
+        return self._cache.get(key)
+
+    def put_resume(self, key: str, resume: Resume) -> None:
+        """Put a resume into cache."""
+        self._cache[key] = resume
+
+    def invalidate_resume(self, key: str | None = None) -> None:
+        """Invalidate cached resume(s)."""
+        if key is None:
+            self._cache.clear()
+        else:
+            self._cache.pop(key, None)
+
+    def clear_cache(self) -> None:
+        """Clear all cached resumes."""
+        self._cache.clear()
+
+    def get_cache_keys(self) -> list[str]:
+        """Get list of cached resume keys."""
+        return list(self._cache.keys())
+
+    def get_cache_size(self) -> int:
+        """Get number of cached resumes."""
+        return len(self._cache)
+
+    def get_memory_usage(self) -> int:
+        """Get estimated memory usage of cached resumes in bytes."""
+        return sum(len(str(resume._data)) for resume in self._cache.values())
+
+
+class DefaultResumeConfigurator:
+    """Default implementation of ResumeConfigurator."""
+
+    def configure_resume(self, resume: Resume, config: SessionConfigProtocol) -> Resume:
+        """Apply session configuration to a resume."""
+        result = resume
+
+        # Apply default template if specified
+        if config.default_template:
+            result = result.with_template(config.default_template)
+
+        # Apply default palette if specified
+        if config.default_palette:
+            result = result.with_palette(config.default_palette)
+
+        # Apply preview mode if enabled
+        if config.preview_mode:
+            result = result.preview()
+
+        return result
+
+
+class ResumeRepository:
+    """Repository for managing resume loading and caching."""
+
+    def __init__(
+        self,
+        loader: ResumeLoader,
+        cache: ResumeCache,
+        configurator: ResumeConfigurator,
+    ) -> None:
+        """Initialize repository with dependencies."""
+        self._loader = loader
+        self._cache = cache
+        self._configurator = configurator
+
+    def get_resume(
+        self,
+        name: str,
+        paths: Paths | None = None,
+        use_cache: bool = True,
+        config: SessionConfigProtocol | None = None,
+    ) -> Resume:
+        """Get a resume, loading from cache or file as needed."""
+        cache_key = name
+
+        # Try cache first
+        if use_cache and (cached_resume := self._cache.get_resume(cache_key)):
+            # Apply configuration to cached resume
+            merged_config = config or NullSessionConfig()
+            return self._configurator.configure_resume(cached_resume, merged_config)
+
+        # Load from file
+        resume = self._loader.load_resume(name, paths=paths)
+
+        # Apply configuration
+        if config:
+            resume = self._configurator.configure_resume(resume, config)
+
+        # Cache the result
+        if use_cache:
+            self._cache.put_resume(cache_key, resume)
+
+        return resume
+
+    def invalidate_cache(self, name: str | None = None) -> None:
+        """Invalidate cached resume(s)."""
+        self._cache.invalidate_resume(name)
+
+    def clear_cache(self) -> None:
+        """Clear all cached resumes."""
+        self._cache.clear_cache()
+
+    def get_cache_info(self) -> dict[str, Any]:
+        """Return information about cached resume data.
+
+        Returns:
+            Dictionary with cache statistics.
+
+        """
+        return {
+            "cached_resumes": self._cache.get_cache_keys(),
+            "cache_size": self._cache.get_cache_size(),
+            "memory_usage_estimate": self._cache.get_memory_usage(),
+        }
+
+    def get_cache_keys(self) -> list[str]:
+        """Get list of cached resume keys."""
+        return self._cache.get_cache_keys()
+
+    def get_cache_size(self) -> int:
+        """Get number of cached resumes."""
+        return self._cache.get_cache_size()
+
+    def get_memory_usage(self) -> int:
+        """Get estimated memory usage of cached resumes in bytes."""
+        return self._cache.get_memory_usage()
+
+
+@dataclass
+class DIContainer:
+    """Dependency injection container for creating configured objects."""
+
+    resume_loader: ResumeLoader = field(default_factory=DefaultResumeLoader)
+    resume_cache: ResumeCache = field(default_factory=MemoryResumeCache)
+    resume_configurator: ResumeConfigurator = field(
+        default_factory=DefaultResumeConfigurator
+    )
+
+    def create_resume_repository(self) -> ResumeRepository:
+        """Create a ResumeRepository with configured dependencies."""
+        return ResumeRepository(
+            loader=self.resume_loader,
+            cache=self.resume_cache,
+            configurator=self.resume_configurator,
+        )