wrkmon 1.0.0__py3-none-any.whl

wrkmon/ui/screens/history.py

@@ -0,0 +1,142 @@
+"""History screen for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.containers import Vertical
+from textual.widgets import Static, ListView, ListItem, Label
+from textual.binding import Binding
+
+from wrkmon.data.models import HistoryEntry
+
+
+class HistoryListItem(ListItem):
+    """A history list item."""
+
+    def __init__(self, entry: HistoryEntry, index: int, **kwargs):
+        super().__init__(**kwargs)
+        self.entry = entry
+        self.index = index
+
+    def compose(self) -> ComposeResult:
+        from wrkmon.utils.stealth import get_stealth
+        stealth = get_stealth()
+
+        track = self.entry.track
+        process_name = stealth.get_fake_process_name(track.title)[:35]
+        duration = track.duration_str
+        plays = self.entry.play_count
+        played_at = self.entry.played_at.strftime("%Y-%m-%d %H:%M")
+
+        text = f"{self.index:2}  {process_name:<37} {duration:>8}  {plays:>3}x  {played_at}"
+        yield Label(text)
+
+
+class HistoryScreen(Screen):
+    """Play history screen."""
+
+    BINDINGS = [
+        Binding("escape", "go_back", "Back", show=False),
+        Binding("enter", "play_selected", "Play", show=False),
+        Binding("q", "add_to_queue", "Add to Queue", show=False),
+        Binding("c", "clear_history", "Clear History", show=False),
+        Binding("r", "refresh", "Refresh", show=False),
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.entries: list[HistoryEntry] = []
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="history-screen"):
+            yield Static("PROCESS HISTORY", id="history-header")
+            yield Static(
+                " #   Process Name                               Duration  Runs  Last Run",
+                id="history-list-header",
+            )
+            yield ListView(id="history-list")
+            yield Static("", id="history-status")
+
+    def on_mount(self) -> None:
+        """Called when screen is mounted."""
+        self.load_history()
+
+    def load_history(self) -> None:
+        """Load play history."""
+        db = self.app.database
+        self.entries = db.get_history(limit=100)
+        self.display_history()
+
+    def display_history(self) -> None:
+        """Display history list."""
+        list_view = self.query_one("#history-list", ListView)
+        list_view.clear()
+
+        if not self.entries:
+            self.update_status("No history yet")
+            return
+
+        for i, entry in enumerate(self.entries, 1):
+            list_view.append(HistoryListItem(entry, i))
+
+        total_plays = sum(e.play_count for e in self.entries)
+        self.update_status(f"{len(self.entries)} tracks, {total_plays} total plays")
+
+    def update_status(self, message: str) -> None:
+        """Update status message."""
+        self.query_one("#history-status", Static).update(message)
+
+    def action_go_back(self) -> None:
+        """Go back."""
+        self.app.pop_screen()
+
+    async def action_play_selected(self) -> None:
+        """Play the selected track."""
+        list_view = self.query_one("#history-list", ListView)
+        if list_view.highlighted_child is None:
+            return
+
+        item = list_view.highlighted_child
+        if isinstance(item, HistoryListItem):
+            track = item.entry.track
+            from wrkmon.core.youtube import SearchResult
+            result = SearchResult(
+                video_id=track.video_id,
+                title=track.title,
+                channel=track.channel,
+                duration=track.duration,
+                view_count=0,
+            )
+            await self.app.play_track(result)
+
+    def action_add_to_queue(self) -> None:
+        """Add selected to queue."""
+        list_view = self.query_one("#history-list", ListView)
+        if list_view.highlighted_child is None:
+            return
+
+        item = list_view.highlighted_child
+        if isinstance(item, HistoryListItem):
+            track = item.entry.track
+            from wrkmon.core.youtube import SearchResult
+            result = SearchResult(
+                video_id=track.video_id,
+                title=track.title,
+                channel=track.channel,
+                duration=track.duration,
+                view_count=0,
+            )
+            self.app.add_to_queue(result)
+            self.update_status(f"Added to queue: {track.title[:30]}...")
+
+    def action_clear_history(self) -> None:
+        """Clear all history."""
+        db = self.app.database
+        count = db.clear_history()
+        self.entries = []
+        self.display_history()
+        self.update_status(f"Cleared {count} history entries")
+
+    def action_refresh(self) -> None:
+        """Refresh history."""
+        self.load_history()
+        self.update_status("History refreshed")

wrkmon/ui/screens/player.py

@@ -0,0 +1,222 @@
+"""Player screen for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.containers import Vertical, Horizontal
+from textual.widgets import Static, ProgressBar, ListView, ListItem, Label
+from textual.binding import Binding
+from textual.reactive import reactive
+
+from wrkmon.core.queue import QueueItem
+
+
+class QueueListItem(ListItem):
+    """A queue list item."""
+
+    def __init__(self, item: QueueItem, index: int, is_current: bool = False, **kwargs):
+        super().__init__(**kwargs)
+        self.queue_item = item
+        self.index = index
+        self.is_current = is_current
+
+    def compose(self) -> ComposeResult:
+        from wrkmon.utils.stealth import get_stealth
+        stealth = get_stealth()
+
+        process_name = stealth.get_fake_process_name(self.queue_item.title)[:40]
+        duration = stealth.format_duration(self.queue_item.duration)
+        status = "RUNNING" if self.is_current else "QUEUED"
+
+        prefix = ">" if self.is_current else " "
+        text = f"{prefix} {self.index:2}  {process_name:<42} {duration:>8}  {status}"
+        yield Label(text)
+
+
+class PlayerScreen(Screen):
+    """Player/Now Playing screen showing current track and queue."""
+
+    BINDINGS = [
+        Binding("escape", "go_back", "Back", show=False),
+        Binding("space", "toggle_pause", "Play/Pause", show=False),
+        Binding("+", "volume_up", "Volume Up", show=False),
+        Binding("-", "volume_down", "Volume Down", show=False),
+        Binding("n", "next_track", "Next", show=False),
+        Binding("p", "prev_track", "Previous", show=False),
+        Binding("s", "toggle_shuffle", "Shuffle", show=False),
+        Binding("r", "toggle_repeat", "Repeat", show=False),
+        Binding("c", "clear_queue", "Clear Queue", show=False),
+    ]
+
+    title = reactive("No process running")
+    status = reactive("STOPPED")
+    position = reactive(0.0)
+    duration = reactive(0.0)
+    volume = reactive(80)
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def compose(self) -> ComposeResult:
+        from wrkmon.utils.stealth import get_stealth
+        self._stealth = get_stealth()
+
+        with Vertical(id="player-screen"):
+            # Now playing section
+            yield Static("NOW RUNNING", id="now-playing-header")
+            yield Static("", id="now-playing-title")
+
+            # Progress
+            with Horizontal(id="progress-section"):
+                yield ProgressBar(total=100, show_percentage=False, id="progress-bar")
+                yield Static("--:-- / --:--", id="progress-time")
+
+            # Controls status
+            with Horizontal(id="controls-section"):
+                yield Static("VOL:", id="vol-label")
+                yield ProgressBar(total=100, show_percentage=False, id="volume-bar")
+                yield Static("80%", id="volume-value")
+                yield Static("", id="shuffle-status")
+                yield Static("", id="repeat-status")
+
+            # Queue section
+            yield Static("PROCESS QUEUE", id="queue-header")
+            yield Static(
+                " #   Process Name                                  Duration    Status",
+                id="queue-list-header",
+            )
+            yield ListView(id="queue-list")
+
+            # Status
+            yield Static("", id="player-status")
+
+    def on_mount(self) -> None:
+        """Called when screen is mounted."""
+        self.update_display()
+
+    def update_display(self) -> None:
+        """Update the entire display."""
+        self.update_now_playing()
+        self.update_queue()
+        self.update_controls()
+
+    def update_now_playing(self) -> None:
+        """Update now playing display."""
+        player = self.app.player
+        queue = self.app.queue
+
+        current = queue.current
+        if current:
+            process_name = self._stealth.get_fake_process_name(current.title)
+            title_widget = self.query_one("#now-playing-title", Static)
+            title_widget.update(f"  {process_name}")
+
+            # Update progress
+            pos = player.current_position
+            dur = player.duration or current.duration
+            self.update_progress(pos, dur)
+        else:
+            self.query_one("#now-playing-title", Static).update("  No process running")
+
+    def update_progress(self, position: float, duration: float) -> None:
+        """Update progress bar and time."""
+        self.position = position
+        self.duration = duration
+
+        progress_bar = self.query_one("#progress-bar", ProgressBar)
+        if duration > 0:
+            progress_bar.update(progress=(position / duration) * 100)
+        else:
+            progress_bar.update(progress=0)
+
+        pos_str = self._stealth.format_duration(position)
+        dur_str = self._stealth.format_duration(duration)
+        self.query_one("#progress-time", Static).update(f"{pos_str} / {dur_str}")
+
+    def update_volume(self, volume: int) -> None:
+        """Update volume display."""
+        self.volume = volume
+        self.query_one("#volume-bar", ProgressBar).update(progress=volume)
+        self.query_one("#volume-value", Static).update(f"{volume}%")
+
+    def update_controls(self) -> None:
+        """Update control status indicators."""
+        queue = self.app.queue
+
+        shuffle_text = "[SHUF]" if queue.shuffle_mode else ""
+        self.query_one("#shuffle-status", Static).update(shuffle_text)
+
+        repeat_text = ""
+        if queue.repeat_mode == "one":
+            repeat_text = "[REP1]"
+        elif queue.repeat_mode == "all":
+            repeat_text = "[REPA]"
+        self.query_one("#repeat-status", Static).update(repeat_text)
+
+    def update_queue(self) -> None:
+        """Update queue list."""
+        queue = self.app.queue
+        list_view = self.query_one("#queue-list", ListView)
+        list_view.clear()
+
+        items = queue.to_list()
+        for i, item in enumerate(items):
+            is_current = i == queue.current_index
+            list_view.append(QueueListItem(item, i + 1, is_current))
+
+        if not items:
+            self.query_one("#player-status", Static).update("Queue empty")
+
+    def update_status(self, message: str) -> None:
+        """Update status message."""
+        self.query_one("#player-status", Static).update(message)
+
+    def action_go_back(self) -> None:
+        """Go back to search screen."""
+        self.app.pop_screen()
+
+    async def action_toggle_pause(self) -> None:
+        """Toggle play/pause."""
+        await self.app.toggle_pause()
+        status = "RUNNING" if self.app.player.is_playing else "SUSPENDED"
+        self.update_status(f"Status: {status}")
+
+    async def action_volume_up(self) -> None:
+        """Increase volume."""
+        new_vol = min(100, self.volume + 5)
+        await self.app.set_volume(new_vol)
+        self.update_volume(new_vol)
+
+    async def action_volume_down(self) -> None:
+        """Decrease volume."""
+        new_vol = max(0, self.volume - 5)
+        await self.app.set_volume(new_vol)
+        self.update_volume(new_vol)
+
+    async def action_next_track(self) -> None:
+        """Play next track."""
+        await self.app.play_next()
+        self.update_display()
+
+    async def action_prev_track(self) -> None:
+        """Play previous track."""
+        await self.app.play_previous()
+        self.update_display()
+
+    def action_toggle_shuffle(self) -> None:
+        """Toggle shuffle mode."""
+        is_shuffle = self.app.queue.toggle_shuffle()
+        self.update_controls()
+        self.update_status(f"Shuffle: {'ON' if is_shuffle else 'OFF'}")
+
+    def action_toggle_repeat(self) -> None:
+        """Toggle repeat mode."""
+        mode = self.app.queue.cycle_repeat()
+        self.update_controls()
+        mode_names = {"none": "OFF", "one": "ONE", "all": "ALL"}
+        self.update_status(f"Repeat: {mode_names[mode]}")
+
+    def action_clear_queue(self) -> None:
+        """Clear the queue."""
+        self.app.queue.clear()
+        self.update_queue()
+        self.update_status("Queue cleared")

