simple-resume 0.1.9__py3-none-any.whl

simple_resume/core/latex/types.py

@@ -0,0 +1,84 @@
+"""LaTeX document data types (pure, immutable)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, ClassVar, Literal, TypedDict
+
+
+class ParagraphBlock(TypedDict):
+    """Define a paragraph text block."""
+
+    kind: Literal["paragraph"]
+    text: str
+
+
+class ListBlock(TypedDict):
+    """Define a bullet or enumerated list block."""
+
+    kind: Literal["itemize", "enumerate"]
+    items: list[str]
+
+
+Block = ParagraphBlock | ListBlock
+
+
+@dataclass(frozen=True)
+class LatexEntry:
+    """Define a single entry in a resume section."""
+
+    title: str
+    subtitle: str | None
+    date_range: str | None
+    blocks: list[Block]
+
+
+@dataclass(frozen=True)
+class LatexSection:
+    """Define a top-level resume section."""
+
+    title: str
+    entries: list[LatexEntry]
+
+
+@dataclass(frozen=True)
+class LatexRenderResult:
+    """Define the result of a LaTeX render operation."""
+
+    tex: str
+    context: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class LatexGenerationContext:
+    """Context object for LaTeX PDF generation, grouping related parameters."""
+
+    last_context: ClassVar[LatexGenerationContext | None] = None
+    resume_data: dict[str, Any] | None
+    processed_data: dict[str, Any]
+    output_path: Path
+    base_path: Path | str | None = None
+    filename: str | None = None
+    paths: Any = None
+    metadata: Any = None
+
+    def __post_init__(self) -> None:
+        """Cache the most recent context for fallback use."""
+        type(self).last_context = self
+
+    @property
+    def raw_data(self) -> dict[str, Any] | None:
+        """Backward-compatible accessor used by some tests."""
+        return self.resume_data
+
+
+__all__ = [
+    "Block",
+    "LatexEntry",
+    "LatexGenerationContext",
+    "LatexRenderResult",
+    "LatexSection",
+    "ListBlock",
+    "ParagraphBlock",
+]

simple_resume/core/markdown.py

@@ -0,0 +1,127 @@
+"""Pure helpers for transforming resume Markdown into HTML."""
+
+from __future__ import annotations
+
+import copy
+from collections.abc import Mapping
+from typing import Any
+
+from markdown import markdown
+
+from simple_resume.core.colors import darken_color, is_valid_color
+from simple_resume.core.constants.colors import (
+    BOLD_DARKEN_FACTOR,
+    DEFAULT_BOLD_COLOR,
+    DEFAULT_COLOR_SCHEME,
+)
+from simple_resume.core.hydration import build_skill_group_payload
+
+
+def derive_bold_color(frame_color: str | None) -> str:
+    """Return a darkened color for bold text."""
+    if isinstance(frame_color, str) and is_valid_color(frame_color):
+        return darken_color(frame_color, BOLD_DARKEN_FACTOR)
+    return DEFAULT_COLOR_SCHEME.get("bold_color", DEFAULT_BOLD_COLOR)
+
+
+def _apply_bold_color(html: str, color: str, font_weight: int = 600) -> str:
+    """Apply color styling to `<strong>` tags in an HTML string."""
+    if not html or "<strong" not in html:
+        return html
+
+    strong_style = f"color: {color}; font-weight: {font_weight} !important;"
+    replacements = {
+        "<strong>": f'<strong class="markdown-strong" style="{strong_style}">',
+        "<strong >": f'<strong class="markdown-strong" style="{strong_style}">',
+    }
+    for needle, replacement in replacements.items():
+        html = html.replace(needle, replacement)
+    return html
+
+
+def transform_markdown_blocks(
+    data: dict[str, Any],
+    *,
+    bold_color: str = DEFAULT_BOLD_COLOR,
+    bold_font_weight: int = 600,
+) -> None:
+    """Convert Markdown fields in-place."""
+    extensions = [
+        "fenced_code",
+        "tables",
+        "codehilite",
+        "nl2br",
+        "attr_list",
+    ]
+
+    description = data.get("description")
+    if isinstance(description, str):
+        data["description"] = _apply_bold_color(
+            markdown(description, extensions=extensions),
+            bold_color,
+            bold_font_weight,
+        )
+
+    body = data.get("body")
+    if isinstance(body, dict):
+        for block_data in body.values():
+            for element in block_data:
+                if isinstance(element, dict):
+                    desc = element.get("description")
+                    if isinstance(desc, str):
+                        element["description"] = _apply_bold_color(
+                            markdown(desc, extensions=extensions),
+                            bold_color,
+                            bold_font_weight,
+                        )
+
+
+def _determine_bold_color(config: Mapping[str, Any] | None) -> str:
+    """Derive the effective bold color from configuration data."""
+    if not config:
+        return DEFAULT_COLOR_SCHEME.get("bold_color", DEFAULT_BOLD_COLOR)
+
+    # First check for explicit bold_color
+    bold_color = config.get("bold_color")
+    if isinstance(bold_color, str) and is_valid_color(bold_color):
+        return bold_color
+
+    # Fall back to frame_color (use directly, not derived)
+    frame_color = config.get("frame_color")
+    if isinstance(frame_color, str) and is_valid_color(frame_color):
+        return frame_color
+
+    # Check other color candidates
+    color_candidates = [
+        config.get("heading_icon_color"),
+        config.get("theme_color"),
+    ]
+    for candidate in color_candidates:
+        if isinstance(candidate, str) and is_valid_color(candidate):
+            return candidate
+
+    return DEFAULT_COLOR_SCHEME.get("bold_color", DEFAULT_BOLD_COLOR)
+
+
+def render_markdown_content(resume_data: dict[str, Any]) -> dict[str, Any]:
+    """Return a copy of resume data with Markdown converted to HTML."""
+    transformed_resume = copy.deepcopy(resume_data)
+
+    config = transformed_resume.get("config")
+    bold_color = _determine_bold_color(config if isinstance(config, Mapping) else None)
+    bold_font_weight = 600  # default
+    if isinstance(config, Mapping):
+        bold_font_weight = int(config.get("bold_font_weight", 600))
+
+    transform_markdown_blocks(
+        transformed_resume, bold_color=bold_color, bold_font_weight=bold_font_weight
+    )
+    transformed_resume.update(build_skill_group_payload(transformed_resume))
+    return transformed_resume
+
+
+__all__ = [
+    "derive_bold_color",
+    "render_markdown_content",
+    "transform_markdown_blocks",
+]

simple_resume/core/models.py

@@ -0,0 +1,102 @@
+"""Core data models for resume rendering."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from simple_resume.core.constants import OutputFormat, RenderMode
+from simple_resume.core.paths import Paths
+
+
+@dataclass(frozen=True)
+class ResumeConfig:
+    """A normalized resume configuration with validated fields."""
+
+    page_width: int | None = None
+    page_height: int | None = None
+    sidebar_width: int | None = None
+    output_mode: str = "markdown"
+    template: str = "resume_no_bars"
+    color_scheme: str = "default"
+
+    # Color fields
+    theme_color: str = "#0395DE"
+    sidebar_color: str = "#F6F6F6"
+    sidebar_text_color: str = "#000000"
+    sidebar_bold_color: str = "#000000"
+    bar_background_color: str = "#DFDFDF"
+    date2_color: str = "#616161"
+    frame_color: str = "#757575"
+    heading_icon_color: str = "#0395DE"
+    bold_color: str = "#585858"
+
+    # Layout customization fields (section heading icons)
+    section_icon_circle_size: float = 7.8
+    section_icon_circle_x_offset: float = 0
+    section_icon_design_size: float = 3.5
+    section_icon_design_x_offset: float = 0
+    section_icon_design_y_offset: float = 0
+    section_heading_text_margin: float = -6
+
+    # Contact icon customization
+    contact_icon_size: float = 5
+    contact_icon_margin_top: float = 0.5
+    contact_icon_margin_right: float = 2
+    contact_icon_gap: float = 4
+
+
+@dataclass(frozen=True)
+class RenderPlan:
+    """A pure data structure describing how to render a resume."""
+
+    name: str
+    mode: RenderMode
+    config: ResumeConfig
+    template_name: str | None = None
+    context: dict[str, Any] | None = None
+    tex: str | None = None
+    palette_metadata: dict[str, Any] | None = None
+    base_path: Path | str = ""
+
+
+@dataclass(frozen=True)
+class ValidationResult:
+    """The result of validating resume data."""
+
+    is_valid: bool
+    errors: list[str]
+    warnings: list[str]
+    normalized_config: ResumeConfig | None = None
+    palette_metadata: dict[str, Any] | None = None
+
+
+@dataclass(frozen=True)
+class GenerationConfig:
+    """A complete configuration for generation operations."""
+
+    # Path configuration
+    data_dir: str | Path | None = None
+    output_dir: str | Path | None = None
+    output_path: str | Path | None = None
+    paths: Paths | None = None
+
+    # Generation options
+    template: str | None = None
+    format: OutputFormat | str = OutputFormat.PDF
+    open_after: bool = False
+    preview: bool = False
+    name: str | None = None
+    pattern: str = "*"
+    browser: str | None = None
+    formats: list[OutputFormat | str] | None = None
+
+
+__all__ = [
+    "GenerationConfig",
+    "RenderMode",
+    "RenderPlan",
+    "ResumeConfig",
+    "ValidationResult",
+]

