ytm-cli 0.7.3__tar.gz → 0.9.0__tar.gz

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytm-cli
-Version: 0.7.3
+Version: 0.9.0
 Summary: YouTube Music CLI tool with interactive terminal interface
 Author-email: thieuluan <thieuluan.dark@gmail.com>
 License-Expression: MIT
@@ -29,6 +29,8 @@ Requires-Dist: mpv
 Requires-Dist: requests
 Requires-Dist: pyperclip
 Requires-Dist: numpy
+Requires-Dist: yt-dlp
+Requires-Dist: yt-dlp-ejs
 Dynamic: license-file
 
 # YTM - YouTube Music CLI

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ytm-cli"
-version = "0.7.3"
+version = "0.9.0"
 description = "YouTube Music CLI tool with interactive terminal interface"
 readme = "README.md"
 license = "MIT"
@@ -34,6 +34,8 @@ dependencies = [
     "requests",
     "pyperclip",
     "numpy",
+    "yt-dlp",
+    "yt-dlp-ejs",
 ]
 
 [dependency-groups]

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/tests/test_config.py

@@ -80,27 +80,6 @@ class TestGetMpvFlags:
 
             assert result == ["--no-video", "--volume=50"]
 
-    def test_get_mpv_flags_no_mpv_section(self):
-        """Test when mpv section doesn't exist"""
-        mock_config = Mock()
-        mock_config.__contains__ = Mock(return_value=False)
-
-        with patch("ytm_cli.config.config", mock_config):
-            result = get_mpv_flags()
-
-            assert result == []
-
-    def test_get_mpv_flags_no_flags_key(self):
-        """Test when mpv section exists but no flags key"""
-        mock_config = Mock()
-        mock_config.__contains__ = Mock(side_effect=lambda x: x == "mpv")
-        mock_config.__getitem__ = Mock(return_value={})
-
-        with patch("ytm_cli.config.config", mock_config):
-            result = get_mpv_flags()
-
-            assert result == []
-
     def test_get_mpv_flags_empty_flags(self):
         """Test when flags value is empty"""
         mock_config = Mock()

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/tests/test_hybrid_player.py

@@ -6,7 +6,23 @@ import unittest
 from unittest.mock import MagicMock, patch
 
 from ytm_cli.ffmpeg_player import FFmpegPlayerService
-from ytm_cli.hybrid_player import CLIHybridPlayerService
+from ytm_cli.hybrid_player import CLIHybridPlayerService, ResolvedAudio, resolve_audio_url
+
+
+def test_resolve_audio_url_includes_required_user_agent():
+    """Return the request metadata required to play a direct stream URL."""
+    result = MagicMock(
+        returncode=0,
+        stdout=('https://example.test/audio\n{"User-Agent": "Test Browser", "Accept": "*/*"}\n'),
+    )
+
+    with (
+        patch("ytm_cli.hybrid_player.get_cookies_browser", return_value=None),
+        patch("ytm_cli.hybrid_player.subprocess.run", return_value=result),
+    ):
+        resolved = resolve_audio_url("video-id")
+
+    assert resolved == ResolvedAudio("https://example.test/audio", "Test Browser")
 
 
 class TestCLIHybridPlayerInitialization(unittest.TestCase):
@@ -171,6 +187,51 @@ class TestCLIHybridPlayerPlayback(unittest.TestCase):
         assert result is True
         player.ffmpeg_player.is_playing_now.assert_called_once()
 
