schenesort 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

schenesort/cli.py

@@ -412,6 +412,85 @@ def index(
         typer.echo(f"With metadata: {stats.get('with_metadata', 0)}")
 
 
+@app.command()
+def thumbnail(
+    path: Annotated[Path, typer.Argument(help="Directory to generate thumbnails for")],
+    recursive: Annotated[
+        bool, typer.Option("--recursive", "-r", help="Process directories recursively")
+    ] = True,
+    force: Annotated[bool, typer.Option("--force", "-f", help="Regenerate all thumbnails")] = False,
+    clear: Annotated[
+        bool, typer.Option("--clear", help="Clear thumbnail cache before generating")
+    ] = False,
+) -> None:
+    """Generate thumbnails for gallery view."""
+    from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn
+
+    from schenesort.thumbnails import (
+        clear_cache,
+        generate_thumbnail,
+        get_cache_stats,
+        thumbnail_exists,
+    )
+
+    path = path.resolve()
+
+    if not path.exists():
+        typer.echo(f"Error: Path '{path}' does not exist.", err=True)
+        raise typer.Exit(1)
+
+    if not path.is_dir():
+        typer.echo(f"Error: Path '{path}' is not a directory.", err=True)
+        raise typer.Exit(1)
+
+    if clear:
+        cleared = clear_cache()
+        typer.echo(f"Cleared {cleared} cached thumbnail(s).")
+
+    pattern = "**/*" if recursive else "*"
+    image_files = [
+        f for f in path.glob(pattern) if f.is_file() and f.suffix.lower() in VALID_IMAGE_EXTENSIONS
+    ]
+
+    if not image_files:
+        typer.echo("No image files found.")
+        raise typer.Exit(0)
+
+    generated = 0
+    skipped = 0
+    failed = 0
+
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TextColumn("{task.completed}/{task.total}"),
+    ) as progress:
+        task = progress.add_task("Generating thumbnails", total=len(image_files))
+
+        for filepath in image_files:
+            if not force and thumbnail_exists(filepath):
+                skipped += 1
+                progress.advance(task)
+                continue
+
+            result = generate_thumbnail(filepath, force=force)
+            if result:
+                generated += 1
+            else:
+                failed += 1
+
+            progress.advance(task)
+
+    typer.echo(f"\nGenerated: {generated}, Skipped: {skipped}, Failed: {failed}")
+
+    # Show cache stats
+    stats = get_cache_stats()
+    typer.echo(f"\nCache: {stats['path']}")
+    typer.echo(f"Total thumbnails: {stats['count']}")
+    typer.echo(f"Cache size: {stats['size_mb']:.1f} MB")
+
+
 @app.command()
 def get(
     tag: Annotated[str | None, typer.Option("--tag", "-t", help="Filter by tag")] = None,
@@ -581,6 +660,48 @@ def browse(
     app_instance.run()
 
 
+@app.command()
+def gallery(
+    tag: Annotated[str | None, typer.Option("--tag", "-t", help="Filter by tag")] = None,
+    mood: Annotated[str | None, typer.Option("--mood", "-m", help="Filter by mood")] = None,
+    color: Annotated[str | None, typer.Option("--color", "-c", help="Filter by color")] = None,
+    style: Annotated[str | None, typer.Option("--style", "-s", help="Filter by style")] = None,
+    subject: Annotated[str | None, typer.Option("--subject", help="Filter by subject")] = None,
+    time: Annotated[str | None, typer.Option("--time", help="Filter by time of day")] = None,
+    screen: Annotated[
+        str | None, typer.Option("--screen", help="Filter by recommended screen (4K, 1440p, etc)")
+    ] = None,
+    min_width: Annotated[
+        int | None, typer.Option("--min-width", help="Minimum width in pixels")
+    ] = None,
+    min_height: Annotated[
+        int | None, typer.Option("--min-height", help="Minimum height in pixels")
+    ] = None,
+    search: Annotated[
+        str | None, typer.Option("--search", "-q", help="Search description, scene, style, subject")
+    ] = None,
+) -> None:
+    """Browse wallpapers in a thumbnail grid with filter sidebar."""
+    from schenesort.tui.grid_app import GridBrowser
+    from schenesort.tui.widgets.filter_panel import FilterValues
+
+    initial_filters = FilterValues(
+        search=search or "",
+        tag=tag or "",
+        mood=mood or "",
+        color=color or "",
+        style=style or "",
+        subject=subject or "",
+        time=time or "",
+        screen=screen or "",
+        min_width=min_width,
+        min_height=min_height,
+    )
+
+    app_instance = GridBrowser(initial_filters=initial_filters)
+    app_instance.run()
+
+
 @app.command()
 def config(
     create: Annotated[
@@ -1225,6 +1346,138 @@ def metadata_update_dimensions(
     typer.echo(f"\n{action} {updated_count} sidecar(s), skipped {skipped_count}.")
 
 
+@app.command()
+def collage(
+    output: Annotated[Path, typer.Argument(help="Output PNG file path")],
+    tag: Annotated[str | None, typer.Option("--tag", "-t", help="Filter by tag")] = None,
+    mood: Annotated[str | None, typer.Option("--mood", "-m", help="Filter by mood")] = None,
+    color: Annotated[str | None, typer.Option("--color", "-c", help="Filter by color")] = None,
+    style: Annotated[str | None, typer.Option("--style", "-s", help="Filter by style")] = None,
+    subject: Annotated[str | None, typer.Option("--subject", help="Filter by subject")] = None,
+    time: Annotated[str | None, typer.Option("--time", help="Filter by time of day")] = None,
+    screen: Annotated[
+        str | None, typer.Option("--screen", help="Filter by recommended screen (4K, 1440p, etc)")
+    ] = None,
+    min_width: Annotated[
+        int | None, typer.Option("--min-width", help="Minimum width in pixels")
+    ] = None,
+    min_height: Annotated[
+        int | None, typer.Option("--min-height", help="Minimum height in pixels")
+    ] = None,
+    search: Annotated[
+        str | None, typer.Option("--search", "-q", help="Search description, scene, style, subject")
+    ] = None,
+    cols: Annotated[int, typer.Option("--cols", help="Number of columns (1-4)")] = 2,
+    rows: Annotated[int, typer.Option("--rows", help="Number of rows (1-4)")] = 2,
+    tile_width: Annotated[
+        int, typer.Option("--tile-width", "-w", help="Width of each tile in pixels")
+    ] = 480,
+    tile_height: Annotated[
+        int, typer.Option("--tile-height", "-h", help="Height of each tile in pixels")
+    ] = 270,
+    random: Annotated[bool, typer.Option("--random", "-R", help="Select images randomly")] = True,
+) -> None:
+    """Create a collage of wallpapers matching the given criteria (max 4x4 grid)."""
+    from PIL import Image
+
+    from schenesort.db import WallpaperDB
+
+    # Validate grid size
+    if cols < 1 or cols > 4:
+        typer.echo("Error: --cols must be between 1 and 4.", err=True)
+        raise typer.Exit(1)
+    if rows < 1 or rows > 4:
+        typer.echo("Error: --rows must be between 1 and 4.", err=True)
+        raise typer.Exit(1)
+
+    num_images = cols * rows
+
+    with WallpaperDB() as db:
+        results = db.query(
+            tag=tag,
+            mood=mood,
+            color=color,
+            style=style,
+            subject=subject,
+            time_of_day=time,
+            screen=screen,
+            min_width=min_width,
+            min_height=min_height,
+            search=search,
+            limit=num_images,
+            random=random,
+        )
+
+        if not results:
+            typer.echo("No wallpapers found matching criteria.", err=True)
+            raise typer.Exit(1)
+
+        if len(results) < num_images:
+            typer.echo(
+                f"Warning: Only found {len(results)} image(s), "
+                f"need {num_images} for {cols}x{rows} grid."
+            )
+
+        # Create collage canvas
+        collage_width = cols * tile_width
+        collage_height = rows * tile_height
+        collage_img = Image.new("RGB", (collage_width, collage_height), color=(0, 0, 0))
+
+        typer.echo(f"Creating {cols}x{rows} collage ({collage_width}x{collage_height})...")
+
+        for idx, r in enumerate(results):
+            if idx >= num_images:
+                break
+
+            filepath = Path(r["path"])
+            row = idx // cols
+            col = idx % cols
+
+            try:
+                with Image.open(filepath) as img:
+                    # Convert to RGB if necessary (handles RGBA, palette, etc.)
+                    if img.mode != "RGB":
+                        img = img.convert("RGB")
+
+                    # Resize to fit tile while preserving aspect ratio, then crop to fill
+                    img_ratio = img.width / img.height
+                    tile_ratio = tile_width / tile_height
+
+                    if img_ratio > tile_ratio:
+                        # Image is wider - fit by height, crop width
+                        new_height = tile_height
+                        new_width = int(tile_height * img_ratio)
+                    else:
+                        # Image is taller - fit by width, crop height
+                        new_width = tile_width
+                        new_height = int(tile_width / img_ratio)
+
+                    img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+                    # Center crop to tile size
+                    left = (new_width - tile_width) // 2
+                    top = (new_height - tile_height) // 2
+                    img = img.crop((left, top, left + tile_width, top + tile_height))
+
+                    # Paste into collage
+                    x = col * tile_width
+                    y = row * tile_height
+                    collage_img.paste(img, (x, y))
+
+                    typer.echo(f"  [{row},{col}] {filepath.name}")
+
+            except Exception as e:
+                typer.echo(f"  [{row},{col}] Failed to load {filepath.name}: {e}", err=True)
+
+        # Save collage
+        output = output.resolve()
+        if not output.suffix.lower() == ".png":
+            output = output.with_suffix(".png")
+
+        collage_img.save(output, "PNG")
+        typer.echo(f"\nSaved collage to: {output}")
+
+
 @metadata_app.command("embed")
 def metadata_embed(
     path: Annotated[Path, typer.Argument(help="Image file or directory")],

schenesort/thumbnails.py

@@ -0,0 +1,127 @@
+"""Thumbnail cache management for gallery view."""
+
+import hashlib
+import os
+from pathlib import Path
+
+from PIL import Image
+
+APP_NAME = "schenesort"
+
+# Thumbnail dimensions - larger for better quality when rendered in terminal
+# Terminal cells are ~32x14 chars, but textual-image benefits from more source pixels
+THUMBNAIL_WIDTH = 320
+THUMBNAIL_HEIGHT = 200
+
+
+def get_cache_dir() -> Path:
+    """Get the XDG cache directory for schenesort thumbnails."""
+    xdg_cache = os.environ.get("XDG_CACHE_HOME", "")
+    if xdg_cache:
+        cache_dir = Path(xdg_cache) / APP_NAME / "thumbnails"
+    else:
+        cache_dir = Path.home() / ".cache" / APP_NAME / "thumbnails"
+    return cache_dir
+
+
+def get_thumbnail_path(image_path: Path) -> Path:
+    """Get the thumbnail path for an image.
+
+    Uses MD5 hash of the absolute path to create a unique filename.
+    """
+    # Use absolute path for consistent hashing
+    abs_path = str(image_path.resolve())
+    path_hash = hashlib.md5(abs_path.encode()).hexdigest()
+    return get_cache_dir() / f"{path_hash}.jpg"
+
+
+def thumbnail_exists(image_path: Path) -> bool:
+    """Check if a thumbnail exists for the given image."""
+    thumb_path = get_thumbnail_path(image_path)
+    if not thumb_path.exists():
+        return False
+
+    # Check if thumbnail is newer than original
+    try:
+        orig_mtime = image_path.stat().st_mtime
+        thumb_mtime = thumb_path.stat().st_mtime
+        return thumb_mtime >= orig_mtime
+    except OSError:
+        return False
+
+
+def generate_thumbnail(image_path: Path, force: bool = False) -> Path | None:
+    """Generate a thumbnail for the given image.
+
+    Args:
+        image_path: Path to the original image
+        force: If True, regenerate even if thumbnail exists
+
+    Returns:
+        Path to the thumbnail, or None if generation failed
+    """
+    if not force and thumbnail_exists(image_path):
+        return get_thumbnail_path(image_path)
+
+    thumb_path = get_thumbnail_path(image_path)
+
+    try:
+        # Ensure cache directory exists
+        thumb_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with Image.open(image_path) as img:
+            # Convert to RGB if necessary (handles RGBA, palette, etc.)
+            if img.mode not in ("RGB", "L"):
+                img = img.convert("RGB")
+
+            # Calculate size preserving aspect ratio
+            img.thumbnail((THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT), Image.Resampling.LANCZOS)
+
+            # Save as JPEG with high quality for better terminal rendering
+            img.save(thumb_path, "JPEG", quality=95, optimize=True)
+
+        return thumb_path
+
+    except Exception:
+        # Clean up partial file if it exists
+        if thumb_path.exists():
+            thumb_path.unlink()
+        return None
+
+
+def clear_cache() -> int:
+    """Clear all cached thumbnails.
+
+    Returns:
+        Number of thumbnails deleted
+    """
+    cache_dir = get_cache_dir()
+    if not cache_dir.exists():
+        return 0
+
+    count = 0
+    for thumb in cache_dir.glob("*.jpg"):
+        try:
+            thumb.unlink()
+            count += 1
+        except OSError:
+            pass
+
+    return count
+
+
+def get_cache_stats() -> dict:
+    """Get statistics about the thumbnail cache."""
+    cache_dir = get_cache_dir()
+    if not cache_dir.exists():
+        return {"count": 0, "size_bytes": 0, "path": str(cache_dir)}
+
+    thumbnails = list(cache_dir.glob("*.jpg"))
+    total_size = sum(t.stat().st_size for t in thumbnails)
+
+    return {
+        "count": len(thumbnails),
+        "size_bytes": total_size,
+        "size_mb": total_size / (1024 * 1024),
+        "path": str(cache_dir),
+    }

schenesort/tui/__init__.py

@@ -1,5 +1,15 @@
 """Schenesort TUI - Terminal UI for browsing wallpapers."""
 
 from schenesort.tui.app import WallpaperBrowser
+from schenesort.tui.grid_app import GridBrowser
+from schenesort.tui.widgets.filter_panel import FilterPanel, FilterValues
+from schenesort.tui.widgets.thumbnail_grid import ThumbnailGrid, ThumbnailText
 
-__all__ = ["WallpaperBrowser"]
+__all__ = [
+    "FilterPanel",
+    "FilterValues",
+    "GridBrowser",
+    "ThumbnailGrid",
+    "ThumbnailText",
+    "WallpaperBrowser",
+]