remove client

app.py

@@ -1,7 +1,6 @@
 import asyncio
 import logging
 import os
-import time
 import threading
 from dataclasses import dataclass
 from enum import Enum
@@ -13,7 +12,6 @@ from discord.ext import commands
 from dotenv import load_dotenv
 import gradio as gr
 from huggingface_hub import hf_hub_download
-from gradio_client import Client
 
 # Configure logging
 logging.basicConfig(
@@ -24,8 +22,6 @@ logger = logging.getLogger(__name__)
 
 class LoopMode(str, Enum):
     NONE = "none"
-    SINGLE = "single"
-    QUEUE = "queue"
 
 
 @dataclass
@@ -33,9 +29,6 @@ class BotConfig:
     ASSETS_DIR: str = "assets"
     SONG_FILE: str = "lofi.mp3"
     HF_REPO: str = "not-lain/assets"
-    HF_SPACE: str = "https://not-lain-ytdlp.hf.space/"
-    MAX_RETRY_ATTEMPTS: int = 3
-    MAX_CACHE_SIZE: int = 100  # Maximum number of songs to cache
 
     @property
     def song_path(self) -> str:
@@ -63,17 +56,6 @@ class MusicBot:
         self.last_context: Optional[commands.Context] = None
         self.loop_mode: LoopMode = LoopMode.NONE
         self.current_song: Optional[QueueItem] = None
-        self.queue: list[QueueItem] = []
-        self.hf_client = Client(config.HF_SPACE, hf_token=None)
-        self.song_cache: dict[str, tuple[str, str]] = {}  # url -> (title, file_path)
-
-    def _manage_cache(self) -> None:
-        """Remove oldest songs if cache exceeds maximum size"""
-        if len(self.song_cache) > self.config.MAX_CACHE_SIZE:
-            # Convert to list to get oldest entries (assuming insertion order is maintained)
-            oldest_urls = list(self.song_cache.keys())[: -self.config.MAX_CACHE_SIZE]
-            for url in oldest_urls:
-                del self.song_cache[url]
 
     async def ensure_voice_state(self, ctx: commands.Context) -> None:
         """Validate voice state and raise appropriate errors"""
@@ -83,46 +65,17 @@ class MusicBot:
         if self.voice_client and ctx.author.voice.channel != self.voice_client.channel:
             raise VoiceStateError("You must be in the same voice channel as the bot!")
 
-    async def download_song(self, queue_item: QueueItem) -> None:
-        """Download song from URL and update queue item with file path, using cache when available"""
-        try:
-            # Check if song is in cache
-            if queue_item.url in self.song_cache:
-                title, file_path = self.song_cache[queue_item.url]
-                queue_item.title = title
-                queue_item.file_path = file_path
-                logger.info(f"Found song in cache: {title}")
-                return
-
-            # Download if not in cache
-            job = self.hf_client.submit(url=queue_item.url, api_name="/predict")
-            while not job.done():
-                time.sleep(0.1)
-            title, file_path = job.outputs()[0]
-
-            # Update cache
-            self.song_cache[queue_item.url] = (title, file_path)
-            self._manage_cache()
-
-            queue_item.title = title
-            queue_item.file_path = file_path
-            logger.info(f"Downloaded and cached new song: {title}")
-        except Exception as e:
-            logger.error(f"Error downloading song: {e}")
-            raise
-
     async def play_next(self, ctx: commands.Context) -> None:
         if self.is_playing:
             return
 
         try:
-            if not self.current_song and self.queue:
-                self.current_song = self.queue.pop(0)
-                # Download song if it hasn't been downloaded yet
-                if not self.current_song.file_path:
-                    await self.download_song(self.current_song)
-            elif not self.current_song:
-                return
+            if not self.current_song:
+                self.current_song = QueueItem(
+                    url=self.config.song_path,
+                    title="Lofi Music",
+                    file_path=self.config.song_path,
+                )
 
             self.is_playing = True
             audio_source = discord.FFmpegPCMAudio(self.current_song.file_path)
@@ -143,9 +96,6 @@ class MusicBot:
     async def handle_song_end(self, ctx: commands.Context) -> None:
         if self.loop_mode == LoopMode.NONE:
             self.current_song = None
-        elif self.loop_mode == LoopMode.QUEUE and self.current_song:
-            self.queue.append(self.current_song)
-            self.current_song = None
 
         if not self.is_playing:
             await self.play_next(ctx)
@@ -177,20 +127,12 @@ class MusicBot:
             self._reset_state()
             return False
 
-    def add_to_queue(self, url: str) -> int:
-        """Add song to queue and return position"""
-        queue_item = QueueItem(url=url)
-        self.queue.append(queue_item)
-        return len(self.queue)
-
     def _reset_state(self) -> None:
         self.is_playing = False
         self.voice_client = None
         self.last_context = None
         self.loop_mode = LoopMode.NONE
         self.current_song = None
-        self.queue.clear()
-        # Note: We don't clear the cache when resetting state
 
 
 async def handle_voice_command(
@@ -241,10 +183,6 @@ async def on_ready():
 async def lofi(interaction: discord.Interaction):
     async def play_lofi(ctx, interaction: discord.Interaction):
         await music_bot.join_voice(ctx)
-        # music_bot.loop_mode = LoopMode.SINGLE
-        music_bot.current_song = QueueItem(
-            url=config.song_path, title="Lofi Music", file_path=config.song_path
-        )
         if not music_bot.is_playing:
             await music_bot.play_next(ctx)
             await interaction.followup.send("Playing lofi music! 🎵")
@@ -254,73 +192,18 @@ async def lofi(interaction: discord.Interaction):
     await handle_voice_command(interaction, play_lofi)
 
 
-@bot.tree.command(name="play", description="Play a youtube song")
-async def play(interaction: discord.Interaction, url: str):
-    async def play_song(ctx, interaction: discord.Interaction):
-        await music_bot.join_voice(ctx)
-
-        if music_bot.is_playing or music_bot.queue:
-            position = music_bot.add_to_queue(url)
-            await interaction.followup.send(
-                f"Added song to queue at position {position}! 🎵"
-            )
-        else:
-            music_bot.add_to_queue(url)
-            await music_bot.play_next(ctx)
-            if music_bot.current_song and music_bot.current_song.title:
-                await interaction.followup.send(
-                    f"Playing {music_bot.current_song.title}! 🎵"
-                )
-            else:
-                await interaction.followup.send("Playing song! 🎵")
-
-    await handle_voice_command(interaction, play_song)
-
-
-@bot.tree.command(name="skip", description="Skip the current song")
-async def skip(interaction: discord.Interaction):
-    # Check if user is in a voice channel
+@bot.tree.command(name="stop", description="Stop the lofi music")
+async def stop(interaction: discord.Interaction):
     if not interaction.user.voice:
         await interaction.response.send_message(
             "You must be in a voice channel to use this command!"
         )
         return
 
-    # Check if bot is in a voice channel
     if not music_bot.voice_client:
-        await interaction.response.send_message("No song is currently playing!")
+        await interaction.response.send_message("No music is currently playing!")
         return
 
-    # Check if user is in the same channel as the bot
-    if interaction.user.voice.channel != music_bot.voice_client.channel:
-        await interaction.response.send_message(
-            "You must be in the same voice channel as the bot!"
-        )
-        return
-
-    if music_bot.voice_client and music_bot.is_playing:
-        music_bot.is_playing = False  # Reset playing state
-        music_bot.voice_client.stop()
-        await interaction.response.send_message("Skipped current song!")
-    else:
-        await interaction.response.send_message("No song is currently playing!")
-
-
-@bot.tree.command(name="leave", description="Disconnect bot from voice channel")
-async def leave(interaction: discord.Interaction):
-    # Check if user is in a voice channel
-    if not interaction.user.voice:
-        await interaction.response.send_message(
-            "You must be in a voice channel to use this command!"
-        )
-        return
-
-    # Check if bot is in a voice channel
-    if not music_bot.voice_client:
-        await interaction.response.send_message("I'm not in any voice channel!")
-        return
-
-    # Check if user is in the same channel as the bot
     if interaction.user.voice.channel != music_bot.voice_client.channel:
         await interaction.response.send_message(
             "You must be in the same voice channel as the bot!"
@@ -333,45 +216,14 @@ async def leave(interaction: discord.Interaction):
     try:
         success = await music_bot.stop_playing(ctx)
         if success:
-            await interaction.followup.send("Successfully disconnected! 👋")
+            await interaction.followup.send("Music stopped and bot disconnected! 👋")
         else:
             await interaction.followup.send(
-                "Failed to disconnect properly. Please try again."
+                "Failed to stop properly. Please try again."
             )
     except Exception as e:
-        print(f"Error during leave command: {e}")
-        await interaction.followup.send("An error occurred while trying to disconnect.")
-
-
-@bot.tree.command(name="loop", description="Set loop mode")
-@app_commands.choices(
-    mode=[app_commands.Choice(name=mode.value, value=mode.value) for mode in LoopMode]
-)
-async def loop(interaction: discord.Interaction, mode: str):
-    try:
-        music_bot.loop_mode = LoopMode(mode)
-        await interaction.response.send_message(f"Loop mode set to: {mode}")
-    except ValueError:
-        await interaction.response.send_message("Invalid loop mode!")
-
-
-@bot.tree.command(name="queue", description="Show current queue")
-async def queue(interaction: discord.Interaction):
-    if not music_bot.queue and not music_bot.current_song:
-        await interaction.response.send_message("Queue is empty!")
-        return
-
-    queue_list = []
-    if music_bot.current_song:
-        status = "🎵 Now playing"
-        title = music_bot.current_song.title or "Loading..."
-        queue_list.append(f"{status}: {title}")
-
-    for i, item in enumerate(music_bot.queue, 1):
-        title = item.title or "Loading..."
-        queue_list.append(f"{i}. {title}")
-
-    await interaction.response.send_message("\n".join(queue_list))
+        print(f"Error during stop command: {e}")
+        await interaction.followup.send("An error occurred while trying to stop.")
 
 
 def initialize_assets() -> None: