headless-music 1.1.1__py3-none-any.whl

headless_music/main.py

@@ -0,0 +1,279 @@
+import sys
+import time
+import select
+import threading
+from rich.console import Console
+from rich.live import Live
+import logging
+
+# Import our modules
+from config import (
+    setup_logging, load_config, validate_config,
+    setup_wizard, CONFIG_FILE
+)
+from player import MusicPlayer
+from fetchers.spotify import SpotifyFetcher
+from fetchers.youtube import YouTubeFetcher
+from ui.layout import create_layout
+from ui.panels import (
+    create_controls_panel, create_now_playing_panel,
+    create_queue_panel, create_progress_panel
+)
+from ui.art import create_ascii_art_panel
+from utils.cache import panel_cache
+
+console = Console()
+
+
+def input_thread(player):
+    """Handle keyboard input with adaptive polling."""
+    poll_interval = 0.5
+
+    while player.is_running:
+        try:
+            readable, _, _ = select.select([sys.stdin], [], [], poll_interval)
+            if readable:
+                char = sys.stdin.read(1)
+                poll_interval = 0.1  # Fast response after input
+
+                if char == 'n':
+                    player.command_queue.put("next")
+                elif char == 'p':
+                    player.command_queue.put("prev")
+                elif char == ' ':
+                    player.command_queue.put("pause")
+                elif char == 'q':
+                    player.command_queue.put("quit")
+                elif char == 'c':
+                    player.command_queue.put("config")
+            else:
+                poll_interval = min(poll_interval * 1.5, 0.5)
+        except Exception as e:
+            logging.error(f"Input thread error: {e}")
+            player.is_running = False
+
+
+def refresh_queue(player, spotify_fetcher, youtube_fetcher):
+    """Refresh queue with new recommendations."""
+    if not player.needs_queue_refresh():
+        return
+
+    seed_tracks = player.playlist[
+        max(0, player.current_index - 10):player.current_index + 1
+    ]
+
+    new_tracks = []
+
+    if spotify_fetcher:
+        new_tracks = spotify_fetcher.get_recommendations(seed_tracks, limit=15)
+
+    if len(new_tracks) < 5 and youtube_fetcher:
+        yt_tracks = youtube_fetcher.search_similar_tracks(seed_tracks, limit=10)
+        new_tracks.extend(yt_tracks)
+
+    if new_tracks:
+        player.extend_playlist(new_tracks)
+    else:
+        # Loop playlist if no new tracks found
+        player.extend_playlist(player.playlist[:20])
+
+
+def main():
+    """Main application loop."""
+    setup_logging()
+
+    config = load_config()
+    if not validate_config(config):
+        config = setup_wizard()
+        if not config:
+            return
+
+    console.print("🎵 Initialising headless_music...", style="bold cyan")
+    console.print(f"📡 Fetching {config['PLAYLIST_SOURCE'].title()} playlist...",
+                  style="bold green")
+
+    # Initialize fetchers
+    spotify_fetcher = SpotifyFetcher(
+        config['SPOTIFY_CLIENT_ID'],
+        config['SPOTIFY_CLIENT_SECRET']
+    )
+    youtube_fetcher = YouTubeFetcher()
+
+    # Fetch initial playlist
+    if config['PLAYLIST_SOURCE'] == 'spotify':
+        if not spotify_fetcher.client:
+            console.print("[red]Failed to initialize Spotify. Exiting.[/red]")
+            return
+        initial_tracks = spotify_fetcher.get_playlist_tracks(config['PLAYLIST_URL'])
+    else:
+        initial_tracks = youtube_fetcher.get_playlist_titles(config['PLAYLIST_URL'])
+
+    if not initial_tracks:
+        console.print("[red]Failed to fetch playlist. Exiting.[/red]")
+        return
+
+    console.print(f"✓ Found {len(initial_tracks)} tracks", style="green")
+    console.print("🎧 Fetching additional tracks...", style="bold green")
+
+    # Fetch additional recommendations
+    additional_tracks = []
+    if spotify_fetcher.client:
+        additional_tracks = spotify_fetcher.get_recommendations(initial_tracks, limit=30)
+        if additional_tracks:
+            console.print(f"✓ Added {len(additional_tracks)} tracks", style="green")
+
+    # Initialize player
+    player = MusicPlayer()
+    player.playlist = initial_tracks + additional_tracks
+
+    if not player.playlist:
+        console.print("[red]No tracks available. Exiting.[/red]")
+        return
+
+    # Setup terminal
+    try:
+        import tty
+        import termios
+        old_settings = termios.tcgetattr(sys.stdin)
+        tty.setcbreak(sys.stdin.fileno())
+    except Exception:
+        old_settings = None
+
+    # Start input thread
+    input_handler = threading.Thread(
+        target=input_thread,
+        args=(player,),
+        daemon=True
+    )
+    input_handler.start()
+
+    console.print("\n✨ Starting playback...\n", style="bold magenta")
+    time.sleep(0.5)
+
+    # Create UI layout
+    layout = create_layout()
+    last_progress_update = time.time()
+    force_refresh_counter = 0
+
+    try:
+        with Live(layout, console=console, screen=True, refresh_per_second=0.5) as live:
+            # Initialize UI
+            player.play_track(0)
+            layout["footer"].update(create_controls_panel())
+
+            # Initial UI update
+            track = player.get_current_track()
+            if track:
+                title, artist, source, image_url = track
+                available_height = max(1, console.height - 11)
+
+                layout["art"].update(
+                    create_ascii_art_panel(image_url, available_height, panel_cache)
+                )
+                layout["now_playing"].update(
+                    create_now_playing_panel(title, artist, source)
+                )
+                layout["sidebar"].update(
+                    create_queue_panel(player.playlist, player.current_index)
+                )
+
+            # Main loop
+            while player.is_running:
+                try:
+                    cmd = player.command_queue.get(timeout=2.0)
+                except:
+                    cmd = None
+
+                if cmd == "next":
+                    refresh_queue(player, spotify_fetcher, youtube_fetcher)
+                    if player.next_track():
+                        track = player.get_current_track()
+                        if track:
+                            title, artist, source, image_url = track
+                            available_height = max(1, console.height - 11)
+
+                            layout["art"].update(
+                                create_ascii_art_panel(image_url, available_height, panel_cache)
+                            )
+                            layout["now_playing"].update(
+                                create_now_playing_panel(title, artist, source)
+                            )
+                            layout["sidebar"].update(
+                                create_queue_panel(player.playlist, player.current_index)
+                            )
+                    force_refresh_counter = 0
+
+                elif cmd == "prev":
+                    if player.prev_track():
+                        track = player.get_current_track()
+                        if track:
+                            title, artist, source, image_url = track
+                            available_height = max(1, console.height - 11)
+
+                            layout["art"].update(
+                                create_ascii_art_panel(image_url, available_height, panel_cache)
+                            )
+                            layout["now_playing"].update(
+                                create_now_playing_panel(title, artist, source)
+                            )
+                            layout["sidebar"].update(
+                                create_queue_panel(player.playlist, player.current_index)
+                            )
+                    force_refresh_counter = 0
+
+                elif cmd == "pause":
+                    player.toggle_pause()
+                    force_refresh_counter = 0
+
+                elif cmd == "config":
+                    player.is_running = False
+                    player.mpv.pause = True
+                    live.stop()
+                    console.clear()
+                    new_config = setup_wizard()
+                    if new_config:
+                        console.print("\n[yellow]Please restart headless_music to apply new settings.[/yellow]")
+                    break
+
+                elif cmd == "quit":
+                    break
+
+                # Update progress every 2 seconds
+                current_time = time.time()
+                if current_time - last_progress_update >= 2.0:
+                    try:
+                        layout["progress"].update(create_progress_panel(player.mpv))
+                        last_progress_update = current_time
+                    except Exception:
+                        pass
+
+                # Periodic forced refresh
+                force_refresh_counter += 1
+                if force_refresh_counter >= 10:
+                    live.refresh()
+                    force_refresh_counter = 0
+
+                # Sleep when idle
+                if cmd is None:
+                    time.sleep(0.2)
+
+    except KeyboardInterrupt:
+        player.is_running = False
+
+    finally:
+        player.quit()
+
+        # Restore terminal
+        if old_settings:
+            try:
+                import termios
+                termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)
+            except Exception:
+                pass
+
+        console.clear()
+        console.print("\nheadless_music stopped. goodbye! 👋 \n", style="bold yellow")
+
+
+if __name__ == "__main__":
+    main()