+    @patch("shutil.which", return_value="/usr/bin/mpv")
+    def test_play_mpv_passes_resolved_user_agent(self, mock_which):
+        """mpv must use the user agent associated with a direct stream URL."""
+        with patch("builtins.print"):
+            player = CLIHybridPlayerService()
+
+        process = MagicMock(pid=123)
+        process.poll.return_value = None
+        resolved = ResolvedAudio("https://example.test/audio", "Test Browser")
+
+        with (
+            patch("ytm_cli.hybrid_player.get_mpv_flags", return_value=["--no-video"]),
+            patch("ytm_cli.hybrid_player.save_player_pid"),
+            patch("ytm_cli.hybrid_player.subprocess.Popen", return_value=process) as mock_popen,
+            patch("ytm_cli.hybrid_player.os.path.exists", return_value=True),
+            patch("ytm_cli.hybrid_player.time.sleep"),
+        ):
+            assert player.play("video-id", "Test Song", resolved) is True
+
+        command = mock_popen.call_args.args[0]
+        assert command[1] == resolved.url
+        assert "--user-agent=Test Browser" in command
+
+    @patch("shutil.which", return_value="/usr/bin/mpv")
+    def test_play_mpv_passes_user_agent_when_stream_is_unresolved(self, mock_which):
+        """mpv's yt-dlp fallback must not request media as libmpv."""
+        with patch("builtins.print"):
+            player = CLIHybridPlayerService()
+
+        process = MagicMock(pid=123)
+        process.poll.return_value = None
+
+        with (
+            patch("ytm_cli.hybrid_player.get_mpv_flags", return_value=["--no-video"]),
+            patch("ytm_cli.hybrid_player.get_cookies_browser", return_value=None),
+            patch("ytm_cli.hybrid_player.save_player_pid"),
+            patch("ytm_cli.hybrid_player.subprocess.Popen", return_value=process) as mock_popen,
+            patch("ytm_cli.hybrid_player.os.path.exists", return_value=True),
+            patch("ytm_cli.hybrid_player.time.sleep"),
+        ):
+            assert player.play("video-id", "Test Song") is True
+
+        command = mock_popen.call_args.args[0]
+        assert any(flag.startswith("--user-agent=Mozilla/") for flag in command)
+
     @patch("shutil.which", return_value=None)
     @patch.object(FFmpegPlayerService, "__init__", return_value=None)
     def test_cleanup_ffmpeg(self, mock_ffmpeg_init, mock_which):

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/tests/test_main.py

@@ -184,23 +184,19 @@ class TestPlaylistCommands:
 
             playlist_create_command("New Playlist", "A test playlist")
 
-            mock_playlist_manager.create_playlist.assert_called_once_with(
-                "New Playlist", "A test playlist"
-            )
+            mock_playlist_manager.create_playlist.assert_called_once_with("New Playlist", "")
 
     def test_playlist_create_command_prompt_for_name(self):
         """Test playlist creation command that prompts for name"""
         with (
             patch("ytm_cli.main.playlist_manager") as mock_playlist_manager,
-            patch("builtins.input", side_effect=["User Playlist", "User description"]),
+            patch("builtins.input", side_effect=["User Playlist"]),
         ):
             mock_playlist_manager.create_playlist.return_value = True
 
             playlist_create_command(None, None)
 
-            mock_playlist_manager.create_playlist.assert_called_once_with(
-                "User Playlist", "User description"
-            )
+            mock_playlist_manager.create_playlist.assert_called_once_with("User Playlist", "")
 
     def test_playlist_show_command_success(self, sample_playlist_data):
         """Test successful playlist show command"""
@@ -277,7 +273,31 @@ class TestMainFunction:
         ):
             main()
 
-            mock_search_and_play.assert_called_once_with("test song query")
+            mock_search_and_play.assert_called_once_with("test song query", None)
+
+    def test_main_backward_compatibility_search_with_select(self, sample_songs):
+        """Test direct search supports auto-select."""
+        test_args = ["ytm_cli", "gio dem qua duong", "-s", "1"]
+
+        with (
+            patch("sys.argv", test_args),
+            patch("ytm_cli.main.search_and_play") as mock_search_and_play,
+        ):
+            main()
+
+            mock_search_and_play.assert_called_once_with("gio dem qua duong", 1)
+
+    def test_main_backward_compatibility_unquoted_search_with_select(self, sample_songs):
+        """Test direct search joins unquoted query words before options."""
+        test_args = ["ytm_cli", "gio", "dem", "qua", "duong", "-s", "1"]
+
+        with (
+            patch("sys.argv", test_args),
+            patch("ytm_cli.main.search_and_play") as mock_search_and_play,
+        ):
+            main()
+
+            mock_search_and_play.assert_called_once_with("gio dem qua duong", 1)
 
     def test_main_search_command(self, sample_songs):
         """Test main function with search command"""

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/tests/test_ui.py

