wrkmon 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

wrkmon/ui/views/search.py

@@ -1,8 +1,9 @@
 """Search view container for wrkmon."""
 
+import asyncio
 import logging
 from textual.app import ComposeResult
-from textual.containers import Vertical
+from textual.containers import Vertical, Horizontal
 from textual.widgets import Static, Input, ListView, ListItem, Label
 from textual.binding import Binding
 from textual.events import Key
@@ -11,6 +12,8 @@ from textual import on
 from wrkmon.core.youtube import SearchResult
 from wrkmon.ui.messages import TrackSelected, TrackQueued, StatusMessage
 from wrkmon.ui.widgets.result_item import ResultItem
+from wrkmon.ui.widgets.thumbnail import ThumbnailPreview
+from wrkmon.utils.config import get_config
 
 logger = logging.getLogger("wrkmon.search")
 
@@ -35,6 +38,8 @@ class SearchView(Vertical):
         Binding("/", "focus_search", "Search", show=True),
         Binding("space", "play_selected", "Play", show=False, priority=True),
         Binding("r", "toggle_repeat", "Repeat", show=True),
+        Binding("t", "toggle_thumbnail", "Thumb", show=True),
+        Binding("y", "cycle_thumbnail_style", "Style", show=True),
     ]
 
     def __init__(self, **kwargs) -> None:
@@ -44,27 +49,87 @@ class SearchView(Vertical):
         self._current_query = ""
         self._load_more_offset = 0
         self._batch_size = 15
+        self._thumbnail_task: asyncio.Task | None = None
+        self._is_trending = False  # True when showing trending, False after search
+
+        # Load settings from config
+        self._config = get_config()
+        self._show_thumbnail = self._config.show_thumbnails
+        self._thumbnail_style = self._config.thumbnail_style
+        self._thumbnail_width = self._config.thumbnail_width
 
     def compose(self) -> ComposeResult:
-        yield Static("SEARCH", id="view-title")
+        yield Static("TRENDING", id="view-title")
 
         with Vertical(id="search-container"):
             yield Input(
-                placeholder="Search processes...",
+                placeholder="Search YouTube music...",
                 id="search-input",
             )
 
         yield Static(
-            " #   Process                                   PID   Duration  Status",
+            " #   Title                                     Channel         Duration  Views",
             id="list-header",
         )
 
-        yield ListView(id="results-list")
-        yield Static("Type to search", id="status-bar")
+        with Horizontal(id="search-content"):
+            yield ListView(id="results-list")
+            with Vertical(id="thumbnail-panel"):
+                yield Static("PREVIEW", id="thumb-title")
+                yield ThumbnailPreview(
+                    width=self._thumbnail_width,
+                    style=self._thumbnail_style,
+                    id="thumb-preview"
+                )
+
+        yield Static("Loading trending music...", id="status-bar")
 
     def on_mount(self) -> None:
-        """Focus the search input on mount."""
-        self.query_one("#search-input", Input).focus()
+        """Load trending videos and setup initial state on mount."""
+        # Apply initial thumbnail visibility
+        if not self._show_thumbnail:
+            try:
+                self.query_one("#thumbnail-panel", Vertical).add_class("hidden")
+            except Exception:
+                pass
+
+        # Load trending videos if enabled
+        if self._config.show_trending_on_start:
+            asyncio.create_task(self._load_trending())
+        else:
+            self.query_one("#search-input", Input).focus()
+            self._update_status("Type to search YouTube music")
+
+    async def _load_trending(self) -> None:
+        """Load trending/popular music videos on startup."""
+        self._is_searching = True
+        self._is_trending = True
+        self._update_status("Loading trending music...")
+
+        try:
+            # Update view title to show trending
+            self.query_one("#view-title", Static).update("TRENDING")
+
+            # Access the app's YouTube client
+            youtube = self.app.youtube
+            self.results = await youtube.get_trending_music(max_results=15)
+
+            if self.results:
+                self._display_results(show_load_more=False)
+                self._update_status(f"Trending: {len(self.results)} popular tracks | Search to find more")
+            else:
+                self._update_status("Could not load trending | Type to search")
+
+        except Exception as e:
+            logger.debug(f"Failed to load trending: {e}")
+            self._update_status("Type to search YouTube music")
+        finally:
+            self._is_searching = False
+            # Focus the list if we have results, otherwise search input
+            if self.results:
+                self.query_one("#results-list", ListView).focus()
+            else:
+                self.query_one("#search-input", Input).focus()
 
     @on(Input.Submitted, "#search-input")
     async def handle_search(self, event: Input.Submitted) -> None:
