wrkmon 1.0.0__py3-none-any.whl

wrkmon/ui/views/playlists.py

@@ -0,0 +1,259 @@
+"""Playlists view container for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static, ListView, ListItem, Label, Input
+from textual.binding import Binding
+from textual import on
+
+from wrkmon.core.youtube import SearchResult
+from wrkmon.data.models import Playlist, Track
+from wrkmon.ui.messages import TrackSelected, TrackQueued, StatusMessage
+from wrkmon.utils.stealth import get_stealth
+
+
+class PlaylistItem(ListItem):
+    """List item for a playlist."""
+
+    def __init__(self, playlist: Playlist, index: int, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.playlist = playlist
+        self.index = index
+
+    def compose(self) -> ComposeResult:
+        count = self.playlist.track_count
+        duration = self.playlist.total_duration_str
+        text = f"{self.index:>2}  {self.playlist.name:<42}  {count:>4} tracks  {duration:>8}"
+        yield Label(text)
+
+
+class TrackItem(ListItem):
+    """List item for a track in a playlist."""
+
+    def __init__(self, track: Track, index: int, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.track = track
+        self.index = index
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        process_name = self._stealth.get_fake_process_name(self.track.title)[:40]
+        duration = self.track.duration_str
+        text = f"  {self.index:>2}  {process_name:<40}  {duration:>8}"
+        yield Label(text)
+
+
+class PlaylistsView(Vertical):
+    """Playlists view - manage playlists and their tracks."""
+
+    BINDINGS = [
+        Binding("a", "queue_selected", "Add to Queue", show=True),
+        Binding("n", "new_playlist", "New Playlist", show=True),
+        Binding("d", "delete_item", "Delete", show=True),
+        Binding("p", "play_all", "Play All", show=True),
+        Binding("escape", "go_back", "Back", show=True),
+    ]
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.playlists: list[Playlist] = []
+        self.current_playlist: Playlist | None = None
+        self.viewing_tracks = False
+
+    def compose(self) -> ComposeResult:
+        yield Static("PLAYLISTS", id="view-title")
+
+        yield Static(
+            " #   Name                                          Tracks    Duration",
+            id="list-header",
+        )
+
+        yield ListView(id="playlist-list")
+
+        yield Input(
+            placeholder="Enter playlist name...",
+            id="new-playlist-input",
+        )
+
+        yield Static("Loading playlists...", id="status-bar")
+
+    def on_mount(self) -> None:
+        """Load playlists on mount."""
+        self.query_one("#new-playlist-input", Input).display = False
+        self.load_playlists()
+
+    def load_playlists(self) -> None:
+        """Load all playlists."""
+        try:
+            db = self.app.database
+            self.playlists = db.get_all_playlists()
+            self._display_playlists()
+        except Exception as e:
+            self._update_status(f"Failed to load: {e}")
+
+    def _display_playlists(self) -> None:
+        """Display playlist list."""
+        self.viewing_tracks = False
+        self.current_playlist = None
+
+        self.query_one("#view-title", Static).update("PLAYLISTS")
+        self.query_one("#list-header", Static).update(
+            " #   Name                                          Tracks    Duration"
+        )
+
+        list_view = self.query_one("#playlist-list", ListView)
+        list_view.clear()
+
+        if not self.playlists:
+            self._update_status("No playlists. Press 'n' to create one.")
+            return
+
+        for i, playlist in enumerate(self.playlists, 1):
+            list_view.append(PlaylistItem(playlist, i))
+
+        self._update_status(f"{len(self.playlists)} playlists")
+
+    def _display_tracks(self, playlist: Playlist) -> None:
+        """Display tracks in a playlist."""
+        self.viewing_tracks = True
+        self.current_playlist = playlist
+
+        # Load full playlist with tracks
+        try:
+            full_playlist = self.app.database.get_playlist(playlist.id)
+            if full_playlist:
+                self.current_playlist = full_playlist
+        except Exception:
+            pass
+
+        self.query_one("#view-title", Static).update(f"PLAYLIST: {playlist.name}")
+        self.query_one("#list-header", Static).update(
+            "   #   Process                                      Duration"
+        )
+
+        list_view = self.query_one("#playlist-list", ListView)
+        list_view.clear()
+
+        if not self.current_playlist.tracks:
+            self._update_status("Playlist empty")
+            return
+
+        for i, track in enumerate(self.current_playlist.tracks, 1):
+            list_view.append(TrackItem(track, i))
+
+        self._update_status(
+            f"{len(self.current_playlist.tracks)} tracks - "
+            f"{self.current_playlist.total_duration_str}"
+        )
+
+    def _update_status(self, message: str) -> None:
+        """Update status bar."""
+        try:
+            self.query_one("#status-bar", Static).update(message)
+        except Exception:
+            pass
+
+    def _track_to_result(self, track: Track) -> SearchResult:
+        """Convert a Track to SearchResult."""
+        return SearchResult(
+            video_id=track.video_id,
+            title=track.title,
+            channel=track.channel,
+            duration=track.duration,
+            view_count=0,
+        )
+
+    def action_go_back(self) -> None:
+        """Go back to playlist list."""
+        if self.viewing_tracks:
+            self._display_playlists()
+
+    @on(ListView.Selected, "#playlist-list")
+    def handle_item_selected(self, event: ListView.Selected) -> None:
+        """Handle Enter key - open playlist or play track."""
+        item = event.item
+
+        if isinstance(item, PlaylistItem):
+            self._display_tracks(item.playlist)
+        elif isinstance(item, TrackItem):
+            result = self._track_to_result(item.track)
+            self.post_message(TrackSelected(result))
+            self._update_status(f"Playing: {item.track.title[:40]}...")
+
+    def action_new_playlist(self) -> None:
+        """Create a new playlist."""
+        if self.viewing_tracks:
+            return
+
+        input_widget = self.query_one("#new-playlist-input", Input)
+        input_widget.display = True
+        input_widget.focus()
+
+    @on(Input.Submitted, "#new-playlist-input")
+    def handle_new_playlist(self, event: Input.Submitted) -> None:
+        """Handle new playlist name submission."""
+        name = event.value.strip()
+        input_widget = self.query_one("#new-playlist-input", Input)
+        input_widget.display = False
+        input_widget.value = ""
+
+        if not name:
+            return
+
+        try:
+            db = self.app.database
+            playlist = db.create_playlist(name)
+            self.playlists.append(playlist)
+            self._display_playlists()
+            self.post_message(StatusMessage(f"Created: {name}", "success"))
+        except Exception as e:
+            self.post_message(StatusMessage(f"Error: {e}", "error"))
+
+    def action_delete_item(self) -> None:
+        """Delete selected item."""
+        list_view = self.query_one("#playlist-list", ListView)
+        if list_view.highlighted_child is None:
+            return
+
+        item = list_view.highlighted_child
+        db = self.app.database
+
+        try:
+            if isinstance(item, PlaylistItem):
+                if db.delete_playlist(item.playlist.id):
+                    self.load_playlists()
+                    self.post_message(StatusMessage(f"Deleted: {item.playlist.name}", "info"))
+            elif isinstance(item, TrackItem) and self.current_playlist:
+                if db.remove_track_from_playlist(self.current_playlist.id, item.track.id):
+                    self._display_tracks(self.current_playlist)
+                    self.post_message(StatusMessage("Track removed", "info"))
+        except Exception as e:
+            self.post_message(StatusMessage(f"Error: {e}", "error"))
+
+    async def action_play_all(self) -> None:
+        """Play all tracks in current playlist."""
+        if not self.current_playlist or not self.current_playlist.tracks:
+            return
+
+        # Add all to queue
+        for track in self.current_playlist.tracks:
+            result = self._track_to_result(track)
+            self.app.add_to_queue(result)
+
+        # Play first
+        first = self.current_playlist.tracks[0]
+        result = self._track_to_result(first)
+        self.post_message(TrackSelected(result))
+        self._update_status("Playing playlist")
+
+    def action_queue_selected(self) -> None:
+        """Add selected track to queue."""
+        list_view = self.query_one("#playlist-list", ListView)
+        if list_view.highlighted_child is None:
+            return
+
+        item = list_view.highlighted_child
+        if isinstance(item, TrackItem):
+            result = self._track_to_result(item.track)
+            self.post_message(TrackQueued(result))
+            self._update_status(f"Queued: {item.track.title[:40]}...")

wrkmon/ui/views/queue.py

@@ -0,0 +1,191 @@
+"""Queue view container for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.containers import Vertical, Horizontal
+from textual.widgets import Static, ListView, ProgressBar
+from textual.binding import Binding
+from textual.reactive import reactive
+
+from wrkmon.ui.widgets.result_item import QueueItem
+from wrkmon.ui.messages import StatusMessage
+from wrkmon.utils.stealth import get_stealth
+
+
+class QueueView(Vertical):
+    """Queue/Player view - shows current playback and queue."""
+
+    BINDINGS = [
+        Binding("space", "toggle_pause", "Play/Pause", show=True),
+        Binding("n", "next_track", "Next", show=True),
+        Binding("p", "prev_track", "Previous", show=True),
+        Binding("s", "toggle_shuffle", "Shuffle", show=True),
+        Binding("r", "toggle_repeat", "Repeat", show=True),
+        Binding("c", "clear_queue", "Clear Queue", show=True),
+        Binding("delete", "remove_selected", "Remove", show=False),
+    ]
+
+    # Reactive state
+    shuffle_enabled = reactive(False)
+    repeat_mode = reactive("none")
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._stealth = get_stealth()
+
+    def compose(self) -> ComposeResult:
+        yield Static("QUEUE", id="view-title")
+
+        # Now playing section
+        with Vertical(id="now-playing-section"):
+            yield Static("NOW RUNNING", id="section-header")
+            yield Static("No process running", id="current-track")
+
+            with Horizontal(id="playback-progress"):
+                yield Static("--:--", id="pos-time")
+                yield ProgressBar(total=100, show_percentage=False, id="track-progress")
+                yield Static("--:--", id="dur-time")
+
+        # Mode indicators
+        with Horizontal(id="mode-indicators"):
+            yield Static("", id="shuffle-indicator")
+            yield Static("", id="repeat-indicator")
+
+        # Queue list
+        yield Static(
+            "   #   Process                                    Duration  Status",
+            id="list-header",
+        )
+        yield ListView(id="queue-list")
+        yield Static("Queue empty", id="status-bar")
+
+    def on_mount(self) -> None:
+        """Initialize the view."""
+        self.refresh_queue()
+
+    def refresh_queue(self) -> None:
+        """Refresh the queue display."""
+        try:
+            queue = self.app.queue
+            list_view = self.query_one("#queue-list", ListView)
+            list_view.clear()
+
+            items = queue.to_list()
+            if not items:
+                self._update_status("Queue empty")
+                return
+
+            for i, item in enumerate(items):
+                is_current = i == queue.current_index
+                list_view.append(
+                    QueueItem(
+                        title=item.title,
+                        duration=item.duration,
+                        index=i + 1,
+                        is_current=is_current,
+                    )
+                )
+
+            self._update_status(f"{len(items)} in queue")
+            self._update_mode_indicators()
+        except Exception:
+            pass
+
+    def update_now_playing(self, title: str, position: float, duration: float) -> None:
+        """Update the now playing display."""
+        try:
+            process_name = self._stealth.get_fake_process_name(title)
+            self.query_one("#current-track", Static).update(process_name)
+            self.query_one("#pos-time", Static).update(self._stealth.format_duration(position))
+            self.query_one("#dur-time", Static).update(self._stealth.format_duration(duration))
+
+            if duration > 0:
+                progress = (position / duration) * 100
+                self.query_one("#track-progress", ProgressBar).update(progress=progress)
+        except Exception:
+            pass
+
+    def _update_status(self, message: str) -> None:
+        """Update status bar."""
+        try:
+            self.query_one("#status-bar", Static).update(message)
+        except Exception:
+            pass
+
+    def _update_mode_indicators(self) -> None:
+        """Update shuffle/repeat indicators."""
+        try:
+            queue = self.app.queue
+
+            shuffle_text = "[SHUFFLE]" if queue.shuffle_mode else ""
+            self.query_one("#shuffle-indicator", Static).update(shuffle_text)
+
+            repeat_text = ""
+            if queue.repeat_mode == "one":
+                repeat_text = "[REPEAT ONE]"
+            elif queue.repeat_mode == "all":
+                repeat_text = "[REPEAT ALL]"
+            self.query_one("#repeat-indicator", Static).update(repeat_text)
+        except Exception:
+            pass
+
+    async def action_toggle_pause(self) -> None:
+        """Toggle playback."""
+        try:
+            await self.app.toggle_pause()
+        except Exception:
+            pass
+
+    async def action_next_track(self) -> None:
+        """Play next track."""
+        try:
+            await self.app.play_next()
+            self.refresh_queue()
+        except Exception:
+            pass
+
+    async def action_prev_track(self) -> None:
+        """Play previous track."""
+        try:
+            await self.app.play_previous()
+            self.refresh_queue()
+        except Exception:
+            pass
+
+    def action_toggle_shuffle(self) -> None:
+        """Toggle shuffle mode."""
+        try:
+            is_shuffle = self.app.queue.toggle_shuffle()
+            self._update_mode_indicators()
+            status = "Shuffle ON" if is_shuffle else "Shuffle OFF"
+            self.post_message(StatusMessage(status, "info"))
+        except Exception:
+            pass
+
+    def action_toggle_repeat(self) -> None:
+        """Cycle repeat mode."""
+        try:
+            mode = self.app.queue.cycle_repeat()
+            self._update_mode_indicators()
+            mode_names = {"none": "OFF", "one": "ONE", "all": "ALL"}
+            self.post_message(StatusMessage(f"Repeat: {mode_names[mode]}", "info"))
+        except Exception:
+            pass
+
+    def action_clear_queue(self) -> None:
+        """Clear the queue."""
+        try:
+            self.app.queue.clear()
+            self.refresh_queue()
+            self.post_message(StatusMessage("Queue cleared", "info"))
+        except Exception:
+            pass
+
+    def action_remove_selected(self) -> None:
+        """Remove selected item from queue."""
+        try:
+            list_view = self.query_one("#queue-list", ListView)
+            if list_view.index is not None:
+                self.app.queue.remove(list_view.index)
+                self.refresh_queue()
+        except Exception:
+            pass

wrkmon/ui/views/search.py

@@ -0,0 +1,150 @@
+"""Search view container for wrkmon."""
+
+import logging
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static, Input, ListView
+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 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),
+    ]
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.results: list[SearchResult] = []
+        self._is_searching = False
+
+    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...")
+
+        try:
+            # Access the app's YouTube client
+            youtube = self.app.youtube
+            self.results = await youtube.search(query, max_results=15)
+            self._display_results()
+        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
+
+    def _display_results(self) -> 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))
+
+        self._update_status(f"Found {len(self.results)} | Enter=Play  A=Queue  /=Search  ↑↓=Nav")
+        list_view.focus()
+
+    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")
+    def handle_result_selected(self, event: ListView.Selected) -> None:
+        """Handle Enter key on a result - play it."""
+        if isinstance(event.item, ResultItem):
+            result = event.item.result
+            self.post_message(TrackSelected(result))
+            self._update_status(f"Playing: {result.title[:40]}...")
+
+    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))
+            self._update_status(f"Queued: {result.title[:40]}...")
+        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."""
+        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()

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