TypeError: unsupported type annotation <class 'wavelink.tracks.YouTubeTrack'>

[glitchplaysgames714]

im trying to make a music bot with discord.py and im getting this error

the error:
TypeError: unsupported type annotation <class 'wavelink.tracks.YouTubeTrack'>

the command
@client.tree.command(name="play",description="plays the music")
async def play(ctx: commands.Context, *, search: wavelink.YouTubeTrack):
if not ctx.voice_client:
vc: wavelink.Player = await ctx.author.voice.channel.connect(cls=wavelink.Player)
else:
vc: wavelink.Player = await ctx.voice_client

    vc.play(search)

[chillymosh]

What python version are you using? 2.x requires at least 3.10

I'd suggest using wavelink 3 though if this is a fresh bot.

Also you using Client which does not support Commands with Context, but you are also using tree which is for app_commands

[EvieePy]

For app_commands E.g. "slash commands" you need to create a transformer. I would suggest moving to Wavelink 3 as this will be easier.

Wavelink 3 Docs
Wavelink 3 Migrating Guide
Wavelink 3 Playable

You can install this version with:
pip install -U wavelink --pre

This is a release candidate build and will soon be the stable release.

On Wavelink 3 you can use the following code as a guide:

import discord
import wavelink
from discord import app_commands


class PlayableTransformer(app_commands.Transformer):
    
    async def transform(self, interaction: discord.Interaction, query: str) -> wavelink.Search:
        tracks: wavelink.Search = await wavelink.Playable.search(query)
        
        return tracks


# Where your commands are...
@client.tree.command(name="play", description="plays the music")
async def play(interaction: discord.Interaction, search: app_commands.Transform[wavelink.Search, PlayableTransformer]) -> None:
    # Do what you need to here first...
    ...
    
    if not search:
        # No tracks were found...
        await interaction.response.send_message("Unable to find any tracks with that query", ephemeral=True)
        return
    
    if isinstance(search, wavelink.Playlist):
        # search is a Playlist
        # You can add the playlist directly to your queue...
        ...
    else:
        # search is a list of Playable
        track: wavelink.Playable = search[0]
        ...

[glitchplaysgames714]

i am not using client i am using bot i just named the variable client and i just pip installed it

[glitchplaysgames714]

btw i meant i just pip installed wavelink

[glitchplaysgames714]

also my full script is `import datetime
import random
import wavelink
import discord
import openai
from discord.ext import commands
from discord import app_commands
import leveling_system
import responses

forbidden_words = ["shit", "fuck", "bitch", "damn", "ass", "asshole", "motherfucker", "fucker", "nigger"] # dont mind this this is for a swear filter lol
openai.api_key = "my api key"

async def send_message(message, user_message, is_private):
try:
response = responses.get_response(user_message)
await message.author.send(response) if is_private else await message.channel.send(response)

except Exception as e:
    print(e)

def contains_forbidden_word(text):
for word in forbidden_words:
if word in text.lower():
return word
return None

def run_discord_bot():
TOKEN = 'my token'
intents = discord.Intents.default()
intents.message_content = True
client = commands.Bot(command_prefix="!", intents=intents)

@client.event
async def on_ready():
    leveling_system.load_data()
    print(f'{client.user} is now running!')
    client.loop.create_task(node_connect())
    try:
        synced = await client.tree.sync()
        print(f'Synced {len(synced)} commands.')
    except Exception as e:
        print(f'Error syncing: {e}')

async def node_connect():
    await client.wait_until_ready()
    await wavelink.NodePool.create_node(bot=client, host='lavalinkinc.ml', port=443, password='incognito', https=True)


@client.event
async def on_wavelink_node_ready(node: wavelink.Node):
    print(f"Node {node.identifier} is ready :D")

@client.tree.command(name="play",description="plays the music")
async def play(ctx: commands.Context, *, search: wavelink.YouTubeTrack):
    if not ctx.voice_client:
        vc: wavelink.Player = await ctx.author.voice.channel.connect(cls=wavelink.Player)
    else:
        vc: wavelink.Player = await ctx.voice_client


    vc.play(search)




@client.tree.command(name="hello")
async def hello(interaction: discord.Interaction):
    embed = {

    }
    await interaction.response.send_message("hi")

@client.tree.command(name="ai")
async def ai(interaction: discord.Interaction, prompt: str):
    try:
        response = openai.Completion.create(
            engine= "davinci",
            prompt= prompt,
            temperature= 0.7,
            max_tokens= 50,
            n= 1,
            stop= "\n",
        )
    except Exception as e:
        await interaction.response.send_message(e)
        return

    generated_text = response.choices[0].text
    await interaction.response.send_message(str(generated_text))

@client.tree.command(name="roll")
async def roll(interaction: discord.Interaction,  min: int = 1,  max: int = 6):
    try:
        await interaction.response.send_message(str(f'ok: {random.randint(min,max)} there now shut it 🗿'))
    except Exception as e:
        await interaction.response.send_message(str(e))

@client.tree.command(name="level")
async def level(interaction: discord.Interaction, username: discord.User = None):
    user = None
    if username == None:
        user = interaction.user
    else:
        user = username
    try:
        await interaction.response.send_message(f'{user.mention} is level {leveling_system.level_data[str(user.id)]["level"]} with {leveling_system.level_data[str(user.id)]["xp"]} XP.')
    except KeyError:
        await interaction.response.send_message(f'{user.mention} has no levels or XP.')

@client.event
async def on_message(message):
    if message.author == client.user:
        return

    username = str(message.author)
    user = message.author.id
    user_message = str(message.content)
    channel = str(message.channel)
    print(f'{username} said: "{user_message}" ({channel})')
    if isinstance(message.channel, discord.DMChannel):
        print('')
    else:
        result = await leveling_system.handle_message(message)
        if result:
            await message.channel.send(result)

        await client.process_commands(message)

    if user_message[0] == '?':
        user_message = user_message[1:]
        await send_message(message, user_message, is_private=True)
    else:
        await send_message(message, user_message, is_private=False)

    forbidden_word = contains_forbidden_word(user_message)
    if forbidden_word:
        await message.author.send(f'<@{message.author.id}>')
        await message.author.send(f'please be kind to our community and do not swear')
        await message.author.send('take this as a warning and do not swear again')
        await message.channel.send(f'{message.author} was timed out for swearing.')
        await message.delete()
        message_received_time = message.created_at

        # Calculate the time 5 minutes (300 seconds) after the message was received
        five_minutes_later = message_received_time + datetime.timedelta(seconds=300)

        # Calculate the timedelta
        time_elapsed = five_minutes_later - message_received_time

        await message.author.timeout(time_elapsed)

client.run(TOKEN)`