async def on_ready(self): """ When the bot has loading all components and extensions. """ # Initialize discord components DiscordComponents(bot=self) # Changing the current bot status self.logger.info( f'Successfully logged in as {self.user}\nSharded to {len(self.guilds)} guilds' ) await self.change_presence(activity=discord.Game( name='Use the prefix "M."')) # Load our extensions to register commands in each specific sector for ext in initial_cogs: self.load_extension(ext) self.logger.info("All extensions have loaded!") # Send a new verification message on every reinstation of the bot embed = self.em(title="Verification", description="This is to make sure you are not a bot!", color=0x00ff00) button = Button(label="Verify") channel = self.get_channel(int(VERIFICATION_CHANNEL)) return await channel.send(embed=embed, components=[button])
async def game(self, ctx): DiscordComponents(self.bot) quote, name = self.get_random_quote() database = self.get_characters() component = self.create_random_components(database, name) question = await ctx.send(quote, components=[component]) try: interaction = await self.bot.wait_for("button_click", timeout=10) if interaction.component.label == name: await question.edit(quote, components=[ Button(style=ButtonStyle.green, label="Correct!", disabled=True) ]) await interaction.respond( type=InteractionType.ChannelMessageWithSource, content="Lucky") else: await question.edit(quote, components=[ Button(style=ButtonStyle.red, label="You're an idiot!", disabled=True) ]) await interaction.respond( type=InteractionType.ChannelMessageWithSource, content="so bad") except: await question.edit( components=[Button(label="Too slow!", disabled=True)])
async def test(self, ctx, *, arg=None): ddb = DiscordComponents(self.bot) counter = 0 m = await ctx.send(f"{counter} Clicks", components=[ Button(style=ButtonStyle.randomColor(), label="Click Me!", id="1", emoji="👉") ]) while True: res = await ddb.wait_for_interact("button_click") if res.channel == ctx.message.channel: counter += 1 await m.edit(f"{counter} Clicks", components=[ Button(style=ButtonStyle.randomColor(), label="Click Me!", id="1", emoji="👉") ]) print(counter) await res.respond( type=InteractionType.ChannelMessageWithSource, content=f'{res.component.label} {counter}') res = await ddb.wait_for_interact("button_click")
async def on_ready(): DiscordComponents(client) await client.change_presence( activity=discord.Activity( name='Life', type=discord.ActivityType.competing)) for filename in os.listdir('./extensions'): if filename.endswith('.py'): client.load_extension(f'extensions.{filename[:-3]}') print('Bot is ready.')
async def on_connect(): t0 = time() DiscordComponents(bot) bot.load_extension('src.cogs.search_engine_cog') bot.load_extension('src.cogs.administration_cog') bot.load_extension('src.cogs.administration_slashcog') bot.load_extension('src.cogs.search_engine_slashcog') auto_save.start() cache_clear.start() #add new servers to settings for servers in bot.guilds: bot.serverSettings = Sudo.server_settings_check(servers.id, bot) #sets bot globals bot.devmode = False #remove old servers from settings delete_queue = [] guild_list = [g.id for g in bot.guilds] for keys in bot.serverSettings.keys(): if int(keys, 0) not in guild_list: delete_queue.append(keys) for keys in delete_queue: del bot.serverSettings[keys] Sudo.save_configs(bot) with open("logs.csv", "r", newline='', encoding='utf-8-sig') as file: lines = [ dict(row) for row in DictReader(file) if datetime.now(timezone.utc) - datetime.fromisoformat(row["Time"]) < timedelta(weeks=8) ] with open("logs.csv", "w", newline='', encoding='utf-8-sig') as file: logFieldnames = [ "Time", "Guild", "User", "User_Plaintext", "Command", "Args" ] writer = DictWriter(file, fieldnames=logFieldnames, extrasaction='ignore') writer.writeheader() writer.writerows(lines) bot.session = ClientSession() bot.botuser = await bot.application_info() await bot.change_presence(activity=Activity( type=ActivityType.listening, name="command prefix '&'")) t1 = time() print(f"Bot alive. Took {t1-t0:.3f}s") return
async def on_ready(): logging.info( 'drop-discord is ready: everything should have loaded successfully.') if os.name == 'nt': if clear_terminal: os.system("cls") if change_terminal_name: os.system(f"title {bot.user}") elif os.name == 'posix': if clear_terminal: os.system("clear") if change_terminal_name: os.system(f"printf '\\033]2;{bot.user}\\a'" ) # Sets terminal name to the bot's user. else: # What the hell is this running on!? print(f"Running on an unknown OS ({os.name})") DiscordComponents(bot) await get_github_config() print( f'I am {bot.user} (user ID {bot.user.id}), in {len(bot.guilds)} guilds.' ) try: if ownerId: owner_refresh.start() activity_changer.start() inactivity_func.start() unban_task.start() except RuntimeError: # whoops, already started. pass if get_config_parameter('geniusApi', str): init_genius(get_config_parameter('geniusApi', str)) global bot_mention global bot_mention_mobile bot_mention = f'<@!{bot.user.id}>' bot_mention_mobile = f'<@{bot.user.id}>' for guild in bot.guilds: # loop through every guild we're in logging.info(f"found guild {guild.name}") try: invites = await guild.invites( ) # get a list of invites from the guild except discord.Forbidden: logging.info('not enough permissions, cancelling') else: logging.info(f"found invites: {invites}") bot.guild_invites[ guild.id] = invites # store the guild's invites internally # anti raid invites thing return
async def on_ready(): DiscordComponents(client) # Load all cogs for file in os.listdir('Cogs'): if not file.startswith('__') and file.endswith('.py'): try: client.load_extension(f'Cogs.{file[:-3]}') except commands.errors.NoEntryPointError: pass print('Cogs loaded')
def __init__(self, dyphanbot): super().__init__(dyphanbot) self._persist_fn = "persistence.json" self._config_fn = "config.json" self._persistence_data = self.load_json(self._persist_fn) self.config = self.load_json(self._config_fn, initial_data={ "enabled_experiments": [], "use_webhooks": False }, save_json=self._save_config) self.ddb = None if 'components' in self.config.get('enabled_experiments', []): try: from discord_components import DiscordComponents self.ddb = DiscordComponents(self.dyphanbot, change_discord_methods=False) except ImportError: self.logger.warn("Experiment 'components' enabled, but 'discord_components' module not found.") self.controller = AudioController(dyphanbot, config=self.config, ddb=self.ddb)
async def on_ready(self): DiscordComponents(self) self.reconnect_time = datetime.utcnow() login_msg = "Bot Connected at {} UTC".format(str(datetime.utcnow())) Logger.log_write( "----------------------------------------------------------\n" "{}\n" "".format(login_msg)) print(login_msg) self.ensure_all_fields_server() IO.write_server(self.servers_config)
async def on_ready(): # for guild in client.guilds: # guild_id = str(guild.id) # guild_name = str(guild.name) # nos = len(guild.members) # owner = str(guild.owner) # print(f"Id = {guild_id} , Name = {guild_name}, Nos = {nos} , Owner {owner}") DiscordComponents(client) print("On Ready Function Working") await client.change_presence(activity=discord.Activity( status=discord.Status.idle, type=discord.ActivityType.watching, name=f"{len(set(client.users))} Members & {len(client.guilds)} Servers" )) print('Guild Function Working')
async def on_ready(self): DiscordComponents(client) print(BANNER) print( "\n----------------------------------------------------------------\n" ) print( f'Der Bot mit dem Namen "{self.user}" wurde erfolgreich gestartet!\n' ) print(f"Discord.py Version: {discord.__version__}") print(f"Python Version: {platform.python_version()}") print( f"Operating System: {platform.system()} {platform.release()} ({os.name})" ) client.loop.create_task(self.status_task())
async def on_ready(): DiscordComponents(bot, change_discord_methods=True) t = time.strftime("%b %d, %I:%M:%S %p") print(f"[{t}] I am running") await bot.change_presence(activity=discord.Game(name="birdflop.com")) cursor = db.cursor(buffered=True) command = """CREATE TABLE IF NOT EXISTS guilds ( id bigint PRIMARY KEY, panel bigint, category bigint, next int NOT NULL, transcript bigint, prefix char(2) DEFAULT '-');""" cursor.execute(command) db.commit() cursor = db.cursor(buffered=True) command = """CREATE TABLE IF NOT EXISTS tickets ( channel bigint PRIMARY KEY, creator bigint NOT NULL, guild bigint NOT NULL, expiry int(11), FOREIGN KEY (guild) REFERENCES guilds (id));""" cursor.execute(command) db.commit() now = int(time.time()) cursor = db.cursor(buffered=True) command = f"SELECT expiry, channel FROM tickets WHERE expiry > 0 AND expiry < %s;" cursor.execute(command, (now, )) result = cursor.fetchall() for r in result: channel = bot.get_channel(r[1]) if channel: await channel.send("This ticket has been automatically closed.") await saveandclose(channel) else: cursor = db.cursor(buffered=True) command = f"DELETE FROM tickets WHERE channel = %s;" cursor.execute(command, (r[1], )) db.commit()
async def on_ready(): DiscordComponents(bot) print("===== [READY] =====") bot.me = await bot.fetch_user(210454616876253184) emotes = await bot.get_guild(BLACK_CARDS_GUILD_ID).fetch_emojis() emotes.extend(await bot.get_guild(RED_CARDS_GUILD_ID).fetch_emojis()) bot.playing_cards = [ Card(emote) for emote in emotes if emote.name != "card_back" ] embed = Embed(title="Bot Online :white_check_mark:", colour=0x77B255) now = datetime.datetime.now() embed.add_field( name="Ready at", value= f"{now.hour}:{now.minute}:{int(now.microsecond/1000)}\n{now.day}/{now.month}/{now.year}", inline=True) startup_time = datetime.datetime.now() - init_time embed.add_field( name="Startup Duration", value= f"{startup_time.seconds}.{str(startup_time.microseconds)[:3]} seconds") await bot.me.send(embed=embed) await bot.change_presence(activity=Game("$help"))
async def on_ready(self): """ Sets the status of the bot, instantiates the logger and adds stuff to the db """ DiscordComponents(self.bot) public_log_channel = self.bot.get_channel( int(os.getenv("PUBLIC_LOG_CHANNEL"))) log_channel = self.bot.get_channel(int(os.getenv("LOG_CHANNEL"))) error_channel = self.bot.get_channel(int(os.getenv("ERROR_CHANNEL"))) hooks = await log_channel.webhooks() if len(hooks) == 0: log_hook = await log_channel.create_webhook( name=f"{self.bot.user.name} logs") else: log_hook = hooks[0] hooks = await error_channel.webhooks() if len(hooks) == 0: error_hook = await error_channel.create_webhook( name=f"{self.bot.user.name} errors") else: error_hook = hooks[0] self.bot.log = Logger(log_hook, error_hook, public_log_channel, self._log_file, self.bot.user.name) await self.bot.log.change_level(int(os.getenv("LOG_LEVEL")), self.bot.user.name) for guild in self.bot.guilds: try: await self.bot.db.execute( "INSERT INTO guilds (id) VALUES ($1)", guild.id) except asyncpg.UniqueViolationError: pass for member in guild.members: try: await self.bot.db.execute( "INSERT INTO users (id, trusted, dad_mode) VALUES ($1, false, false)", member.id) except asyncpg.UniqueViolationError: pass try: await self.bot.db.execute( "INSERT INTO mutes (guild, member) VALUES ($1, $2)", guild.id, member.id) except asyncpg.UniqueViolationError: pass for channel in guild.text_channels: try: await self.bot.db.execute( "INSERT INTO channels (id, guild_id) VALUES ($1, $2)", channel.id, guild.id) except asyncpg.UniqueViolationError: pass types = { "playing": discord.ActivityType.playing, "watching": discord.ActivityType.watching, "streaming": discord.ActivityType.streaming, "listening": discord.ActivityType.listening, "competing": discord.ActivityType.competing, "custom": discord.ActivityType.custom } activity = discord.Activity(type=types[os.getenv("ACTIVITY_TYPE")], name=os.getenv("ACTIVITY")) statuses = { "online": discord.Status.online, "idle": discord.Status.idle, "dnd": discord.Status.dnd, "invisible": discord.Status.invisible } await self.bot.change_presence(status=statuses[os.getenv("STATUS")], activity=activity) await self.bot.log.info("Bot online") await self.bot.log.public("Bot online!")
import config from discord.ext import commands from discord_components import DiscordComponents, Button, ButtonStyle, InteractionType bot = commands.Bot(command_prefix='$') components = DiscordComponents(bot) @bot.command() async def test(ctx): await ctx.send("Przyciski", components=[Button(style=ButtonStyle.blue, label="test1", disabled=True), Button(style=ButtonStyle.red, label="test2")]) res = await bot.wait_for("button_click") await res.respond( type=InteractionType.ChannelMessageWithSource, content=res.component.label ) bot.run(config.bot_token)
async def on_ready(): DiscordComponents(bot) print('Im alive.')
cfg["Settings"]["prefix"].strip("\""), cfg["Settings"]["secondary-prefix"].strip("\"")) else: prefixes = commands.when_mentioned_or( cfg["Settings"]["prefix"].strip("\"")) intents = discord.Intents.all() client = commands.Bot(command_prefix=prefixes, case_insensitive=True, help_command=ComradeHelp(), intents=intents, status=discord.Status.online, activity=discord.Game(cfg["Settings"]["Status"])) ddb = DiscordComponents(client) slash = SlashCommand(client, override_type=True, sync_commands=True, sync_on_cog_reload=True, delete_from_unused_guilds=True) # Listeners for client events @client.event async def on_error(event, *args, **kwargs): try: raise event except discord.HTTPException: os.system("kill 1") # hard restart on 429
def __init__(self, bot): self.bot = bot self.db = db() DiscordComponents(self.bot) with open("json/picture.json", "r") as f: self.colla_num = json.load(f)
async def on_ready(): DiscordComponents(client)
async def on_ready(): DiscordComponents(bot) channel = bot.get_channel(int(jdata['Bot_channel'])) await channel.send('OuO Bot is now Online') print("\\OuO Bot is online/")
async def on_ready(): DiscordComponents(bot) print(f"Logged in as {bot.user}!")
def command_prefix(bot, message): if message.guild is None: return '' else: return 'n!' async def get_prefix(ctx): return '' if ctx.guild is None else 'n!' bot = commands.Bot(command_prefix, case_insensitive=True) slash = SlashCommand(bot, sync_commands=True) bot.remove_command('help') ddb = DiscordComponents(bot) @bot.event async def on_ready(): print(f'Logged in as {bot.user}!') activity = discord.Game(name=f"n!help | Naxxatra Bot") await bot.change_presence(activity=activity) def apod_get(): url = f"https://api.nasa.gov/planetary/apod?api_key={os.getenv('NASA_API_KEY')}" r = requests.get(url) content = r.json() embed = discord.Embed(title=content['title'], description=content['explanation'],
class Audio(Plugin): """ Handles the 'audio' commands for DyphanBot """ def __init__(self, dyphanbot): super().__init__(dyphanbot) self._persist_fn = "persistence.json" self._config_fn = "config.json" self._persistence_data = self.load_json(self._persist_fn) self.config = self.load_json(self._config_fn, initial_data={ "enabled_experiments": [], "use_webhooks": False }, save_json=self._save_config) self.ddb = None if 'components' in self.config.get('enabled_experiments', []): try: from discord_components import DiscordComponents self.ddb = DiscordComponents(self.dyphanbot, change_discord_methods=False) except ImportError: self.logger.warn("Experiment 'components' enabled, but 'discord_components' module not found.") self.controller = AudioController(dyphanbot, config=self.config, ddb=self.ddb) def _save_persistence(self): return self.save_json(self._persist_fn, self._persistence_data) def _save_config(self, filename, data): return self.dyphanbot.data.save_json(filename, data, indent=4) async def help(self, message, args): prefix = self.get_local_prefix(message) command = args[0] if args else 'audio' invocation = "{}{}".format(prefix, command) return { "helptext": HELP_TEXT, "shorthelp": "Plays audio in voice channels.", "sections": [{ "name": "> {} join".format(invocation), "value": "Joins the voice channel the user is in.", "inline": False }, { "name": "> {} play `URL or search query`".format(invocation), "value": "Joins and plays a URL or searches YouTube. " "Resumes a paused audio if called by itself.", "inline": False }, { "name": "> {} pause".format(invocation), "value": "Pauses the currently playing audio.", "inline": False }, { "name": "> {} stop".format(invocation), "value": "Stops playing audio and clears the playlist queue.", "inline": False }, { "name": "> {} repeat".format(invocation), "value": "Toggles repeat for the current or next song.", "inline": False }, { "name": "> {} volume `(+/-)1-100`".format(invocation), "value": ("Sets the volume. Can be either number from 1 to 100, " "or a change preceeded by `+` or `-`.\n" "Displays the current volume if called by itself.\n" "e.g:\n" " `{0} volume 75` sets volume to *75%*\n" " `{0} volume +10` increases volume by *10%*\n" " `{0} volume -5` decreases volume by *5%*\n" " `{0} volume` displays current volume (*80%* after " "running the previous commands)\n").format(invocation), "inline": False }, { "name": "> {} skip".format(invocation), "value": "Skips to the next queued audio source.", "inline": False }, { "name": "> {} status".format(invocation), "value": "Displays the currently playing/paused audio.", "inline": False }, { "name": "> {} queue".format(invocation), "value": "Lists the queued playlist.", "inline": False }, { "name": "> {} leave".format(invocation), "value": "Disconnects from the voice channel.", "inline": False }] } async def playonjoin(self, message, args): # Highly experimental, doesn't even work... might scrap if message.author.id not in self.dyphanbot.get_bot_masters(): return guild_id = str(message.guild.id) query = " ".join(args).strip() if not query: return await message.channel.send("You haven't specified a query.") if not message.author.voice or not message.author.voice.channel: return await message.channel.send("You're not in a voice channel.") if guild_id not in self._persistence_data: self._persistence_data[guild_id] = { "playonjoin": {} } msg = await message.channel.send("Preparing requested source(s)...") try: ytdl_extractor = YTDLExtractor() info = await ytdl_extractor.process_entries(query) if isinstance(info, YTDLPlaylist) and not info.title: info.title = "*Untitled Playlist*" vchannel = message.author.voice.channel vch_id = str(vchannel.id) poj = self._persistence_data[guild_id]['playonjoin'] if vch_id not in poj: poj[vch_id] = {} poj[vch_id]['query'] = query poj[vch_id]['text_channel'] = str(message.channel.id) self._persistence_data[guild_id]['playonjoin'] = poj self._save_persistence() await msg.edit( content="Play-on-join was successfully set for `{}`.".format( vchannel.name), embed=discord.Embed( title=info.title or "*Untitled*", url=info.web_url if info.web_url and info.web_url.startswith("http") else discord.Embed.Empty )) except AudioExtractionError as err: self.logger.error(err.message) return await msg.edit(content=err.display_message) except ValueError: pass except Exception as e: await message.channel.send("Whoops! Something went wrong... ```py\n{}: {}\n```".format(type(e).__name__, e)) raise @Plugin.event async def on_voice_state_update(self, member, before, after): # Highly experimental, doesn't even work... might scrap if member.id not in self.dyphanbot.get_bot_masters(): return v_client = member.guild.voice_client if member != member.guild.me: try: vchannel = None guild_id = str(member.guild.id) poj = self._persistence_data[guild_id]['playonjoin'] if after.channel != before.channel: if after.channel and str(after.channel.id) in poj: self.logger.info("PoJ Voice join: %s", str(member)) vchannel = after.channel if v_client and v_client.is_connected(): # bot is busy now... we'll get em next time return poj_channel = poj[str(vchannel.id)] query = poj_channel['query'] text_channel = poj_channel['text_channel'] try: await self.controller.join(vchannel.guild, vchannel, reconnect=False) player = self.controller.get_player(self.dyphanbot, None, vchannel.guild) after_playback = partial(self.controller.stab_player_to_death, vchannel.guild) await player.prepare_entries(query, None, silent=True, requester=member, custom_data={ "after_playback": after_playback } ) except ConnectionClosed: await self.controller.stab_player_to_death(vchannel.guild) elif before.channel and str(before.channel.id) in poj: self.logger.info("PoJ Voice leave: %s", str(member)) vchannel = before.channel if not v_client or (v_client and not v_client.is_connected()): return if len(vchannel.members) > 1: return if v_client.channel == vchannel: await v_client.disconnect(force=True) # K I L L await self.controller.stab_player_to_death(vchannel.guild) return except KeyError: pass async def join(self, message, args): if not message.author.voice or not message.author.voice.channel: return await message.channel.send( "You're not in a voice channel... ~~dummy~~") return await self.controller.join( message.guild, message.author.voice.channel) async def play(self, message, args): query = " ".join(args) if len(args) <= 0 or query.strip() == "": resumed = await self.controller.resume(message.guild, message) if not resumed: await message.channel.send("Nothing was paused, bruh.") return if not message.author.voice or not message.author.voice.channel: return await message.channel.send( "You're not in a voice channel... ~~dummy~~") return await self.controller.play( message.guild, message.author.voice.channel, query, message) async def pause(self, message, args): paused = await self.controller.pause(message.guild, message) if paused is False: return await message.channel.send( "I wasn't even playing anything~~, baka~~!") if paused is None: return await message.channel.send("Already paused, bruh.") return paused async def stop(self, message, args): stopped = await self.controller.stop(message.guild, message) if not stopped: return await message.channel.send("I wasn't even playing anything!") return await message.channel.send("Stopped the playlist.") async def repeat(self, message, args): repeat_toggle = await self.controller.repeat(message.guild, message) if repeat_toggle is None: return await message.channel.send("I need to be in a voice channel...") return await message.channel.send( "**`{0}`**: Turned {1} repeat.".format( message.author, "ON" if repeat_toggle else "OFF" )) async def volume(self, message, args): current_volume = await self.controller.volume(message.guild, message=message) if current_volume is False: return await message.channel.send("I ain't in a voice chat, bruh..") if len(args) <= 0: return await message.channel.send( "Volume: **{0:.0f}%**\n" "Use `{1}{2} volume <amount>` where `<amount>` is either a " "number from 1 to 100 or an increment/decrement.\n" "To increase or decrease the volume by an amount, preceed the " "number with a `+` or `-` respectively.".format( current_volume, self.get_local_prefix(message), "audio" )) volume_in: str = args[0].strip() delta = volume_in and (volume_in.startswith("+") or volume_in.startswith("-")) try: volume = int(volume_in) change_volume = await self.controller.volume( message.guild, volume, delta, message=message) if change_volume is False: return await message.channel.send( "I ain't in a voice channel, bruh..") if change_volume is None: return await message.channel.send( "Volume goes from 1 to 100...") return await message.channel.send( "**`{0}`**: Set the volume to **{1:.0f}%**".format( message.author, change_volume)) except ValueError: return await message.channel.send( "... What? Volume has to be set by a number from 1 to 100 or " "an increment/decrement with `+`/`-` respectively.") async def skip(self, message, args): skipped = await self.controller.skip(message.guild, message) if skipped is False: return await message.channel.send("I'm not even in a voice channel!") if skipped is None: return await message.channel.send("I wasn't playing anything!") return skipped async def status(self, message, args): status = await self.controller.status(message.guild, message) if status is False: return await message.channel.send( "I'm not even connected to a voice channel, dude!!") if status is None: return await message.channel.send("I'm not playing anything...") return status async def queue(self, message, args): status = await self.controller.status(message.guild) queue = await self.controller.queue(message.guild, message) if queue is False: return await message.channel.send( "I'm not even connected to a voice channel, dude!!") queue_str = "" if status: progress_str = utils.secs_to_hms(status.get_progress()) duration_str = utils.secs_to_hms(status.duration) if status.duration else "?" queue_str += "{0} **{1}:**\n **`{2}`**{3}\n\n".format( "\u25B6\uFE0E" if status.is_playing else "\u23F8\uFE0E", status.np_str if status.np_str else "Now Playing", status.title, "\n[ {} / {} ]".format(progress_str, duration_str) ) if queue['is_empty'] and not queue['next_source']: queue_str += "Playlist queue is empty..." elif queue['size'] <= 0 and not queue['next_source']: queue_str += "Playlist queue has no songs." else: queue_str += "**Next Up:**\n" queue_str += "» *`{0}`*\n".format(queue['next_source'].title) if queue['next_source'] else "" for entry in queue['entries']: queue_str += "• `{0}`\n".format(entry.title) if queue['next_count'] > 0: queue_str += "*+ {} more...*".format(queue['next_count']) return await message.channel.send(embed=discord.Embed( title="Queue", description=queue_str, colour=discord.Colour(0x7289DA) )) async def leave(self, message, args): leaving = await self.controller.leave(message.guild) if leaving is False: return await message.channel.send( "I'm not connected to a voice channel, bruh...") async def reset(self, message, args): await self.controller.reset(message.guild) return await message.channel.send("Reset player. Maybe it works now?") async def experiments(self, message, args): if str(message.author.id) not in self.dyphanbot.get_bot_masters(): print("no permission!") return if len(args) <= 0: return # no need to say anything about this command... subcmd = args[0] experiments = args[1:] if subcmd == "enable": self.config["enabled_experiments"] = experiments await message.reply("Set enabled experiments to: {}".format( " ".join([f"`{x}`" for x in experiments]) )) elif subcmd == "list": await message.reply("Enabled audio plugin experiments: {}".format( " ".join([f"`{x}`" for x in self.config.get("enabled_experiments", [])]) )) @Plugin.event async def on_socket_response(self, res): if 'components' in self.config.get('enabled_experiments', []) and self.ddb: try: from discord_components import InteractionEventType if (res["t"] != "INTERACTION_CREATE") or (res["d"]["type"] != 3): return ctx = self.ddb._get_context(res) for key, value in InteractionEventType.items(): if value == res["d"]["data"]["component_type"]: self.dyphanbot.dispatch(key, ctx) break except ImportError: pass @Plugin.event async def on_button_click(self, res): print("button clicked...") if 'components' in self.config.get('enabled_experiments', []): try: from discord_components import InteractionType author = res.guild.get_member(res.user.id) # res.author doesn't actually get this if res.component.id == "play-pause": play_or_pause = "paused" pausing = await self.controller.pause(res.guild, res.message) if not pausing: play_or_pause = "resumed" await self.controller.resume(res.guild, res.message) return await res.respond( content=f"*{author.display_name}* {play_or_pause} playback.", type=InteractionType.ChannelMessageWithSource, flags=None) elif res.component.id == "stop": stopping = await self.controller.stop(res.guild, res.message) if stopping: return await res.respond( content=f"*{author.display_name}* stopped playback and cleared queue.", type=InteractionType.ChannelMessageWithSource, flags=None) elif res.component.id == "skip": skipping = await self.controller.skip(res.guild, res.message) if skipping: return await res.respond( content=f"*{author.display_name}* skipped this playback.", type=InteractionType.ChannelMessageWithSource, flags=None) elif res.component.id == "repeat": repeat_toggle = await self.controller.repeat(res.guild, res.message) if repeat_toggle is not None: await self.controller.status(res.guild, res.message, res.channel) return await res.respond( content=f"*{author.display_name}* put it on repeat." if repeat_toggle else f"*{author.display_name}* turned off repeat.", type=InteractionType.ChannelMessageWithSource, flags=None) except ImportError: pass @Plugin.command async def audio(self, client, message, args, _cmd='audio'): """ The Voice command. Handles subcommands for playing and controlling audio. """ sub_cmds = ['join', 'play', 'fplay', 'pause', 'stop', 'repeat', 'volume', 'skip', 'status', 'queue', 'leave', 'reset'] if len(args) > 0: scmd = args[0].strip() if scmd in sub_cmds: if not hasattr(self, scmd): return await message.channel.send("Not implemented yet...") await getattr(self, scmd)(message, args[1:]) elif scmd == 'playonjoin': await self.playonjoin(message,args[1:]) elif scmd == 'experiments': await self.experiments(message, args[1:]) elif scmd == 'help': await self.dyphanbot.bot_controller.help(message, [_cmd]) else: await message.channel.send("lol wut?") else: await message.channel.send("La la la!!") @Plugin.command async def voice(self, client, message, args): return await self.audio(client, message, args, _cmd='voice') @Plugin.command(cmd='music') async def music_cmd(self, client, message, args): return await self.audio(client, message, args, _cmd='music') @Plugin.command(cmd='m') async def m_cmd(self, client, message, args): return await self.audio(client, message, args, _cmd='m')
async def on_ready(self): DiscordComponents(self.bot)
def __init__(self, bot): self.bot = bot DiscordComponents(bot)
import discord sys.path.insert(1, (os.path.dirname(os.path.dirname(__file__)))) from functools import reduce from discord.ext import commands from src import tkfinder, util from src.resources import embed, const from github import Github from discord_components import DiscordComponents base_path = os.path.dirname(__file__) config = configurator.Configurator(os.path.abspath(os.path.join(base_path, "resources", "config.json"))) prefix = '§' description = 'The premier Tekken 7 Frame bot, made by Baikonur#4927, continued by Tib#1303' bot = commands.Bot(command_prefix=prefix, description=description) buttons = DiscordComponents(bot) # Set logger to log errors logger = logging.getLogger(__name__) logger.setLevel(logging.WARNING) logfile_directory = os.path.abspath(os.path.join(base_path, "..", "log")) logfile_path = logfile_directory + "\\logfile.log" # Create logfile if not exists if not os.path.exists(logfile_directory): os.makedirs(logfile_directory) if not os.path.isfile(logfile_path): open(logfile_path, "w")
def main(): """the main method""" # Initialize logging init_logging() # Initialize the client print("Starting up...") client = Bot('!', intents=intents) #start webserver webserver_thread = threading.Thread(target=run_server, args=(aiohttp_server(client), )) webserver_thread.start() # enable slash commands and send them to the discord API SlashCommand(client, sync_commands=True) # enable buttons DiscordComponents(client) # load slash command cogs # to do that, loop through the files and import all classes and commands print("Loading commands...") slash_dir = "slash_commands" for file in os.listdir(slash_dir): if file.endswith(".py"): file = file.removesuffix(".py") extension = f"{slash_dir}.{file}" client.load_extension(extension) # pylint: disable=no-member print(f"{len(client.slash.commands)} commands loaded") # Define event handlers for the client # on_ready may be called multiple times in the event of a reconnect, @client.event async def on_ready(): if this.running: return this.running = True print("Logged in") # run further launch event loops await launch_event_loops(client) # The message handler for both new message and edits @client.event async def common_handle_message(message): text = message.content # if the message was from an dm, post it in #admin-discussions: Don't do that if bot send an command if isinstance(message.channel, discord.channel.DMChannel): if not message.author.bot: if not text.startswith(COMMAND_PREFIX): admin_discussions_channel = client.get_channel( admin_discussions_channel_id) if message.attachments: attached_files = [ discord.File(BytesIO(await attachment.read()), filename=attachment.filename) for attachment in message.attachments ] await admin_discussions_channel.send( f"From {message.author.mention}: \n{text}", files=attached_files) else: await admin_discussions_channel.send( f"From {message.author.mention}: \n{text}") await message.author.send( "Forwarded your message to staff, you will be contacted shortly 🙃" ) if 'äbidöpfel' in text: texts = [ '<:NeriaHeart:671389916277506063> <:NeriaHeart:671389916277506063> <:NeriaHeart:671389916277506063>', 'knows what`s up', 'knows you can do the thing', 'has been voted plushie of the month', 'knows da wey', 'yes!', 'does`nt yeet teammtes of the map, be like Häbidöpfel', 'debuggin has proven effective 99.9% of the time (editors note: now 98.9%)', 'is cuteness incarnate' ] addition = random.choice(texts) await message.channel.send(f'Häbidöpfel {addition}') if "welcome" in text.lower() and message.mentions: for mention in message.mentions: neria_id = 109022023979667456 if mention.id == neria_id: welcome_choice = [ "Welcome", "I mirëpritur", "Dobrodošli", "Vitejte", "Welkom", "Tere tulemast", "Tervetuloa", "Bienvenue", "Herzlich willkommen", "Üdvözöljük", "Velkominn", "Fáilte", "Benvenuta", "Velkommen", "Witamy", "Bine ați venit (this is spelled correctly thanks to <@171371726444167168>)", "Bienvenidas", "Välkommen", "Croeso", "Yeeeeeeeeeeeeeeeeeeeeeeeeeeeeehaw", ] await message.channel.send( f'{random.choice(welcome_choice)} <@{neria_id}>!') if client.user in message.mentions: # If bot has been tagged notification = client.get_emoji( 751771924866269214) # notification/angerping # sentimentPositive = client.get_emoji(670369126983794700) #POGGERS # sentimentNegative = client.get_emoji(670672093263822877) #SadChamp await message.add_reaction(notification) # mute pepe for an hour if he trashes destiny if message.author.id == 367385031569702912420: if "destiny" in text.lower(): for insult in ["suck", "bad", "f**k", "shit", "trash"]: if insult in text.lower(): # mute pepe and msg him about it await assignRolesToUser([muted_role_id], message.author, message.guild) await message.author.send( "Stop trashing on destiny, muted for an hour :)") nick = message.author.nick await message.author.edit( nick="!Pepe the Muted for an Hour") # remove muted role after an hour await asyncio.sleep(60 * 60) await removeRolesFromUser([muted_role_id], message.author, message.guild) await message.author.edit(nick=nick) await message.author.send("Unmuted again :(") return # run the command if starts with ! if text.startswith(COMMAND_PREFIX) and text != COMMAND_PREFIX: cmd_split = text[len(COMMAND_PREFIX):].split() try: await message_handler.handle_command(cmd_split[0].lower(), cmd_split[1:], message, client) except: print("Error while handling message", flush=True) raise else: badwords = [ 'kanen', 'cyber', 'dicknugget', 'nigg', 'cmonbrug', ' bo ', 'bloodoak', 'ascend', 'c**k', 'c**t' ] goodchannels = [ 670400011519000616, # general 670400027155365929, # media 670402166103474190, # spoiler-chat 670362162660900895, # off-topic # 672541982157045791 #markov-chat-channel ] if not message.content.startswith('http') and len( message.clean_content) > 5 and not any([ badword in message.clean_content.lower() for badword in badwords ]) and message.channel.id in goodchannels: await insertIntoMessageDB(message.clean_content, message.author.id, message.channel.id, message.id) if message.author.name == 'EscalatorBot': for user in message.mentions: member = await message.guild.fetch_member(user.id) await member.add_roles( message.guild.get_role(registered_role_id) ) # registered role await member.remove_roles( message.guild.get_role(not_registered_role_id) ) # unregistered role await message.channel.send( f'{member.mention} has been marked as Registered') await member.send( 'Registration successful!\nCome say hi in <#670400011519000616>' ) # update user DB destinyID = await lookupDestinyID(member.id) await updateDB(destinyID) @client.event async def on_message(message): # ignore msg from itself if (message.author == client.user): return asyncio.ensure_future(common_handle_message(message)) @client.event async def on_member_join(member): # inform the user that they should register with the bot await member.send(embed=embed_message( f'Welcome to Descend {member.name}!', 'You can join the destiny clan in **#registration**. \nYou can find our current requirements in the same channel. \n\nWe have a wide variety of roles you can earn, for more information, check out #community-roles. \n\nIf you have any problems / questions, do not hesitate to write **@ElevatorBot** (me) a personal message with your problem / question' )) @client.event async def on_member_remove(member): await removeFromClanAfterLeftDiscord(client, member) @client.event async def on_message_edit(before, after): await common_handle_message(after) # https://discordpy.readthedocs.io/en/latest/api.html#discord.RawReactionActionEvent @client.event async def on_raw_reaction_add(payload): if not payload.member or payload.member.bot: return # check if reaction is on a persistent message await check_reaction_for_persistent_message(client, payload) @client.event async def on_voice_state_update(member, before, after): guild = member.guild lfg_voice_category_channel = await get_persistent_message_or_channel( client, "lfgVoiceCategory", guild.id) if before.channel is None: # print(f'{member.name} joined VC {after.channel.name}') await joined_channel(client, member, after.channel) return if after.channel is None: # print(f'{member.name} left VC {before.channel.name}') await left_channel(client, member, before.channel, after.channel, lfg_voice_category_channel) return if before.channel != after.channel: # print(f'{member.name} changed VC from {before.channel.name} to {after.channel.name}') await joined_channel(client, member, after.channel) await left_channel(client, member, before.channel, after.channel, lfg_voice_category_channel) return @client.event async def on_member_update(before, after): """ Add member role after Role Screening """ if before.bot or after.bot: return if before.pending and not after.pending: member = client.get_guild(before.guild.id).get_member(before.id) # add @member await assignRolesToUser([member_role_id], member, member.guild) # add @Not Registered to user await assignRolesToUser([not_registered_role_id], member, member.guild) # add filler roles await assignRolesToUser([divider_raider_role_id], member, member.guild) await assignRolesToUser([divider_achievement_role_id], member, member.guild) await assignRolesToUser([divider_misc_role_id], member, member.guild) @client.event async def on_slash_command(ctx: SlashContext): """ Gets triggered every slash command """ # print the command print( f"{ctx.author.display_name} used '/{ctx.name}' with kwargs '{ctx.kwargs}'" ) # log the command logger = logging.getLogger('slash_commands') logger.info( f"InteractionID '{ctx.interaction_id}' - User '{ctx.author.name}' with discordID '{ctx.author.id}' executed '/{ctx.name}' with kwargs '{ctx.kwargs}' in guildID '{ctx.guild.id}', channelID '{ctx.channel.id}'" ) @client.event async def on_slash_command_error(ctx: SlashContext, error: Exception): """ Gets triggered on slash errors """ await ctx.send(embed=embed_message( "Error", f"Sorry, something went wrong \nPlease contact a {ctx.guild.get_role(dev_role_id)}", error)) # log the error logger = logging.getLogger('slash_commands') logger.exception( f"InteractionID '{ctx.interaction_id}' - Error {error} - Traceback: \n{''.join(traceback.format_tb(error.__traceback__))}" ) # raising error again to making deving easier raise error @client.event async def on_button_click(interaction: discord_components.Context): # look if they are lfg buttons if interaction.component.id.startswith("lfg"): # get the lfg message lfg_message = await get_lfg_message( client=interaction.bot, lfg_message_id=interaction.message.id, guild=interaction.guild) if interaction.component.label == "Join": res = await lfg_message.add_member( member=interaction.guild.get_member(interaction.author.id)) if res: await interaction.respond(type=6) else: await interaction.respond( type=discord_components.InteractionType. ChannelMessageWithSource, embed=embed_message( "Error", "You could not be added to the event\nThis is either because you are already in the event, the event is full, or the creator has blacklisted you from their events" )) if interaction.component.label == "Leave": res = await lfg_message.remove_member( member=interaction.guild.get_member(interaction.author.id)) if res: await interaction.respond(type=6) else: await interaction.respond( type=discord_components.InteractionType. ChannelMessageWithSource, embed=embed_message( "Error", "You could not be removed from the event\nThis is because you are neither in the main nor in the backup roster" )) if interaction.component.label == "Backup": res = await lfg_message.add_backup( member=interaction.guild.get_member(interaction.author.id)) if res: await interaction.respond(type=6) else: await interaction.respond( type=discord_components.InteractionType. ChannelMessageWithSource, embed=embed_message( "Error", "You could not be added as a backup to the event\nThis is either because you are already in the backup roster, or the creator has blacklisted you from their events" )) # Finally, set the bot running client.run(BOT_TOKEN)