headless_music/player.py

@@ -0,0 +1,75 @@
+import logging
+import queue
+import threading
+from mpv import MPV
+
+
+class MusicPlayer:
+    def __init__(self):
+        self.mpv = MPV(
+            ytdl=True,
+            video=False,
+            keep_open=False,
+            keep_open_pause=False,
+            cache=True,
+            demuxer_max_bytes='50M',
+            cache_secs=10
+        )
+        self.current_index = 0
+        self.playlist = []
+        self.command_queue = queue.Queue()
+        self.is_running = True
+        self._setup_observers()
+
+    def _setup_observers(self):
+        @self.mpv.property_observer('idle-active')
+        def handle_song_end(_name, value):
+            if value and self.is_running:
+                self.command_queue.put("next")
+
+    def play_track(self, index):
+        if index < 0 or index >= len(self.playlist):
+            if index >= len(self.playlist) and len(self.playlist) > 0:
+                index = 0
+            else:
+                return False
+
+        self.current_index = index
+        title, artist, _, _ = self.playlist[self.current_index]
+
+        try:
+            query = f"{title} {artist} audio"
+            self.mpv.play(f"ytdl://ytsearch1:{query}")
+            self.mpv.pause = False
+            return True
+        except Exception as e:
+            logging.error(f"Error playing track: {e}")
+            self.command_queue.put("next")
+            return False
+
+    def next_track(self):
+        return self.play_track(self.current_index + 1)
+
+    def prev_track(self):
+        return self.play_track(max(0, self.current_index - 1))
+
+    def toggle_pause(self):
+        self.mpv.pause = not self.mpv.pause
+
+    def get_current_track(self):
+        if 0 <= self.current_index < len(self.playlist):
+            return self.playlist[self.current_index]
+        return None
+
+    def needs_queue_refresh(self, threshold=5):
+        return len(self.playlist) - self.current_index < threshold
+
+    def extend_playlist(self, tracks):
+        self.playlist.extend(tracks)
+
+    def quit(self):
+        self.is_running = False
+        try:
+            self.mpv.quit()
+        except Exception:
+            pass