simple_resume/core/palettes/__init__.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Palette discovery utilities and registries (pure core)."""
+
+from __future__ import annotations
+
+from simple_resume.core.palettes.exceptions import (
+    PaletteError,
+    PaletteGenerationError,
+    PaletteLookupError,
+    PaletteRemoteDisabled,
+    PaletteRemoteError,
+)
+from simple_resume.core.palettes.fetch_types import (
+    PaletteFetchRequest,
+    PaletteResolution,
+)
+from simple_resume.core.palettes.generators import generate_hcl_palette
+from simple_resume.core.palettes.registry import (
+    Palette,
+    PaletteRegistry,
+    build_palette_registry,
+)
+from simple_resume.core.palettes.resolution import resolve_palette_config
+
+__all__ = [
+    "Palette",
+    "PaletteRegistry",
+    "build_palette_registry",
+    "generate_hcl_palette",
+    "PaletteError",
+    "PaletteLookupError",
+    "PaletteGenerationError",
+    "PaletteRemoteDisabled",
+    "PaletteRemoteError",
+    "PaletteFetchRequest",
+    "PaletteResolution",
+    "resolve_palette_config",
+]

simple_resume/core/palettes/common.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Define common types and utilities for palette modules."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+_CACHE_ENV = "SIMPLE_RESUME_PALETTE_CACHE_DIR"
+
+
+@dataclass(frozen=True)
+class Palette:
+    """Define palette metadata and resolved swatches."""
+
+    name: str
+    swatches: tuple[str, ...]
+    source: str
+    metadata: dict[str, object] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, object]:
+        """Serialize palette to a JSON-friendly structure."""
+        return {
+            "name": self.name,
+            "swatches": list(self.swatches),
+            "source": self.source,
+            "metadata": dict(self.metadata),
+        }
+
+
+class PaletteSource(str, Enum):
+    """Define supported palette sources for resume configuration."""
+
+    REGISTRY = "registry"
+    GENERATOR = "generator"
+    REMOTE = "remote"
+
+    @classmethod
+    def normalize(
+        cls, value: str | PaletteSource | None, *, param_name: str | None = None
+    ) -> PaletteSource:
+        """Convert arbitrary input into a `PaletteSource` enum member."""
+        if value is None:
+            return cls.REGISTRY
+        if isinstance(value, cls):
+            return value
+        if not isinstance(value, str):
+            raise TypeError(
+                f"Palette source must be string or PaletteSource, got {type(value)}"
+            )
+
+        normalized = value.strip().lower()
+        try:
+            return cls(normalized)
+        except ValueError as exc:
+            label = f"{param_name} " if param_name else ""
+            supported_sources = ", ".join(
+                sorted(member.value for member in cls.__members__.values())
+            )
+            raise ValueError(
+                f"Unsupported {label}source: {value}. Supported sources: "
+                f"{supported_sources}"
+            ) from exc
+
+
+def get_cache_dir() -> Path:
+    """Return palette cache directory."""
+    custom = os.environ.get(_CACHE_ENV)
+    if custom:
+        return Path(custom).expanduser()
+    return Path.home() / ".cache" / "simple-resume" / "palettes"

simple_resume/core/palettes/data/default_palettes.json

@@ -0,0 +1,58 @@
+[
+  {
+    "name": "default",
+    "colors": [
+      "#0395DE",
+      "#F6F6F6",
+      "#DFDFDF",
+      "#616161",
+      "#757575"
+    ],
+    "source": "default",
+    "metadata": {
+      "description": "Professional blue default palette"
+    }
+  },
+  {
+    "name": "modern_teal",
+    "colors": [
+      "#0891B2",
+      "#F0FDFA",
+      "#CCFBF1",
+      "#134E4A",
+      "#0E7490"
+    ],
+    "source": "default",
+    "metadata": {
+      "description": "Default teal palette"
+    }
+  },
+  {
+    "name": "ocean",
+    "colors": [
+      "#005B96",
+      "#E6F7FF",
+      "#A7C6ED",
+      "#013A63",
+      "#0A2463"
+    ],
+    "source": "default",
+    "metadata": {
+      "description": "Classic ocean blues used by legacy templates"
+    }
+  },
+  {
+    "name": "ocean_blue",
+    "colors": [
+      "#0275D8",
+      "#F0F8FF",
+      "#CFE2FF",
+      "#023E8A",
+      "#03045E"
+    ],
+    "source": "default",
+    "metadata": {
+      "description": "Ocean-inspired palette for CLI demos"
+    }
+  }
+]

simple_resume/core/palettes/exceptions.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Exception types used by the palette subsystem."""
+
+from __future__ import annotations
+
+
+class PaletteError(RuntimeError):
+    """Base class for palette-related failures."""
+
+
+class PaletteLookupError(PaletteError):
+    """Raised when a named palette cannot be located."""
+
+
+class PaletteGenerationError(PaletteError):
+    """Raised when a generator cannot produce the requested swatches."""
+
+
+class PaletteRemoteDisabled(PaletteError):
+    """Raised when remote palette access is disabled by configuration."""
+
+
+class PaletteRemoteError(PaletteError):
+    """Raised when a remote palette provider returns an error."""
+
+
+__all__ = [
+    "PaletteError",
+    "PaletteGenerationError",
+    "PaletteLookupError",
+    "PaletteRemoteDisabled",
+    "PaletteRemoteError",
+]

