simplegals 0.1.0__py3-none-any.whl

simplegals/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

simplegals/cli.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .core.config import init_project, load_project_config
+from .core.gallery import build, clean, validate
+from .workers.progress import ProgressState, format_cli_progress
+
+
+def _resolve_config(args: argparse.Namespace) -> Path:
+    return Path(args.config) if args.config else Path.cwd() / "simpleGal.json"
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    config_path = Path(args.config) if args.config else None
+    result = init_project(Path.cwd(), config_path=config_path)
+    print(f"Initialized: {result}")
+    return 0
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    config_path = _resolve_config(args)
+    try:
+        config = load_project_config(config_path)
+    except FileNotFoundError:
+        print(f"Config not found: {config_path}. Run 'simpleGals init' first.", file=sys.stderr)
+        return 1
+    errors = validate(Path.cwd(), config)
+    if errors:
+        for e in errors:
+            print(f"  error: {e}", file=sys.stderr)
+        return 1
+    print("Validation passed.")
+    return 0
+
+
+def cmd_build(args: argparse.Namespace) -> int:
+    config_path = _resolve_config(args)
+    try:
+        config = load_project_config(config_path)
+    except FileNotFoundError:
+        print(f"Config not found: {config_path}. Run 'simpleGals init' first.", file=sys.stderr)
+        return 1
+
+    _first = [True]
+
+    def _on_progress(state: ProgressState) -> None:
+        text = format_cli_progress(state)
+        if _first[0]:
+            sys.stderr.write(text + "\n")
+            _first[0] = False
+        else:
+            sys.stderr.write(f"\x1b[2A\r{text}\n")
+        sys.stderr.flush()
+
+    log_path, had_errors = build(Path.cwd(), config, progress_callback=_on_progress, force=args.force)
+
+    if had_errors:
+        print(f"\nBuild completed with errors. Log: {log_path}", file=sys.stderr)
+        lines = log_path.read_text(encoding="utf-8").splitlines()
+        tail = lines[-20:] if len(lines) > 20 else lines
+        print("\n--- last 20 lines of build log ---", file=sys.stderr)
+        print("\n".join(tail), file=sys.stderr)
+        return 1
+
+    print(f"Build complete. Log: {log_path}")
+    return 0
+
+
+def cmd_clean(args: argparse.Namespace) -> int:
+    clean(Path.cwd())
+    print("Cleaned .meta/")
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="simpleGals",
+        description="Static HTML image gallery generator",
+    )
+    parser.add_argument(
+        "-c", "--config",
+        metavar="PATH",
+        help="Path to simpleGal.json (default: ./simpleGal.json)",
+    )
+
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("init", help="Create a stub simpleGal.json in the current directory")
+    sub.add_parser("validate", help="Validate config and input images")
+    build_parser = sub.add_parser("build", help="Build the gallery")
+    build_parser.add_argument(
+        "--force", "-f",
+        action="store_true",
+        help="Rebuild all output files, ignoring the cache",
+    )
+    sub.add_parser("clean", help="Remove all cached metadata from .meta/")
+
+    args = parser.parse_args()
+
+    handlers = {
+        "init": cmd_init,
+        "validate": cmd_validate,
+        "build": cmd_build,
+        "clean": cmd_clean,
+    }
+    sys.exit(handlers[args.command](args))
+
+
+if __name__ == "__main__":
+    main()

simplegals/core/config.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import platform
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class GlobalConfig:
+    file_panel_width: int | str = 30
+    scroll_rate: float = 2.0
+    preview_delay: int = 125
+
+
+@dataclass
+class Layout:
+    columns: int = 4
+    rows: int = 5
+
+
+@dataclass
+class ProjectConfig:
+    title: str = "Gallery"
+    description: str = ""
+    layout: Layout = field(default_factory=Layout)
+    quality: int = 90
+    copyright: str = ""
+    template: str | None = None
+    images: dict = field(default_factory=dict)
+
+
+def global_config_path() -> Path:
+    system = platform.system()
+    if system == "Darwin":
+        return Path.home() / "Library" / "Application Support" / "simplegals" / "config.json"
+    if system == "Windows":
+        import os
+        appdata = os.environ.get("APPDATA", str(Path.home()))
+        return Path(appdata) / "simplegals" / "config.json"
+    import os
+    xdg = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
+    return Path(xdg) / "simplegals" / "config.json"
+
+
+def load_global_config(path: Path | None = None) -> GlobalConfig:
+    p = path or global_config_path()
+    if not p.exists():
+        return GlobalConfig()
+    data = json.loads(p.read_text(encoding="utf-8"))
+    return GlobalConfig(**{k: v for k, v in data.items() if k in GlobalConfig.__dataclass_fields__})
+
+
+def save_global_config(config: GlobalConfig, path: Path | None = None) -> None:
+    p = path or global_config_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(asdict(config), indent=2), encoding="utf-8")
+
+
+def load_project_config(path: Path) -> ProjectConfig:
+    if not path.exists():
+        raise FileNotFoundError(f"Config not found: {path}")
+    data = json.loads(path.read_text(encoding="utf-8"))
+    layout_data = data.pop("layout", {})
+    layout = Layout(**{k: v for k, v in layout_data.items() if k in Layout.__dataclass_fields__})
+    fields = {k: v for k, v in data.items() if k in ProjectConfig.__dataclass_fields__}
+    fields["layout"] = layout
+    return ProjectConfig(**fields)
+
+
+def save_project_config(config: ProjectConfig, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(asdict(config), indent=2), encoding="utf-8")
+
+
+def init_project(project_dir: Path, config_path: Path | None = None) -> Path:
+    target = config_path or (project_dir / "simpleGal.json")
+    if not target.exists():
+        save_project_config(ProjectConfig(), target)
+    return target
+
+
+def settings_hash(config: ProjectConfig) -> str:
+    data = json.dumps(
+        {"copyright": config.copyright, "quality": config.quality, "template": config.template},
+        sort_keys=True,
+    )
+    return hashlib.sha256(data.encode()).hexdigest()[:16]