headless_music/ui/__init__.py

@@ -0,0 +1,17 @@
+from .layout import create_layout
+from .panels import (
+    create_controls_panel,
+    create_now_playing_panel,
+    create_queue_panel,
+    create_progress_panel
+)
+from .art import create_ascii_art_panel
+
+__all__ = [
+    'create_layout',
+    'create_controls_panel',
+    'create_now_playing_panel',
+    'create_queue_panel',
+    'create_progress_panel',
+    'create_ascii_art_panel'
+]

headless_music/ui/art.py

@@ -0,0 +1,95 @@
+import io
+import logging
+import requests
+from functools import lru_cache
+from PIL import Image
+from rich.text import Text
+from rich.panel import Panel
+
+
+@lru_cache(maxsize=32)
+def generate_ascii_art(image_url, height):
+    try:
+        height = max(1, min(height, 30))
+        width = height * 2
+
+        response = requests.get(image_url, timeout=3)
+        response.raise_for_status()
+
+        with Image.open(io.BytesIO(response.content)) as img:
+            img = img.resize((width, height), Image.Resampling.LANCZOS)
+            img = img.convert("RGB")
+
+            ascii_lines = [None] * height
+
+            for y in range(height):
+                line_parts = []
+                for x in range(width):
+                    r, g, b = img.getpixel((x, y))
+                    line_parts.append(f"[rgb({r},{g},{b}) on rgb({r},{g},{b})]▀[/]")
+                ascii_lines[y] = ''.join(line_parts)
+
+            return Text.from_markup("\n".join(ascii_lines), justify="center")
+
+    except Exception as e:
+        logging.warning(f"Failed to generate ASCII art: {e}")
+        return None
+
+_PLACEHOLDER_CACHE = {}
+
+
+def get_placeholder_art(height=8):
+    if height in _PLACEHOLDER_CACHE:
+        return _PLACEHOLDER_CACHE[height]
+
+    base_art = [
+        "╔══════════════╗",
+        "║              ║",
+        "║    [bold]🎵[/bold]        ║",
+        "║              ║",
+        "║   [dim]headless[/dim]   ║",
+        "║   [dim]_music[/dim]    ║",
+        "║              ║",
+        "╚══════════════╝",
+    ]
+    base_height = len(base_art)
+    scaled_art_lines = []
+
+    if height <= 0:
+        result = Text("")
+    elif height < base_height:
+        start_index = (base_height - height) // 2
+        for i in range(height):
+            scaled_art_lines.append(f"  [green]{base_art[start_index + i]}[/green]")
+        result = Text.from_markup("\n".join(scaled_art_lines), justify="center")
+    else:
+        top_padding = (height - base_height) // 2
+        bottom_padding = height - base_height - top_padding
+        scaled_art_lines.extend([""] * top_padding)
+        for line in base_art:
+            scaled_art_lines.append(f"  [green]{line}[/green]")
+        scaled_art_lines.extend([""] * bottom_padding)
+        result = Text.from_markup("\n".join(scaled_art_lines), justify="center")
+
+    _PLACEHOLDER_CACHE[height] = result
+    return result
+
+
+def create_ascii_art_panel(image_url, height, cache):
+    cache_key = f"{image_url}_{height}"
+    cached = cache.get(cache_key)
+    if cached:
+        return cached
+
+    if image_url:
+        try:
+            art = generate_ascii_art(image_url, height)
+            if art:
+                panel = Panel(art, border_style="dim", padding=(0, 0))
+                cache.set(cache_key, panel)
+                return panel
+        except Exception:
+            pass
+
+    panel = Panel(get_placeholder_art(height), border_style="dim")
+    return panel