simple_resume/core/palettes/fetch_types.py

@@ -0,0 +1,52 @@
+"""Palette request and response types for pure core operations.
+
+These types allow core functions to describe what network operations
+are needed without actually performing them, keeping the core pure.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class PaletteFetchRequest:
+    """Request to fetch palette from remote source.
+
+    This describes a network operation that should be executed by the shell layer.
+    The core layer creates these requests but never executes them directly.
+    """
+
+    source: str  # e.g., "colourlovers"
+    keywords: list[str] | None = None
+    num_results: int = 1
+    order_by: str = "score"
+
+
+@dataclass(frozen=True)
+class PaletteResolution:
+    """Result of palette resolution - either colors or fetch request.
+
+    This represents the result of pure palette resolution logic.
+    It either contains resolved colors (for local sources) or a
+    fetch request (for remote sources) that the shell should execute.
+    """
+
+    colors: list[str] | None = None
+    metadata: dict[str, Any] | None = None
+    fetch_request: PaletteFetchRequest | None = None
+
+    @property
+    def needs_fetch(self) -> bool:
+        """Check if this resolution requires network fetching."""
+        return self.fetch_request is not None
+
+    @property
+    def has_colors(self) -> bool:
+        """Check if this resolution already contains colors."""
+        return self.colors is not None and len(self.colors) > 0
+
+
+__all__ = [
+    "PaletteFetchRequest",
+    "PaletteResolution",
+]