@@ -74,10 +139,17 @@ class SearchView(Vertical):
             return
 
         self._is_searching = True
+        self._is_trending = False  # No longer showing trending
         self._update_status("Searching...")
         self._current_query = query
         self._load_more_offset = 0
 
+        # Update view title to SEARCH
+        try:
+            self.query_one("#view-title", Static).update("SEARCH")
+        except Exception:
+            pass
+
         try:
             # Access the app's YouTube client
             youtube = self.app.youtube
@@ -134,7 +206,8 @@ class SearchView(Vertical):
 
         # Build status with repeat indicator
         repeat_status = self._get_repeat_status()
-        status = f"Found {len(self.results)} | Enter/Space=Play  A=Queue  R=Repeat{repeat_status}"
+        thumb_status = " [THUMB ON]" if self._show_thumbnail else ""
+        status = f"Found {len(self.results)} | Enter=Play A=Queue R=Repeat T=Thumb{repeat_status}{thumb_status}"
         self._update_status(status)
         list_view.focus()
 
@@ -143,9 +216,9 @@ class SearchView(Vertical):
         try:
             mode = self.app.queue.repeat_mode
             if mode == "one":
-                return " [REPEAT ONE]"
+                return " [R1]"
             elif mode == "all":
-                return " [REPEAT ALL]"
+                return " [RA]"
         except Exception:
             pass
         return ""
@@ -168,11 +241,93 @@ class SearchView(Vertical):
             return item.result
         return None
 
+    def _update_thumbnail_preview(self) -> None:
+        """Update thumbnail preview for currently highlighted item."""
+        if not self._show_thumbnail:
+            return
+
+        result = self._get_selected()
+        if result:
+            try:
+                preview = self.query_one("#thumb-preview", ThumbnailPreview)
+                title = self.query_one("#thumb-title", Static)
+                title.update(result.title[:35] + "..." if len(result.title) > 35 else result.title)
+                preview.set_video(result.video_id)
+            except Exception:
+                pass
+        else:
+            self._clear_thumbnail()
+
+    def _clear_thumbnail(self) -> None:
+        """Clear the thumbnail preview."""
+        try:
+            preview = self.query_one("#thumb-preview", ThumbnailPreview)
+            title = self.query_one("#thumb-title", Static)
+            title.update("PREVIEW")
+            preview.clear()
+        except Exception:
+            pass
+
+    @on(ListView.Highlighted, "#results-list")
+    def handle_highlight_changed(self, event: ListView.Highlighted) -> None:
+        """Update thumbnail when highlighted item changes."""
+        self._update_thumbnail_preview()
+
+    def action_toggle_thumbnail(self) -> None:
+        """Toggle thumbnail preview visibility."""
+        self._show_thumbnail = not self._show_thumbnail
+        # Save to config
+        self._config.show_thumbnails = self._show_thumbnail
+
+        try:
+            panel = self.query_one("#thumbnail-panel", Vertical)
+            if self._show_thumbnail:
+                panel.remove_class("hidden")
+                self._update_thumbnail_preview()
+            else:
+                panel.add_class("hidden")
+
+            # Update status
+            repeat_status = self._get_repeat_status()
+            thumb_status = " [THUMB ON]" if self._show_thumbnail else ""
+            count = len(self.results) if self.results else 0
+            self._update_status(f"Found {count} | T=Thumb{repeat_status}{thumb_status}")
+        except Exception:
+            pass
+
+    def action_cycle_thumbnail_style(self) -> None:
+        """Cycle through thumbnail rendering styles (Y key)."""
+        styles = ["colored_blocks", "colored_simple", "braille", "blocks"]
+        style_names = {
+            "colored_blocks": "Color Blocks",
+            "colored_simple": "Color Simple",
+            "braille": "Braille",
+            "blocks": "Grayscale",
+        }
+
+        try:
+            current_idx = styles.index(self._thumbnail_style) if self._thumbnail_style in styles else 0
+            next_idx = (current_idx + 1) % len(styles)
+            self._thumbnail_style = styles[next_idx]
+
+            # Save to config
+            self._config.thumbnail_style = self._thumbnail_style
+
+            # Update the preview widget
+            preview = self.query_one("#thumb-preview", ThumbnailPreview)
+            preview.set_style(self._thumbnail_style)
+
+            # Update status to show new style
+            self._update_status(f"Thumbnail style: {style_names[self._thumbnail_style]}")
+        except Exception:
+            pass
+
     def action_clear_search(self) -> None:
         """Clear the search input."""
         search_input = self.query_one("#search-input", Input)
         if search_input.value:
             search_input.value = ""
+        self._clear_thumbnail()
         search_input.focus()
 
     @on(ListView.Selected, "#results-list")
@@ -204,7 +359,8 @@ class SearchView(Vertical):
             mode_names = {"none": "OFF", "one": "ONE", "all": "ALL"}
             repeat_status = self._get_repeat_status()
             count = len(self.results) if self.results else 0
-            self._update_status(f"Repeat: {mode_names[mode]} | Found {count}{repeat_status}")
+            thumb_status = " [THUMB ON]" if self._show_thumbnail else ""
+            self._update_status(f"Repeat: {mode_names[mode]} | Found {count}{repeat_status}{thumb_status}")
         except Exception:
             pass
 

wrkmon/ui/widgets/header.py

@@ -5,6 +5,7 @@ from textual.containers import Horizontal
 from textual.reactive import reactive
 from textual.widgets import Static
 
+from wrkmon import __version__
 from wrkmon.utils.stealth import get_stealth
 
 
@@ -13,6 +14,8 @@ class HeaderBar(Static):
 
     cpu = reactive(23)
     mem = reactive(45)
+    update_available = reactive(False)
+    latest_version = reactive("")
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
@@ -20,7 +23,8 @@ class HeaderBar(Static):
 
     def compose(self) -> ComposeResult:
         with Horizontal(id="header-inner"):
-            yield Static("WRKMON", id="app-title")
+            yield Static(f"WRKMON v{__version__}", id="app-title")
+            yield Static("", id="update-indicator")
             yield Static("", id="current-view")
             yield Static(self._format_stats(), id="sys-stats")
 
@@ -44,6 +48,14 @@ class HeaderBar(Static):
         """React to memory changes."""
         self._refresh_stats()
 
+    def watch_update_available(self) -> None:
+        """React to update availability changes."""
+        self._refresh_update_indicator()
+
+    def watch_latest_version(self) -> None:
+        """React to latest version changes."""
+        self._refresh_update_indicator()
+
     def _refresh_stats(self) -> None:
         """Update the stats display."""
         try:
@@ -51,9 +63,27 @@ class HeaderBar(Static):
         except Exception:
             pass
 
+    def _refresh_update_indicator(self) -> None:
+        """Update the update indicator."""
+        try:
+            indicator = self.query_one("#update-indicator", Static)
+            if self.update_available and self.latest_version:
+                indicator.update(f"[UPDATE: v{self.latest_version}]")
+                indicator.add_class("update-available")
+            else:
+                indicator.update("")
+                indicator.remove_class("update-available")
+        except Exception:
+            pass
+
     def set_view_name(self, name: str) -> None:
         """Update the current view indicator."""
         try:
             self.query_one("#current-view", Static).update(f"/{name.upper()}")
         except Exception:
             pass
+
+    def set_update_info(self, available: bool, version: str = "") -> None:
+        """Set update availability information."""
+        self.update_available = available
+        self.latest_version = version

wrkmon/ui/widgets/player_bar.py

@@ -19,6 +19,7 @@ class PlayerBar(Static):
     volume = reactive(80)
     status_text = reactive("")  # For showing errors/buffering
     repeat_mode = reactive("none")  # none, one, all
+    is_muted = reactive(False)
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
@@ -46,7 +47,15 @@ class PlayerBar(Static):
                 yield Static(f"{self.volume}%", id="vol-value")
 
     def _get_status_icon(self) -> str:
-        return "▶" if self.is_playing else "■"
+        """Get status icon with color markup."""
+        if self.is_playing:
+            return "[bold green]▶[/]"
+        else:
+            return "[bold orange1]⏸[/]"
+
+    def _get_status_text(self) -> str:
+        """Get status text for stopped state."""
+        return "[dim]■[/]"
 
     def _format_time(self, seconds: float) -> str:
         return self._stealth.format_duration(seconds)
@@ -59,21 +68,32 @@ class PlayerBar(Static):
         """Update title display."""
         try:
             display_title = self._format_title(new_title) if new_title else "No process running"
-            self.query_one("#track-title", Static).update(display_title)
+            title_widget = self.query_one("#track-title", Static)
+            title_widget.update(display_title)
         except Exception:
             pass
 
     def watch_is_playing(self) -> None:
         """Update play/pause icon."""
         try:
