wrkmon 1.0.1__py3-none-any.whl

wrkmon/ui/views/search.py

@@ -0,0 +1,258 @@
+"""Search view container for wrkmon."""
+
+import logging
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static, Input, ListView, ListItem, Label
+from textual.binding import Binding
+from textual.events import Key
+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
+
+logger = logging.getLogger("wrkmon.search")
+
+
+class LoadMoreItem(ListItem):
+    """Special list item for loading more results."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.is_load_more = True
+
+    def compose(self):
+        yield Label("  >>> Load More Results <<<", classes="load-more")
+
+
+class SearchView(Vertical):
+    """Main search view - search YouTube and display results."""
+
+    BINDINGS = [
+        Binding("a", "queue_selected", "Add to Queue", show=True),
+        Binding("escape", "clear_search", "Clear", show=True),
+        Binding("/", "focus_search", "Search", show=True),
+        Binding("space", "play_selected", "Play", show=False, priority=True),
+        Binding("r", "toggle_repeat", "Repeat", show=True),
+    ]
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.results: list[SearchResult] = []
+        self._is_searching = False
+        self._current_query = ""
+        self._load_more_offset = 0
+        self._batch_size = 15
+
+    def compose(self) -> ComposeResult:
+        yield Static("SEARCH", id="view-title")
+
+        with Vertical(id="search-container"):
+            yield Input(
+                placeholder="Search processes...",
+                id="search-input",
+            )
+
+        yield Static(
+            " #   Process                                   PID   Duration  Status",
+            id="list-header",
+        )
+
+        yield ListView(id="results-list")
+        yield Static("Type to search", id="status-bar")
+
+    def on_mount(self) -> None:
+        """Focus the search input on mount."""
+        self.query_one("#search-input", Input).focus()
+
+    @on(Input.Submitted, "#search-input")
+    async def handle_search(self, event: Input.Submitted) -> None:
+        """Execute search when Enter is pressed."""
+        query = event.value.strip()
+        if not query or self._is_searching:
+            return
+
+        self._is_searching = True
+        self._update_status("Searching...")
+        self._current_query = query
+        self._load_more_offset = 0
+
+        try:
+            # Access the app's YouTube client
+            youtube = self.app.youtube
+            self.results = await youtube.search(query, max_results=self._batch_size)
+            self._display_results(show_load_more=True)
+        except Exception as e:
+            self._update_status(f"Search failed: {e}")
+            self.post_message(StatusMessage(f"Search error: {e}", "error"))
+        finally:
+            self._is_searching = False
+
+    async def _load_more_results(self) -> None:
+        """Load more search results."""
+        if not self._current_query or self._is_searching:
+            return
+
+        self._is_searching = True
+        self._update_status("Loading more...")
+
+        try:
+            youtube = self.app.youtube
+            self._load_more_offset += self._batch_size
+            # Search with offset by fetching more and skipping existing
+            new_results = await youtube.search(
+                self._current_query,
+                max_results=self._batch_size + self._load_more_offset
+            )
+            # Get only the new results we don't have yet
+            if len(new_results) > len(self.results):
+                self.results = new_results
+                self._display_results(show_load_more=True)
+            else:
+                self._update_status(f"No more results | Found {len(self.results)} total")
+        except Exception as e:
+            self._update_status(f"Load more failed: {e}")
+        finally:
+            self._is_searching = False
+
+    def _display_results(self, show_load_more: bool = False) -> None:
+        """Display search results in the list."""
+        list_view = self.query_one("#results-list", ListView)
+        list_view.clear()
+
+        if not self.results:
+            self._update_status("No results found")
+            return
+
+        for i, result in enumerate(self.results, 1):
+            list_view.append(ResultItem(result, i))
+
+        # Add "Load More" option at the end
+        if show_load_more:
+            list_view.append(LoadMoreItem())
+
+        # 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}"
+        self._update_status(status)
+        list_view.focus()
+
+    def _get_repeat_status(self) -> str:
+        """Get repeat mode status string."""
+        try:
+            mode = self.app.queue.repeat_mode
+            if mode == "one":
+                return " [REPEAT ONE]"
+            elif mode == "all":
+                return " [REPEAT ALL]"
+        except Exception:
+            pass
+        return ""
+
+    def _update_status(self, message: str) -> None:
+        """Update the status bar."""
+        try:
+            self.query_one("#status-bar", Static).update(message)
+        except Exception:
+            pass
+
+    def _get_selected(self) -> SearchResult | None:
+        """Get the currently selected result."""
+        list_view = self.query_one("#results-list", ListView)
+        if list_view.highlighted_child is None:
+            return None
+
+        item = list_view.highlighted_child
+        if isinstance(item, ResultItem):
+            return item.result
+        return None
+
+    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 = ""
+        search_input.focus()
+
+    @on(ListView.Selected, "#results-list")
+    async def handle_result_selected(self, event: ListView.Selected) -> None:
+        """Handle Enter key on a result - play it or load more."""
+        if isinstance(event.item, LoadMoreItem):
+            await self._load_more_results()
+        elif isinstance(event.item, ResultItem):
+            result = event.item.result
+            self.post_message(TrackSelected(result))
+            repeat_status = self._get_repeat_status()
+            self._update_status(f"Playing: {result.title[:40]}...{repeat_status}")
+
+    def action_play_selected(self) -> None:
+        """Play the selected track (Space key)."""
+        list_view = self.query_one("#results-list", ListView)
+        if not list_view.has_focus:
+            return
+        result = self._get_selected()
+        if result:
+            self.post_message(TrackSelected(result))
+            repeat_status = self._get_repeat_status()
+            self._update_status(f"Playing: {result.title[:40]}...{repeat_status}")
+
+    def action_toggle_repeat(self) -> None:
+        """Cycle repeat mode (R key)."""
+        try:
+            mode = self.app.queue.cycle_repeat()
+            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}")
+        except Exception:
+            pass
+
+    def action_queue_selected(self) -> None:
+        """Add selected track to queue."""
+        logger.info("=== 'a' PRESSED: action_queue_selected ===")
+        result = self._get_selected()
+        logger.info(f"  Selected result: {result}")
+        if result:
+            logger.info(f"  Posting TrackQueued for: {result.title}")
+            self.post_message(TrackQueued(result))
+            repeat_status = self._get_repeat_status()
+            self._update_status(f"Queued: {result.title[:40]}...{repeat_status}")
+        else:
+            logger.warning("  No result selected!")
+
+    def focus_input(self) -> None:
+        """Focus the search input (called from parent)."""
+        self.query_one("#search-input", Input).focus()
+
+    def action_focus_search(self) -> None:
+        """Focus the search input (/ key)."""
+        self.focus_input()
+
+    def on_key(self, event: Key) -> None:
+        """Handle key events - up at top of list goes to search, down from search goes to list."""
+        if event.key == "up":
+            list_view = self.query_one("#results-list", ListView)
+            # If list is focused and at top (index 0), go to search input
+            if list_view.has_focus and list_view.index == 0:
+                self.focus_input()
+                event.prevent_default()
+                event.stop()
+        elif event.key == "down":
+            search_input = self.query_one("#search-input", Input)
+            # If search input is focused, go to list
+            if search_input.has_focus:
+                list_view = self.query_one("#results-list", ListView)
+                if len(list_view.children) > 0:
+                    list_view.focus()
+                    list_view.index = 0
+                    event.prevent_default()
+                    event.stop()
+
+    def focus_list(self) -> None:
+        """Focus the results list (called from parent)."""
+        list_view = self.query_one("#results-list", ListView)
+        if len(list_view.children) > 0:
+            list_view.focus()
+        else:
+            self.query_one("#search-input", Input).focus()

wrkmon/ui/widgets/__init__.py

@@ -0,0 +1,7 @@
+"""Reusable widgets for wrkmon TUI."""
+
+from wrkmon.ui.widgets.header import HeaderBar
+from wrkmon.ui.widgets.player_bar import PlayerBar
+from wrkmon.ui.widgets.result_item import ResultItem
+
+__all__ = ["HeaderBar", "PlayerBar", "ResultItem"]

wrkmon/ui/widgets/header.py

@@ -0,0 +1,59 @@
+"""Header bar widget for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.reactive import reactive
+from textual.widgets import Static
+
+from wrkmon.utils.stealth import get_stealth
+
+
+class HeaderBar(Static):
+    """Application header with title and fake system stats."""
+
+    cpu = reactive(23)
+    mem = reactive(45)
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="header-inner"):
+            yield Static("WRKMON", id="app-title")
+            yield Static("", id="current-view")
+            yield Static(self._format_stats(), id="sys-stats")
+
+    def _format_stats(self) -> str:
+        return f"CPU:{self.cpu:>3}%  MEM:{self.mem:>3}%"
+
+    def on_mount(self) -> None:
+        """Start periodic stats updates."""
+        self.set_interval(3.0, self._update_stats)
+
+    def _update_stats(self) -> None:
+        """Update fake system stats."""
+        self.cpu = self._stealth.get_fake_cpu()
+        self.mem = self._stealth.get_fake_memory()
+
+    def watch_cpu(self) -> None:
+        """React to CPU changes."""
+        self._refresh_stats()
+
+    def watch_mem(self) -> None:
+        """React to memory changes."""
+        self._refresh_stats()
+
+    def _refresh_stats(self) -> None:
+        """Update the stats display."""
+        try:
+            self.query_one("#sys-stats", Static).update(self._format_stats())
+        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