@@ -10,7 +10,7 @@ with (
     patch("curses.init_pair"),
     patch("curses.color_pair"),
 ):
-    from ytm_cli.ui import display_player_status
+    from ytm_cli.ui import display_player_status, draw_player
 
 
 def _capture_status_output(*args, width=80, terminal_size_error=False, **kwargs):
@@ -27,6 +27,96 @@ def _capture_status_output(*args, width=80, terminal_size_error=False, **kwargs)
     return buf.getvalue()
 
 
+class _FakeScreen:
+    """Small curses screen double that exposes complete rendered frames."""
+
+    def __init__(self, height, width):
+        self.height = height
+        self.width = width
+        self.rows = []
+        self.erase()
+
+    def getmaxyx(self):
+        return self.height, self.width
+
+    def erase(self):
+        self.rows = [[" "] * self.width for _ in range(self.height)]
+
+    def addstr(self, y, x, text, _attr=0):
+        for offset, char in enumerate(text):
+            if 0 <= y < self.height and 0 <= x + offset < self.width:
+                self.rows[y][x + offset] = char
+
+    def refresh(self):
+        pass
+
+    def render(self):
+        return "\n".join("".join(row).rstrip() for row in self.rows)
+
+
+def _render_player(height=24, width=80, **overrides):
+    values = {
+        "song_title": "Neon Cruise",
+        "artist": "Synthwave Demo Band",
+        "is_paused": False,
+        "track_idx": 2,
+        "track_total": 8,
+        "elapsed": 72,
+        "duration": 180,
+        "bands": [0.1, 0.3, 0.7, 0.4] * 6,
+        "next_title": "Rainy Afternoon Lo-Fi",
+        "next_artist": "ChillCat",
+    }
+    values.update(overrides)
+    screen = _FakeScreen(height, width)
+    with (
+        patch("ytm_cli.ui.curses.color_pair", return_value=0),
+        patch("ytm_cli.ui.time.time", return_value=100),
+    ):
+        draw_player(screen, **values)
+    return screen.render()
+
+
+class TestDrawPlayer:
+    """Render-level coverage for the responsive full-screen player."""
+
+    def test_standard_layout_has_clear_hierarchy_and_queue_context(self):
+        rendered = _render_player()
+
+        for text in (
+            "YTM // PLAYER",
+            "PLAYING  2 / 8",
+            "NOW PLAYING",
+            "Neon Cruise",
+            "Synthwave Demo Band",
+            "1:12",
+            "40%",
+            "UP NEXT",
+            "Rainy Afternoon Lo-Fi · ChillCat",
+            "[SPACE] pause",
+            "[D] dislike",
+        ):
+            assert text in rendered
+
+    def test_compact_layout_keeps_essential_information_visible(self):
+        rendered = _render_player(height=10, width=42, is_paused=True)
+
+        assert "PAUSED" in rendered
+        assert "Neon Cruise" in rendered
+        assert "Synthwave Demo Band" in rendered
+        assert "[SPC]" in rendered
+        assert "[Q]" in rendered
+        assert "NOW PLAYING" not in rendered
+
+    def test_tiny_layout_does_not_overlap_brand_and_status(self):
+        rendered = _render_player(height=6, width=24)
+
+        first_line = rendered.splitlines()[0]
+        assert "PLAYING" in first_line
+        assert "YTM●" not in first_line
+        assert "Neon Cruise" in rendered
+
+
 class TestDisplayPlayerStatus:
     """Tests for display_player_status function.
 

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/ytm_cli/__init__.py

@@ -1,3 +1,3 @@
 """YouTube Music CLI - A terminal interface for YouTube Music"""
 
-__version__ = "0.7.3"
+__version__ = "0.9.0"

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/ytm_cli/config.py

@@ -19,6 +19,8 @@ def get_config_path() -> str:
 config = configparser.ConfigParser()
 config.read(get_config_path())
 
+_PID_FILE = get_config_dir() / "player.pid"
+
 _ytmusic = None
 
 
@@ -41,9 +43,36 @@ def get_mpv_flags():
     """Get MPV flags from config"""
     if "mpv" in config and "flags" in config["mpv"]:
         return config["mpv"]["flags"].split()
-    return []
+    return ["--no-video"]
+
+
+def get_cookies_browser() -> str | None:
+    """Get the browser to extract cookies from (for yt-dlp authentication)."""
+    return config.get("general", "cookies_from_browser", fallback=None)
 
 
 def get_config_value(section, key, fallback=None):
     """Get a value from the config"""
     return config.get(section, key, fallback=fallback)
+
+
+def save_player_pid(pid: int) -> None:
+    """Save MPV player PID to file"""
+    with open(_PID_FILE, "w") as f:
+        f.write(str(pid))
+
+
+def get_player_pid() -> int | None:
+    """Get MPV player PID from file"""
+    if _PID_FILE.exists():
+        try:
+            return int(_PID_FILE.read_text().strip())
+        except (ValueError, OSError):
+            return None
+    return None
+
+
+def clear_player_pid() -> None:
+    """Clear the player PID file"""
+    if _PID_FILE.exists():
+        _PID_FILE.unlink()

{ytm_cli-0.7.3 → ytm_cli-0.9.0}/ytm_cli/hybrid_player.py

@@ -7,10 +7,56 @@ import socket
 import subprocess
 import tempfile
 import time
+from typing import NamedTuple
 
-from .config import get_mpv_flags
+from yt_dlp.utils.networking import std_headers
+
+from .config import clear_player_pid, get_cookies_browser, get_mpv_flags, save_player_pid
 from .ffmpeg_player import FFmpegPlayerService
-from .verbose_logger import log_error, log_info, log_section
+from .verbose_logger import is_verbose, log_error, log_info, log_section
+
+
+class ResolvedAudio(NamedTuple):
+    """Direct audio URL and the user agent required to request it."""
+
+    url: str
+    user_agent: str
+
+
+def resolve_audio_url(video_id: str) -> ResolvedAudio | None:
+    """Pre-resolve audio stream details via yt-dlp."""
+    try:
+        cmd = [
+            "yt-dlp",
+            "-f",
+            "bestaudio",
+            "--print",
+            "%(url)s",
+            "--print",
+            "%(http_headers)j",
+        ]
+        browser = get_cookies_browser()
+        if browser:
+            cmd.extend(["--cookies-from-browser", browser])
+        cmd.append(f"https://music.youtube.com/watch?v={video_id}")
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.returncode == 0:
+            lines = result.stdout.strip().splitlines()
+            for url, raw_headers in zip(lines, lines[1:], strict=False):
+                if not url.startswith(("http://", "https://")):
+                    continue
+                headers = json.loads(raw_headers)
+                user_agent = headers.get("User-Agent")
+                if isinstance(user_agent, str) and user_agent:
+                    return ResolvedAudio(url, user_agent)
+    except (json.JSONDecodeError, subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+    return None
 
 
 class CLIHybridPlayerService:
@@ -54,21 +100,25 @@ class CLIHybridPlayerService:
         """Check if any player is available"""
         return self.player_type != "none"
 
-    def play(self, video_id: str, title: str = "") -> bool:
-        """Start playing a song"""
+    def play(
+        self, video_id: str, title: str = "", resolved_audio: ResolvedAudio | None = None
+    ) -> bool:
+        """Start playing a song, optionally using pre-resolved stream details."""
         if not self.is_available():
             log_error("Play attempted but no audio player available")
             print("No audio player available")
             return False
 
         if self.player_type == "mpv":
-            return self._play_mpv(video_id, title)
+            return self._play_mpv(video_id, title, resolved_audio)
         elif self.player_type == "ffmpeg" and self.ffmpeg_player:
             return self.ffmpeg_player.play(video_id, title)
 
         return False
 
-    def _play_mpv(self, video_id: str, title: str = "") -> bool:
+    def _play_mpv(
+        self, video_id: str, title: str = "", resolved_audio: ResolvedAudio | None = None
+    ) -> bool:
         """Play using mpv"""
         try:
             # Clean up previous process if exists
@@ -77,7 +127,11 @@ class CLIHybridPlayerService:
             # Create socket for IPC
             self.socket_path = tempfile.mktemp(suffix=".sock")
 
-            url = f"https://music.youtube.com/watch?v={video_id}"
+            url = (
+                resolved_audio.url
+                if resolved_audio
+                else f"https://music.youtube.com/watch?v={video_id}"
+            )
             mpv_flags = get_mpv_flags()
             mpv_flags.extend(
                 [
@@ -85,21 +139,59 @@ class CLIHybridPlayerService:
                     "--af-append=@vstats:lavfi=[astats=metadata=1:reset=1:length=0.1]",
                 ]
             )
+            user_agent = resolved_audio.user_agent if resolved_audio else std_headers["User-Agent"]
+            mpv_flags.append(f"--user-agent={user_agent}")
+            # Pass cookies to mpv's internal yt-dlp when playing unresolved URLs
+            if not resolved_audio:
+                browser = get_cookies_browser()
+                if browser:
+                    mpv_flags.append(f"--ytdl-raw-options=cookies-from-browser={browser}")
 
             log_info(f"Starting MPV playback: {title or video_id}")
             self.mpv_process = subprocess.Popen(
                 ["mpv", url] + mpv_flags,
                 stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
+                stderr=subprocess.PIPE,
             )
 
+            # Save MPV PID for --terminate
+            if self.mpv_process:
+                save_player_pid(self.mpv_process.pid)
+
             # Wait for mpv to create the IPC socket before returning
-            for _ in range(20):
+            for _ in range(30):
                 time.sleep(0.1)
+                # Check if mpv exited early (e.g., yt-dlp failure)
+                if self.mpv_process.poll() is not None:
+                    stderr_out = ""
+                    if self.mpv_process.stderr:
+                        stderr_out = self.mpv_process.stderr.read().decode(errors="replace")
+                        self.mpv_process.stderr.close()
+                    log_error(
+                        f"MPV exited early (code {self.mpv_process.returncode}): {stderr_out[:200]}"
+                    )
+                    clear_player_pid()
+                    self.mpv_process = None
+                    return False
                 if os.path.exists(self.socket_path):
+                    if is_verbose():
+                        ao = self._get_mpv_property("current-ao")
+                        volume = self._get_mpv_property("volume")
+                        mute = self._get_mpv_property("mute")
+                        aid = self._get_mpv_property("aid")
+                        log_info(
+                            f"MPV audio output: ao={ao or 'unknown'}, aid={aid}, "
+                            f"volume={volume}, mute={mute}"
+                        )
+                    # Detach stderr now that startup succeeded (avoid blocking on pipe)
+                    if self.mpv_process.stderr:
+                        self.mpv_process.stderr.close()
                     return True
-            # Socket not created but process is running
-            return self.mpv_process.poll() is None
+
+            # Socket not created but process is running — close stderr pipe
+            if self.mpv_process and self.mpv_process.stderr:
+                self.mpv_process.stderr.close()
+            return self.mpv_process.poll() is None if self.mpv_process else False
         except Exception as e:
             log_error(f"Failed to start mpv: {e}")
             print(f"Failed to start mpv: {e}")
@@ -114,6 +206,7 @@ class CLIHybridPlayerService:
             if self.socket_path and os.path.exists(self.socket_path):
                 os.unlink(self.socket_path)
                 self.socket_path = None
+            clear_player_pid()
         elif self.player_type == "ffmpeg" and self.ffmpeg_player:
             self.ffmpeg_player.stop()
 
@@ -140,7 +233,6 @@ class CLIHybridPlayerService:
         if self.player_type == "mpv" and self.mpv_process:
             if self.mpv_process.poll() is not None:
                 return False
-            # Also check if mpv reports idle (finished playing)
             if self.socket_path and os.path.exists(self.socket_path):
                 idle = self._get_mpv_property("idle-active")
                 if idle is True: