Revise paste 611e3afe0648c

import re
import disnake
from disnake import ApplicationCommandInteraction as Interaction
from disnake.ext import commands
import lavalink
import logging

# Configure logging
logging.basicConfig(level=logging.DEBUG)
url_rx = re.compile(r'https?://(?:www\.)?.+')
CHOICE = commands.option_enum(["Youtube", "Spotify", "Soundcloud"])

class LavalinkVoiceClient(disnake.VoiceProtocol):
    def __init__(self, client: disnake.Client, channel: disnake.abc.Connectable):
        self.client = client
        self.channel = channel
        self.guild_id = channel.guild.id
        self._destroyed = False

if not hasattr(self.client, 'lavalink'):
            self.client.lavalink = lavalink.Client(client.user.id)
            self.client.lavalink.add_node(
                host='localhost',
                port=2333,
                password='youshallnotpass',
                region='us',
                name='default-node'
            )

self.lavalink = self.client.lavalink

async def on_voice_server_update(self, data):
        lavalink_data = {'t': 'VOICE_SERVER_UPDATE', 'd': data}
        await self.lavalink.voice_update_handler(lavalink_data)

async def on_voice_state_update(self, data):
        channel_id = data['channel_id']

if not channel_id:
            await self._destroy()
            return

self.channel = self.client.get_channel(int(channel_id))
        lavalink_data = {'t': 'VOICE_STATE_UPDATE', 'd': data}
        await self.lavalink.voice_update_handler(lavalink_data)

async def connect(self, *, timeout: float, reconnect: bool, self_deaf: bool = False, self_mute: bool = False) -> None:
        self.lavalink.player_manager.create(guild_id=self.channel.guild.id)
        await self.channel.guild.change_voice_state(
            channel=self.channel,
            self_mute=self_mute,
            self_deaf=self_deaf
        )

async def disconnect(self, *, force: bool = False) -> None:
        player = self.lavalink.player_manager.get(self.channel.guild.id)

if not force and not player.is_connected:
            return

await self.channel.guild.change_voice_state(channel=None)
        player.channel_id = None
        await self._destroy()

async def _destroy(self):
        if self._destroyed:
            return

self._destroyed = True

try:
            await self.lavalink.player_manager.destroy(self.guild_id)
        except lavalink.ClientError as e:
            logger.error(f'Error destroying Lavalink player: {e}')

class Music(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

@commands.Cog.listener()
    async def on_ready(self):
        if not hasattr(self.bot, 'lavalink'):
            self.bot.lavalink = lavalink.Client(self.bot.user.id)
            self.bot.lavalink.add_node(
                host='localhost',
                port=2333,
                password='youshallnotpass',
                region='us',
                name='default-node'
            )

async def create_player(self, inter):
        if inter.guild is None:
            await inter.response.send_message("This command can only be used in a server.")
            return

player = self.bot.lavalink.player_manager.create(inter.guild.id)
        should_connect = inter.data['name'] in ('play',)

voice_client = inter.guild.voice_client

if not inter.author.voice or not inter.author.voice.channel:
            await inter.response.send_message('You need to join a voice channel first.')
            return

voice_channel = inter.author.voice.channel

if voice_client is None:
            if not should_connect:
                await inter.response.send_message("I'm not playing music.")
                return

permissions = voice_channel.permissions_for(inter.guild.me)

if not permissions.connect or not permissions.speak:
                await inter.response.send_message('I need the `CONNECT` and `SPEAK` permissions.')
                return

if voice_channel.user_limit > 0:
                if len(voice_channel.members) >= voice_channel.user_limit and not inter.guild.me.guild_permissions.move_members:
                    raise commands.CommandInvokeError('Your voice channel is full!')

player.store('channel', inter.channel.id)

# Automatically join the voice channel if the bot is not already connected
            
            await voice_channel.connect(cls=LavalinkVoiceClient)
        elif voice_client.channel.id != voice_channel.id:
            # If the bot is connected to another channel, raise an error
            raise commands.CommandInvokeError('You need to be in the same voice channel as the bot.')

return True

@commands.slash_command(name='play', description='Searches and plays a song from a given query.')
    async def play(self, inter, query: str, source: CHOICE = None):
        await self.create_player(inter)
        player = self.bot.lavalink.player_manager.get(inter.guild.id)
        # print(player)
        query = query.strip('<>')
        # print(source)
        if not url_rx.match(query):
            if source == 'Spotify':
                query = f'sprec:{query}'
            elif source == 'Soundcloud':
                query = f'scsearch:{query}'
            elif source == 'Youtube':
                query = f'ytsearch:{query}'
            else:
                query = f'ytsearch:{query}'
        # print(query)
        results = await player.node.get_tracks(query)

embed = disnake.Embed(color=disnake.Color.blurple())

if results.load_type == lavalink.LoadType.EMPTY:
            return await inter.response.send_message("I couldn't find any tracks for that query.")
        elif results.load_type == lavalink.LoadType.PLAYLIST:
            tracks = results.tracks

for track in tracks:
                player.add(track=track, requester=inter.author.id)

embed.title = 'Playlist Enqueued!'
            embed.description = f'{results.playlist_info.name} - {len(tracks)} tracks'
        else:
            track = results.tracks[0]
            embed.title = 'Track Enqueued'
            embed.description = f'[{track.title}]({track.uri})'

player.add(track=track, requester=inter.author.id)

await inter.response.send_message(embed=embed)

if not player.is_playing:
            await player.play()

@commands.slash_command(name='stop', description='Stops the player and clears the queue.')
    async def stop(self, inter):
        player = self.bot.lavalink.player_manager.get(inter.guild.id)