wrkmon/ui/widgets/player_bar.py

@@ -0,0 +1,129 @@
+"""Player bar widget - persistent playback controls at the bottom."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.reactive import reactive
+from textual.widgets import Static, ProgressBar
+
+from wrkmon.utils.stealth import get_stealth
+
+
+class PlayerBar(Static):
+    """Persistent player bar showing current track and playback controls."""
+
+    # Reactive state
+    title = reactive("No process running")
+    is_playing = reactive(False)
+    position = reactive(0.0)
+    duration = reactive(0.0)
+    volume = reactive(80)
+    status_text = reactive("")  # For showing errors/buffering
+    repeat_mode = reactive("none")  # none, one, all
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="player-bar-inner"):
+            # Now playing row
+            with Horizontal(id="now-playing-row"):
+                yield Static("NOW", id="now-label", classes="label")
+                yield Static(self._get_status_icon(), id="play-status")
+                yield Static(self.title, id="track-title")
+                yield Static("", id="repeat-indicator")
+
+            # Progress row
+            with Horizontal(id="progress-row"):
+                yield Static(self._format_time(0), id="time-current")
+                yield ProgressBar(total=100, show_percentage=False, id="progress")
+                yield Static(self._format_time(0), id="time-total")
+
+            # Volume row
+            with Horizontal(id="volume-row"):
+                yield Static("VOL", id="vol-label", classes="label")
+                yield ProgressBar(total=100, show_percentage=False, id="volume")
+                yield Static(f"{self.volume}%", id="vol-value")
+
+    def _get_status_icon(self) -> str:
+        return "▶" if self.is_playing else "■"
+
+    def _format_time(self, seconds: float) -> str:
+        return self._stealth.format_duration(seconds)
+
+    def _format_title(self, title: str) -> str:
+        return self._stealth.get_fake_process_name(title)
+
+    # Watchers for reactive properties
+    def watch_title(self, new_title: str) -> None:
+        """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)
+        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())
+        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))
+            if self.duration > 0:
+                progress = (new_pos / self.duration) * 100
+                self.query_one("#progress", ProgressBar).update(progress=progress)
+        except Exception:
+            pass
+
+    def watch_duration(self, new_dur: float) -> None:
+        """Update total duration display."""
+        try:
+            self.query_one("#time-total", Static).update(self._format_time(new_dur))
+        except Exception:
+            pass
+
+    def watch_volume(self, new_vol: int) -> None:
+        """Update volume display."""
+        try:
+            self.query_one("#volume", ProgressBar).update(progress=new_vol)
+            self.query_one("#vol-value", Static).update(f"{new_vol}%")
+        except Exception:
+            pass
+
+    def watch_repeat_mode(self, new_mode: str) -> None:
+        """Update repeat indicator."""
+        try:
+            indicator = ""
+            if new_mode == "one":
+                indicator = "[R1]"
+            elif new_mode == "all":
+                indicator = "[RA]"
+            self.query_one("#repeat-indicator", Static).update(indicator)
+        except Exception:
+            pass
+
+    def update_playback(
+        self,
+        title: str | None = None,
+        is_playing: bool | None = None,
+        position: float | None = None,
+        duration: float | None = None,
+    ) -> None:
+        """Batch update playback state."""
+        if title is not None:
+            self.title = title
+        if is_playing is not None:
+            self.is_playing = is_playing
+        if position is not None:
+            self.position = position
+        if duration is not None:
+            self.duration = duration
+
+    def set_volume(self, volume: int) -> None:
+        """Update volume display."""
+        self.volume = max(0, min(100, volume))