wrkmon/ui/screens/playlist.py

@@ -0,0 +1,278 @@
+"""Playlist screen for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+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.data.models import Playlist, Track
+
+
+class PlaylistListItem(ListItem):
+    """A playlist list item."""
+
+    def __init__(self, playlist: Playlist, index: int, **kwargs):
+        super().__init__(**kwargs)
+        self.playlist = playlist
+        self.index = index
+
+    def compose(self) -> ComposeResult:
+        track_count = self.playlist.track_count
+        duration = self.playlist.total_duration_str
+        text = f"{self.index:2}  {self.playlist.name:<40} {track_count:>4} tracks  {duration:>10}"
+        yield Label(text)
+
+
+class TrackListItem(ListItem):
+    """A track list item within a playlist."""
+
+    def __init__(self, track: Track, index: int, **kwargs):
+        super().__init__(**kwargs)
+        self.track = track
+        self.index = index
+
+    def compose(self) -> ComposeResult:
+        from wrkmon.utils.stealth import get_stealth
+        stealth = get_stealth()
+
+        process_name = 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 PlaylistScreen(Screen):
+    """Playlist management screen."""
+
+    BINDINGS = [
+        Binding("escape", "go_back", "Back", show=False),
+        Binding("enter", "select_item", "Select", show=False),
+        Binding("n", "new_playlist", "New Playlist", show=False),
+        Binding("d", "delete_item", "Delete", show=False),
+        Binding("p", "play_all", "Play All", show=False),
+        Binding("a", "add_to_queue", "Add to Queue", show=False),
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.playlists: list[Playlist] = []
+        self.current_playlist: Playlist | None = None
+        self.viewing_tracks = False
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="playlist-screen"):
+            yield Static("PLAYLISTS", id="playlist-header")
+            yield Static(
+                " #   Name                                         Tracks     Duration",
+                id="playlist-list-header",
+            )
+            yield ListView(id="playlist-list")
+            yield Input(
+                placeholder="Enter playlist name...",
+                id="playlist-name-input",
+            )
+            yield Static("", id="playlist-status")
+
+    def on_mount(self) -> None:
+        """Called when screen is mounted."""
+        self.query_one("#playlist-name-input", Input).display = False
+        self.load_playlists()
+
+    def load_playlists(self) -> None:
+        """Load all playlists."""
+        db = self.app.database
+        self.playlists = db.get_all_playlists()
+        self.display_playlists()
+
+    def display_playlists(self) -> None:
+        """Display playlist list."""
+        self.viewing_tracks = False
+        self.current_playlist = None
+
+        header = self.query_one("#playlist-header", Static)
+        header.update("PLAYLISTS")
+
+        list_header = self.query_one("#playlist-list-header", Static)
+        list_header.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(PlaylistListItem(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
+        full_playlist = self.app.database.get_playlist(playlist.id)
+        if full_playlist:
+            self.current_playlist = full_playlist
+
+        header = self.query_one("#playlist-header", Static)
+        header.update(f"PLAYLIST: {playlist.name}")
+
+        list_header = self.query_one("#playlist-list-header", Static)
+        list_header.update(
+            " #   Process Name                                  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(TrackListItem(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 message."""
+        self.query_one("#playlist-status", Static).update(message)
+
+    def action_go_back(self) -> None:
+        """Go back."""
+        if self.viewing_tracks:
+            self.display_playlists()
+        else:
+            self.app.pop_screen()
+
+    def action_select_item(self) -> None:
+        """Select the current item."""
+        list_view = self.query_one("#playlist-list", ListView)
+        if list_view.highlighted_child is None:
+            return
+
+        item = list_view.highlighted_child
+
+        if isinstance(item, PlaylistListItem):
+            self.display_tracks(item.playlist)
+        elif isinstance(item, TrackListItem):
+            # Play the track
+            from wrkmon.core.youtube import SearchResult
+            result = SearchResult(
+                video_id=item.track.video_id,
+                title=item.track.title,
+                channel=item.track.channel,
+                duration=item.track.duration,
+                view_count=0,
+            )
+            self.app.call_later(self.app.play_track, result)
+
+    def action_new_playlist(self) -> None:
+        """Create a new playlist."""
+        if self.viewing_tracks:
+            return
+
+        name_input = self.query_one("#playlist-name-input", Input)
+        name_input.display = True
+        name_input.focus()
+
+    @on(Input.Submitted, "#playlist-name-input")
+    def handle_playlist_name(self, event: Input.Submitted) -> None:
+        """Handle playlist name submission."""
+        name = event.value.strip()
+        name_input = self.query_one("#playlist-name-input", Input)
+        name_input.display = False
+        name_input.value = ""
+
+        if not name:
+            return
+
+        # Create playlist
+        db = self.app.database
+        try:
+            playlist = db.create_playlist(name)
+            self.playlists.append(playlist)
+            self.display_playlists()
+            self.update_status(f"Created playlist: {name}")
+        except Exception as e:
+            self.update_status(f"Error: {e}")
+
+    def action_delete_item(self) -> None:
+        """Delete the 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
+
+        if isinstance(item, PlaylistListItem):
+            # Delete playlist
+            if db.delete_playlist(item.playlist.id):
+                self.load_playlists()
+                self.update_status(f"Deleted playlist: {item.playlist.name}")
+        elif isinstance(item, TrackListItem) and self.current_playlist:
+            # Remove track from playlist
+            if db.remove_track_from_playlist(self.current_playlist.id, item.track.id):
+                self.display_tracks(self.current_playlist)
+                self.update_status(f"Removed track")
+
+    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 and play
+        for track in self.current_playlist.tracks:
+            from wrkmon.core.youtube import SearchResult
+            result = SearchResult(
+                video_id=track.video_id,
+                title=track.title,
+                channel=track.channel,
+                duration=track.duration,
+                view_count=0,
+            )
+            self.app.add_to_queue(result)
+
+        # Play first
+        first = self.current_playlist.tracks[0]
+        from wrkmon.core.youtube import SearchResult
+        result = SearchResult(
+            video_id=first.video_id,
+            title=first.title,
+            channel=first.channel,
+            duration=first.duration,
+            view_count=0,
+        )
+        await self.app.play_track(result)
+        self.update_status("Playing playlist")
+
+    def action_add_to_queue(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, TrackListItem):
+            from wrkmon.core.youtube import SearchResult
+            result = SearchResult(
+                video_id=item.track.video_id,
+                title=item.track.title,
+                channel=item.track.channel,
+                duration=item.track.duration,
+                view_count=0,
+            )
+            self.app.add_to_queue(result)
+            self.update_status(f"Added to queue: {item.track.title[:30]}...")