async def unmute(self, ctx, user: str): """Unmute command""" server = ctx.message.server # Check for permissions before proceed if not commands.bot_has_permissions(manage_roles=True): await self.bot.say( "I'm not able to manage permissions without `Manage Roles` permission." ) return elif not not commands.bot_has_permissions(mute_members=True): await self.bot.say( "I'm not able to mute voice without `Mute Members` permission." ) members = await utils.get_members(self.bot, ctx.message, user) if members is None: return member = ctx.message.server.get_member_named(members[0]) # Reset permissions await self.set_permissions(server, member, None) # Remove mute task for a member and remove him from database if member.id in self.timers_storage[server.id]: self.timers_storage[server.id][member.id].cancel() self.remove_muted_member(member, server) await self.send("Member {} has been unmuted by command.".format( member.name))
def __init__(self, config: configparser.ConfigParser, redis: aredis.StrictRedis, **kwargs): super().__init__(activity=discord.Activity( name='out for new incidents', type=discord.ActivityType.watching), command_prefix=self.get_command_prefix, intents=INTENTS, **kwargs) self.config = config self.default_prefix = self.config.get('general', 'default_prefix') # eval() for supporting hex colors, should be safe because it's # directly from the config self.colorsg = { key: eval(value) for key, value in self.config.items('colors:generic') } self.errorlog = None if self.config.getboolean('errorlog', 'enabled'): self.errorlog = Path(self.config.get('errorlog', 'path')) self.storage = Storage(redis) self.shoppy = httpx.AsyncClient(headers={ 'Authorization': self.config.get('shoppy', 'api key'), 'User-Agent': 'python-httpx (Incident Reporter Bot)' }, base_url='https://shoppy.gg/') self._loaded_extensions = False self.add_check( commands.bot_has_permissions(embed_links=True).predicate, call_once=True) self.add_check(is_guild_banned().predicate, call_once=True)
def has_perms(): perms = { 'send_messages': True, 'embed_links': True, 'external_emojis': True } return commands.bot_has_permissions(**perms)
def setup(bot): bot._original_help_command = bot.help_command bot.help_command = MyHelp( command_attrs={"brief": "Get information about my commands!"}) bot.help_command.add_check( commands.bot_has_permissions(embed_links=True, send_messages=True)) bot.help_command.cog = bot.cogs["Info"]
def __init__(self, bot: TTSBot): help_command = FancyHelpCommand() bot.help_command = help_command bot.help_command.cog = self bot.help_command.add_check( commands.bot_has_permissions( send_messages=True, embed_links=True).predicate # type: ignore )
async def on_member_join(user): channel = user.guild.system_channel if commands.bot_has_permissions(send_message=False): return with open('./cogs/fun/JoinMessages.json') as f: d = json.load(f) greeting = random.choice(list(d.values())) if channel is not None: await channel.send(f"*{greeting.replace('{user}', f'**{user}**')}*")
async def unmute(self, ctx, user : discord.Member=None): """- Unmute command""" server = ctx.message.guild #check for permissions before proceeding if not commands.bot_has_permissions(manage_roles=True): await ctx.message.channel.send("I'm not able to manage permissions without `Manage Roles` permission.") elif not commands.bot_has_permissions(mute_members=True): await ctx.message.channel.send("I'm not able to mute voice without `Mute Members` permission.") if not user: await ctx.message.channel.send("Specify a user, fren") #reset permissions await self.set_permission(server, user, None) #remove mute task for a member and remove him from database if user.id in self.timers_storage[server.id]: self.timers_storage[server.id][user.id].cancel() self.remove_muted_member(user, server) await ctx.message.channel.send("Member {} has been unmuted by command.".format(user.name))
def __init__(self, **kwargs): self.cluster_name = kwargs.pop("cluster_name") self.cluster_idx = kwargs.pop("cluster_idx") self.config = kwargs.pop("config", None) if self.config is None: self.config = __import__("config") self.ready = False self.menus = {} loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) super().__init__(**kwargs, loop=loop, command_prefix=determine_prefix) # Load extensions self.load_extension("jishaku") for i in cogs.default: self.load_extension(f"cogs.{i}") self.add_check( commands.bot_has_permissions( read_messages=True, send_messages=True, embed_links=True, attach_files=True, read_message_history=True, add_reactions=True, external_emojis=True, ).predicate) self.add_check(is_enabled) # Run bot self.log.info( f'[Cluster#{self.cluster_name}] {kwargs["shard_ids"]}, {kwargs["shard_count"]}' ) self.loop.create_task(self.do_startup_tasks()) self.run(kwargs["token"])
async def on_message(self, message): if not self.bot.ready(): return user = message.author stats = self.bot.stats if user.bot: return if not commands.bot_has_permissions(send_messages=True): stats.other_messages_processed += 1 return if str(message.channel.type) == "private": guild_id = fn.guild.id else: guild_id = message.guild.id prefix = fn.getprefix(self.bot, message) commandcheck = message.content[len(prefix):] for command in cm.commands: if commandcheck.startswith(command): return for command in cm.devcmds: if commandcheck.startswith(command): return priority, status = "all", "on" if str(message.channel.type) != "private": db.addchannel(message.channel.id, guild_id) priority = db.getpriority(guild_id) status = db.getstatus(message.channel.id) if status == "on": trigger_detected = tr.respond(message, priority)[0] if trigger_detected: stats.triggers_processed += 1 db.usetrigger(user.id) return stats.other_messages_processed += 1
def __init__(self, **kwargs): self.cluster_name = kwargs.pop("cluster_name") self.cluster_idx = kwargs.pop("cluster_idx") self.config = kwargs.pop("config", None) if self.config is None: self.config = __import__("config") self.ready = False self.menus = ExpiringDict(max_len=300, max_age_seconds=300) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) super().__init__(**kwargs, loop=loop, command_prefix=determine_prefix) # Load extensions self.load_extension("jishaku") for i in cogs.default: self.load_extension(f"cogs.{i}") self.add_check( commands.bot_has_permissions( read_messages=True, send_messages=True, embed_links=True, attach_files=True, read_message_history=True, add_reactions=True, external_emojis=True, ).predicate) self.add_check(is_enabled) self.activity = discord.Game("p!help • poketwo.net") self.http_session = aiohttp.ClientSession() # Run bot self.loop.create_task(self.do_startup_tasks()) self.run(kwargs["token"])
def __init_subclass__(cls, *, game_cls, name=None, cmd=None, aliases=(), **kwargs): super().__init_subclass__(**kwargs) cls.name = name or cls.__name__ cls.__game_class__ = game_cls cmd_name = cmd or cls.__name__.lower() group_help = inspect.getdoc(cls._game).format(name=cls.name) # We can't use the decorator because all the check decorator does is # add the predicate to an attribute called __commands_checks__, which # gets deleted after the first command. group = commands.group(name=cmd_name, aliases=aliases, help=group_help, invoke_without_command=True) group_command = group( commands.bot_has_permissions(embed_links=True)(cls._game)) setattr(cls, f'{cmd_name}', group_command) gc = group_command.command for name, member in inspect.getmembers(cls): if not name.startswith('_game_'): continue name = name[6:] game_help = inspect.getdoc(member).format(name=cls.name, cmd=cmd_name) command = gc(name=name, help=game_help)(member) setattr(cls, f'{cmd_name}_{name}', command) setattr(cls, f'_{cls.__name__}__error', cls._error)
async def mute(self, ctx, user : discord.Member=None, period=''): """ - Mute for specific time.""" amount = 0 if period: amount = int(period[:-1]) if amount < 0: await ctx.message.channel.send("Invalid amount of time, fren") return server = ctx.message.guild #Check for permissions before proceeding if not commands.bot_has_permissions(manage_roles=True): await ctx.message.channel.send("I'm not able to manage permissions without `Manage Roles` permission") return elif not commands.bot_has_permissions(mute_members=True): await ctx.message.channel.send("I'm not able to mute voice without `Mute Members` permission.") if not user: await ctx.message.channel.send("Specify a user, fren") #member = ctx.message.guild.get_member_named(user) if user.id in self.timers_storage[server.id]: await ctx.message.channel.send("This member is already muted, fren") return #set permissions await self.set_permission(server, user, False) if amount: multiplier = period[-1] if period[-1] in ('s', 'm', 'h', 'd', 'y') else 's' def multiply_time(m, secs): return { m == 's': secs * 1, m == 'm': secs * 60, m == 'h': secs * 60 * 60, m == 'd': secs * 60 * 60 * 24, m == 'y': secs * 60 * 60 * 24 * 365, }[True] period = multiply_time(multiplier, amount) period *= 10 #Set unmute timer unmute_timer = self.bot.loop.create_task(self.unmute_timer(server, user, period)) self.timers_storage[server.id].update({user.id: unmute_timer}) #write muted user to database db = self.bot.db values = (user.id, user.name, period, server.id) db.execute("INSERT INTO mutes(member_id, member_name, mute_time, server_id) VALUES (?,?,strftime('%s','now') + ?,?)", values) db.commit() def convert_time(secs): return { 1 <= secs < 60: '{} second(s)'.format(secs), 60 <= secs < 3600: '{0[0]} minute(s) {0[1]} second(s)'.format(divmod(secs, 60)), 3600 <= secs < 86400: '{0[0]} hour(s) {0[1]} minute(s)'.format(divmod(secs, 60 * 60)), 86400 <= secs: '{0[0]} day(s) {0[1]} hour(s)'.format(divmod(secs, 60 * 60 * 24)), }[True] mute_time = convert_time(period) await ctx.message.channel.send("Member {} has been muted for {}".format(user.name, mute_time)) else: await ctx.message.channel.send("Member {} has been muted permanently".format(user.name))
def __init__(self, **kwargs) -> None: self.pipe = kwargs.pop("pipe") self.cluster_name = kwargs.pop("cluster_name") # We need new loop, because the launcher is using one loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) config = self._load_config() self.config = config # Default prefix self.def_prefix = config['bot']['prefix'] self._log_webhook = config['bot']['logs-webhook'] self.maintenance_mode = config['bot']['start-in-maintenance'] self.is_beta = config['bot']['beta'] self.ipc_ping = 0 # Common emojis emojis = config['emoji'] self.check_emoji = emojis['check'] self.gold_emoji = emojis['gold'] self.gem_emoji = emojis['gem'] self.tile_emoji = emojis['farm_tile'] self.xp_emoji = emojis['xp'] self.warehouse_emoji = emojis['warehouse'] self._init_logger() self.log.info(f"Shards: {kwargs['shard_ids']}" f", shard count: {kwargs['shard_count']}") self.enable_field_guard(config['bot']['startup-farm-guard-duration']) try: loop.run_until_complete(self._connect_db()) except Exception: self.log.exception("Could not connect to Postgres") self._connect_redis() self.custom_prefixes = {} self.user_cache = UserManager(self.redis, self.db_pool) intents = discord.Intents.none() intents.guilds = True intents.guild_messages = True super().__init__(intents=intents, chunk_guilds_at_startup=False, max_messages=7500, command_prefix=self.get_custom_prefix, case_insensitive=True, strip_after_prefix=True, **kwargs, loop=loop) self.global_cooldown = commands.CooldownMapping.from_cooldown( 4, 9, commands.BucketType.user) self.spam_control = commands.CooldownMapping.from_cooldown( 10, 12.0, commands.BucketType.user) self._auto_spam_count = Counter() self.add_check(self.check_global_cooldown, call_once=True) self.add_check( commands.bot_has_permissions(read_message_history=True, embed_links=True, add_reactions=True).predicate) for extension in self.config['bot']['initial-cogs']: try: self.log.debug(f"Loading extension: {extension}") self.load_extension(extension) except Exception: self.log.exception(f"Failed to load extension: {extension}") if self.is_beta: self.log.warning("Loading the beta debug extension") self.load_extension("bot.cogs.beta") self.run()
async def on_command_error(self, ctx, error): if isinstance(error, commands.CommandOnCooldown): await ctx.send(f"Hey, <@{ctx.author.id}>.. {error}!") elif isinstance(error, commands.CommandNotFound): await ctx.send( f"Yo, <@{ctx.author.id}>.. There's no such commands. " + "Try checking `a;help`!") elif isinstance(error, commands.MissingRequiredArgument): await ctx.send("Not to be rude. But you've got " + f"the parameters wrong, <@{ctx.author.id}>. " + "Don't be lazy and read the `help` command!") await asyncio.sleep(0.5) await ctx.send_help(ctx.command) elif isinstance(error, commands.MemberNotFound): msg = await ctx.send( "No such members. Try again, but try with someone in the " + f"server, <@{ctx.author.id}>.") await asyncio.sleep(0.5) await msg.edit( content=msg.content + " Oh! And `everyone` or `roles` is not a valid option.") elif isinstance(error, commands.TooManyArguments): msg = await ctx.send( f"<@{ctx.author.id}>, there's too many arguments. " + "Don't be lazy and read the `help` command!") await asyncio.sleep(0.5) await ctx.send_help(ctx.command) await asyncio.sleep(0.5) await msg.edit(content=msg.content + " Read that!") elif isinstance(error, commands.UserInputError): msg = await ctx.send( f"<@{ctx.author.id}>, are you okay? I don't think " + "you're using the command correctly.") await asyncio.sleep(0.5) await ctx.send_help(ctx.command) await asyncio.sleep(0.5) await msg.edit(content=msg.content + " Will that help?") elif isinstance(error, commands.MaxConcurrencyReached): await ctx.send(f"Yo, <@{ctx.author.id}>! CHILL?") elif isinstance(error, commands.NotOwner): await ctx.send("That command is only for my awesome creator.") elif isinstance(error, commands.PrivateMessageOnly): await ctx.send( "That command can only be used within a Private Message. " + "Kindly, send me a Private Message and initiate the " + "command again. I won't bite.") elif isinstance(error, commands.NoPrivateMessage): await ctx.send( "That command can only be used within a Discord Server.") elif self.bot.is_ws_ratelimited(): await ctx.send( "We are being rate limited. Nothing can be helped here. " + "Please wait and try again.") elif not commands.bot_has_permissions(): await ctx.send("Please check that I have the permission, " + "`View Channels`, `Send Messages`, `Embed Links` " + "`Add Reactions`, `Read Message History`, " + "and `Manage Messages`.") else: await self.notifyOwner(ctx, error) official_server = False if ctx.guild.id == int(os.getenv("GUILD_ID")): official_server = True if not official_server: await ctx.send("I encountered a bug. Don't worry. " + "I've logged the bug. However, " + "if it still happens, you might " + "want to join the support server " + "through the `server` command " + "for a more thorough assistance.") else: await ctx.send("I encountered a bug. Don't worry. " + "I've logged the bug.")
top.gg-token: My top.gg API token discord.boats-token: My discord.boats API token discordbotlist.com-token: My discordbotlist.com API token """ scope = [ 'https://spreadsheets.google.com/feeds', 'https://www.googleapis.com/auth/drive' ] creds = ServiceAccountCredentials.from_json_keyfile_dict( json.loads(os.environ['GOOGLE_CREDENTIALS']), scope) gs_client = gspread.authorize(creds) dictionary = PyDictionary() client = commands.Bot(command_prefix="$") client.remove_command("help") client.add_check(commands.bot_has_permissions(send_messages=True).predicate) rw = RandomWords() authors = [] index = 0 @tasks.loop(seconds=15) async def change_status(): global index statuses = [ 'https://aadits-hangman.herokuapp.com', f'{len(client.guilds)} servers', '$help || $start', 'Youtube', 'People winning hangman', 'Audit dev me', 'https://discord.gg/CRGE5nF', 'https://dsc.gg/hangman',
def __init__(self, **kwargs): self.disabled_message = DEFAULT_DISABLED_MESSAGE self.pipe = kwargs.pop("pipe") self.cluster_name = kwargs.pop("cluster_name") self.cluster_idx = kwargs.pop("cluster_idx") self.env = kwargs.pop("env") self.embed_color = 0xF44336 self.battles = None self.dbl_token = kwargs.pop("dbl_token") self.database_uri = kwargs.pop("database_uri") self.database_name = kwargs.pop("database_name") loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) super().__init__(**kwargs, loop=loop, command_prefix=determine_prefix) self.mongo = helpers.mongo.Database(self, self.database_uri, self.database_name) self._last_result = None self.waiting = False self.enabled = False self.sprites = None self.log = logging.getLogger(f"Cluster#{self.cluster_name}") self.log.setLevel(logging.DEBUG) handler = logging.FileHandler( filename=f"logs/commands-{self.cluster_name}.log", encoding="utf-8", mode="a", ) handler.setFormatter( logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s") ) self.log.handlers = [handler] discord_logger = logging.getLogger("discord") discord_logger.setLevel(logging.INFO) discord_handler = logging.FileHandler( filename=f"logs/discord-{self.cluster_name}.log", encoding="utf-8", mode="a" ) discord_handler.setFormatter( logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s") ) discord_logger.addHandler(discord_handler) self.log.info( f'[Cluster#{self.cluster_name}] {kwargs["shard_ids"]}, {kwargs["shard_count"]}' ) # Load extensions self.load_extension("jishaku") for i in dir(cogs): if not i.startswith("_"): self.load_extension(f"cogs.{i}") self.add_check(helpers.checks.enabled(self)) self.add_check( commands.bot_has_permissions( read_messages=True, send_messages=True, embed_links=True, attach_files=True, read_message_history=True, add_reactions=True, external_emojis=True, ).predicate ) # Run bot self.ipc = Server( self, "localhost", 8765 + self.cluster_idx, kwargs["secret_key"] ) @self.ipc.route() async def stop(data): try: await self.close() return {"success": True} except Exception as err: return {"success": False, "error": err} @self.ipc.route() async def stats(data): return { "success": True, "guild_count": len(self.guilds), "shard_count": len(self.shards), "user_count": sum(x.member_count for x in self.guilds), "latency": sum(x[1] for x in self.latencies), } @self.ipc.route() async def reload(data): try: await self.reload_modules() return {"success": True} except Exception as err: return {"success": False, "error": err} @self.ipc.route() async def disable(data): self.enabled = False if hasattr(data, "message") and data.message is not None: self.disabled_message = data.message else: self.disabled_message = DEFAULT_DISABLED_MESSAGE return {"success": True} @self.ipc.route() async def enable(data): self.enabled = True self.disabled_message = DEFAULT_DISABLED_MESSAGE return {"success": True} @self.ipc.route() async def move_request(data): self.dispatch( "move_request", data.cluster_idx, data.user_id, data.species_id, data.actions, ) return {"success": True} @self.ipc.route() async def move_decide(data): self.dispatch("move_decide", data.user_id, data.action) return {"success": True} @self.ipc.route() async def send_dm(data): user = await self.fetch_user(data.user) await user.send(data.message) return {"success": True} @self.ipc.route() async def eval(data): data = await self.exec(data.code) return {"success": True, "result": data} self.ipc.start() self.ipc_client = Client(secret_key=kwargs["secret_key"]) self.loop.create_task(self.do_startup_tasks()) self.run(kwargs["token"])
def has_administrator_permission(ctx: commands.Context) -> bool: is_guild(ctx) commands.has_permissions(administrator=True)(ctx) commands.bot_has_permissions(administrator=True)(ctx) return True