ytm-cli 0.7.2__tar.gz → 0.8.0__tar.gz

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytm-cli
-Version: 0.7.2
+Version: 0.8.0
 Summary: YouTube Music CLI tool with interactive terminal interface
 Author-email: thieuluan <thieuluan.dark@gmail.com>
 License-Expression: MIT
@@ -14,9 +14,13 @@ Classifier: Intended Audience :: End Users/Desktop
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Multimedia :: Sound/Audio :: Players
-Requires-Python: >=3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ytmusicapi
@@ -60,7 +64,7 @@ Stream music directly from YouTube Music in your terminal with intuitive control
 
 ### Requirements
 
-- Python **3.14+** (set in `pyproject.toml`)
+- Python **3.10+** (set in `pyproject.toml`)
 - [mpv media player](https://mpv.io/installation/) (must be installed system-wide)
 - [`ffmpeg`](https://ffmpeg.org/) on `PATH` for the real-time spectrum visualizer (optional — falls back to a stereo oscilloscope if missing)
 

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/README.md

@@ -31,7 +31,7 @@ Stream music directly from YouTube Music in your terminal with intuitive control
 
 ### Requirements
 
-- Python **3.14+** (set in `pyproject.toml`)
+- Python **3.10+** (set in `pyproject.toml`)
 - [mpv media player](https://mpv.io/installation/) (must be installed system-wide)
 - [`ffmpeg`](https://ffmpeg.org/) on `PATH` for the real-time spectrum visualizer (optional — falls back to a stereo oscilloscope if missing)
 

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ytm-cli"
-version = "0.7.2"
+version = "0.8.0"
 description = "YouTube Music CLI tool with interactive terminal interface"
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.14"
+requires-python = ">=3.10"
 authors = [
     { name = "thieuluan", email = "thieuluan.dark@gmail.com" },
 ]
@@ -20,6 +20,10 @@ classifiers = [
     "Operating System :: POSIX :: Linux",
     "Operating System :: MacOS",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
     "Topic :: Multimedia :: Sound/Audio :: Players",
 ]
@@ -56,7 +60,7 @@ include = ["ytm_cli*"]
 [tool.ruff]
 # Set line length to match pylint (100 characters)
 line-length = 100
-target-version = "py314"
+target-version = "py310"
 
 [tool.ruff.lint]
 # Enable flake8 rules and other important checks

{ytm_cli-0.7.2 → ytm_cli-0.8.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,7 @@ 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_search_command(self, sample_songs):
         """Test main function with search command"""

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli/__init__.py

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

{ytm_cli-0.7.2 → ytm_cli-0.8.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,31 @@ 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_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.2 → ytm_cli-0.8.0}/ytm_cli/dislikes.py

@@ -72,7 +72,7 @@ class DislikeManager:
                     with open(self.dislikes_file, encoding="utf-8") as f:
                         data = json.load(f)
                         existing_songs = data.get("songs", [])
-                except json.JSONDecodeError, FileNotFoundError:
+                except (json.JSONDecodeError, FileNotFoundError):
                     pass
 
             # Create dislike entry

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli/ffmpeg_player.py

@@ -50,7 +50,7 @@ class FFmpegPlayerService:
                 ["ffplay", "-version"], capture_output=True, text=True, timeout=5
             )
             return result.returncode == 0
-        except subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError:
+        except (subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError):
             return False
 
     def play(self, video_id: str, title: str = "") -> bool:

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli/hybrid_player.py

@@ -8,11 +8,35 @@ import subprocess
 import tempfile
 import time
 
-from .config import get_mpv_flags
+from .config import clear_player_pid, get_mpv_flags, save_player_pid
 from .ffmpeg_player import FFmpegPlayerService
 from .verbose_logger import log_error, log_info, log_section
 
 
+def resolve_audio_url(video_id: str) -> str | None:
+    """Pre-resolve audio stream URL via yt-dlp. Returns direct URL or None."""
+    try:
+        result = subprocess.run(
+            [
+                "yt-dlp",
+                "-f",
+                "bestaudio",
+                "--get-url",
+                f"https://music.youtube.com/watch?v={video_id}",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.returncode == 0:
+            url = result.stdout.strip().split("\n")[0]
+            if url.startswith("http"):
+                return url
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+    return None
+
+
 class CLIHybridPlayerService:
     """Hybrid player for CLI mode that uses mpv by default, falls back to FFmpeg if needed"""
 
@@ -54,21 +78,21 @@ 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_url: str | None = None) -> bool:
+        """Start playing a song. If resolved_url is provided, skip yt-dlp resolution."""
         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_url)
         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_url: str | None = None) -> bool:
         """Play using mpv"""
         try:
             # Clean up previous process if exists
@@ -77,7 +101,7 @@ 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_url or f"https://music.youtube.com/watch?v={video_id}"
             mpv_flags = get_mpv_flags()
             mpv_flags.extend(
                 [
@@ -90,16 +114,38 @@ class CLIHybridPlayerService:
             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):
+                    # 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 +160,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()
 
@@ -170,7 +217,7 @@ class CLIHybridPlayerService:
                 parsed = json.loads(line)
                 if "event" not in parsed and parsed.get("error") == "success":
                     return parsed.get("data")
-        except OSError, json.JSONDecodeError, UnicodeDecodeError:
+        except (OSError, json.JSONDecodeError, UnicodeDecodeError):
             pass
         return None
 

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli/main.py

@@ -4,6 +4,7 @@ import argparse
 import curses
 import sys
 from curses import wrapper
+from datetime import datetime
 
 from rich import print
 
@@ -120,7 +121,7 @@ def search_and_play(query=None, auto_select=None):
                 if selected_index < 0 or selected_index >= len(results[:songs_to_display]):
                     print("[red]Invalid selection.[/red]")
                     return
-            except ValueError, KeyboardInterrupt:
+            except (ValueError, KeyboardInterrupt):
                 return
 
         if selected_index is None:
@@ -132,6 +133,18 @@ def search_and_play(query=None, auto_select=None):
     # Fetch radio in background so the first song starts immediately
     import threading
 
+    # Pre-resolve audio URL in parallel with radio fetch — eliminates ~3s yt-dlp
+    # wait from mpv startup path
+    from .hybrid_player import resolve_audio_url
+
+    prefetched_url = [None]
+
+    def prefetch_first_url():
+        prefetched_url[0] = resolve_audio_url(song["videoId"])
+
+    url_thread = threading.Thread(target=prefetch_first_url, daemon=True)
+    url_thread.start()
+
     def fetch_radio():
         log_step("Fetching radio playlist", f"videoId: {song['videoId']}")
         log_api_call("ytmusic.get_watch_playlist", {"videoId": song["videoId"]})
@@ -163,7 +176,7 @@ def search_and_play(query=None, auto_select=None):
     radio_thread = threading.Thread(target=fetch_radio, daemon=True)
     radio_thread.start()
 
-    play_music_with_controls(playlist)
+    play_music_with_controls(playlist, prefetched_url_thread=(url_thread, prefetched_url))
 
 
 # Playlist Commands
@@ -202,15 +215,24 @@ def playlist_list_command():
 def playlist_create_command(name, description=""):
     """Create a new playlist"""
     if not name:
-        name = input("Enter playlist name: ").strip()
+        name = input("Enter playlist name (or press Enter for default): ").strip()
         if not name:
-            print("[red]Playlist name is required[/red]")
-            return
+            # Generate unique default name with timestamp and counter
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            base_name = f"My Playlist #{timestamp}"
+            name = base_name
+
+            # Check if this name already exists and add counter if needed
+            existing_names = playlist_manager.get_playlist_names()
+            if name in existing_names:
+                counter = 1
+                while f"{base_name}_{counter}" in existing_names:
+                    counter += 1
+                name = f"{base_name}_{counter}"
 
-    if not description:
-        description = input("Enter description (optional): ").strip()
+            print(f"[cyan]Using default name: {name}[/cyan]")
 
-    playlist_manager.create_playlist(name, description)
+    playlist_manager.create_playlist(name, "")
 
 
 def playlist_show_command(name):
@@ -242,7 +264,7 @@ def playlist_show_command(name):
                         return
                 else:
                     name = choice
-            except ValueError, KeyboardInterrupt:
+            except (ValueError, KeyboardInterrupt):
                 return
 
     playlist = playlist_manager.get_playlist(name)
@@ -306,7 +328,7 @@ def playlist_play_command(name):
                         return
                 else:
                     name = choice
-            except ValueError, KeyboardInterrupt:
+            except (ValueError, KeyboardInterrupt):
                 return
 
     playlist = playlist_manager.get_playlist(name)
@@ -376,7 +398,7 @@ def playlist_delete_command(name):
                         return
                 else:
                     name = choice
-            except ValueError, KeyboardInterrupt:
+            except (ValueError, KeyboardInterrupt):
                 return
 
     # Confirm deletion
@@ -402,7 +424,7 @@ def llm_create_playlist_command(llm_client, prompt, num_songs=15, auto_play=Fals
     print(f"[cyan]Searching YouTube Music for {len(response.songs)} songs...[/cyan]")
 
     # Create the playlist
-    if not playlist_manager.create_playlist(playlist_name, f"AI-generated: {prompt}"):
+    if not playlist_manager.create_playlist(playlist_name, ""):
         return
 
     # Search each song on YTMusic and add to playlist
@@ -444,11 +466,25 @@ def main():
         len(sys.argv) >= 2
         and not sys.argv[1].startswith("-")
         and sys.argv[1] not in ["search", "playlist", "llm"]
-        and "--verbose" not in sys.argv
-        and "--select" not in sys.argv
+        and "--terminate" not in sys.argv
     ):
+        # Extract --select/-s value if present
+        auto_select = None
+        for i, arg in enumerate(sys.argv):
+            if arg in ("--select", "-s") and i + 1 < len(sys.argv):
+                try:
+                    auto_select = int(sys.argv[i + 1])
+                except ValueError:
+                    pass
+                break
+
+        # Extract --verbose if present
+        verbose = "--verbose" in sys.argv
+
         # This is likely a song query, handle it directly (backward compatible mode)
-        search_and_play(sys.argv[1])
+        if verbose:
+            set_verbose(True)
+        search_and_play(sys.argv[1], auto_select)
         return
 
     # Allow `llm "prompt"` as shortcut for `llm ask "prompt"`
@@ -498,6 +534,11 @@ During music playback:
         action="store_true",
         help="Run with a fake playlist + synthetic spectrum (for screenshots / docs)",
     )
+    parser.add_argument(
+        "--terminate",
+        action="store_true",
+        help="Terminate all running ytm-cli sessions",
+    )
 
     # Create subcommands
     subparsers = parser.add_subparsers(
@@ -616,10 +657,46 @@ During music playback:
 
     args = parser.parse_args()
 
-    # Set verbose mode globally
-    global _VERBOSE, _VERBOSE_FILE
-    _VERBOSE = getattr(args, "verbose", False)
-    _VERBOSE_FILE = getattr(args, "log_file", None)
+    # Handle --terminate flag
+    if getattr(args, "terminate", False):
+        import os
+        import signal
+        import subprocess
+
+        current_pid = os.getpid()
+        parent_pid = os.getppid()
+        terminated = 0
+
+        # Find ytm-cli processes using subprocess with timeout
+        try:
+            result = subprocess.run(
+                ["pgrep", "-f", "ytm.cli"], capture_output=True, text=True, timeout=5
+            )
+            pids = [int(p) for p in result.stdout.strip().split("\n") if p.strip()]
+        except (subprocess.TimeoutExpired, FileNotFoundError, ValueError):
+            pids = []
+
+        for pid in pids:
+            if pid in (current_pid, parent_pid):
+                continue
+            try:
+                os.kill(pid, signal.SIGTERM)
+                terminated += 1
+            except (ProcessLookupError, PermissionError):
+                pass
+
+        # Also terminate MPV process if PID file exists
+        from .config import get_player_pid
+
+        player_pid = get_player_pid()
+        if player_pid:
+            try:
+                os.kill(player_pid, signal.SIGTERM)
+            except (ProcessLookupError, PermissionError):
+                pass
+
+        print(f"Terminated {terminated} ytm-cli session(s)")
+        return
 
     # Initialize verbose logger
     set_verbose(_VERBOSE, _VERBOSE_FILE)

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli/player.py

@@ -9,6 +9,7 @@ import subprocess
 import sys
 import tempfile
 import termios
+import threading
 import time
 import tty
 
@@ -72,7 +73,7 @@ class CavaVisualizer:
                 values = [int(v) for v in last_line.split(";") if v.strip()]
                 if values:
                     self.bars = values
-        except BlockingIOError, ValueError:
+        except (BlockingIOError, ValueError):
             pass
         return self.bars
 
@@ -115,7 +116,7 @@ def _mpv_ipc(socket_path, command, expect_response=False):
                         continue
                     try:
                         data = json.loads(line.decode())
-                    except json.JSONDecodeError, UnicodeDecodeError:
+                    except (json.JSONDecodeError, UnicodeDecodeError):
                         continue
                     if "event" in data:
                         continue
@@ -127,7 +128,7 @@ def _mpv_ipc(socket_path, command, expect_response=False):
             sock.close()
             return None
         sock.close()
-    except OSError, json.JSONDecodeError, UnicodeDecodeError, TimeoutError:
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError, TimeoutError):
         return None
 
 
@@ -190,7 +191,7 @@ def get_mpv_audio_levels(socket_path):
             return None
         try:
             db = float(raw)
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
         if db != db or db <= floor_db:  # NaN or -inf / silence
             return 0.0
@@ -302,14 +303,25 @@ def add_song_to_playlist_interactive(song_data):
             print("\nCreate new playlist:")
             playlist_name = input("Playlist name: ").strip()
             if not playlist_name:
-                print("Cancelled - no name provided.")
-                time.sleep(1)
-                return False
+                # Generate unique default name with timestamp and counter
+                from datetime import datetime
+
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                base_name = f"My Playlist #{timestamp}"
+                playlist_name = base_name
+
+                # Check if this name already exists and add counter if needed
+                existing_names = playlist_manager.get_playlist_names()
+                if playlist_name in existing_names:
+                    counter = 1
+                    while f"{base_name}_{counter}" in existing_names:
+                        counter += 1
+                    playlist_name = f"{base_name}_{counter}"
 
-            description = input("Description (optional): ").strip()
+                print(f"[cyan]Using default name: {playlist_name}[/cyan]")
 
             # Create the playlist
-            if playlist_manager.create_playlist(playlist_name, description):
+            if playlist_manager.create_playlist(playlist_name, ""):
                 selected_playlist = playlist_name
             else:
                 print("Failed to create playlist.")
@@ -390,7 +402,7 @@ def get_and_display_lyrics(video_id, title, socket_path=None):
         return False
 
 
-def play_music_with_controls(playlist, playlist_name=None, demo=False):
+def play_music_with_controls(playlist, playlist_name=None, demo=False, prefetched_url_thread=None):
     """Play music with keyboard controls using curses-based UI
 
     Args:
@@ -398,6 +410,7 @@ def play_music_with_controls(playlist, playlist_name=None, demo=False):
         playlist_name: Name of user playlist (if playing from a user playlist)
         demo: When True, use the demo player + synthetic spectrum (no audio,
             no network) so screenshot tooling can capture deterministic frames.
+        prefetched_url_thread: Tuple of (thread, result_list) for async URL resolution.
     """
     from .verbose_logger import log_info, log_section
 
@@ -446,6 +459,38 @@ def play_music_with_controls(playlist, playlist_name=None, demo=False):
         toast_msg = None
         toast_expire = 0
 
+        # Pre-resolved URLs: {video_id: url or None}
+        prefetch_cache: dict[str, str | None] = {}
+        prefetch_lock = threading.Lock()
+        _initial_url_thread = None
+
+        # Track the caller's prefetch thread (already running in parallel since song selection)
+        if prefetched_url_thread and playlist:
+            _initial_url_thread = prefetched_url_thread  # (thread, result_list)
+
+        def _prefetch_url(vid: str):
+            """Resolve audio URL in background and cache it."""
+            if demo:
+                return
+            from .hybrid_player import resolve_audio_url
+
+            url = resolve_audio_url(vid)
+            with prefetch_lock:
+                prefetch_cache[vid] = url
+
+        def _get_cached_url(vid: str) -> str | None:
+            nonlocal _initial_url_thread
+            # Check if the initial prefetch thread has finished
+            if _initial_url_thread and playlist:
+                url_thread, url_result = _initial_url_thread
+                if not url_thread.is_alive():
+                    if url_result[0]:
+                        with prefetch_lock:
+                            prefetch_cache[playlist[0]["videoId"]] = url_result[0]
+                    _initial_url_thread = None
+            with prefetch_lock:
+                return prefetch_cache.get(vid)
+
         def fire(msg):
             nonlocal toast_msg, toast_expire
             toast_msg = msg
@@ -471,26 +516,77 @@ def play_music_with_controls(playlist, playlist_name=None, demo=False):
                 track_num = current_song_index + 1
                 track_total = len(playlist)
 
-                draw_player(
-                    stdscr,
-                    song_title,
-                    artist,
-                    is_paused,
-                    track_num,
-                    track_total,
-                    None,
-                    None,
-                    frame,
-                    toast_msg,
-                    toast_expire,
-                )
+                # Prefetch next song's URL while this one loads/plays
+                next_idx = current_song_index + 1
+                if next_idx < len(playlist) and not demo:
+                    next_vid = playlist[next_idx]["videoId"]
+                    if _get_cached_url(next_vid) is None and next_vid not in prefetch_cache:
+                        threading.Thread(
+                            target=_prefetch_url, args=(next_vid,), daemon=True
+                        ).start()
+
+                # Start playback in background so the UI keeps animating.
+                # Wait briefly for prefetch to resolve (animating meanwhile),
+                # then start mpv with whatever URL we have.
+                play_result = [None]  # None = pending, True/False = done
+                play_started = False
+                fire("Loading...")
+
+                while play_result[0] is None:
+                    # Once prefetch resolves (or after a short wait), kick off mpv
+                    if not play_started:
+                        resolved_url = _get_cached_url(video_id)
+                        if resolved_url is not None or frame > 5:
+                            # Either got prefetched URL or waited ~1s — start mpv
+                            def _start_play(
+                                vid=video_id,
+                                title=display_title,
+                                url=resolved_url,
+                                _res=play_result,
+                            ):
+                                _res[0] = player.play(vid, title, resolved_url=url)
+
+                            threading.Thread(target=_start_play, daemon=True).start()
+                            play_started = True
+
+                    draw_player(
+                        stdscr,
+                        song_title,
+                        artist,
+                        is_paused,
+                        track_num,
+                        track_total,
+                        None,
+                        None,
+                        frame,
+                        toast_msg,
+                        toast_expire,
+                    )
+                    frame += 1
+                    key = stdscr.getch()
+                    if key == ord("q") or key == 3:
+                        quit_pressed = True
+                        return
+                    if key == ord("n"):
+                        current_song_index += 1
+                        if play_started:
+                            time.sleep(0.1)
+                            if play_result[0] is True:
+                                player.stop()
+                        fire("Next →")
+                        break
+
+                if play_result[0] is None:
+                    # broke out via 'n'
+                    continue
 
-                if not player.play(video_id, display_title):
+                if not play_result[0]:
                     fire(f"Failed: {song_title}")
                     current_song_index += 1
                     continue
 
                 is_paused = False
+                toast_msg = None  # clear "Loading..." toast
 
                 lyrics_just_viewed = False
 

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli/playlists.py

@@ -263,7 +263,7 @@ class PlaylistManager:
                             data = json.load(f)
                         if data.get("name", "").lower() == playlist_name.lower():
                             return filepath
-                    except json.JSONDecodeError, FileNotFoundError:
+                    except (json.JSONDecodeError, FileNotFoundError):
                         continue
         except OSError:
             pass

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli/spectrum.py

@@ -114,7 +114,7 @@ class SpectrumAnalyzer:
                 with self._lock:
                     self._bands = prev.copy()
                     self._has_data = True
-        except OSError, ValueError:
+        except (OSError, ValueError):
             pass
         finally:
             self._running = False

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli/ui.py

@@ -387,7 +387,7 @@ def add_song_to_playlist_ui(stdscr, song):
     try:
         input_bytes = stdscr.getstr(current_line, 4, max_x - 6)
         input_str = input_bytes.decode("utf-8").strip()
-    except curses.error, UnicodeDecodeError:
+    except (curses.error, UnicodeDecodeError):
         input_str = ""
     finally:
         curses.noecho()
@@ -403,7 +403,7 @@ def add_song_to_playlist_ui(stdscr, song):
             if 0 <= playlist_index < len(playlists):
                 playlist_name = playlists[playlist_index]
                 return playlist_manager.add_song_to_playlist(playlist_name, song)
-        except ValueError, IndexError:
+        except (ValueError, IndexError):
             pass
 
     # Treat as new playlist name
@@ -648,15 +648,23 @@ def draw_player(
     history = list(_WAVE_HISTORY)
     have_real = bool(history) and audio_levels is not None
 
-    if bands:
+    if is_paused:
+        mode_label = ""
+        # Gentle breathing wave: slow sine that ripples across bars
+        t = time.time()
+        for i in range(nbars):
+            # Slow ripple from center outward
+            dist = abs(i - nbars / 2.0) / (nbars / 2.0)
+            phase = t * 1.2 - dist * 2.5
+            breath = 0.08 + 0.12 * (0.5 + 0.5 * math.sin(phase))
+            _draw_bar(scr, bar_bottom, wx + i * 2, breath, _WAVE_ROWS, bar_attr)
+    elif bands:
         mode_label = "spectrum"
         n_in = len(bands)
         for i in range(nbars):
             lo = int(i * n_in / nbars)
             hi = max(lo + 1, int((i + 1) * n_in / nbars))
             level = max(bands[lo:hi])
-            if is_paused:
-                level *= 0.3
             _draw_bar(scr, bar_bottom, wx + i * 2, level, _WAVE_ROWS, bar_attr)
     elif have_real:
         mode_label = ""
@@ -672,19 +680,14 @@ def draw_player(
             else:
                 level = recent[nbars - 1 - i][1]
 
-            if is_paused:
-                level *= 0.3
             _draw_bar(scr, bar_bottom, wx + i * 2, level, _WAVE_ROWS, bar_attr)
     else:
         mode_label = "sim"
         for i in range(nbars):
-            if not is_paused:
-                seed = _WAVE_SEEDS[i % len(_WAVE_SEEDS)]
-                phase = frame * 0.7 + i * 0.65
-                val = 0.5 + 0.5 * math.sin(phase)
-                level = (seed / 40.0) * (0.4 + 0.6 * val)
-            else:
-                level = 0.05
+            seed = _WAVE_SEEDS[i % len(_WAVE_SEEDS)]
+            phase = frame * 0.7 + i * 0.65
+            val = 0.5 + 0.5 * math.sin(phase)
+            level = (seed / 40.0) * (0.4 + 0.6 * val)
             _draw_bar(scr, bar_bottom, wx + i * 2, level, _WAVE_ROWS, bar_attr)
 
     # Mode indicator: lets you confirm which visualizer pipeline is live.

{ytm_cli-0.7.2 → ytm_cli-0.8.0}/ytm_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytm-cli
-Version: 0.7.2
+Version: 0.8.0
 Summary: YouTube Music CLI tool with interactive terminal interface
 Author-email: thieuluan <thieuluan.dark@gmail.com>
 License-Expression: MIT
@@ -14,9 +14,13 @@ Classifier: Intended Audience :: End Users/Desktop
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Multimedia :: Sound/Audio :: Players
-Requires-Python: >=3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ytmusicapi
@@ -60,7 +64,7 @@ Stream music directly from YouTube Music in your terminal with intuitive control
 
 ### Requirements
 
-- Python **3.14+** (set in `pyproject.toml`)
+- Python **3.10+** (set in `pyproject.toml`)
 - [mpv media player](https://mpv.io/installation/) (must be installed system-wide)
 - [`ffmpeg`](https://ffmpeg.org/) on `PATH` for the real-time spectrum visualizer (optional — falls back to a stereo oscilloscope if missing)