simplegals/core/gallery.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import json
+import multiprocessing
+import threading
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+import bitmath
+
+from .config import ProjectConfig, settings_hash
+from .metadata import (
+    ImageSidecar,
+    OutputMeta,
+    ThumbMeta,
+    check_staleness,
+    file_sha256,
+    load_sidecar,
+    now_rfc3339,
+    save_sidecar,
+)
+from .template import render_gallery
+from ..workers.pool import dispatch
+from ..workers.progress import ProgressState, drain_queue, format_cli_progress
+
+SUPPORTED_EXTENSIONS: frozenset[str] = frozenset({".jpg", ".jpeg", ".png"})
+
+
+def ensure_project_dirs(project_dir: Path) -> tuple[Path, Path, Path]:
+    in_dir = project_dir / "in"
+    out_dir = project_dir / "out"
+    meta_dir = project_dir / ".meta"
+    for d in (in_dir, out_dir, meta_dir):
+        d.mkdir(parents=True, exist_ok=True)
+    return in_dir, out_dir, meta_dir
+
+
+def scan_sources(in_dir: Path) -> list[Path]:
+    return sorted(
+        p for p in in_dir.iterdir()
+        if p.is_file() and p.suffix.lower() in SUPPORTED_EXTENSIONS
+    )
+
+
+def validate(project_dir: Path, config: ProjectConfig) -> list[str]:
+    errors: list[str] = []
+    in_dir = project_dir / "in"
+    if not in_dir.exists():
+        errors.append(f"Missing input directory: {in_dir}")
+        return errors
+    source_names = {p.name for p in scan_sources(in_dir)}
+    for name in config.images:
+        if name not in source_names:
+            errors.append(f"Image in config not found in in/: {name}")
+    return errors
+
+
+def clean(project_dir: Path) -> None:
+    meta_dir = project_dir / ".meta"
+    if meta_dir.exists():
+        for p in meta_dir.iterdir():
+            if p.is_file():
+                p.unlink()
+
+
+def prune_removed_sources(
+    out_dir: Path,
+    meta_dir: Path,
+    source_names: set[str],
+) -> int:
+    """Delete out/ and .meta/ artifacts for sources no longer present in in/.
+
+    Returns the number of source entries pruned.
+    """
+    removed = 0
+    for sidecar in meta_dir.glob("*.json"):
+        name = sidecar.stem  # e.g. "DSC_8297.jpg" (strip trailing .json)
+        if name in source_names:
+            continue
+        stem = Path(name).stem
+        ext = Path(name).suffix
+        sidecar.unlink(missing_ok=True)
+        (meta_dir / f"{stem}_thumb{ext}").unlink(missing_ok=True)
+        (out_dir / name).unlink(missing_ok=True)
+        (out_dir / f"{stem}_thumb{ext}").unlink(missing_ok=True)
+        (out_dir / f"{stem}_item.html").unlink(missing_ok=True)
+        removed += 1
+    return removed
+
+
+def build(
+    project_dir: Path,
+    config: ProjectConfig,
+    progress_callback=None,
+    force: bool = False,
+) -> tuple[Path, bool]:
+    """Run a full gallery build. Returns (log_path, had_errors)."""
+    in_dir, out_dir, meta_dir = ensure_project_dirs(project_dir)
+
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    log_path = meta_dir / f"build-{ts}.log"
+    log_lines: list[str] = []
+
+    def log(msg: str) -> None:
+        log_lines.append(msg)
+
+    sources = scan_sources(in_dir)
+    log(f"Found {len(sources)} source image(s) in {in_dir}")
+
+    source_names = {s.name for s in sources}
+    pruned = prune_removed_sources(out_dir, meta_dir, source_names)
+    if pruned:
+        log(f"Pruned {pruned} removed source(s) from out/ and .meta/")
+
+    if force:
+        log("Force rebuild requested — skipping cache.")
+
+    thumb_tasks: list[tuple] = []
+    output_tasks: list[tuple] = []
+
+    for source in sources:
+        if force:
+            thumb_stale, output_stale = True, True
+        else:
+            thumb_stale, output_stale = check_staleness(source, meta_dir, config)
+        if thumb_stale:
+            thumb_tasks.append((str(source), str(meta_dir), None))
+        if output_stale:
+            output_tasks.append((str(source), str(out_dir), {
+                "quality": config.quality,
+                "copyright": config.copyright,
+                "template": config.template,
+            }))
+
+    log(f"Tasks: {len(thumb_tasks)} thumb, {len(output_tasks)} output")
+
+    had_errors = False
+    if thumb_tasks or output_tasks:
+        q: multiprocessing.Queue = multiprocessing.Queue()
+        state = ProgressState(
+            thumb_total=len(thumb_tasks),
+            output_total=len(output_tasks),
+        )
+        _done = threading.Event()
+
+        def _run_dispatch() -> None:
+            dispatch(thumb_tasks, output_tasks, q)
+            _done.set()
+
+        dispatch_thread = threading.Thread(target=_run_dispatch, daemon=True)
+        dispatch_thread.start()
+
+        while not _done.wait(timeout=0.05):
+            state = drain_queue(q, state, timeout=0.02)
+            if progress_callback:
+                progress_callback(state)
+
+        # final drain after all workers finish
+        state = drain_queue(q, state, timeout=0.1)
+        if progress_callback:
+            progress_callback(state)
+
+        dispatch_thread.join()
+        log(format_cli_progress(state))
+        if state.thumb_failed or state.output_failed:
+            had_errors = True
+            log(f"Errors: {state.thumb_failed} thumb, {state.output_failed} output")
+
+    s_hash = settings_hash(config)
+    for source in sources:
+        sidecar = load_sidecar(meta_dir, source.name) or ImageSidecar(
+            source=source.name,
+            mtime=now_rfc3339(),
+            sha256=file_sha256(source),
+            settings_hash=s_hash,
+        )
+        thumb_path = meta_dir / f"{source.stem}_thumb{source.suffix}"
+        if thumb_path.exists():
+            sidecar.thumb = ThumbMeta(path=str(thumb_path), generated_at=now_rfc3339())
+        output_path = out_dir / source.name
+        if output_path.exists():
+            sidecar.output = OutputMeta(
+                path=str(output_path),
+                thumb_path=str(out_dir / f"{source.stem}_thumb{source.suffix}"),
+                generated_at=now_rfc3339(),
+            )
+            sidecar.settings_hash = s_hash
+        save_sidecar(meta_dir, sidecar)
+
+    raw_records = []
+    for source in sources:
+        img_config = config.images.get(source.name, {})
+        size_str = bitmath.getsize(str(source), bestprefix=True).format("{value:.2f} {unit}")
+        mtime_dt = datetime.fromtimestamp(source.stat().st_mtime, tz=timezone.utc)
+        raw_records.append({
+            "filename": source.name,
+            "output_path": source.name,
+            "thumb_path": f"{source.stem}_thumb{source.suffix}",
+            "caption": img_config.get("caption", ""),
+            "alt": img_config.get("alt", ""),
+            "include": img_config.get("include", True),
+            "date": mtime_dt.strftime("%Y-%m-%d"),
+            "size": size_str,
+            "item_page": f"{source.stem}_item.html",
+        })
+
+    log("Rendering HTML templates...")
+    render_gallery(out_dir, config, raw_records)
+    log("Build complete.")
+
+    log_path.write_text("\n".join(log_lines) + "\n", encoding="utf-8")
+
+    jsonl_path = meta_dir / "build.jsonl"
+    entry = {
+        "ts": now_rfc3339(),
+        "sources": len(sources),
+        "thumb_tasks": len(thumb_tasks),
+        "output_tasks": len(output_tasks),
+        "had_errors": had_errors,
+        "log": str(log_path),
+    }
+    with open(jsonl_path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(entry) + "\n")
+
+    return log_path, had_errors