-            self.query_one("#play-status", Static).update(self._get_status_icon())
+            status_widget = self.query_one("#play-status", Static)
+            status_widget.update(self._get_status_icon())
+
+            # Update CSS classes for styling
+            if self.is_playing:
+                status_widget.remove_class("paused")
+                status_widget.remove_class("stopped")
+            else:
+                status_widget.add_class("paused")
         except Exception:
             pass
 
     def watch_position(self, new_pos: float) -> None:
         """Update progress bar and time."""
         try:
-            self.query_one("#time-current", Static).update(self._format_time(new_pos))
+            time_widget = self.query_one("#time-current", Static)
+            time_widget.update(self._format_time(new_pos))
+
             if self.duration > 0:
                 progress = (new_pos / self.duration) * 100
                 self.query_one("#progress", ProgressBar).update(progress=progress)
@@ -91,7 +111,16 @@ class PlayerBar(Static):
         """Update volume display."""
         try:
             self.query_one("#volume", ProgressBar).update(progress=new_vol)
-            self.query_one("#vol-value", Static).update(f"{new_vol}%")
+            vol_text = f"{new_vol}%" if not self.is_muted else "[red]MUTE[/]"
+            self.query_one("#vol-value", Static).update(vol_text)
+        except Exception:
+            pass
+
+    def watch_is_muted(self, is_muted: bool) -> None:
+        """Update mute indicator."""
+        try:
+            vol_text = f"{self.volume}%" if not is_muted else "[red]MUTE[/]"
+            self.query_one("#vol-value", Static).update(vol_text)
         except Exception:
             pass
 
@@ -100,9 +129,9 @@ class PlayerBar(Static):
         try:
             indicator = ""
             if new_mode == "one":
-                indicator = "[R1]"
+                indicator = "[bold purple]⟳1[/]"
             elif new_mode == "all":
-                indicator = "[RA]"
+                indicator = "[bold purple]⟳∞[/]"
             self.query_one("#repeat-indicator", Static).update(indicator)
         except Exception:
             pass
@@ -127,3 +156,7 @@ class PlayerBar(Static):
     def set_volume(self, volume: int) -> None:
         """Update volume display."""
         self.volume = max(0, min(100, volume))
+
+    def set_muted(self, muted: bool) -> None:
+        """Update mute state."""
+        self.is_muted = muted

wrkmon/ui/widgets/thumbnail.py

