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

wrkmon/core/media_keys.py

@@ -0,0 +1,377 @@
+"""Cross-platform media key support for wrkmon.
+
+Linux: Uses MPRIS D-Bus interface (standard way for desktop environments)
+Windows/macOS: Uses pynput for global hotkey listening
+"""
+
+import asyncio
+import logging
+import sys
+from typing import Callable, Optional, Any
+
+logger = logging.getLogger("wrkmon.media_keys")
+
+# Platform detection
+IS_LINUX = sys.platform == "linux"
+IS_WINDOWS = sys.platform == "win32"
+IS_MACOS = sys.platform == "darwin"
+
+# Check available backends
+MPRIS_AVAILABLE = False
+PYNPUT_AVAILABLE = False
+
+if IS_LINUX:
+    try:
+        from dbus_next.aio import MessageBus
+        from dbus_next.service import ServiceInterface, method, dbus_property
+        from dbus_next import Variant, BusType
+        MPRIS_AVAILABLE = True
+    except ImportError:
+        logger.debug("dbus-next not installed, MPRIS support disabled")
+
+if IS_WINDOWS or IS_MACOS:
+    try:
+        from pynput import keyboard
+        PYNPUT_AVAILABLE = True
+    except ImportError:
+        logger.debug("pynput not installed, global hotkey support disabled")
+
+
+# ============================================
+# MPRIS Implementation (Linux)
+# ============================================
+
+if MPRIS_AVAILABLE:
+    class MPRISRootInterface(ServiceInterface):
+        """MPRIS MediaPlayer2 root interface."""
+
+        def __init__(self, callback: Callable):
+            super().__init__("org.mpris.MediaPlayer2")
+            self._callback = callback
+
+        @method()
+        def Raise(self):
+            pass
+
+        @method()
+        def Quit(self):
+            asyncio.create_task(self._callback("quit"))
+
+        @dbus_property()
+        def CanQuit(self) -> "b":
+            return True
+
+        @dbus_property()
+        def CanRaise(self) -> "b":
+            return False
+
+        @dbus_property()
+        def HasTrackList(self) -> "b":
+            return False
+
+        @dbus_property()
+        def Identity(self) -> "s":
+            return "wrkmon"
+
+        @dbus_property()
+        def DesktopEntry(self) -> "s":
+            return "wrkmon"
+
+        @dbus_property()
+        def SupportedUriSchemes(self) -> "as":
+            return ["https", "http"]
+
+        @dbus_property()
+        def SupportedMimeTypes(self) -> "as":
+            return ["audio/mpeg", "audio/ogg", "audio/webm"]
+
+
+    class MPRISPlayerInterface(ServiceInterface):
+        """MPRIS MediaPlayer2.Player interface."""
+
+        def __init__(self, callback: Callable):
+            super().__init__("org.mpris.MediaPlayer2.Player")
+            self._callback = callback
+            self._is_playing = False
+            self._position = 0
+            self._metadata: dict = {}
+            self._volume = 1.0
+
+        @method()
+        def Next(self):
+            logger.info("MPRIS: Next track")
+            asyncio.create_task(self._callback("next"))
+
+        @method()
+        def Previous(self):
+            logger.info("MPRIS: Previous track")
+            asyncio.create_task(self._callback("previous"))
+
+        @method()
+        def Pause(self):
+            logger.info("MPRIS: Pause")
+            asyncio.create_task(self._callback("pause"))
+
+        @method()
+        def PlayPause(self):
+            logger.info("MPRIS: PlayPause")
+            asyncio.create_task(self._callback("play_pause"))
+
+        @method()
+        def Stop(self):
+            logger.info("MPRIS: Stop")
+            asyncio.create_task(self._callback("stop"))
+
+        @method()
+        def Play(self):
+            logger.info("MPRIS: Play")
+            asyncio.create_task(self._callback("play"))
+
+        @method()
+        def Seek(self, offset: "x"):
+            asyncio.create_task(self._callback("seek", offset / 1_000_000))
+
+        @method()
+        def SetPosition(self, track_id: "o", position: "x"):
+            asyncio.create_task(self._callback("set_position", position / 1_000_000))
+
+        @dbus_property()
+        def PlaybackStatus(self) -> "s":
+            return "Playing" if self._is_playing else "Paused"
+
+        @dbus_property()
+        def Rate(self) -> "d":
+            return 1.0
+
+        @dbus_property()
+        def Metadata(self) -> "a{sv}":
+            return self._metadata
+
+        @dbus_property()
+        def Volume(self) -> "d":
+            return self._volume
+
+        @Volume.setter
+        def Volume(self, value: "d"):
+            self._volume = max(0.0, min(1.0, value))
+            asyncio.create_task(self._callback("set_volume", int(self._volume * 100)))
+
+        @dbus_property()
+        def Position(self) -> "x":
+            return int(self._position * 1_000_000)
+
+        @dbus_property()
+        def MinimumRate(self) -> "d":
+            return 1.0
+
+        @dbus_property()
+        def MaximumRate(self) -> "d":
+            return 1.0
+
+        @dbus_property()
+        def CanGoNext(self) -> "b":
+            return True
+
+        @dbus_property()
+        def CanGoPrevious(self) -> "b":
+            return True
+
+        @dbus_property()
+        def CanPlay(self) -> "b":
+            return True
+
+        @dbus_property()
+        def CanPause(self) -> "b":
+            return True
+
+        @dbus_property()
+        def CanSeek(self) -> "b":
+            return True
+
+        @dbus_property()
+        def CanControl(self) -> "b":
+            return True
+
+        def set_playing(self, playing: bool):
+            self._is_playing = playing
+
+        def set_position(self, pos: float):
+            self._position = pos
+
+        def set_volume(self, vol: int):
+            self._volume = vol / 100.0
+
+        def set_metadata(self, title: str, artist: str, duration: int, art_url: str, track_id: str):
+            self._metadata = {
+                "mpris:trackid": Variant("o", f"/org/mpris/MediaPlayer2/Track/{track_id or 'unknown'}"),
+                "mpris:length": Variant("x", duration * 1_000_000),
+                "xesam:title": Variant("s", title),
+                "xesam:artist": Variant("as", [artist] if artist else []),
+            }
+            if art_url:
+                self._metadata["mpris:artUrl"] = Variant("s", art_url)
+
+
+# ============================================
+# Cross-platform MediaKeysHandler
+# ============================================
+
+class MediaKeysHandler:
+    """Cross-platform media keys handler."""
+
+    def __init__(self, callback: Callable):
+        """
+        Initialize media keys handler.
+
+        Args:
+            callback: Async function called with (command, *args).
+                     Commands: 'play', 'pause', 'play_pause', 'stop',
+                              'next', 'previous', 'seek', 'set_volume', 'quit'
+        """
+        self._callback = callback
+        self._running = False
+
+        # Platform-specific components
+        self._bus: Optional[Any] = None
+        self._root_interface: Optional[Any] = None
+        self._player_interface: Optional[Any] = None
+        self._keyboard_listener: Optional[Any] = None
+
+    @property
+    def is_available(self) -> bool:
+        """Check if media keys are available on this platform."""
+        if IS_LINUX:
+            return MPRIS_AVAILABLE
+        return PYNPUT_AVAILABLE
+
+    @property
+    def is_running(self) -> bool:
+        """Check if media keys handler is active."""
+        return self._running
+
+    @property
+    def backend_name(self) -> str:
+        """Get the name of the active backend."""
+        if IS_LINUX and MPRIS_AVAILABLE:
+            return "MPRIS (D-Bus)"
+        elif PYNPUT_AVAILABLE:
+            return "pynput (global hotkeys)"
+        return "none"
+
+    async def start(self) -> bool:
+        """Start listening for media keys."""
+        if self._running:
+            return True
+
+        if IS_LINUX:
+            return await self._start_mpris()
+        elif PYNPUT_AVAILABLE:
+            return self._start_pynput()
+
+        logger.info("No media key backend available")
+        return False
+
+    async def stop(self):
+        """Stop listening for media keys."""
+        if IS_LINUX and self._bus:
+            try:
+                self._bus.disconnect()
+            except Exception:
+                pass
+
+        if self._keyboard_listener:
+            try:
+                self._keyboard_listener.stop()
+            except Exception:
+                pass
+
+        self._running = False
+        logger.info("Media keys handler stopped")
+
+    async def _start_mpris(self) -> bool:
+        """Start MPRIS D-Bus service (Linux)."""
+        if not MPRIS_AVAILABLE:
+            return False
+
+        try:
+            self._bus = await MessageBus(bus_type=BusType.SESSION).connect()
+            self._root_interface = MPRISRootInterface(self._callback)
+            self._player_interface = MPRISPlayerInterface(self._callback)
+
+            self._bus.export("/org/mpris/MediaPlayer2", self._root_interface)
+            self._bus.export("/org/mpris/MediaPlayer2", self._player_interface)
+
+            await self._bus.request_name("org.mpris.MediaPlayer2.wrkmon")
+
+            self._running = True
+            logger.info("MPRIS service started - media keys active")
+            return True
+
+        except Exception as e:
+            logger.warning(f"Failed to start MPRIS: {e}")
+            return False
+
+    def _start_pynput(self) -> bool:
+        """Start pynput global hotkey listener (Windows/macOS)."""
+        if not PYNPUT_AVAILABLE:
+            return False
+
+        try:
+            def on_press(key):
+                try:
+                    # Check for media keys
+                    if hasattr(key, 'name'):
+                        if key == keyboard.Key.media_play_pause:
+                            asyncio.create_task(self._callback("play_pause"))
+                        elif key == keyboard.Key.media_next:
+                            asyncio.create_task(self._callback("next"))
+                        elif key == keyboard.Key.media_previous:
+                            asyncio.create_task(self._callback("previous"))
+                        elif key == keyboard.Key.media_volume_up:
+                            asyncio.create_task(self._callback("volume_up"))
+                        elif key == keyboard.Key.media_volume_down:
+                            asyncio.create_task(self._callback("volume_down"))
+                        elif key == keyboard.Key.media_volume_mute:
+                            asyncio.create_task(self._callback("mute"))
+                except Exception as e:
+                    logger.debug(f"Error handling key: {e}")
+
+            self._keyboard_listener = keyboard.Listener(on_press=on_press)
+            self._keyboard_listener.start()
+
+            self._running = True
+            logger.info("pynput listener started - media keys active")
+            return True
+
+        except Exception as e:
+            logger.warning(f"Failed to start pynput listener: {e}")
+            return False
+
+    def update_playback(self, is_playing: bool = None, position: float = None, volume: int = None):
+        """Update playback state (for MPRIS)."""
+        if not self._player_interface:
+            return
+        if is_playing is not None:
+            self._player_interface.set_playing(is_playing)
+        if position is not None:
+            self._player_interface.set_position(position)
+        if volume is not None:
+            self._player_interface.set_volume(volume)
+
+    def update_track(self, title: str = "", artist: str = "", duration: int = 0,
+                     art_url: str = "", track_id: str = ""):
+        """Update current track metadata (for MPRIS)."""
+        if self._player_interface:
+            self._player_interface.set_metadata(title, artist, duration, art_url, track_id)
+
+
+# Singleton instance
+_handler: Optional[MediaKeysHandler] = None
+
+
+def get_media_keys_handler(callback: Callable = None) -> Optional[MediaKeysHandler]:
+    """Get or create the media keys handler."""
+    global _handler
+    if _handler is None and callback:
+        _handler = MediaKeysHandler(callback)
+    return _handler

