simple-resume 0.1.9__py3-none-any.whl

simple_resume/core/generate/plan.py

@@ -0,0 +1,131 @@
+"""Provide pure generation planning helpers for CLI and session shells."""
+
+from __future__ import annotations
+
+import copy
+from collections.abc import Sequence
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from simple_resume.core.constants import OutputFormat
+from simple_resume.core.models import GenerationConfig
+from simple_resume.core.paths import Paths
+
+
+class CommandType(str, Enum):
+    """Define kinds of generation commands the shell can execute."""
+
+    SINGLE = "single"
+    BATCH_SINGLE = "batch_single"
+    BATCH_ALL = "batch_all"
+
+
+@dataclass(frozen=True)
+class GenerationCommand:
+    """Define a pure description of a generation step."""
+
+    kind: CommandType
+    format: OutputFormat | None
+    config: GenerationConfig
+    overrides: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class GeneratePlanOptions:
+    """Define normalized inputs for planning CLI/session work."""
+
+    name: str | None
+    data_dir: Path | None
+    template: str | None
+    output_path: Path | None
+    output_dir: Path | None
+    preview: bool
+    open_after: bool
+    browser: str | None
+    formats: Sequence[OutputFormat]
+    overrides: dict[str, Any]
+    paths: Paths | None = None
+    pattern: str = "*"
+
+
+def build_generation_plan(options: GeneratePlanOptions) -> list[GenerationCommand]:
+    """Return the deterministic commands needed to satisfy the request."""
+    if not options.formats:
+        raise ValueError("At least one output format must be specified")
+
+    plan: list[GenerationCommand] = []
+    overrides = copy.deepcopy(options.overrides)
+
+    if options.name:
+        for format_type in options.formats:
+            plan.append(
+                GenerationCommand(
+                    kind=CommandType.SINGLE,
+                    format=format_type,
+                    config=GenerationConfig(
+                        name=options.name,
+                        data_dir=options.data_dir,
+                        template=options.template,
+                        format=format_type,
+                        output_path=options.output_path,
+                        open_after=options.open_after,
+                        preview=options.preview,
+                        browser=options.browser,
+                        paths=options.paths,
+                        pattern=options.pattern,
+                    ),
+                    overrides=copy.deepcopy(overrides),
+                )
+            )
+        return plan
+
+    if len(options.formats) == 1:
+        format_type = options.formats[0]
+        plan.append(
+            GenerationCommand(
+                kind=CommandType.BATCH_SINGLE,
+                format=format_type,
+                config=GenerationConfig(
+                    data_dir=options.data_dir,
+                    template=options.template,
+                    output_dir=options.output_dir,
+                    open_after=options.open_after,
+                    preview=options.preview,
+                    browser=options.browser,
+                    paths=options.paths,
+                    pattern=options.pattern,
+                ),
+                overrides=copy.deepcopy(overrides),
+            )
+        )
+        return plan
+
+    plan.append(
+        GenerationCommand(
+            kind=CommandType.BATCH_ALL,
+            format=None,
+            config=GenerationConfig(
+                data_dir=options.data_dir,
+                template=options.template,
+                output_dir=options.output_dir,
+                open_after=options.open_after,
+                preview=options.preview,
+                browser=options.browser,
+                formats=list(options.formats),
+                paths=options.paths,
+                pattern=options.pattern,
+            ),
+            overrides=copy.deepcopy(overrides),
+        )
+    )
+    return plan
+
+
+__all__ = [
+    "CommandType",
+    "GenerationCommand",
+    "GeneratePlanOptions",
+    "build_generation_plan",
+]

simple_resume/core/hydration.py