@@ -0,0 +1,230 @@
+"""ASCII thumbnail widget for wrkmon - with color support."""
+
+import asyncio
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.reactive import reactive
+from textual.widgets import Static
+
+from wrkmon.utils.ascii_art import get_or_fetch_ascii, get_cached_ascii, clear_cache
+
+
+class ThumbnailPreview(Static):
+    """Widget to display colored ASCII art thumbnail preview."""
+
+    DEFAULT_CSS = """
+    ThumbnailPreview {
+        width: 100%;
+        height: auto;
+        min-height: 8;
+        max-height: 18;
+        background: #0d1117;
+        padding: 0;
+    }
+
+    ThumbnailPreview.loading {
+        color: #6e7681;
+    }
+
+    ThumbnailPreview.hidden {
+        display: none;
+    }
+    """
+
+    video_id = reactive("")
+    is_loading = reactive(False)
+    style_mode = reactive("colored_blocks")  # colored_blocks, colored_simple, blocks, braille
+
+    def __init__(
+        self,
+        video_id: str = "",
+        width: int = 45,
+        style: str = "colored_blocks",
+        **kwargs
+    ) -> None:
+        super().__init__(**kwargs)
+        self._ascii_width = width
+        self._current_task: asyncio.Task | None = None
+        self.style_mode = style
+        if video_id:
+            self.video_id = video_id
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="ascii-content", markup=True)
+
+    def on_mount(self) -> None:
+        """Load thumbnail on mount if video_id is set."""
+        if self.video_id:
+            self._load_thumbnail()
+
+    def watch_video_id(self, video_id: str) -> None:
+        """React to video_id changes."""
+        if video_id:
+            self._load_thumbnail()
+        else:
+            self._clear_thumbnail()
+
+    def _load_thumbnail(self) -> None:
+        """Load ASCII thumbnail for current video."""
+        if not self.video_id:
+            return
+
+        # Check cache first
+        cache_key = f"{self.video_id}_{self.style_mode}_{self._ascii_width}"
+        from wrkmon.utils.ascii_art import _thumbnail_cache
+        cached = _thumbnail_cache.get(cache_key)
+        if cached:
+            self._display_ascii(cached)
+            return
+
+        # Load async
+        self.is_loading = True
+        self.add_class("loading")
+        self._update_content("[dim]Loading...[/]")
+
+        # Cancel any existing task
+        if self._current_task and not self._current_task.done():
+            self._current_task.cancel()
+
+        # Start new load task
+        self._current_task = asyncio.create_task(self._fetch_and_display())
+
+    async def _fetch_and_display(self) -> None:
+        """Fetch thumbnail and display it."""
+        try:
+            ascii_art = await get_or_fetch_ascii(
+                self.video_id,
+                width=self._ascii_width,
+                style=self.style_mode,
+            )
+
+            if ascii_art:
+                self._display_ascii(ascii_art)
+            else:
+                self._update_content("[dim]No thumbnail[/]")
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            self._update_content(f"[red]Error: {e}[/]")
+        finally:
+            self.is_loading = False
+            self.remove_class("loading")
+
+    def _display_ascii(self, ascii_art: str) -> None:
+        """Display ASCII art in the widget."""
+        self._update_content(ascii_art)
+
+    def _update_content(self, content: str) -> None:
+        """Update the content display."""
+        try:
+            widget = self.query_one("#ascii-content", Static)
+            widget.update(content)
+        except Exception:
+            pass
+
+    def _clear_thumbnail(self) -> None:
+        """Clear the thumbnail display."""
+        self._update_content("")
+
+    def set_video(self, video_id: str) -> None:
+        """Set video ID and load thumbnail."""
+        self.video_id = video_id
+
+    def set_style(self, style: str) -> None:
+        """Change the rendering style and reload."""
+        if style != self.style_mode:
+            self.style_mode = style
+            if self.video_id:
+                self._load_thumbnail()
+
+    def clear(self) -> None:
+        """Clear the thumbnail."""
+        self.video_id = ""
+
+    def show(self) -> None:
+        """Show the widget."""
+        self.remove_class("hidden")
+
+    def hide(self) -> None:
+        """Hide the widget."""
+        self.add_class("hidden")
+
+    def cycle_style(self) -> str:
+        """Cycle through rendering styles."""
+        styles = ["colored_blocks", "colored_simple", "braille", "blocks"]
+        current_idx = styles.index(self.style_mode) if self.style_mode in styles else 0
+        next_idx = (current_idx + 1) % len(styles)
+        self.set_style(styles[next_idx])
+        return styles[next_idx]
+
+
+class ThumbnailPanel(Container):
+    """Panel containing thumbnail preview with title."""
+
+    DEFAULT_CSS = """
+    ThumbnailPanel {
+        width: 100%;
+        height: auto;
+        background: #161b22;
+        border: solid #30363d;
+        padding: 1;
+    }
+
+    ThumbnailPanel > #panel-title {
+        height: 1;
+        color: #58a6ff;
+        text-style: bold;
+        margin-bottom: 1;
+    }
+
+    ThumbnailPanel.hidden {
+        display: none;
+    }
+    """
+
+    def __init__(self, title: str = "Preview", width: int = 45, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._title = title
+        self._width = width
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._title, id="panel-title", markup=True)
+        yield ThumbnailPreview(width=self._width, id="thumbnail-preview")
+
+    def set_video(self, video_id: str, title: str = "") -> None:
+        """Set video to preview."""
+        if title:
+            try:
+                display_title = title[:40] + "..." if len(title) > 40 else title
+                self.query_one("#panel-title", Static).update(f"[bold]{display_title}[/]")
+            except Exception:
+                pass
+
+        try:
+            self.query_one("#thumbnail-preview", ThumbnailPreview).set_video(video_id)
+        except Exception:
+            pass
+
+    def clear(self) -> None:
+        """Clear the preview."""
+        try:
+            self.query_one("#thumbnail-preview", ThumbnailPreview).clear()
+            self.query_one("#panel-title", Static).update("Preview")
+        except Exception:
+            pass
+
+    def cycle_style(self) -> str:
+        """Cycle the thumbnail style."""
+        try:
+            return self.query_one("#thumbnail-preview", ThumbnailPreview).cycle_style()
+        except Exception:
+            return "colored_blocks"
+
+    def show(self) -> None:
+        """Show the panel."""
+        self.remove_class("hidden")
+
+    def hide(self) -> None:
+        """Hide the panel."""
+        self.add_class("hidden")