wrkmon/ui/widgets/result_item.py

@@ -0,0 +1,98 @@
+"""Result item widget for displaying search results, queue items, etc."""
+
+from textual.app import ComposeResult
+from textual.widgets import ListItem, Label
+
+from wrkmon.core.youtube import SearchResult
+from wrkmon.utils.stealth import get_stealth
+
+
+class ResultItem(ListItem):
+    """A list item representing a search result or track."""
+
+    def __init__(
+        self,
+        result: SearchResult,
+        index: int,
+        status: str = "READY",
+        show_duration: bool = True,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.result = result
+        self.index = index
+        self.status = status
+        self.show_duration = show_duration
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        process_name = self._stealth.get_fake_process_name(self.result.title)
+        pid = self._stealth.get_fake_pid()
+
+        if self.show_duration:
+            duration = self._stealth.format_duration(self.result.duration)
+            text = f"{self.index:>2}  {process_name:<38}  {pid:>5}  {duration:>7}  {self.status}"
+        else:
+            text = f"{self.index:>2}  {process_name:<42}  {pid:>5}  {self.status}"
+
+        yield Label(text, classes="result-text")
+
+
+class QueueItem(ListItem):
+    """A list item representing a queue entry."""
+
+    def __init__(
+        self,
+        title: str,
+        duration: int,
+        index: int,
+        is_current: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.title = title
+        self.duration = duration
+        self.index = index
+        self.is_current = is_current
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        process_name = self._stealth.get_fake_process_name(self.title)
+        duration = self._stealth.format_duration(self.duration)
+        status = "RUNNING" if self.is_current else "QUEUED"
+        marker = "▶" if self.is_current else " "
+
+        text = f"{marker} {self.index:>2}  {process_name:<40}  {duration:>7}  {status}"
+        yield Label(text, classes="queue-text")
+
+
+class HistoryItem(ListItem):
+    """A list item representing a history entry."""
+
+    def __init__(
+        self,
+        title: str,
+        duration: int,
+        play_count: int,
+        last_played: str,
+        index: int,
+        video_id: str,
+        channel: str,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.title = title
+        self.duration = duration
+        self.play_count = play_count
+        self.last_played = last_played
+        self.index = index
+        self.video_id = video_id
+        self.channel = channel
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        process_name = self._stealth.get_fake_process_name(self.title)[:32]
+        duration = self._stealth.format_duration(self.duration)
+
+        text = f"{self.index:>2}  {process_name:<34}  {duration:>7}  {self.play_count:>3}x  {self.last_played}"
+        yield Label(text, classes="history-text")

wrkmon/utils/__init__.py

@@ -0,0 +1,6 @@
+"""Utility modules for wrkmon."""
+
+from wrkmon.utils.config import Config
+from wrkmon.utils.stealth import StealthManager
+
+__all__ = ["Config", "StealthManager"]