headless_music/ui/layout.py

@@ -0,0 +1,19 @@
+from rich.layout import Layout
+
+
+def create_layout():
+    layout = Layout()
+
+    layout.split_row(
+        Layout(name="sidebar", size=40),
+        Layout(name="main", ratio=1)
+    )
+
+    layout["main"].split_column(
+        Layout(name="art", ratio=1),
+        Layout(name="now_playing", size=5),
+        Layout(name="progress", size=1),
+        Layout(name="footer", size=3)
+    )
+
+    return layout

headless_music/ui/panels.py

@@ -0,0 +1,103 @@
+from rich.panel import Panel
+from rich.text import Text
+from rich.progress_bar import ProgressBar
+from rich.layout import Layout
+from utils.helpers import format_time, truncate_string
+
+_CONTROLS_PANEL = None
+
+
+def create_controls_panel():
+    global _CONTROLS_PANEL
+    if _CONTROLS_PANEL is None:
+        _CONTROLS_PANEL = Panel(
+            Text.from_markup(
+                "[bold cyan]n[/bold cyan] next  •  [bold cyan]p[/bold cyan] prev  •  "
+                "[bold cyan]space[/bold cyan] pause/play  •  [bold cyan]q[/bold cyan] quit  •  "
+                "[bold cyan]c[/bold cyan] config",
+                justify="center"
+            ),
+            border_style="dim"
+        )
+    return _CONTROLS_PANEL
+
+
+def create_now_playing_panel(title, artist, source):
+    source_color = "red" if source == "YouTube" else "green"
+
+    title = truncate_string(title, 60)
+    artist = truncate_string(artist, 40)
+
+    display_text = Text.from_markup(
+        f"\n[bold]{title}[/bold]\n[dim]{artist}[/dim]\n"
+        f"Source: [{source_color}]{source}[/{source_color}]\n"
+    )
+    return Panel(display_text, title="Now Playing",
+                 padding=(0, 2, 0, 2), border_style="dim")
+
+
+def create_queue_panel(master_playlist, current_index):
+    lines = []
+
+    if 0 <= current_index < len(master_playlist):
+        title, artist, _, _ = master_playlist[current_index]
+        title = truncate_string(title, 30)
+        artist = truncate_string(artist, 30)
+
+        lines.append(Text.from_markup(f"[bold green] > {title}[/bold green]"))
+        lines.append(Text.from_markup(f"   [dim]{artist}[/dim]"))
+        lines.append(Text.from_markup("---"))
+
+    end_idx = min(current_index + 11, len(master_playlist))
+
+    if end_idx == current_index + 1 and len(master_playlist) > 0:
+        lines.append(Text.from_markup("  [dim]Fetching more tracks...[/dim]"))
+    else:
+        for i in range(current_index + 1, end_idx):
+            title, artist, _, _ = master_playlist[i]
+            title = truncate_string(title, 30)
+            artist = truncate_string(artist, 30)
+
+            lines.append(Text.from_markup(f"   {i - current_index}. {title}"))
+            lines.append(Text.from_markup(f"      [dim]{artist}[/dim]"))
+
+    if not lines:
+        return Panel(Text("  [dim]Loading queue...[/dim]"),
+                     title="Queue", border_style="dim", padding=(1,1))
+
+    return Panel(Text("\n").join(lines), title="Queue",
+                 border_style="dim", padding=(1,1))
+
+_progress_layout = None
+
+
+def create_progress_panel(player):
+    global _progress_layout
+
+    try:
+        time_pos = player.time_pos or 0
+        duration = player.duration or 0
+        percent = (time_pos / duration * 100) if duration else 0
+
+        bar = ProgressBar(total=100, completed=percent, width=None,
+                         complete_style="green", pulse=duration == 0)
+        time_display = Text(f"{format_time(time_pos)} / {format_time(duration)}",
+                           justify="right")
+        icon = "⏸" if player.pause else "▶"
+
+        if _progress_layout is None:
+            _progress_layout = Layout()
+            _progress_layout.split_row(
+                Layout(name="icon", size=3),
+                Layout(name="bar"),
+                Layout(name="time", size=15)
+            )
+
+        _progress_layout["icon"].update(Text(f" {icon} "))
+        _progress_layout["bar"].update(bar)
+        _progress_layout["time"].update(time_display)
+
+        return _progress_layout
+    except Exception:
+        return Layout(Text(""))
+

