schenesort 2.3.0__py3-none-any.whl → 2.4.1__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[
@@ -1246,8 +1367,8 @@ def collage(
     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,
+    cols: Annotated[int, typer.Option("--cols", help="Number of columns")] = 6,
+    rows: Annotated[int, typer.Option("--rows", help="Number of rows")] = 6,
     tile_width: Annotated[
         int, typer.Option("--tile-width", "-w", help="Width of each tile in pixels")
     ] = 480,
@@ -1256,17 +1377,17 @@ def collage(
     ] = 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)."""
+    """Create a collage of wallpapers matching the given criteria."""
     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)
+    if cols < 1:
+        typer.echo("Error: --cols must be at least 1.", err=True)
         raise typer.Exit(1)
-    if rows < 1 or rows > 4:
-        typer.echo("Error: --rows must be between 1 and 4.", err=True)
+    if rows < 1:
+        typer.echo("Error: --rows must be at least 1.", err=True)
         raise typer.Exit(1)
 
     num_images = cols * rows

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",
+]

schenesort/tui/grid_app.py

@@ -0,0 +1,302 @@
+"""Gallery Grid Browser TUI application."""
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal
+from textual.screen import Screen
+from textual.widgets import Footer, Header, Static
+
+from schenesort.db import WallpaperDB
+from schenesort.tui.widgets.filter_panel import FilterPanel, FilterValues
+from schenesort.tui.widgets.image_preview import ImagePreview
+from schenesort.tui.widgets.metadata_panel import MetadataPanel
+from schenesort.tui.widgets.thumbnail_grid import ThumbnailGrid
+from schenesort.xmp import read_xmp
+
+
+class DetailScreen(Screen):
+    """Screen for viewing a single image with metadata."""
+
+    BINDINGS = [
+        Binding("escape", "pop_screen", "Back", show=True),
+        Binding("q", "pop_screen", "Back", show=False),
+        Binding("j", "next_image", "Next", show=True),
+        Binding("k", "prev_image", "Previous", show=True),
+        Binding("down", "next_image", "Next", show=False),
+        Binding("up", "prev_image", "Previous", show=False),
+    ]
+
+    CSS = """
+    DetailScreen {
+        layout: vertical;
+    }
+
+    DetailScreen #detail-container {
+        width: 100%;
+        height: 1fr;
+    }
+
+    DetailScreen #image-panel {
+        width: 60%;
+        height: 100%;
+        border: solid $primary;
+    }
+
+    DetailScreen #metadata-panel {
+        width: 40%;
+        height: 100%;
+        border: solid $secondary;
+    }
+
+    DetailScreen #detail-status {
+        dock: bottom;
+        height: 1;
+        background: $surface;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(self, images: list[Path], start_index: int = 0, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._images = images
+        self._current_index = start_index
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal(id="detail-container"):
+            yield ImagePreview(id="image-panel")
+            yield MetadataPanel(id="metadata-panel")
+        yield Static("", id="detail-status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Show the initial image."""
+        self._show_current_image()
+
+    def _show_current_image(self) -> None:
+        """Display the current image and metadata."""
+        if not self._images or not (0 <= self._current_index < len(self._images)):
+            return
+
+        current = self._images[self._current_index]
+
+        # Update image
+        preview = self.query_one("#image-panel", ImagePreview)
+        preview.load_image(current)
+
+        # Update metadata
+        metadata = read_xmp(current)
+        panel = self.query_one("#metadata-panel", MetadataPanel)
+        panel.update_metadata(metadata, current.name)
+
+        # Update status
+        status = self.query_one("#detail-status", Static)
+        status.update(f"{current.name}  [{self._current_index + 1}/{len(self._images)}]")
+
+    def action_next_image(self) -> None:
+        """Show next image."""
+        if self._current_index < len(self._images) - 1:
+            self._current_index += 1
+            self._show_current_image()
+
+    def action_prev_image(self) -> None:
+        """Show previous image."""
+        if self._current_index > 0:
+            self._current_index -= 1
+            self._show_current_image()
+
+    def action_pop_screen(self) -> None:
+        """Return to the grid view."""
+        self.app.pop_screen()
+
+
+class GridBrowser(App):
+    """A TUI application for browsing wallpapers in a thumbnail grid with filters."""
+
+    TITLE = "Schenesort - Gallery"
+
+    CSS = """
+    Screen {
+        layout: vertical;
+    }
+
+    #main-container {
+        width: 100%;
+        height: 1fr;
+    }
+
+    #filter-panel {
+        width: 22;
+        height: 100%;
+        border: solid $secondary;
+    }
+
+    #grid-panel {
+        width: 1fr;
+        height: 100%;
+        border: solid $primary;
+    }
+
+    #status-bar {
+        dock: bottom;
+        height: 1;
+        background: $surface;
+        color: $text;
+        padding: 0 1;
+    }
+
+    #status-left {
+        width: 1fr;
+    }
+
+    #status-right {
+        width: auto;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=True),
+        Binding("ctrl+c", "quit", "Quit", show=False, priority=True),
+        Binding("ctrl+q", "quit", "Quit", show=False, priority=True),
+        Binding("tab", "focus_next_panel", "Switch Panel", show=True),
+        Binding("shift+tab", "focus_prev_panel", "Switch Panel", show=False),
+        Binding("enter", "open_detail", "Open", show=True),
+        Binding("escape", "clear_filters", "Clear Filters", show=True),
+        Binding("r", "refresh", "Refresh", show=True),
+    ]
+
+    def __init__(self, initial_filters: FilterValues | None = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._initial_filters = initial_filters or FilterValues()
+        self._images: list[Path] = []
+        self._db_path: Path | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal(id="main-container"):
+            yield FilterPanel(initial_filters=self._initial_filters, id="filter-panel")
+            yield ThumbnailGrid(id="grid-panel")
+        with Horizontal(id="status-bar"):
+            yield Static("Loading...", id="status-left")
+            yield Static("", id="status-right")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Initialize the browser when mounted."""
+        # Set initial focus to the grid
+        self.query_one("#grid-panel", ThumbnailGrid).focus()
+        # Load initial data
+        self._query_database(self._initial_filters)
+
+    def _query_database(self, filters: FilterValues) -> None:
+        """Query the database with the given filters."""
+        try:
+            with WallpaperDB() as db:
+                self._db_path = db.db_path
+                results = db.query(
+                    search=filters.search or None,
+                    tag=filters.tag or None,
+                    mood=filters.mood or None,
+                    color=filters.color or None,
+                    style=filters.style or None,
+                    subject=filters.subject or None,
+                    time_of_day=filters.time or None,
+                    screen=filters.screen or None,
+                    min_width=filters.min_width,
+                    min_height=filters.min_height,
+                )
+
+            # Extract paths and filter for existing files
+            self._images = [Path(r["path"]) for r in results if Path(r["path"]).exists()]
+
+            # Update grid
+            grid = self.query_one("#grid-panel", ThumbnailGrid)
+            grid.set_images(self._images)
+
+            # Update status
+            self._update_status()
+
+        except Exception as e:
+            self._update_status(error=str(e))
+
+    def _update_status(self, error: str | None = None) -> None:
+        """Update the status bar."""
+        left_status = self.query_one("#status-left", Static)
+        right_status = self.query_one("#status-right", Static)
+
+        if error:
+            left_status.update(f"[red]Error: {error}[/red]")
+            right_status.update("")
+        else:
+            count = len(self._images)
+            if count == 0:
+                left_status.update("[dim]No images matching filters[/dim]")
+            else:
+                left_status.update(f"{count} image{'s' if count != 1 else ''} matching")
+
+            grid = self.query_one("#grid-panel", ThumbnailGrid)
+            if grid.image_count > 0:
+                right_status.update(f"{grid.selected_index + 1}/{grid.image_count}")
+            else:
+                right_status.update("")
+
+    def on_filter_panel_filters_changed(self, event: FilterPanel.FiltersChanged) -> None:
+        """Handle filter changes from the filter panel."""
+        self._query_database(event.filters)
+
+    def on_thumbnail_grid_selection_changed(
+        self,
+        event: ThumbnailGrid.SelectionChanged,  # noqa: ARG002
+    ) -> None:
+        """Handle selection changes in the grid."""
+        self._update_status()
+
+    def on_thumbnail_grid_image_selected(self, event: ThumbnailGrid.ImageSelected) -> None:
+        """Handle image selection (Enter pressed) - open detail view."""
+        self._open_detail_view(event.index)
+
+    def _open_detail_view(self, start_index: int = 0) -> None:
+        """Open the detail view with the current image list."""
+        if not self._images:
+            return
+
+        # Push detail screen onto the stack
+        self.push_screen(DetailScreen(self._images, start_index))
+
+    def action_focus_next_panel(self) -> None:
+        """Switch focus to the next panel."""
+        current = self.focused
+        filter_panel = self.query_one("#filter-panel", FilterPanel)
+        grid_panel = self.query_one("#grid-panel", ThumbnailGrid)
+
+        # Check if focus is in the filter panel area
+        if current is not None and filter_panel in current.ancestors_with_self:
+            grid_panel.focus()
+        else:
+            # Focus the first input in the filter panel
+            try:
+                first_input = filter_panel.query("Input").first()
+                first_input.focus()
+            except Exception:
+                filter_panel.focus()
+
+    def action_focus_prev_panel(self) -> None:
+        """Switch focus to the previous panel (reverse of next)."""
+        self.action_focus_next_panel()
+
+    def action_open_detail(self) -> None:
+        """Open detail view for the selected image."""
+        grid = self.query_one("#grid-panel", ThumbnailGrid)
+        self._open_detail_view(grid.selected_index)
+
+    def action_clear_filters(self) -> None:
+        """Clear all filters."""
+        filter_panel = self.query_one("#filter-panel", FilterPanel)
+        filter_panel.clear_filters()
+
+    def action_refresh(self) -> None:
+        """Refresh the grid with current filters."""
+        filter_panel = self.query_one("#filter-panel", FilterPanel)
+        self._query_database(filter_panel.filters)

schenesort/tui/widgets/filter_panel.py

@@ -0,0 +1,249 @@
+"""Filter panel widget for gallery grid view."""
+
+from dataclasses import dataclass
+
+from textual.app import ComposeResult
+from textual.containers import VerticalScroll
+from textual.message import Message
+from textual.widgets import Input, Label, Static
+
+
+@dataclass
+class FilterValues:
+    """Container for all filter values."""
+
+    search: str = ""
+    tag: str = ""
+    mood: str = ""
+    color: str = ""
+    style: str = ""
+    subject: str = ""
+    time: str = ""
+    screen: str = ""
+    min_width: int | None = None
+    min_height: int | None = None
+
+    def is_empty(self) -> bool:
+        """Check if all filters are empty."""
+        return (
+            not self.search
+            and not self.tag
+            and not self.mood
+            and not self.color
+            and not self.style
+            and not self.subject
+            and not self.time
+            and not self.screen
+            and self.min_width is None
+            and self.min_height is None
+        )
+
+
+class FilterPanel(VerticalScroll):
+    """Sidebar panel with filter inputs for gallery view."""
+
+    class FiltersChanged(Message):
+        """Emitted when any filter value changes."""
+
+        def __init__(self, filters: FilterValues) -> None:
+            self.filters = filters
+            super().__init__()
+
+    DEFAULT_CSS = """
+    FilterPanel {
+        width: 100%;
+        height: 100%;
+        background: $surface;
+        padding: 1;
+    }
+
+    FilterPanel .filter-title {
+        text-style: bold;
+        color: $text;
+        margin-bottom: 1;
+        text-align: center;
+    }
+
+    FilterPanel .filter-label {
+        color: $text-muted;
+        margin-top: 1;
+    }
+
+    FilterPanel Input {
+        margin-bottom: 0;
+    }
+
+    FilterPanel Input:focus {
+        border: tall $accent;
+    }
+
+    FilterPanel .filter-section {
+        margin-top: 1;
+    }
+
+    FilterPanel .filter-hint {
+        color: $text-disabled;
+        text-style: italic;
+        margin-top: 1;
+    }
+    """
+
+    def __init__(self, initial_filters: FilterValues | None = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._filters = initial_filters or FilterValues()
+        self._pending_change: int = 0
+
+    def compose(self) -> ComposeResult:
+        yield Static("Filters", classes="filter-title")
+
+        yield Label("Search", classes="filter-label")
+        yield Input(
+            value=self._filters.search,
+            placeholder="description, scene...",
+            id="filter-search",
+        )
+
+        yield Label("Tag", classes="filter-label")
+        yield Input(
+            value=self._filters.tag,
+            placeholder="e.g. nature",
+            id="filter-tag",
+        )
+
+        yield Label("Mood", classes="filter-label")
+        yield Input(
+            value=self._filters.mood,
+            placeholder="e.g. peaceful",
+            id="filter-mood",
+        )
+
+        yield Label("Color", classes="filter-label")
+        yield Input(
+            value=self._filters.color,
+            placeholder="e.g. blue",
+            id="filter-color",
+        )
+
+        yield Label("Style", classes="filter-label")
+        yield Input(
+            value=self._filters.style,
+            placeholder="e.g. photography",
+            id="filter-style",
+        )
+
+        yield Label("Subject", classes="filter-label")
+        yield Input(
+            value=self._filters.subject,
+            placeholder="e.g. landscape",
+            id="filter-subject",
+        )
+
+        yield Label("Time", classes="filter-label")
+        yield Input(
+            value=self._filters.time,
+            placeholder="e.g. sunset",
+            id="filter-time",
+        )
+
+        yield Label("Screen", classes="filter-label")
+        yield Input(
+            value=self._filters.screen,
+            placeholder="e.g. 4K, 1440p",
+            id="filter-screen",
+        )
+
+        yield Label("Min Width", classes="filter-label")
+        yield Input(
+            value=str(self._filters.min_width) if self._filters.min_width else "",
+            placeholder="pixels",
+            id="filter-min-width",
+        )
+
+        yield Label("Min Height", classes="filter-label")
+        yield Input(
+            value=str(self._filters.min_height) if self._filters.min_height else "",
+            placeholder="pixels",
+            id="filter-min-height",
+        )
+
+        yield Static("Press Tab to switch to grid", classes="filter-hint")
+
+    def on_input_changed(self, event: Input.Changed) -> None:  # noqa: ARG002
+        """Handle input changes with debouncing."""
+        # Increment counter to track which change this is
+        self._pending_change += 1
+        current_change = self._pending_change
+
+        # Schedule the filter update with a small delay
+        self.set_timer(0.3, lambda: self._emit_filter_change(current_change))
+
+    def _emit_filter_change(self, change_id: int) -> None:
+        """Gather all filter values and emit the change message."""
+        # Only process if this is the most recent change
+        if change_id != self._pending_change:
+            return
+
+        # Read all input values
+        search = self.query_one("#filter-search", Input).value.strip()
+        tag = self.query_one("#filter-tag", Input).value.strip()
+        mood = self.query_one("#filter-mood", Input).value.strip()
+        color = self.query_one("#filter-color", Input).value.strip()
+        style = self.query_one("#filter-style", Input).value.strip()
+        subject = self.query_one("#filter-subject", Input).value.strip()
+        time = self.query_one("#filter-time", Input).value.strip()
+        screen = self.query_one("#filter-screen", Input).value.strip()
+
+        # Parse numeric values
+        min_width_str = self.query_one("#filter-min-width", Input).value.strip()
+        min_height_str = self.query_one("#filter-min-height", Input).value.strip()
+
+        min_width = None
+        min_height = None
+        try:
+            if min_width_str:
+                min_width = int(min_width_str)
+        except ValueError:
+            pass
+        try:
+            if min_height_str:
+                min_height = int(min_height_str)
+        except ValueError:
+            pass
+
+        self._filters = FilterValues(
+            search=search,
+            tag=tag,
+            mood=mood,
+            color=color,
+            style=style,
+            subject=subject,
+            time=time,
+            screen=screen,
+            min_width=min_width,
+            min_height=min_height,
+        )
+
+        self.post_message(self.FiltersChanged(self._filters))
+
+    @property
+    def filters(self) -> FilterValues:
+        """Get the current filter values."""
+        return self._filters
+
+    def clear_filters(self) -> None:
+        """Clear all filter inputs."""
+        for input_id in [
+            "#filter-search",
+            "#filter-tag",
+            "#filter-mood",
+            "#filter-color",
+            "#filter-style",
+            "#filter-subject",
+            "#filter-time",
+            "#filter-screen",
+            "#filter-min-width",
+            "#filter-min-height",
+        ]:
+            self.query_one(input_id, Input).value = ""
+        self._filters = FilterValues()
+        self.post_message(self.FiltersChanged(self._filters))

schenesort/tui/widgets/thumbnail_grid.py

@@ -0,0 +1,291 @@
+"""Thumbnail grid widget for gallery view."""
+
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, VerticalScroll
+from textual.message import Message
+from textual.widgets import Static
+from textual_image.widget import Image
+
+from schenesort.thumbnails import get_thumbnail_path, thumbnail_exists
+
+
+class ThumbnailText(Static):
+    """Text fallback for when no thumbnail exists."""
+
+    DEFAULT_CSS = """
+    ThumbnailText {
+        width: 32;
+        height: 14;
+        content-align: center middle;
+        text-align: center;
+        color: $text-muted;
+        background: $surface;
+    }
+
+    ThumbnailText.selected {
+        border: solid $primary;
+    }
+    """
+
+    def __init__(self, image_path: Path, index: int, **kwargs) -> None:
+        name = image_path.stem
+        if len(name) > 28:
+            name = name[:25] + "..."
+        super().__init__(name, **kwargs)
+        self.image_path = image_path
+        self.index = index
+
+
+# Type alias for cell widgets
+CellWidget = Image | ThumbnailText
+
+
+def create_thumbnail_cell(image_path: Path, index: int) -> CellWidget:
+    """Create a cell widget for the given image using its thumbnail."""
+    if thumbnail_exists(image_path):
+        thumb_path = get_thumbnail_path(image_path)
+        img = Image(thumb_path)
+        # Store metadata on the widget
+        img.image_path = image_path  # type: ignore[attr-defined]
+        img.index = index  # type: ignore[attr-defined]
+        return img
+    return ThumbnailText(image_path, index)
+
+
+class ThumbnailGrid(VerticalScroll, can_focus=True):
+    """Scrollable grid of image thumbnails with keyboard navigation."""
+
+    BINDINGS = [
+        Binding("up", "move_up", "Up", show=False),
+        Binding("down", "move_down", "Down", show=False),
+        Binding("left", "move_left", "Left", show=False),
+        Binding("right", "move_right", "Right", show=False),
+        Binding("k", "move_up", "Up", show=False),
+        Binding("j", "move_down", "Down", show=False),
+        Binding("h", "move_left", "Left", show=False),
+        Binding("l", "move_right", "Right", show=False),
+        Binding("enter", "select", "Select", show=False),
+        Binding("home", "first", "First", show=False),
+        Binding("end", "last", "Last", show=False),
+        Binding("g", "first", "First", show=False),
+        Binding("G", "last", "Last", show=False, key_display="shift+g"),
+    ]
+
+    class ImageSelected(Message):
+        """Emitted when an image is selected (Enter pressed)."""
+
+        def __init__(self, image_path: Path, index: int) -> None:
+            self.image_path = image_path
+            self.index = index
+            super().__init__()
+
+    class SelectionChanged(Message):
+        """Emitted when the selection changes."""
+
+        def __init__(self, image_path: Path, index: int) -> None:
+            self.image_path = image_path
+            self.index = index
+            super().__init__()
+
+    DEFAULT_CSS = """
+    ThumbnailGrid {
+        width: 100%;
+        height: 100%;
+        background: $background;
+    }
+
+    ThumbnailGrid:focus {
+        border: solid $accent;
+    }
+
+    ThumbnailGrid #grid-container {
+        layout: grid;
+        grid-gutter: 0;
+        width: 100%;
+    }
+
+    ThumbnailGrid #grid-container Image {
+        width: 32;
+        height: 14;
+        margin: 0;
+        padding: 0;
+        border: solid $background;
+    }
+
+    ThumbnailGrid #grid-container Image.selected {
+        border: solid $primary;
+    }
+
+    ThumbnailGrid .empty-message {
+        color: $text-disabled;
+        text-style: italic;
+        text-align: center;
+        width: 100%;
+        padding: 4;
+    }
+    """
+
+    CELL_WIDTH = 32
+    CELL_HEIGHT = 14
+
+    def __init__(self, images: list[Path] | None = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._images: list[Path] = images or []
+        self._selected_index: int = 0
+        self._columns: int = 1
+        self._cells: list[CellWidget] = []
+        self._grid_container: Container | None = None
+
+    def compose(self) -> ComposeResult:
+        self._grid_container = Container(id="grid-container")
+        yield self._grid_container
+
+    def on_mount(self) -> None:
+        """Initialize the grid on mount."""
+        # Defer initial build to after layout
+        self.call_after_refresh(self._initial_build)
+
+    def _initial_build(self) -> None:
+        """Build grid after initial layout."""
+        self._calculate_columns()
+        self._rebuild_grid()
+
+    def on_resize(self) -> None:
+        """Recalculate columns when resized."""
+        old_columns = self._columns
+        self._calculate_columns()
+        if old_columns != self._columns:
+            self._rebuild_grid()
+
+    def _calculate_columns(self) -> None:
+        """Calculate number of columns based on container width."""
+        available_width = max(self.size.width - 2, self.CELL_WIDTH)
+        self._columns = max(1, available_width // self.CELL_WIDTH)
+
+    def _rebuild_grid(self) -> None:
+        """Rebuild the grid with current images and column count."""
+        if self._grid_container is None:
+            return
+
+        container = self._grid_container
+
+        # Clear all children from container
+        container.remove_children()
+        self._cells.clear()
+
+        if not self._images:
+            container.mount(Static("No images to display", classes="empty-message"))
+            return
+
+        # Update grid columns CSS
+        container.styles.grid_size_columns = self._columns
+
+        # Calculate and set container height based on rows
+        # (textual-image needs explicit height, not height: auto, to render in scroll containers)
+        num_rows = (len(self._images) + self._columns - 1) // self._columns
+        container_height = num_rows * self.CELL_HEIGHT
+        container.styles.height = container_height
+
+        # Create cells
+        for idx, image_path in enumerate(self._images):
+            cell = create_thumbnail_cell(image_path, idx)
+            self._cells.append(cell)
+            container.mount(cell)
+
+        # Update selection
+        self._update_selection()
+
+    def set_images(self, images: list[Path]) -> None:
+        """Update the images displayed in the grid."""
+        self._images = images
+        self._selected_index = 0 if images else -1
+        self._calculate_columns()
+        self._rebuild_grid()
+
+    def _update_selection(self) -> None:
+        """Update the visual selection state."""
+        for idx, cell in enumerate(self._cells):
+            if idx == self._selected_index:
+                cell.add_class("selected")
+            else:
+                cell.remove_class("selected")
+
+        # Scroll selected cell into view
+        if 0 <= self._selected_index < len(self._cells):
+            self._cells[self._selected_index].scroll_visible()
+
+    def _move_selection(self, delta: int) -> None:
+        """Move selection by delta amount."""
+        if not self._images:
+            return
+
+        new_index = self._selected_index + delta
+        new_index = max(0, min(len(self._images) - 1, new_index))
+
+        if new_index != self._selected_index:
+            self._selected_index = new_index
+            self._update_selection()
+            self.post_message(
+                self.SelectionChanged(self._images[self._selected_index], self._selected_index)
+            )
+
+    def action_move_up(self) -> None:
+        """Move selection up by one row."""
+        self._move_selection(-self._columns)
+
+    def action_move_down(self) -> None:
+        """Move selection down by one row."""
+        self._move_selection(self._columns)
+
+    def action_move_left(self) -> None:
+        """Move selection left by one cell."""
+        self._move_selection(-1)
+
+    def action_move_right(self) -> None:
+        """Move selection right by one cell."""
+        self._move_selection(1)
+
+    def action_first(self) -> None:
+        """Move selection to first image."""
+        if self._images:
+            self._selected_index = 0
+            self._update_selection()
+            self.post_message(
+                self.SelectionChanged(self._images[self._selected_index], self._selected_index)
+            )
+
+    def action_last(self) -> None:
+        """Move selection to last image."""
+        if self._images:
+            self._selected_index = len(self._images) - 1
+            self._update_selection()
+            self.post_message(
+                self.SelectionChanged(self._images[self._selected_index], self._selected_index)
+            )
+
+    def action_select(self) -> None:
+        """Select the current image (open in detail view)."""
+        if 0 <= self._selected_index < len(self._images):
+            self.post_message(
+                self.ImageSelected(self._images[self._selected_index], self._selected_index)
+            )
+
+    @property
+    def selected_image(self) -> Path | None:
+        """Get the currently selected image path."""
+        if 0 <= self._selected_index < len(self._images):
+            return self._images[self._selected_index]
+        return None
+
+    @property
+    def selected_index(self) -> int:
+        """Get the currently selected index."""
+        return self._selected_index
+
+    @property
+    def image_count(self) -> int:
+        """Get the number of images in the grid."""
+        return len(self._images)

{schenesort-2.3.0.dist-info → schenesort-2.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schenesort
-Version: 2.3.0
+Version: 2.4.1
 Summary: Wallpaper collection management CLI tool
 License-File: LICENSE
 Requires-Python: >=3.13
@@ -12,12 +12,14 @@ Requires-Dist: textual>=0.95.0
 Requires-Dist: typer>=0.21.1
 Description-Content-Type: text/markdown
 
-# Schenesort v2.3.0
+# Schenesort v2.4.1
 
-A CLI tool for managing wallpaper collections with model generated metadata, terminal UI browsing, and SQLite-based
-querying.
+![Collage example](docs/collage.png)
+
+A cli tool for managing wallpaper collections with model generated metadata, sweet tui, and sql metadata querying.
+
+schenesort takes a directory of random wallpapers, with random filenames, and uses olama with a decent vision model to:
 
-schenesort takes a directory of random wallpapers, with random filenames, and uses olama with a decent vision model to
 - look at each wallpaper
 - rename the wallpaper to something sensible
 - drop a XMP sidecar with metadata about the file
@@ -51,12 +53,18 @@ setup](./ollama-setup.md).
 # Generate metadata for images
 schenesort metadata generate ~/wallpapers -r
 
-# Browse with TUI
-schenesort browse ~/wallpapers
-
 # Index the collection
 schenesort index ~/wallpapers
 
+# Generate thumbnails for gallery
+schenesort thumbnail ~/wallpapers -r
+
+# Browse with gallery (thumbnail grid with filters)
+schenesort gallery
+
+# Browse single images with TUI
+schenesort browse ~/wallpapers
+
 # Query wallpapers
 schenesort get --mood peaceful --screen 4K
 schenesort get -1 -p | xargs feh  # random wallpaper
@@ -67,6 +75,8 @@ schenesort get -1 -p | xargs feh  # random wallpaper
 | Command                      | Description                                         |
 |------------------------------|-----------------------------------------------------|
 | `browse`                     | Terminal UI browser with image preview and metadata |
+| `gallery`                    | Thumbnail grid browser with filters                 |
+| `thumbnail`                  | Generate thumbnail cache for gallery                |
 | `index`                      | Build SQLite index for fast querying                |
 | `get`                        | Query wallpapers by metadata attributes             |
 | `stats`                      | Show collection statistics from index               |
@@ -100,6 +110,7 @@ schenesort get --mood peaceful -b  # browse query results
 ![Browse example - Stallman](docs/browse-stallman.png)
 
 **Keyboard shortcuts:**
+
 | Key          | Action         |
 |--------------|----------------|
 | `j` / `Down` | Next image     |
@@ -111,6 +122,65 @@ schenesort get --mood peaceful -b  # browse query results
 
 The TUI uses textual-image for rendering, which auto-detects terminal graphics support (Sixel, iTerm2, Kitty).
 
+## Gallery Browser
+
+![Gallery example](docs/gallery.png)
+
+Browse your indexed collection with a thumbnail grid and filter panel:
+
+```bash
+# Open gallery browser
+schenesort gallery
+
+# Pre-filter results
+schenesort gallery --mood peaceful
+schenesort gallery --tag nature --style photography
+```
+
+The gallery requires an indexed collection (`schenesort index`) and cached thumbnails for fast loading.
+
+### Generate Thumbnails
+
+```bash
+# Generate thumbnails for a directory
+schenesort thumbnail ~/wallpapers
+
+# Recursive with progress bar
+schenesort thumbnail ~/wallpapers -r
+
+# Force regenerate all thumbnails
+schenesort thumbnail ~/wallpapers --force
+
+# Clear thumbnail cache
+schenesort thumbnail ~/wallpapers --clear
+```
+
+Thumbnails are cached at `~/.cache/schenesort/thumbnails/` (320x200 JPEG).
+
+**Gallery keyboard shortcuts:**
+
+| Key              | Action                |
+|------------------|-----------------------|
+| `j` / `Down`     | Move down             |
+| `k` / `Up`       | Move up               |
+| `h` / `Left`     | Move left             |
+| `l` / `Right`    | Move right            |
+| `g` / `Home`     | First image           |
+| `G` / `End`      | Last image            |
+| `Enter`          | Open detail view      |
+| `Tab`            | Switch panel          |
+| `Escape`         | Clear filters         |
+| `r`              | Refresh               |
+| `q` / `Ctrl+C`   | Quit                  |
+
+**Detail view shortcuts:**
+
+| Key              | Action                |
+|------------------|-----------------------|
+| `j` / `Down`     | Next image            |
+| `k` / `Up`       | Previous image        |
+| `Escape` / `q`   | Back to grid          |
+
 ## Collection Indexing and Querying
 
 Build a SQLite index for fast querying across your entire collection:
@@ -151,10 +221,10 @@ The database is stored at `$XDG_DATA_HOME/schenesort/index.db` (default: `~/.loc
 
 ## Collage Generation
 
-Create a collage grid (up to 4x4) from wallpapers matching query criteria:
+Create a collage grid from wallpapers matching query criteria:
 
 ```bash
-# Create a 2x2 collage (default)
+# Create a 6x6 collage (default)
 schenesort collage output.png --mood peaceful
 
 # Create a 4x4 collage of landscape images
@@ -167,12 +237,14 @@ schenesort collage collage.png --tile-width 640 --tile-height 360
 schenesort collage night_cities.png --time night --subject urban --cols 3 --rows 2
 ```
 
-![Collage example](docs/collage.png)
+`schenesort collage landscape.png --cols 4 --rows 4 --tile-width 640 --tile-height 360 --tag landscape`
+
+![Collage example](docs/landscape.png)
 
 | Option          | Description                          | Default |
 |-----------------|--------------------------------------|---------|
-| `--cols`        | Number of columns (1-4)              | 2       |
-| `--rows`        | Number of rows (1-4)                 | 2       |
+| `--cols`        | Number of columns                    | 6       |
+| `--rows`        | Number of rows                       | 6       |
 | `--tile-width`  | Width of each tile in pixels         | 480     |
 | `--tile-height` | Height of each tile in pixels        | 270     |
 | `--random`      | Select images randomly               | True    |
@@ -277,6 +349,7 @@ schenesort cleanup ~/wallpapers -r
 ## Configuration
 
 Schenesort follows XDG Base Directory spec:
+
 - Config: `$XDG_CONFIG_HOME/schenesort/config.toml` (default: `~/.config/schenesort/config.toml`)
 - Data: `$XDG_DATA_HOME/schenesort/index.db` (default: `~/.local/share/schenesort/index.db`)
 
@@ -354,7 +427,7 @@ See [schenesort.yazi/README.md](schenesort.yazi/README.md) for details.
 
 ## XMP Sidecar Format
 
-```
+```text
 ~/wallpapers/
 ├── mountain_sunset.jpg
 ├── mountain_sunset.jpg.xmp   ← metadata stored here

schenesort-2.4.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+schenesort/__init__.py,sha256=Z7bmXIWiFUCKj1j4JRlPZvmfzc4RC10Lh1WCKNsJn20,61
+schenesort/cli.py,sha256=tBsZ9TUI-UI6vSjSs98_WiHHR0g-RpvXeboCD4SaXI4,55641
+schenesort/config.py,sha256=8EuYv2nma3QKnLPSAgAsaOHZlORzinHjy-Bj_LKPfJA,2739
+schenesort/db.py,sha256=RbfZN6d5O5MkTRPbu51fA7tQLOJf1huIjxFdoT4sESk,11398
+schenesort/thumbnails.py,sha256=-B4vlh2w_NdUkO0tshcpZPUSs6M8S6G_abiBPp3xVOY,3631
+schenesort/xmp.py,sha256=1VS_I4akY8Dv_KLPOdzPgBCFy0280oSCsMmo-_A9cNE,9749
+schenesort/tui/__init__.py,sha256=BsOc1PedYBguvYBpnny_T9ST-dIa_52xYWlLdNemha4,449
+schenesort/tui/app.py,sha256=HGKBnszTJXtLu9Mo7eJY4wiO2qkB7dFftBoM4GC_js4,6202
+schenesort/tui/grid_app.py,sha256=hrS-dEwQ9wFmcQz2ZT7jy6lYOdSCidEY5Zlfmpv8sI8,10032
+schenesort/tui/widgets/__init__.py,sha256=3cm7vfXG5-xC_UhIbgEtuMxq5I5tXg6okokJ4ecjGIE,202
+schenesort/tui/widgets/filter_panel.py,sha256=BZf8T1H4u4eTUj2bt6ILvQ3m_hwx20DRfc02YVJ4zQk,7273
+schenesort/tui/widgets/image_preview.py,sha256=j_KTQBJk0vbO18FzTo-GYkRlgerBe1K3VGQwMPbEuUw,2846
+schenesort/tui/widgets/metadata_panel.py,sha256=8DnsvDdKf3jzqHOo7dDmxJxL0Mjx5mX7HNwwcMUcJn0,4860
+schenesort/tui/widgets/thumbnail_grid.py,sha256=-81CL4pBI7Q7J_PD2MbeaI-SNckEdfuNZdA14m7q348,9407
+schenesort-2.4.1.dist-info/METADATA,sha256=Drs4ynmh9VhrN9gHmFkmapj3T_g7VH4bcRIyFP6ysuo,14724
+schenesort-2.4.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+schenesort-2.4.1.dist-info/entry_points.txt,sha256=J5lS-N6KgmzjutFi5bG1jv-4Wszbz3MfcOHcbznBVcw,50
+schenesort-2.4.1.dist-info/licenses/LICENSE,sha256=sMw3SMb9ec9dbM2twEMVeunsGwuljza-9kEXg4kSJpg,1070
+schenesort-2.4.1.dist-info/RECORD,,

schenesort-2.3.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-schenesort/__init__.py,sha256=Z7bmXIWiFUCKj1j4JRlPZvmfzc4RC10Lh1WCKNsJn20,61
-schenesort/cli.py,sha256=LU_s4c7Eg_uozxP5I599TV9Y-WirQxx0h-8LvFNYlqM,51550
-schenesort/config.py,sha256=8EuYv2nma3QKnLPSAgAsaOHZlORzinHjy-Bj_LKPfJA,2739
-schenesort/db.py,sha256=RbfZN6d5O5MkTRPbu51fA7tQLOJf1huIjxFdoT4sESk,11398
-schenesort/xmp.py,sha256=1VS_I4akY8Dv_KLPOdzPgBCFy0280oSCsMmo-_A9cNE,9749
-schenesort/tui/__init__.py,sha256=bqSyRlefPfsYhUxsub4Rltz7yjCQVPXvhzj9n2bn370,141
-schenesort/tui/app.py,sha256=HGKBnszTJXtLu9Mo7eJY4wiO2qkB7dFftBoM4GC_js4,6202
-schenesort/tui/widgets/__init__.py,sha256=3cm7vfXG5-xC_UhIbgEtuMxq5I5tXg6okokJ4ecjGIE,202
-schenesort/tui/widgets/image_preview.py,sha256=j_KTQBJk0vbO18FzTo-GYkRlgerBe1K3VGQwMPbEuUw,2846
-schenesort/tui/widgets/metadata_panel.py,sha256=8DnsvDdKf3jzqHOo7dDmxJxL0Mjx5mX7HNwwcMUcJn0,4860
-schenesort-2.3.0.dist-info/METADATA,sha256=F8AMExvB_0nU7CgGkW2CM1az2XJizdQafy0EBJkwnPw,12592
-schenesort-2.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-schenesort-2.3.0.dist-info/entry_points.txt,sha256=J5lS-N6KgmzjutFi5bG1jv-4Wszbz3MfcOHcbznBVcw,50
-schenesort-2.3.0.dist-info/licenses/LICENSE,sha256=sMw3SMb9ec9dbM2twEMVeunsGwuljza-9kEXg4kSJpg,1070
-schenesort-2.3.0.dist-info/RECORD,,