@@ -0,0 +1,55 @@
+"""Provide pure helpers for transforming hydrated resume data."""
+
+from __future__ import annotations
+
+import copy
+from collections.abc import Mapping
+from typing import Any, Callable
+
+from simple_resume.core.skills import format_skill_groups
+
+NormalizeConfigFn = Callable[
+    [dict[str, Any], str], tuple[dict[str, Any], dict[str, Any] | None]
+]
+RenderMarkdownFn = Callable[[dict[str, Any]], dict[str, Any]]
+
+
+def build_skill_group_payload(resume_data: Mapping[str, Any]) -> dict[str, Any]:
+    """Return the computed skill group payload for sidebar sections."""
+    return {
+        "expertise_groups": format_skill_groups(resume_data.get("expertise")),
+        "programming_groups": format_skill_groups(resume_data.get("programming")),
+        "keyskills_groups": format_skill_groups(resume_data.get("keyskills")),
+        "certification_groups": format_skill_groups(resume_data.get("certification")),
+    }
+
+
+def hydrate_resume_structure(
+    source_yaml: dict[str, Any],
+    *,
+    filename: str = "",
+    transform_markdown: bool = True,
+    normalize_config_fn: NormalizeConfigFn,
+    render_markdown_fn: RenderMarkdownFn,
+) -> dict[str, Any]:
+    """Return normalized resume data using injected pure helpers."""
+    processed_resume = copy.deepcopy(source_yaml)
+
+    config = processed_resume.get("config")
+    if isinstance(config, dict):
+        normalized_config, palette_meta = normalize_config_fn(config, filename)
+        processed_resume["config"] = normalized_config
+        if palette_meta:
+            meta = dict(processed_resume.get("meta", {}))
+            meta["palette"] = palette_meta
+            processed_resume["meta"] = meta
+
+    if transform_markdown:
+        processed_resume = render_markdown_fn(processed_resume)
+    else:
+        processed_resume.update(build_skill_group_payload(processed_resume))
+
+    return processed_resume
+
+
+__all__ = ["build_skill_group_payload", "hydrate_resume_structure"]

simple_resume/core/importers/__init__.py

@@ -0,0 +1,3 @@
+"""Importers for external resume formats."""
+
+__all__ = []

simple_resume/core/importers/json_resume.py

