async def skip(ctx, queue=queue): global loop serverid = ctx.message.guild.id song_there = os.path.isfile("song.mp3") voice = discord.utils.get(client.voice_clients, guild=ctx.guild) if voice.is_playing() != None: voice.stop() video = pafy.new(queuenames[serverid[0]]) best = video.getbest() source = FFmpegPCMAudio(best.url, **FFMPEG_OPTIONS) url, title = _search(queue[0]) if loop == True: queue.append(queuenames[serverid[0]]) queue.remove(queuenames[serverid[0]]) else: queue.remove(queuenames[serverid[0]]) else: voice.stop() video = pafy.new(queuenames[serverid[0]]) best = video.getbest() source = FFmpegPCMAudio(best.url, **FFMPEG_OPTIONS) url, title = _search(queuenames[serverid[0]]) if loop == True: queue.append(queuenames[serverid[0]]) queue.remove(queuenames[serverid[0]]) else: queue.remove(queuenames[serverid[0]]) await ctx.send(f'Now playing {title[0]}') voice.play(source)
async def _play(self, ctx): if not self.vc.is_playing() and self.queue: temp = 0 song_short = "" for i in range(len(self.queue[0])): if self.queue[0][i] == '-': temp += 1 if temp == 2: break song_short += self.queue[0][i] self.do = False await ctx.send(f"```Now playing {song_short[13:]}```") await asyncio.sleep(1.40) for emoji in self.emojis: await ctx.channel.last_message.add_reaction(emoji) await asyncio.sleep(1.20) self.do = True if not self.loop: if self.queue: self.source = FFmpegPCMAudio(self.queue.pop(0)) if self.loop: if self.queue: self.source = FFmpegPCMAudio(self.queue[0]) self.vc.play(self.source, after=self.next_song)
async def play(self, ctx, url: str): #Kopiera in en URL länk voice_channel = ctx.author.voice.channel try: #ansluter till en röstkanal sen laddar ner videon och sen spelar voice = await voice_channel.connect() with youtube_dl.YoutubeDL(ydl_opts) as ydl: ydl.download([url]) for file in os.listdir("./"): if file.endswith(".mp3"): os.rename(file, "song.mp3") source = FFmpegPCMAudio("song.mp3") player = voice.play(source) player = player except: try: #om botten redan ansluten spelas ljudet upp och raderar filen os.remove("song.mp3") time.sleep(1) voice = discord.utils.get(self.client.voice_clients, guild=ctx.guild) with youtube_dl.YoutubeDL(ydl_opts) as ydl: ydl.download([url]) for file in os.listdir("./"): if file.endswith(".mp3"): os.rename(file, "song.mp3") source = FFmpegPCMAudio("song.mp3") player = voice.play(source) except: #spelar bara upp ljudet voice = discord.utils.get(self.client.voice_clients, guild=ctx.guild) with youtube_dl.YoutubeDL(ydl_opts) as ydl: ydl.download([url]) for file in os.listdir("./"): if file.endswith(".mp3"): os.rename(file, "song.mp3") source = FFmpegPCMAudio("song.mp3")
async def audio_player_task(self): while True: self.next.clear() if self.loop: # YTDLSource(PCMVolumeTransformer(AudioSource)) can't be # rewinded, the only way is to recreate it with the same # source if self.current.state == 'downloaded': recreated_source = FFmpegPCMAudio( f'{self.bot.command_prefix}.mp3'.replace('..', '.')) else: recreated_source = FFmpegPCMAudio( self.current.source.stream_url, **YTDLSource.FFMPEG_OPTIONS, ) # if FFmpegPCMAudio fails to read source (e.g. file is missing or # failed to connect to server), .read() returns b'' if not recreated_source.read(): self.loop = False self.voice.stop() self.next.set() else: self.current.source = YTDLSource( self._ctx, recreated_source, data=self.current.source.data, volume=self.volume, ) self.voice.play(self.current.source, after=self.play_next_song) else: # Try to get the next song from SongQueue within # given timeout. If no song will be added to the # queue in time, the player will disconnect due # to performance reasons. try: async with timeout(SONG_QUEUE_TIMEOUT): self.current = await self.songs.get() except asyncio.TimeoutError: await self.current.source.channel.send( f'No new songs in queue for {SONG_QUEUE_TIMEOUT} seconds. Bot now disconnects.' ) self.bot.loop.create_task(self.suspend()) self.exists = False return # feedback to Discord (feedback on loop can produce spam) await self.current.source.channel.send( embed=self.current.create_embed().add_field( name='Loop', value=self.loop).add_field( name='Volume', value=int(self.volume * 100))) self.voice.play(self.current.source, after=self.play_next_song) await self.next.wait()
async def __music_player(self): if self.__player: if self.__music_list: if not self.__player.is_playing() and not self.__paused: actual_music = self.remove_caracteres(self.__music_list.pop(0)) if os.path.exists(f'./music_cache/{actual_music}.m4a'): self.__player.play(FFmpegPCMAudio(f'./music_cache/{actual_music}.m4a')) else: self.__player.play(FFmpegPCMAudio(f'./music_cache/{actual_music}.webm')) await self.__original_channel.send(f':notes: Reproduzindo {actual_music}!')
async def bababooey(bot, message): author_voice_status = message.author.voice if author_voice_status is not None and author_voice_status.channel is not None: bababooey_audio_stream = FFmpegPCMAudio( 'bossbot/resources/bababooey.mp3') voice_client = await author_voice_status.channel.connect() voice_client.play(bababooey_audio_stream) while voice_client.is_playing(): sleep(1) bababooey_audio_stream.cleanup() await voice_client.disconnect() else: await message.channel.send( 'https://www.youtube.com/watch?v=U_cPir6MwLM')
async def play_youtube_url(youtube_url, context, channel_voice): # Create StreamPlayer voice_client = await channel_voice.connect() # Download song await context.send(':robot: Fetching song ...') file_id = uuid.uuid1().hex yt = YouTube(youtube_url) song_title = yt.title filename = '{0}.{1}'.format(file_id, extension) yt.streams.get_audio_only().download(filename=file_id) # Send message to text channel await context.send( ':musical_keyboard: Playing {0} :musical_keyboard:'.format(song_title)) # Setting bot status await bot.change_presence( activity=Activity(type=ActivityType.playing, name=song_title)) # Play music voice_client.play(FFmpegPCMAudio(filename), after=lambda: print('done')) # Check if audio is playing while voice_client.is_playing(): await asyncio.sleep(1) # Disconnect after the player has finished os.remove(filename) voice_client.stop() await voice_client.disconnect() # Setting bot status await bot.change_presence(None)
async def play(self, ctx, query): """ Play an audio clip - schokobons - raus """ ydl_opts = { 'format': 'bestaudio/best', 'postprocessors': [{ 'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '192', }], } await ctx.trigger_typing() uri = self.parse(query) if uri: with youtube_dl.YoutubeDL(ydl_opts) as ydl: song_info = ydl.extract_info(uri, download=False) audio_stream = song_info["formats"][0]["url"] audio_source = FFmpegPCMAudio(audio_stream) async with Player() as player: vc = await player.connect(self.bot, ctx.author.voice.channel) await player.play(vc, audio_source) await ctx.send(f"Playing: {uri}") else: await ctx.send(f"Clip '{query}' not found")
async def rand(ctx): channel = ctx.message.author.voice.channel if not channel: await ctx.send("Wejdź do kanału głosowego") return voice = get(client.voice_clients, guild=ctx.guild) if voice and voice.is_connected(): await voice.move_to(channel) else: voice = await channel.connect() lista = [] for file in os.listdir("C:\\Users\\kacpe\\Desktop\\DiscordBot\\v2\\mp3"): if file.endswith(".mp3"): lista.append(file) plik = random.choice(lista) sciezka = f"mp3\\{plik}" source = FFmpegPCMAudio(sciezka) l = subprocess.run([ 'ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', sciezka ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) dlugosc = float(l.stdout) player = voice.play(source) server = ctx.message.guild.voice_client time.sleep(dlugosc) await server.disconnect()
async def on_ready(): await client.get_channel(creds.text_channel_id ).send(f"Playing {videoname}") vca = client.get_channel(creds.voice_channel_id) vc = await vca.connect() YDL_OPTIONS = {'format': 'bestaudio', 'noplaylist': 'True'} FFMPEG_OPTIONS = { 'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 'options': '-vn' } if not vc.is_playing(): with YoutubeDL(YDL_OPTIONS) as ydl: info = ydl.extract_info(url, download=False) URL = info['formats'][0]['url'] vc.play(FFmpegPCMAudio(URL, **FFMPEG_OPTIONS)) while vc.is_playing(): await sleep(1) await client.close() os.execl(sys.executable, sys.executable, *sys.argv) else: await client.get_channel(creds.text_channel_id ).send("Already playing song") return
async def 멜론차트(ctx): if not vc.is_playing(): options = webdriver.ChromeOptions() options.add_argument("headless") global entireText YDL_OPTIONS = {'format': 'bestaudio', 'noplaylist':'True'} FFMPEG_OPTIONS = {'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 'options': '-vn'} chromedriver_dir = r"C:\python bot\chromedriver.exe" driver = webdriver.Chrome(chromedriver_dir, options = options) driver.get("https://www.youtube.com/results?search_query=멜론차트") source = driver.page_source bs = BeautifulSoup(source, 'lxml') entire = bs.find_all('a', {'id': 'video-title'}) entireNum = entire[0] entireText = entireNum.text.strip() musicurl = entireNum.get('href') url = 'https://www.youtube.com'+musicurl driver.quit() musicnow.insert(0, entireText) with YoutubeDL(YDL_OPTIONS) as ydl: info = ydl.extract_info(url, download=False) URL = info['formats'][0]['url'] await ctx.send(embed = discord.Embed(title= "노래 재생", description = "현재 " + musicnow[0] + "을(를) 재생하고 있습니다.", color = 0x00ff00)) vc.play(FFmpegPCMAudio(URL, **FFMPEG_OPTIONS), after = lambda e: play_next(ctx)) else: await ctx.send("이미 노래가 재생 중이라 노래를 재생할 수 없어요!")
async def urlplay(ctx, *, url): try: global vc vc = await ctx.message.author.voice.channel.connect() except: try: await vc.move_to(ctx.message.author.voice.channel) except: await ctx.send("채널에 유저가 접속해있지 않았습니다.") YDL_OPTIONS = {'format': 'bestaudio', 'noplaylist': 'True'} FFMPEG_OPTIONS = { 'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 'options': '-vn' } if not vc.is_playing(): with YoutubeDL(YDL_OPTIONS) as ydl: info = ydl.extract_info(url, download=False) URL = info['formats'][0]['url'] vc.play(FFmpegPCMAudio(URL, **FFMPEG_OPTIONS)) await ctx.send(embed=discord.Embed(title="play", description="현재 " + url + "을(를) 재생하고 있습니다.", color=0x00ff00)) else: await ctx.send("노래가 이미 재생되고 있습니다!")
async def playmugs(ctx: Context): # Filter based on channel source and author role author_roles = [role.name for role in ctx.message.author.roles] if (ctx.message.channel.id != CMD_CHANNEL_ID or PRESIDENT_ROLE not in author_roles): return # Play mug sounds vc = cast(VoiceClient, ctx.voice_client) print("Playing music") vc.play(FFmpegPCMAudio("assets/mugs.mp3")) while vc.is_playing(): await asyncio.sleep(0.01) print("Music done") # Add a sleep here if desired voice_chann = cast(VoiceChannel, ctx.voice_client.channel) target_channel = await bot.fetch_channel(TARGET_CHANNEL_ID) # NOTE: this only moves members that joined after the bot print(voice_chann.members) for user in voice_chann.members: if user.id == bot.user.id: continue await user.move_to(target_channel) await user.edit(mute=True)
async def _download_and_play(): try: self._guild._bot.log.debug('waiting for cache...') await cache self._guild._bot.log.debug('finish cache...') except: self._guild._bot.log.error('cannot cache...') self._guild._bot.log.error(traceback.format_exc()) async with self._aiolocks['player']: if self.state != PlayerState.PAUSE: await self._play() boptions = "-nostdin" aoptions = "-vn" self._guild._bot.log.debug( "Creating player with options: {} {} {}".format( boptions, aoptions, entry._local_url)) source = SourcePlaybackCounter( PCMVolumeTransformer( FFmpegPCMAudio(entry._local_url, before_options=boptions, options=aoptions, stderr=subprocess.PIPE), self.volume)) async with self._aiolocks['player']: self._player = self._guild._voice_client self._guild._voice_client.play(source, after=_playback_finished) self._source = source self.state = PlayerState.PLAYING
async def play(self, context: commands.Context, station: str = None): if not station: await context.send("Podaj nazwę stacji (w cudzysłowie)") return if not context.author.voice: await context.send( f"Dołącz najpierw do kanału głosowego, @{context.author}.") return if station not in self.stations_list.keys(): await context.send(f"Nie odnaleziono stacji {station}") return else: station_url = self.stations_list.get(station) audio_source: AudioSource = FFmpegPCMAudio(station_url) try: voice_client: VoiceClient = await context.author.voice.channel.connect( ) await self._play_stream(audio_source, voice_client) except ClientException as ce: for vc in self.bot.voice_clients: if vc.channel == context.author.voice.channel: vc.stop() await self._play_stream(audio_source, vc) else: await context.send("Błąd odtwarzania") return except CommandInvokeError as cie: await context.send( f"Dołącz najpierw do kanału głosowego, {context.author}.") return
async def intro_message_0(context): global state if state != 0: await context.send("ERROR invalid command at this time") return state = 1 AUDIO_CHANNEL = discord.utils.get(context.guild.channels, name="Paddy's Pub") await AUDIO_CHANNEL.connect() await context.send(file=discord.File('title_card.png')) await context.send(file=discord.File('time_stamp.png')) vc = cast(VoiceClient, context.voice_client) print("Playing Theme Song") vc.play(FFmpegPCMAudio("its-always-sunny-in-philadelphia-theme-song.mp3")) while vc.is_playing(): await asyncio.sleep(0.01) print("Theme Song done") await context.send(file=discord.File('emoji/paddys.png')) with open('messages/intro_0_0.txt', 'r') as file: message = file.read() await context.send(message) await context.send(file=discord.File('chardeemacdennis.png')) with open('messages/intro_0_1.txt', 'r') as file: message = file.read() await context.send(message)
async def _play(self): """ Heavy lifting of playing songs Grabs the appropiate streaming URL, sends the `now playing` message, and initiates playback in the vc. Args: None Returns: None Raises: None """ track_url = self.current_track.getStreamURL() audio_stream = FFmpegPCMAudio(track_url) while self.voice_channel.is_playing(): asyncio.sleep(2) self.voice_channel.play(audio_stream, after=self._toggle_next) plex_log.debug("%s - URL: %s", self.current_track, track_url) embed, img = self._build_embed_track(self.current_track) self.np_message_id = await self.ctx.send(embed=embed, file=img)
async def campfire(ctx): vc.play(FFmpegPCMAudio('campfire.mp3'), after=lambda e: print("coś", e)) while vc.is_playing(): await asyncio.sleep(1) vc.stop() await vc.disconnect()
async def join(self, ctx): """ Makes SuitsBot join the voice channel """ try: # Gets the voice channel the author is in author_voice_channel = ctx.author.voice.channel if ctx.author.voice is not None else None if author_voice_channel is None: # Ignore command if author is not in voice await ctx.send("You are not in a voice channel right now") return if in_voice_channel( author_voice_channel ): # Ignore request if bot already in voice channel await ctx.send("The bot is already in voice with you") return # Connect to author's channel await ctx.send("Joining voice channel...") self.bot.voice = await join_audio_channel(author_voice_channel) if self.bot.voice: # Plays joining voice clip self.bot.voice.play( FFmpegPCMAudio(SOUNDS_DIR + 'hello_there_obi.mp3')) else: await ctx.send( f"I'm sorry {ctx.author.mention}, but I was not able to join {author_voice_channel}" ) except Exception as e: await utils.report(str(e), source="join command", ctx=ctx)
async def queue(ctx, url=None): log(ctx.message.content, ctx.message.author) # joining channel try: channel = ctx.message.author.voice.channel if not channel: await ctx.send("You must be connected to a voice channel") return voice = get(client.voice_clients, guild=ctx.guild) if voice and voice.is_connected(): await voice.move_to(channel) else: voice = await channel.connect() except AttributeError: await ctx.send("You must be connected to a voice channel") return # downloads and queues song if url exists if url: youtube.enqueue(url) else: await ctx.send(f"Usage: `{config.PREFIX}play [youtube url]`") return # plays the song song = youtube.pop_queue() voice.play(FFmpegPCMAudio(song)) await ctx.send(f"Playing: {song}")
async def play2(ctx, url): channel = ctx.message.author.voice.channel print("my channel was ", channel) await ctx.send(channel) voice = await channel.connect() YDL_OPTIONS = {'format': 'bestaudio', 'noplaylist': 'True'} FFMPEG_OPTIONS = { 'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 'options': '-vn' } #voice = get(Client.voice_clients, guild=ctx.guild) if not voice.is_playing(): with YoutubeDL(YDL_OPTIONS) as ydl: args = ctx.message.content.split(" ") betterargs = " ".join(args[1:]) #info = ydl.extract_info('https://www.youtube.com/watch?v=' + betterargs, download=False) info = ydl.extract_info( 'https://www.youtube.com/watch?v=zczFoOBe1eQ', download=False) URL = info['formats'][0]['url'] voice.source = discord.PCMVolumeTransformer(voice.source, volume=1.0) voice.play(FFmpegPCMAudio(URL, **FFMPEG_OPTIONS)) voice.is_playing() else: await ctx.send("Already playing song") return
async def ispovest(ctx): ispovest = random.choice(os.listdir("Ispovesti")) video_name = ispovest[:-4] video_link = 'Ispovesti/' + ispovest # check where the message was typed if ctx.voice_client is None: channel = ctx.author.voice.channel await channel.connect() YDL_OPTIONS = {'format': 'bestaudio/best', 'outtmpl': '%(extractor)s-%(id)s-%(title)s.%(ext)s', 'restrictfilenames': True, 'noplaylist': True, 'nocheckcertificate': True, 'ignoreerrors': False, 'logtostderr': False, 'quiet': True, 'no_warnings': True, 'default_search': 'auto', # bind to ipv4 since ipv6 addresses cause issues sometimes 'source_address': '0.0.0.0' } FFMPEG_OPTIONS = {'options': '-vn'} # voice = get(bot.voice_client, guild=ctx.guild) server = ctx.message.guild voice_channel = server.voice_client if not voice_channel.is_playing(): voice_channel.play(FFmpegPCMAudio( source=video_link, **FFMPEG_OPTIONS)) voice_channel.is_playing() await ctx.send(video_name) else: await ctx.send("Cekaj da zavrsim pricu") return
async def play(ctx, url): voice = discord.utils.get(bot.voice_clients, guild=ctx.guild) if ctx.voice_client is None: channel = ctx.author.voice.channel await channel.connect() ydl_opts = {'format': 'bestaudio'} server = ctx.message.guild voice_channel = server.voice_client FFMPEG_OPTIONS = { 'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 'options': 'vn' } if not voice_channel.is_playing(): with yt_dlp.YoutubeDL(ydl_opts) as ydl: info = ydl.extract_info(url, download=False) url2 = info['formats'][0]['url'] print(url2) voice_channel.play(FFmpegPCMAudio(source=url2, **FFMPEG_OPTIONS)) voice_channel.is_playing() else: await ctx.send("Cekaj da se zavrsi play ili kucaj '!stop'.") return
async def leave(self, ctx): voice_client = await self.get_current_voice_client() if voice_client: bye = FFmpegPCMAudio("Cogs/VoiceClient/farewell.mp3") voice_client.play(bye) await asyncio.sleep(2.5) await voice_client.disconnect()
async def play(ctx,*args): if len(args) == 0: await ctx.send("Which song to play?") if len(args)>1: searchterm = ' '.join(args) print(searchterm) elif len(args)==1: searchterm = args[0] print(searchterm) first_url = "https://www.youtube.com" results = YoutubeSearch(searchterm,max_results=10).to_json() res = eval(results) url = first_url + res['videos'][0]['url_suffix'] channel = ctx.message.author.voice.channel vc = await channel.connect() #'format': 'bestaudio', YDL_OPTIONS = {'noplaylist':'True'} FFMPEG_OPTIONS = {'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 'options': '-vn'} if not vc.is_playing(): with YoutubeDL(YDL_OPTIONS) as ydl: info = ydl.extract_info(url, download=False) URL = info['formats'][0]['url'] vc.play(FFmpegPCMAudio(URL, **FFMPEG_OPTIONS)) await ctx.send("Now Playing: " + res['videos'][0]['title']) vc.is_playing() else: await ctx.send("Already playing song") return
async def meme(self, ctx, search: str = "windows-xp-error"): search = search + " " + ctx.getargs() filenames = list(os.listdir(memespath)) result = process.extractOne(search, filenames) filename = result[0] print("[Music] - Suchergebnis:", search, result) if result[1] >= 75: player = PCMVolumeTransformer( FFmpegPCMAudio(source=os.path.join(memespath, filename), **ffmpeg_options)) if ctx.voice_client.is_playing(): ctx.voice_client.stop() ctx.voice_client.play( player, after=lambda e: print('[Music] - Fehler: %s' % e) if e else None) await ctx.sendEmbed(title="Memetime!", color=self.color, fields=[("Meme", str(filename).split(".")[0])]) else: raise commands.BadArgument( message= "Es wurden keine mit '{}' übereinstimmende Audiodatei gefunden." .format(search))
async def meme(self, ctx, search: str = "windows-xp-error", *args): search = " ".join((search, ) + args) filenames = list(os.listdir(MEMESPATH)) result = process.extractOne(search, filenames) filename = result[0] print("[Music] - Suchergebnis:", search, result) if result[1] >= 75: player = PCMVolumeTransformer( FFmpegPCMAudio(source=os.path.join( MEMESPATH, filename), **FFMPEG_OPTIONS)) if ctx.voice_client.is_playing(): ctx.voice_client.stop() ctx.voice_client.play( player, after=lambda e: print('[Music] - Fehler: %s' % e) if e else None) await ctx.sendEmbed(title="Memetime!", fields=[("Meme", str(filename).split(".")[0])]) else: raise ErrorMessage( message= "Es wurden keine mit '{}' übereinstimmende Audiodatei gefunden." .format(search))
async def oynat(ctx): await gel(ctx) key = ctx.message.content input = key.replace("-oynat ", "") YDL_OPTIONS = { 'format': 'bestaudio/best', 'noplaylist': 'False', 'default_search': 'auto' } FFMPEG_OPTIONS = { 'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 'options': '-vn' } voice = get(client.voice_clients, guild=ctx.guild) if not voice.is_playing(): with YoutubeDL(YDL_OPTIONS) as ydl: info = ydl.extract_info(input, download=False) if str(input).startswith('http'): URL = info['formats'][0]['url'] else: ##URL = info['entries'][0]['formats'][0]['url'] print(info) ctx.channel.send('oynatıyorum') voice.play(FFmpegPCMAudio(URL, **FFMPEG_OPTIONS)) voice.is_playing() else: await ctx.send("dur bi") return
async def play_sound(ctx, file_name: str): opus = ctypes.util.find_library('opus') load_opus(opus) if not exists(f"sounds/{file_name}.mp3"): await ctx.send("This sound has been injected!") return if not ctx.author.voice and not ctx.author.voice.channel: await ctx.send(f"{ctx.author.name} is not in a voice channel") client.currently_playing = True voice_channel = ctx.author.voice.channel vc = await voice_channel.connect() vc.play( FFmpegPCMAudio(executable=join(script_path, "bin", "ffmpeg"), source=join(script_path, "sounds", f"{file_name}.mp3"))) while vc.is_playing(): await sleep(.1) client.currently_playing = False await vc.disconnect() await ctx.message.delete()
async def coco(ctx): with con: con.execute(f'INSERT INTO coldOnes (time, username) VALUES (?,?);', (datetime.datetime.now(), ctx.author.id)) cursor = con.execute("SELECT COUNT(*) FROM coldOnes") myresult = cursor.fetchall() chance = randint(1, 100) if chance > 90: await ctx.send("I'm gnot a gnelf, I'm gnot a gnoblin, I'm a gnome, and you've been GNOMED!".format(myresult[0][0]), hidden=True) else: await ctx.send(f"Nice! {myresult[0][0]} cold ones have been opened!", hidden=True) if not ctx.author.voice: return channel = ctx.author.voice.channel if not channel: return await channel.connect() # Generate a number between 1 and 1000 audiochance = randint(1, 1000) # figure out what track this corrisponds to index = bisect_right(tracks, (audiochance, '')) source = FFmpegPCMAudio(tracks[index][1]) ctx.voice_client.play(source) while ctx.voice_client.is_playing(): await asyncio.sleep(1) await ctx.voice_client.disconnect()