first commit

bot/voice_manager.py

@@ -0,0 +1,295 @@
+"""
+voice_manager.py - Voice connection, queue, and playback for Discord music.
+
+Uses yt-dlp to download bestaudio to disk, then plays via FFmpegPCMAudio.
+Files persist indefinitely in AUDIO_DIR (acts as a cache).
+"""
+
+import os
+import asyncio
+import time
+import yt_dlp
+import discord
+
+AUDIO_DIR = "/app/audio_cache"
+os.makedirs(AUDIO_DIR, exist_ok=True)
+
+connections = {}
+queues = {}
+playing = {}
+download_locks = {}
+retries = {}
+command_channels = {}
+
+
+def _get_download_lock(guild_id):
+    if guild_id not in download_locks:
+        download_locks[guild_id] = asyncio.Lock()
+    return download_locks[guild_id]
+
+
+def _format_duration(seconds):
+    if not seconds:
+        return "??:??"
+    m, s = divmod(int(seconds), 60)
+    return f"{m}:{s:02d}"
+
+
+def _get_cached_path(video_id):
+    for ext in [".webm", ".opus", ".m4a", ".mp3", ".ogg", ".flac"]:
+        path = os.path.join(AUDIO_DIR, f"{video_id}{ext}")
+        if os.path.exists(path):
+            return path
+    return None
+
+
+def _download_sync(query):
+    ydl_opts = {
+        "format": "bestaudio",
+        "outtmpl": os.path.join(AUDIO_DIR, "%(id)s.%(ext)s"),
+        "no-playlist": True,
+        "quiet": True,
+        "no_warnings": True,
+        "socket_timeout": 30,
+    }
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(query, download=False)
+        video_id = info.get("id")
+        title = info.get("title", "Unknown")
+        duration = info.get("duration")
+        artist = info.get("artist") or info.get("creator") or info.get("channel", "")
+
+        cached = _get_cached_path(video_id)
+        if cached:
+            return cached, title, duration, artist
+
+        ydl.download([query])
+
+        filepath = _get_cached_path(video_id)
+        if not filepath:
+            for f in os.listdir(AUDIO_DIR):
+                if f.startswith(video_id):
+                    filepath = os.path.join(AUDIO_DIR, f)
+                    break
+
+        if not filepath:
+            raise RuntimeError(f"Downloaded file not found for {video_id}")
+
+        return filepath, title, duration, artist
+
+
+async def join_voice(message):
+    guild_id = message.guild.id
+
+    if guild_id in connections:
+        return connections[guild_id]
+
+    voice_state = message.author.voice
+    if not voice_state:
+        return None
+
+    channel = voice_state.channel
+    try:
+        vc = await channel.connect()
+        connections[guild_id] = vc
+        return vc
+    except Exception as e:
+        print(f"Error joining voice channel: {e}")
+        return None
+
+
+async def resolve_and_enqueue(message, query):
+    guild_id = message.guild.id
+    command_channels[guild_id] = message.channel
+
+    if guild_id not in queues:
+        queues[guild_id] = []
+
+    vc = connections.get(guild_id)
+    if not vc:
+        vc = await join_voice(message)
+        if not vc:
+            await message.channel.send("You need to be in a voice channel first.")
+            return None
+
+    lock = _get_download_lock(guild_id)
+
+    announce_msg = await message.channel.send("Preparing...")
+
+    def do_download():
+        return _download_sync(query)
+
+    try:
+        async with lock:
+            position = len(queues[guild_id]) + 1
+            filepath, title, duration, artist = await asyncio.to_thread(do_download)
+
+            if guild_id not in retries:
+                retries[guild_id] = {}
+            retries[guild_id][filepath] = 0
+
+        queues[guild_id].append(
+            {
+                "filepath": filepath,
+                "title": title,
+                "duration": duration,
+                "artist": artist,
+            }
+        )
+
+        if guild_id not in playing or not playing[guild_id]:
+            await announce_msg.delete()
+            await play_next(guild_id)
+        else:
+            await announce_msg.edit(
+                content=f'Added "{title}" to queue at position #{position}.'
+            )
+
+        return queues[guild_id][-1]
+
+    except Exception as e:
+        print(f"Download error for '{query}': {e}")
+        await message.channel.send(f'Couldn\'t download "{query}".')
+        return None
+
+
+# UNUSED: kept for reference — play_next uses its own inline _after closure
+# def _after_callback(guild_id):
+#     playing.pop(guild_id, None)
+#
+#     loop = asyncio.get_event_loop()
+#     loop.call_soon_threadsafe(lambda: asyncio.ensure_future(_play_next_async(guild_id)))
+#
+#
+# async def _play_next_async(guild_id):
+#     await play_next(guild_id)
+
+
+async def play_next(guild_id):
+    vc = connections.get(guild_id)
+    if not vc:
+        return
+
+    if not vc.is_connected():
+        connections.pop(guild_id, None)
+        return
+
+    if vc.is_playing():
+        return
+
+    queue = queues.get(guild_id, [])
+    if not queue:
+        return
+
+    item = queue.pop(0)
+    filepath = item["filepath"]
+    title = item["title"]
+    duration = item["duration"]
+    artist = item["artist"]
+
+    channel = command_channels.get(guild_id)
+
+    def _after(error):
+        if error:
+            print(f"Playback error: {error}")
+        playing.pop(guild_id, None)
+        loop = asyncio.get_event_loop()
+        loop.call_soon_threadsafe(lambda: asyncio.ensure_future(play_next(guild_id)))
+
+    try:
+        source = discord.FFmpegPCMAudio(filepath)
+        vc.play(source, after=_after)
+        playing[guild_id] = {
+            "started_at": time.time(),
+            "duration": duration,
+            "title": title,
+            "artist": artist,
+        }
+
+        display = title
+        if artist:
+            display = f"{title} ({artist})"
+
+        if channel:
+            await channel.send(f"Now playing: {display}")
+
+    except Exception as e:
+        print(f"Playback error for {filepath}: {e}")
+        retry_count = retries.get(guild_id, {}).get(filepath, 0)
+        if retry_count < 1:
+            if guild_id not in retries:
+                retries[guild_id] = {}
+            retries[guild_id][filepath] = retry_count + 1
+            queue.insert(0, item)
+            if channel:
+                await channel.send(f"Playback failed, retrying: {title}")
+            await play_next(guild_id)
+        else:
+            if guild_id in retries:
+                retries[guild_id].pop(filepath, None)
+            if channel:
+                await channel.send(f'Couldn\'t play "{title}", skipping.')
+            await play_next(guild_id)
+
+
+def skip(guild_id):
+    vc = connections.get(guild_id)
+    if vc and vc.is_playing():
+        vc.stop()
+
+
+def stop(guild_id):
+    vc = connections.pop(guild_id, None)
+    if vc:
+        vc.stop()
+        asyncio.ensure_future(vc.disconnect())
+    queues.pop(guild_id, None)
+    playing.pop(guild_id, None)
+    retries.pop(guild_id, None)
+
+
+def get_queue(guild_id):
+    queue = queues.get(guild_id, [])
+    current = playing.get(guild_id)
+
+    lines = []
+
+    if current:
+        duration = current.get("duration", 0)
+        elapsed = time.time() - current.get("started_at", time.time())
+        remaining = max(0, duration - elapsed)
+        title = current.get("title", "Unknown")
+        artist = current.get("artist", "")
+        display = f"{title} ({artist})" if artist else title
+        lines.append(
+            f"**Now playing:** {display} ({_format_duration(remaining)} remaining)"
+        )
+    else:
+        lines.append("Nothing currently playing.")
+
+    if queue:
+        lines.append("")
+        lines.append("**Up next:**")
+        for i, item in enumerate(queue, 1):
+            title = item.get("title", "Unknown")
+            artist = item.get("artist", "")
+            duration = _format_duration(item.get("duration"))
+            display = f"{title} ({artist})" if artist else title
+            lines.append(f"{i}. {display} ({duration})")
+
+    return "\n".join(lines)
+
+
+def get_now_playing(guild_id):
+    current = playing.get(guild_id)
+    if not current:
+        return "Nothing currently playing."
+
+    duration = current.get("duration", 0)
+    elapsed = time.time() - current.get("started_at", time.time())
+    remaining = max(0, duration - elapsed)
+    title = current.get("title", "Unknown")
+    artist = current.get("artist", "")
+    display = f"{title} ({artist})" if artist else title
+
+    return f"Currently playing: **{display}**\n{_format_duration(remaining)} remaining"