simplegals/core/metadata.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .config import ProjectConfig, settings_hash as compute_settings_hash
+
+
+@dataclass
+class ThumbMeta:
+    path: str
+    generated_at: str
+
+
+@dataclass
+class OutputMeta:
+    path: str
+    thumb_path: str
+    generated_at: str
+
+
+@dataclass
+class ImageSidecar:
+    source: str
+    mtime: str
+    sha256: str
+    settings_hash: str
+    thumb: ThumbMeta | None = None
+    output: OutputMeta | None = None
+
+
+def sidecar_path(meta_dir: Path, source_name: str) -> Path:
+    return meta_dir / f"{source_name}.json"
+
+
+def load_sidecar(meta_dir: Path, source_name: str) -> ImageSidecar | None:
+    p = sidecar_path(meta_dir, source_name)
+    if not p.exists():
+        return None
+    data = json.loads(p.read_text(encoding="utf-8"))
+    thumb = ThumbMeta(**data["thumb"]) if data.get("thumb") else None
+    output = OutputMeta(**data["output"]) if data.get("output") else None
+    return ImageSidecar(
+        source=data["source"],
+        mtime=data["mtime"],
+        sha256=data["sha256"],
+        settings_hash=data["settings_hash"],
+        thumb=thumb,
+        output=output,
+    )
+
+
+def save_sidecar(meta_dir: Path, sidecar: ImageSidecar) -> None:
+    meta_dir.mkdir(parents=True, exist_ok=True)
+    p = sidecar_path(meta_dir, sidecar.source)
+    p.write_text(json.dumps(asdict(sidecar), indent=2), encoding="utf-8")
+
+
+def file_sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(65536), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def now_rfc3339() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _mtime_str(path: Path) -> str:
+    return datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc).isoformat()
+
+
+def check_staleness(
+    source: Path,
+    meta_dir: Path,
+    config: ProjectConfig,
+) -> tuple[bool, bool]:
+    """Return (thumb_needs_regen, output_needs_regen)."""
+    sidecar = load_sidecar(meta_dir, source.name)
+    if sidecar is None:
+        return True, True
+
+    current_s_hash = compute_settings_hash(config)
+    current_mtime = _mtime_str(source)
+
+    def _artifacts_exist() -> tuple[bool, bool]:
+        thumb_missing = sidecar.thumb is None or not Path(sidecar.thumb.path).exists()
+        output_missing = sidecar.output is None or not Path(sidecar.output.path).exists()
+        return thumb_missing, output_missing
+
+    if current_mtime == sidecar.mtime:
+        thumb_missing, output_missing = _artifacts_exist()
+        return thumb_missing, output_missing or current_s_hash != sidecar.settings_hash
+
+    current_sha = file_sha256(source)
+    if current_sha == sidecar.sha256:
+        # touched but unchanged — refresh stored mtime
+        sidecar.mtime = current_mtime
+        save_sidecar(meta_dir, sidecar)
+        thumb_missing, output_missing = _artifacts_exist()
+        return thumb_missing, output_missing or current_s_hash != sidecar.settings_hash
+
+    return True, True