@@ -0,0 +1,284 @@
+"""Import helpers for the JSON Resume (jsonresume.org) open resume format.
+
+This module intentionally does *not* attempt a 1:1 mapping of every JSON Resume
+field to simple-resume. Instead, it provides a pragmatic conversion that:
+
+- Produces a valid simple-resume payload (including a non-empty ``config`` block)
+- Preserves key content (basics, work, education, projects)
+- Uses markdown-friendly formatting for highlights
+
+Schema reference (v1.0.x): https://github.com/jsonresume/resume-schema
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+
+def looks_like_json_resume(payload: Any) -> bool:
+    """Return True if payload resembles a JSON Resume document."""
+    if not isinstance(payload, Mapping):
+        return False
+    basics = payload.get("basics")
+    return isinstance(basics, Mapping) and "full_name" not in payload
+
+
+def _strip_url_prefix(url: str, prefix: str) -> str:
+    if url.startswith(prefix):
+        return url[len(prefix) :].lstrip("/")
+    return url
+
+
+def _to_markdown_bullets(items: Any) -> str:
+    if not items:
+        return ""
+    if isinstance(items, str):
+        return items
+    if not isinstance(items, list):
+        return str(items)
+    cleaned = [str(item).strip() for item in items if item]
+    if not cleaned:
+        return ""
+    return "\n".join(f"- {line}" for line in cleaned)
+
+
+def _join_nonempty(*parts: Any, sep: str = "\n\n") -> str:
+    chunks = [str(p).strip() for p in parts if isinstance(p, str) and p.strip()]
+    return sep.join(chunks)
+
+
+def _get_str(data: Mapping[str, Any], key: str) -> str | None:
+    """Extract a non-empty stripped string or return None."""
+    val = data.get(key)
+    if isinstance(val, str) and val.strip():
+        return val.strip()
+    return None
+
+
+def _convert_basics_simple(basics: Mapping[str, Any], result: dict[str, Any]) -> None:
+    """Extract simple scalar fields from basics into result."""
+    field_map = {
+        "name": "full_name",
+        "email": "email",
+        "phone": "phone",
+        "url": "web",
+        "image": "image_uri",
+        "label": "headline",
+        "summary": "description",
+    }
+    for src_key, dst_key in field_map.items():
+        val = _get_str(basics, src_key)
+        if val:
+            result[dst_key] = val
+
+
+def _convert_location(basics: Mapping[str, Any], result: dict[str, Any]) -> None:
+    """Extract location from basics into result['address']."""
+    location = basics.get("location")
+    if not isinstance(location, Mapping):
+        return
+
+    address_lines: list[str] = []
+    addr = _get_str(location, "address")
+    if addr:
+        address_lines.append(addr)
+
+    city, region, postal = (
+        location.get("city"),
+        location.get("region"),
+        location.get("postalCode"),
+    )
+    line2_parts = [
+        str(x).strip()
+        for x in (city, region, postal)
+        if isinstance(x, str) and x.strip()
+    ]
+    if line2_parts:
+        address_lines.append(" ".join(line2_parts))
+
+    country = _get_str(location, "countryCode")
+    if country:
+        address_lines.append(country)
+
+    if address_lines:
+        result["address"] = address_lines
+
+
+def _convert_profiles(basics: Mapping[str, Any], result: dict[str, Any]) -> None:
+    """Extract linkedin/github from profiles into result."""
+    profiles = basics.get("profiles")
+    if not isinstance(profiles, list):
+        return
+
+    for profile in profiles:
+        if not isinstance(profile, Mapping):
+            continue
+        network = str(profile.get("network", "")).strip().lower()
+        purl = _get_str(profile, "url")
+        username = _get_str(profile, "username")
+
+        if network == "linkedin":
+            if purl:
+                result["linkedin"] = _strip_url_prefix(
+                    purl, "https://www.linkedin.com/"
+                )
+            elif username:
+                result["linkedin"] = username
+        elif network == "github":
+            if purl:
+                result["github"] = _strip_url_prefix(purl, "https://github.com/")
+            elif username:
+                result["github"] = username
+
+
+def _convert_work(payload: Mapping[str, Any]) -> list[dict[str, Any]]:
+    """Convert work entries to simple-resume format."""
+    work = payload.get("work")
+    if not isinstance(work, list):
+        return []
+
+    entries: list[dict[str, Any]] = []
+    for item in work:
+        if not isinstance(item, Mapping):
+            continue
+        highlights = _to_markdown_bullets(item.get("highlights"))
+        raw_summary = item.get("summary")
+        summary_str = str(raw_summary).strip() if raw_summary else ""
+        desc = _join_nonempty(summary_str, highlights)
+        entries.append(
+            {
+                "start": item.get("startDate") or "",
+                "end": item.get("endDate") or "",
+                "title": item.get("position") or "",
+                "company": item.get("name") or "",
+                "company_link": item.get("url") or "",
+                "description": desc or "",
+            }
+        )
+    return entries
+
+
+def _convert_education(payload: Mapping[str, Any]) -> list[dict[str, Any]]:
+    """Convert education entries to simple-resume format."""
+    education = payload.get("education")
+    if not isinstance(education, list):
+        return []
+
+    entries: list[dict[str, Any]] = []
+    for item in education:
+        if not isinstance(item, Mapping):
+            continue
+        study = str(item.get("studyType", "")).strip()
+        area = str(item.get("area", "")).strip()
+        title = " ".join(x for x in (study, area) if x)
+
+        desc_parts: list[str] = []
+        gpa = item.get("gpa")
+        if gpa:
+            desc_parts.append(f"GPA: {gpa}")
+        courses_md = _to_markdown_bullets(item.get("courses"))
+        if courses_md:
+            desc_parts.append("Courses:\n" + courses_md)
+
+        entries.append(
+            {
+                "start": item.get("startDate") or "",
+                "end": item.get("endDate") or "",
+                "title": title,
+                "company": item.get("institution") or "",
+                "description": _join_nonempty(*desc_parts) or "",
+            }
+        )
+    return entries
+
+
+def _convert_projects(payload: Mapping[str, Any]) -> list[dict[str, Any]]:
+    """Convert project entries to simple-resume format."""
+    projects = payload.get("projects")
+    if not isinstance(projects, list):
+        return []
+
+    entries: list[dict[str, Any]] = []
+    for item in projects:
+        if not isinstance(item, Mapping):
+            continue
+        highlights = _to_markdown_bullets(item.get("highlights"))
+        raw_desc = item.get("description")
+        desc_str = str(raw_desc).strip() if raw_desc else ""
+        desc = _join_nonempty(desc_str, highlights)
+        entries.append(
+            {
+                "start": item.get("startDate") or "",
+                "end": item.get("endDate") or "",
+                "title": item.get("name") or "",
+                "title_link": item.get("url") or "",
+                "company": item.get("entity") or "",
+                "description": desc or "",
+            }
+        )
+    return entries
+
+
+def _convert_skills(payload: Mapping[str, Any], result: dict[str, Any]) -> None:
+    """Extract skills into expertise and keyskills."""
+    skills = payload.get("skills")
+    if not isinstance(skills, list):
+        return
+
+    expertise: list[str] = []
+    keyskills: list[str] = []
+    for group in skills:
+        if not isinstance(group, Mapping):
+            continue
+        group_name = _get_str(group, "name")
+        if group_name:
+            expertise.append(group_name)
+        keywords = group.get("keywords")
+        if isinstance(keywords, list):
+            for kw in keywords:
+                if isinstance(kw, str) and kw.strip():
+                    keyskills.append(kw.strip())
+
+    if expertise:
+        result["expertise"] = sorted(set(expertise))
+    if keyskills:
+        result["keyskills"] = sorted(set(keyskills))
+
+
+def json_resume_to_simple_resume(payload: Mapping[str, Any]) -> dict[str, Any]:
+    """Convert a JSON Resume payload into a simple-resume YAML-shaped dict."""
+    basics = payload.get("basics")
+    basics = basics if isinstance(basics, Mapping) else {}
+
+    result: dict[str, Any] = {
+        "template": "resume_no_bars",
+        "config": {"template": "resume_no_bars"},
+    }
+
+    # Convert basics section
+    _convert_basics_simple(basics, result)
+    _convert_location(basics, result)
+    _convert_profiles(basics, result)
+
+    # Build body sections
+    body: dict[str, list[dict[str, Any]]] = {}
+    work_entries = _convert_work(payload)
+    if work_entries:
+        body["Experience"] = work_entries
+    education_entries = _convert_education(payload)
+    if education_entries:
+        body["Education"] = education_entries
+    project_entries = _convert_projects(payload)
+    if project_entries:
+        body["Projects"] = project_entries
+    if body:
+        result["body"] = body
+
+    # Convert skills
+    _convert_skills(payload, result)
+
+    return result
+
+
+__all__ = ["json_resume_to_simple_resume", "looks_like_json_resume"]

simple_resume/core/latex/__init__.py

@@ -0,0 +1,60 @@
+"""Core LaTeX functionality (pure, deterministic, no side effects).
+
+This package contains pure business logic for LaTeX document generation.
+All functions are deterministic and have no side effects (no file I/O,
+no network access, no randomness).
+
+The shell layer (simple_resume.shell.render.latex) handles all I/O operations
+including template loading, file system access, and LaTeX compilation.
+"""
+
+from simple_resume.core.latex.context import build_latex_context_pure
+from simple_resume.core.latex.conversion import (
+    collect_blocks,
+    convert_inline,
+    normalize_iterable,
+)
+from simple_resume.core.latex.escaping import escape_latex, escape_url
+from simple_resume.core.latex.fonts import fontawesome_support_block
+from simple_resume.core.latex.formatting import format_date, linkify
+from simple_resume.core.latex.sections import (
+    build_contact_lines,
+    prepare_sections,
+    prepare_skill_sections,
+)
+from simple_resume.core.latex.types import (
+    Block,
+    LatexEntry,
+    LatexRenderResult,
+    LatexSection,
+    ListBlock,
+    ParagraphBlock,
+)
+
+__all__ = [
+    # Types
+    "Block",
+    "LatexEntry",
+    "LatexRenderResult",
+    "LatexSection",
+    "ListBlock",
+    "ParagraphBlock",
+    # Escaping
+    "escape_latex",
+    "escape_url",
+    # Conversion
+    "collect_blocks",
+    "convert_inline",
+    "normalize_iterable",
+    # Formatting
+    "format_date",
+    "linkify",
+    # Sections
+    "build_contact_lines",
+    "prepare_sections",
+    "prepare_skill_sections",
+    # Context
+    "build_latex_context_pure",
+    # Fonts
+    "fontawesome_support_block",
+]

simple_resume/core/latex/context.py

@@ -0,0 +1,56 @@
+"""LaTeX context building functions (pure version without I/O)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from simple_resume.core.latex.conversion import collect_blocks, convert_inline
+from simple_resume.core.latex.sections import (
+    build_contact_lines,
+    prepare_sections,
+    prepare_skill_sections,
+)
+
+
+def build_latex_context_pure(data: dict[str, Any]) -> dict[str, Any]:
+    """Prepare the LaTeX template context from raw resume data (pure version).
+
+    This is the pure, core version of context building that does NOT perform
+    any file system operations. The fontawesome_block is set to None and must
+    be added by the shell layer which has access to the file system.
+
+    Args:
+        data: Raw resume data dictionary.
+
+    Returns:
+        Dictionary of context variables for LaTeX template rendering.
+        Note: fontawesome_block will be None and must be set by shell layer.
+
+    Examples:
+        >>> data = {"full_name": "John Doe", "job_title": "Engineer"}
+        >>> context = build_latex_context_pure(data)
+        >>> context["full_name"]
+        'John Doe'
+        >>> context["headline"]
+        'Engineer'
+
+    """
+    full_name = convert_inline(str(data.get("full_name", "")))
+    headline = data.get("job_title")
+    rendered_headline = convert_inline(str(headline)) if headline else None
+    summary_blocks = collect_blocks(data.get("description"))
+
+    return {
+        "full_name": full_name,
+        "headline": rendered_headline,
+        "contact_lines": build_contact_lines(data),
+        "summary_blocks": summary_blocks,
+        "skill_sections": prepare_skill_sections(data),
+        "sections": prepare_sections(data),
+        "fontawesome_block": None,  # Must be set by shell layer
+    }
+
+
+__all__ = [
+    "build_latex_context_pure",
+]