headless_music/utils/__init__.py

@@ -0,0 +1,10 @@
+from .helpers import format_time, truncate_string
+from .cache import SimpleCache, panel_cache, art_cache
+
+__all__ = [
+    'format_time',
+    'truncate_string',
+    'SimpleCache',
+    'panel_cache',
+    'art_cache'
+]

headless_music/utils/cache.py

@@ -0,0 +1,23 @@
+from functools import wraps
+import logging
+
+
+class SimpleCache:
+    def __init__(self, max_size=100):
+        self._cache = {}
+        self._max_size = max_size
+
+    def get(self, key):
+        return self._cache.get(key)
+
+    def set(self, key, value):
+        if len(self._cache) >= self._max_size:
+            first_key = next(iter(self._cache))
+            del self._cache[first_key]
+        self._cache[key] = value
+
+    def clear(self):
+        self._cache.clear()
+
+panel_cache = SimpleCache(max_size=50)
+art_cache = SimpleCache(max_size=32)

headless_music/utils/helpers.py

@@ -0,0 +1,15 @@
+from functools import lru_cache
+
+
+@lru_cache(maxsize=128)
+def format_time(seconds):
+    if seconds is None or seconds < 0:
+        return "--:--"
+    m, s = divmod(int(seconds), 60)
+    return f"{m:02}:{s:02}"
+
+
+def truncate_string(text, max_length, suffix="..."):
+    if len(text) <= max_length:
+        return text
+    return text[:max_length] + suffix