simplegals/core/processor.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import piexif
+from PIL import Image
+
+from .config import ProjectConfig
+
+SGUI_THUMB_MAX: tuple[int, int] = (300, 300)
+HTML_THUMB_MAX: tuple[int, int] = (600, 450)
+
+
+def _thumb_name(source: Path) -> str:
+    return f"{source.stem}_thumb{source.suffix}"
+
+
+def generate_sgui_thumb(source: Path, meta_dir: Path) -> Path:
+    """Generate .meta/<stem>_thumb<ext> for sgui preview. Not subject to publishing settings."""
+    dest = meta_dir / _thumb_name(source)
+    with Image.open(source) as img:
+        img = img.copy()
+        img.thumbnail(SGUI_THUMB_MAX, Image.LANCZOS)
+        img.save(dest)
+    return dest
+
+
+def generate_output(
+    source: Path,
+    out_dir: Path,
+    config: ProjectConfig,
+) -> tuple[Path, Path]:
+    """Generate out/<filename>.<ext> and out/<stem>_thumb<ext>. Returns (output_path, thumb_path)."""
+    output_path = out_dir / source.name
+    thumb_path = out_dir / _thumb_name(source)
+
+    with Image.open(source) as img:
+        img = img.copy()
+
+        if config.copyright:
+            img = _inject_copyright(img, config.copyright, source)
+
+        save_kwargs: dict = {"quality": config.quality}
+        img.save(output_path, **_format_save_kwargs(source, save_kwargs))
+
+        img.thumbnail(HTML_THUMB_MAX, Image.LANCZOS)
+        img.save(thumb_path, **_format_save_kwargs(source, save_kwargs))
+
+    return output_path, thumb_path
+
+
+def _format_save_kwargs(source: Path, kwargs: dict) -> dict:
+    ext = source.suffix.lower()
+    if ext in (".jpg", ".jpeg"):
+        return kwargs
+    if ext == ".png":
+        # Pillow maps quality 0-100 → compress_level 0-9
+        compress = max(0, min(9, round((100 - kwargs.get("quality", 90)) / 11)))
+        return {"compress_level": compress}
+    return {}
+
+
+def _inject_copyright(img: Image.Image, copyright: str, source: Path) -> Image.Image:
+    ext = source.suffix.lower()
+    if ext not in (".jpg", ".jpeg"):
+        return img
+    try:
+        exif_bytes = img.info.get("exif", b"")
+        if exif_bytes:
+            exif_dict = piexif.load(exif_bytes)
+        else:
+            exif_dict = {"0th": {}, "Exif": {}, "GPS": {}, "1st": {}}
+        exif_dict["0th"][piexif.ImageIFD.Copyright] = copyright.encode("utf-8")
+        img.info["exif"] = piexif.dump(exif_dict)
+    except Exception:
+        pass
+    return img