wrkmon/core/queue.py

@@ -16,6 +16,7 @@ class QueueItem:
     channel: str
     duration: int
     added_at: float = 0.0
+    playback_position: int = 0  # Last played position in seconds
 
     @classmethod
     def from_search_result(cls, result: SearchResult) -> "QueueItem":
@@ -28,8 +29,34 @@ class QueueItem:
             channel=result.channel,
             duration=result.duration,
             added_at=time.time(),
+            playback_position=0,
         )
 
+    @classmethod
+    def from_dict(cls, data: dict) -> "QueueItem":
+        """Create a queue item from a dictionary."""
+        import time
+
+        return cls(
+            video_id=data["video_id"],
+            title=data["title"],
+            channel=data["channel"],
+            duration=data["duration"],
+            added_at=data.get("added_at", time.time()),
+            playback_position=data.get("playback_position", 0),
+        )
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for serialization."""
+        return {
+            "video_id": self.video_id,
+            "title": self.title,
+            "channel": self.channel,
+            "duration": self.duration,
+            "added_at": self.added_at,
+            "playback_position": self.playback_position,
+        }
+
     @property
     def url(self) -> str:
         """Get the YouTube URL."""
@@ -262,3 +289,31 @@ class PlayQueue:
         if self.shuffle_mode and self._shuffle_order:
             return [self.items[i] for i in self._shuffle_order]
         return list(self.items)
+
+    def update_playback_position(self, video_id: str, position: int) -> None:
+        """Update the playback position for a queue item."""
+        for item in self.items:
+            if item.video_id == video_id:
+                item.playback_position = position
+                break
+
+    def get_playback_position(self, video_id: str) -> int:
+        """Get the saved playback position for a queue item."""
+        for item in self.items:
+            if item.video_id == video_id:
+                return item.playback_position
+        return 0
+
+    def to_dict_list(self) -> list[dict]:
+        """Convert all items to list of dicts for serialization."""
+        return [item.to_dict() for item in self.items]
+
+    def load_from_dicts(self, items: list[dict], current_index: int = -1) -> None:
+        """Load queue from list of dicts."""
+        self.clear()
+        for data in items:
+            item = QueueItem.from_dict(data)
+            self.items.append(item)
+        self.current_index = current_index if -1 <= current_index < len(self.items) else -1
+        if self.shuffle_mode:
+            self._create_shuffle_order()

wrkmon/core/youtube.py

@@ -176,3 +176,105 @@ class YouTubeClient:
                 )
         except Exception:
             return None
+
+    async def get_trending_music(self, max_results: int = 10) -> list[SearchResult]:
+        """Get trending/popular music videos."""
+        return await asyncio.to_thread(self._get_trending_sync, max_results)
+
+    def _get_trending_sync(self, max_results: int) -> list[SearchResult]:
+        """Fetch trending music from YouTube Music charts or popular searches."""
+        results = []
+
+        # Try to get from YouTube Music trending/charts
+        trending_queries = [
+            "https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf",  # Popular Music
+            "https://www.youtube.com/playlist?list=PL4fGSI1pDJn6puJdseH2Rt9sMvt9E2M4i",  # Trending Music
+        ]
+
+        opts = {
+            **self._search_opts,
+            "playlistend": max_results,
+            "extract_flat": True,
+        }
+
+        # Try playlist first
+        for playlist_url in trending_queries:
+            try:
+                with yt_dlp.YoutubeDL(opts) as ydl:
+                    info = ydl.extract_info(playlist_url, download=False)
+
+                    if info and "entries" in info:
+                        for entry in info["entries"][:max_results]:
+                            if entry is None:
+                                continue
+                            result = SearchResult(
+                                video_id=entry.get("id", ""),
+                                title=entry.get("title", "Unknown"),
+                                channel=entry.get("channel", entry.get("uploader", "Unknown")),
+                                duration=entry.get("duration", 0) or 0,
+                                view_count=entry.get("view_count", 0) or 0,
+                                thumbnail_url=entry.get("thumbnail"),
+                            )
+                            if result.video_id:
+                                results.append(result)
+
+                        if results:
+                            return results[:max_results]
+            except Exception:
+                continue
+
+        # Fallback: search for popular music
+        fallback_searches = [
+            "popular music 2024",
+            "trending songs",
+            "top hits music",
+        ]
+
+        for query in fallback_searches:
+            try:
+                search_results = self._search_sync(query, max_results)
+                if search_results:
+                    return search_results
+            except Exception:
+                continue
+
+        return results
+
+    async def get_recommendations(self, video_id: str, max_results: int = 5) -> list[SearchResult]:
+        """Get recommended videos based on a video (related videos)."""
+        return await asyncio.to_thread(self._get_recommendations_sync, video_id, max_results)
+
+    def _get_recommendations_sync(self, video_id: str, max_results: int) -> list[SearchResult]:
+        """Get related/recommended videos."""
+        results = []
+        url = f"https://www.youtube.com/watch?v={video_id}"
+
+        opts = {
+            "quiet": True,
+            "no_warnings": True,
+            "extract_flat": False,
+            "noplaylist": True,
+        }
+
+        try:
+            with yt_dlp.YoutubeDL(opts) as ydl:
+                info = ydl.extract_info(url, download=False)
+
+                if info and "related_videos" in info:
+                    for entry in info["related_videos"][:max_results]:
+                        if entry is None:
+                            continue
+                        result = SearchResult(
+                            video_id=entry.get("id", ""),
+                            title=entry.get("title", "Unknown"),
+                            channel=entry.get("channel", entry.get("uploader", "Unknown")),
+                            duration=entry.get("duration", 0) or 0,
+                            view_count=entry.get("view_count", 0) or 0,
+                            thumbnail_url=entry.get("thumbnail"),
+                        )
+                        if result.video_id:
+                            results.append(result)
+        except Exception:
+            pass
+
+        return results

wrkmon/data/database.py

@@ -424,3 +424,123 @@ class Database:
             )
 
         return entries
+
+    # ==================== Queue Persistence ====================
+
+    def save_queue(
+        self,
+        items: list[dict],
+        current_index: int,
+        shuffle_mode: bool,
+        repeat_mode: str,
+    ) -> None:
+        """
+        Save the current queue to database.
+
+        Args:
+            items: List of dicts with video_id, title, channel, duration, playback_position
+            current_index: Current playing index
+            shuffle_mode: Whether shuffle is enabled
+            repeat_mode: 'none', 'one', or 'all'
+        """
+        # Clear existing queue
+        self._conn.execute("DELETE FROM queue")
+
+        # Save each item
+        for position, item in enumerate(items):
+            # Get or create track
+            track = self.get_or_create_track(
+                video_id=item["video_id"],
+                title=item["title"],
+                channel=item["channel"],
+                duration=item["duration"],
+            )
+
+            self._conn.execute(
+                """
+                INSERT INTO queue (track_id, position, playback_position)
+                VALUES (?, ?, ?)
+                """,
+                (track.id, position, item.get("playback_position", 0)),
+            )
+
+        # Save queue state
+        self._conn.execute(
+            """
+            UPDATE queue_state SET
+                current_index = ?,
+                shuffle_mode = ?,
+                repeat_mode = ?,
+                updated_at = ?
+            WHERE id = 1
+            """,
+            (current_index, int(shuffle_mode), repeat_mode, datetime.now()),
+        )
+
+        self._conn.commit()
+
+    def load_queue(self) -> tuple[list[dict], int, bool, str]:
+        """
+        Load the saved queue from database.
+
+        Returns:
+            Tuple of (items, current_index, shuffle_mode, repeat_mode)
+            items is a list of dicts with video_id, title, channel, duration, playback_position
+        """
+        items = []
+
+        # Load queue items
+        cursor = self._conn.execute(
+            """
+            SELECT q.position, q.playback_position, t.video_id, t.title, t.channel, t.duration
+            FROM queue q
+            JOIN tracks t ON t.id = q.track_id
+            ORDER BY q.position
+            """
+        )
+
+        for row in cursor.fetchall():
+            items.append({
+                "video_id": row["video_id"],
+                "title": row["title"],
+                "channel": row["channel"],
+                "duration": row["duration"],
+                "playback_position": row["playback_position"],
+            })
+
+        # Load queue state
+        cursor = self._conn.execute(
+            "SELECT current_index, shuffle_mode, repeat_mode FROM queue_state WHERE id = 1"
+        )
+        row = cursor.fetchone()
+
+        if row:
+            current_index = row["current_index"]
+            shuffle_mode = bool(row["shuffle_mode"])
+            repeat_mode = row["repeat_mode"]
+        else:
+            current_index = -1
+            shuffle_mode = False
+            repeat_mode = "none"
+
+        return items, current_index, shuffle_mode, repeat_mode
+
+    def update_queue_item_position(self, video_id: str, playback_position: int) -> None:
+        """Update the playback position for a queue item."""
+        self._conn.execute(
+            """
+            UPDATE queue SET playback_position = ?
+            WHERE track_id = (SELECT id FROM tracks WHERE video_id = ?)
+            """,
+            (playback_position, video_id),
+        )
+        self._conn.commit()
+
+    def clear_queue(self) -> None:
+        """Clear the saved queue."""
+        self._conn.execute("DELETE FROM queue")
+        self._conn.execute(
+            "UPDATE queue_state SET current_index = -1, updated_at = ? WHERE id = 1",
+            (datetime.now(),),
+        )
+        self._conn.commit()