def __init__(self): super().__init__( command_prefix=self.prefix, help_command=None, allowed_mentions=discord.AllowedMentions(everyone=False, replied_user=False), intents=intent, strip_after_prefix=True, case_insensitive=True, enable_debug_events=True, ) self.consts = {"qu": {}, "ch": {}, "ne": [], "tc": {}, "pci": {}, "ticket_time": {}} self.raw_config = ast.literal_eval(raw_save) self.dbclient = motor.AsyncIOMotorClient(cstr) self.sync_dbclient = pymongo.MongoClient(cstr) self.db = self.dbclient[db_name] self.sync_db = self.sync_dbclient[db_name] self.web_pass = web_pass self.debug = os.environ["DEBUG"] == "True" self.texts = common_resources.Texts self.default_user_settings = { "level_dm": False, } self.oemojis: dict[str, discord.Emoji] = {} self.guild_settings: DefaultDict[int, GuildSettings] = defaultdict(lambda: copy.deepcopy(DEFAULT_SETTINGS)) print("-- Loading saves from db: ", end="") self.load_saves() print("Done") print("Debug mode: " + str(self.debug)) if self.debug: self.loop.create_task(self.auto_reload()) self.check(commands.cooldown(2, 2))
async def _build_commands(self): for key in self.owoe.types: # Avoid duplicate commands by removing them. if key in self.bot.all_commands.keys(): self.bot.remove_command(key) helptext = f"{key.capitalize()}!" async def callback(self, ctx, *tags): tags = list(tags) for tag in tags: if tag not in self.owoe.tags: tags.remove(tag) url_image = await self.owoe.random_image(type_=ctx.command.name, tags=tags) if isinstance(url_image, str): embed = discord.Embed() embed.set_image(url=url_image) embed.set_footer(text="Powered by weeb.sh") await ctx.send(embed=embed) return await ctx.send("No image matching your criteria was found.") # Ew, gross. command = commands.command(name=key, help=helptext)(callback) command = commands.cooldown(6, 12, commands.BucketType.channel)(command) command.instance = self setattr(self, key, command) self.bot.add_command(command)
def cooldown(rate, per_sec=0, per_min=0, per_hour=0, type=commands.BucketType.default): return commands.cooldown(rate, per_sec + 60 * per_min + 3600 * per_hour, type)
def __init__(self, config_file:str='config/config.json', commandline_args=None, *args, **kwargs): # Things I would need anyway if kwargs.get('command_prefix'): super().__init__(*args, **kwargs) else: super().__init__(command_prefix=get_prefix, *args, **kwargs) # Store the config file for later self.config = None self.config_file = config_file self.reload_config() self.commandline_args = commandline_args self.bad_argument = compile(r'(User|Member) "(.*)" not found') self._invite_link = None # Aiohttp session for use in DBL posting self.session = ClientSession(loop=self.loop) # Allow database connections like this self.database = DatabaseConnection self.redis = RedisConnection # Allow get_guild and setup for server-specific trees self.server_specific_families = [] # list[guild_id] FamilyTreeMember.bot = self CustomisedTreeUser.bot = self # Store the startup method so I can see if it completed successfully self.startup_time = dt.now() self.startup_method = None self.deletion_method = None # Add a cache for proposing users self.proposal_cache = ProposalCache() # Add a list of blacklisted guilds and users self.blacklisted_guilds = [] self.blocked_users = {} # user_id: list(user_id) # Dictionary of custom prefixes self.guild_prefixes = {} # guild_id: prefix # See who voted for the bot and when self.dbl_votes = {} # uid: timestamp (of last vote) # Add a cooldown to help cooldown(1, 5, BucketType.user)(self.get_command('help'))
def cooldown(amount: int, channel_wide: bool = False, server_wide: bool = False): return commands.cooldown( 1, amount, getattr( commands.BucketType, "guild" if server_wide else ("channel" if channel_wide else "user")))
def short_cooldown( type: cooldowns.BucketType = cooldowns.BucketType.channel ) -> commands.Command: """ Rate-limiting decorator ("once in 30s"). Limitations are channel-based by default (controlled by `type`). """ return commands.cooldown(rate=1, per=30, type=type)
def __init__(self, config_file: str = 'config/config.json', *args, **kwargs): '''Make the bot WEW''' # Get the command prefix from the kwargs if kwargs.get('command_prefix'): super().__init__(*args, **kwargs) else: super().__init__(command_prefix=get_prefix, *args, **kwargs) # Hang out and make all the stuff I'll need self.config: dict = None # the config dict - None until reload_config() is sucessfully called self.config_file = config_file # the config filename - used in reload_config() self.reload_config() # populate bot.config self.bad_argument = compile( r'(User|Member) "(.*)" not found') # bad argument regex converter self._invite_link = None # the invite for the bot - dynamically generated self.shallow_users = { } # id: (User, age) - age is how long until it needs re-fetching from Discord self.support_guild = None # the support guild - populated by patreon check and event log self.session = ClientSession( loop=self.loop) # aiohttp session for get/post requests self.database = DatabaseConnection # database connection class self.redis = RedisConnection # redis connection class self.server_specific_families = [ ] # list[guild_id] - guilds that have server-specific families attached FamilyTreeMember.bot = self CustomisedTreeUser.bot = self ProposalCache.bot = self TreeCache.bot = self self.startup_time = dt.now() # store bot startup time self.startup_method = None # store startup method so I can see errors in it self.deletion_method = None # store deletion method so I can cancel it on shutdown self.proposal_cache = ProposalCache( ) # cache for users who've been proposed to/are proposing self.blacklisted_guilds = [ ] # a list of guilds that are blacklisted by the bot self.blocked_users = defaultdict( list) # user_id: list(user_id) - users who've blocked other users self.guild_settings = {} # guild_id: Dict - custom setings per guild self.dbl_votes = {} # uid: timestamp (of last vote) - cast dbl votes self.tree_cache = TreeCache() # cache of users generating trees cooldown(1, 5, BucketType.user)( self.get_command('help')) # add cooldown to help command
class Times(commands.Cog): def __init__(self, bot): self.bot = bot @commands.cooldown(1, 60, commands.BucketType.user) @in_bot_commands() @commands.command(name="when", help_command="!when", description="Check when the hackathon starts or ends", help="Check when the hackathon starts or ends" )
def __init__(self, config_file: str = 'config/config.json', commandline_args=None, *args, **kwargs): # Things I would need anyway if kwargs.get('command_prefix'): super().__init__(*args, **kwargs) else: super().__init__(command_prefix=get_prefix, *args, **kwargs) # Store the config file for later self.config = None self.config_file = config_file self.reload_config() self.commandline_args = commandline_args # Add webserver stuff so I can come back to it later self.web_runner = None # Allow database connections like this self.database = DatabaseConnection self.database.config = self.config['database'] # Store the startup method so I can see if it completed successfully self.startup_method = self.loop.create_task(self.startup()) self.deletion_method = self.loop.create_task(self.delete_loop()) # Add a cache for proposing users self.proposal_cache = RemovalDict() # Add a list of blacklisted guilds self.blacklisted_guilds = [] # Dictionary of custom prefixes self.guild_prefixes = {} # guild_id: prefix # Add a cooldown to help cooldown(1, 5, BucketType.user)(self.get_command('help'))
def predicate(ctx): cooldown_end = cooldown_actions.get_cooldown_end_time( ctx.message.author) if cooldown_end is None: return True else: now = int(time.time()) if not now > cooldown_end: seconds_remaining = cooldown_end - now raise commands.CommandOnCooldown(commands.cooldown(1, 900), seconds_remaining) else: return True
def __new__(cls, name, bases, attrs, *, generator: BaseImageGenerator, **kwargs): for attr_name in dir(generator): attr = getattr(generator, attr_name) if not getattr(attr, "__image_generator__", False): continue signature = inspect.signature(attr) params = signature.parameters if len(params) == 2 and list(params.values())[1].annotation == ImageType: cmd = Command(image_paste_command(attr_name), name=attr_name) elif all([p.annotation == str for p in list(params.values())[1:]]): cmd = Command( text_write_command(attr_name, len(params) - 1), name=attr_name ) else: raise RuntimeError("Unknown image generator args") cooldown(1, 5, BucketType.user)(cmd) attrs[attr.__name__] = cmd self = super().__new__(cls, name, bases, attrs, **kwargs) return self
def __init__(self, _bot): self.bot: "bot.DemocracivBot" = _bot self.bot.loop.create_task(self._transform_description()) for command in self.walk_commands(): if command.help: self.bot.loop.create_task( self._transform_command_help(command)) if not command._buckets._cooldown: cooldown_deco = commands.cooldown(1, config.BOT_COMMAND_COOLDOWN, commands.BucketType.user) cooldown_deco(command)
def add_pattern(self, doc): async def func(self, ctx): await ctx.send(random.choice(doc['messages'])) func.__name__ = doc['name'] func.__doc__ = 'pattern: ' + doc['pattern'] aliases = doc.get('aliases') seconds = doc.get('seconds') if seconds != 0: func = commands.cooldown(1, seconds if seconds else 900, commands.BucketType.guild)(func) func = commands.command(name=doc['name'], aliases=aliases if aliases else [], hidden=True)(func) func.instance = self self.__cog_commands__ += (func, )
def make_cmd(name: str, help_desc: 'Optional[str]', embeds: 'dict[str, discord.Embed]', cooldown: 'tuple[int, int]', aliases: list[str]) -> commands.Command: if len(embeds) > 1: # multi-console commands require a check async def multi_cmd(self, ctx, *, consoles=''): supported_consoles = list(embeds) for s in supported_consoles: if s in {'dsi', 'wii'}: # special case for legacy channel supported_consoles.append('legacy') # replace aliases with the expected console requested_consoles = { get_console_name(c) for c in consoles.split() } # and then check if any of the consoles are supported here requested_consoles = { c.lower() for c in requested_consoles if c.lower() in supported_consoles } channel_name = ctx.channel.name if not isinstance( ctx.channel, discord.DMChannel) else '' if not requested_consoles: if channel_name.startswith(tuple(supported_consoles)): requested_consoles = {'auto'} else: valid = set(supported_consoles) for v in supported_consoles: valid |= name_to_aliases[v] await ctx.send( f'Please specify a console. Valid options are: {", ".join(sorted(valid))}' ) ctx.command.reset_cooldown(ctx) return for console in requested_consoles: for embed_console, embed in embeds.items(): cons = [embed_console] if embed_console in {'dsi', 'wii'}: # special case for legacy channel cons.append('legacy') if check_console(console, channel_name, tuple(cons)): await ctx.send(embed=embed) cmd = multi_cmd else: # single-console commands can simply print the one embed async def simple_cmd(self, ctx): # this is kinda ugly, but basically it gets the first (and only) value of the dict await ctx.send(embed=next(iter(embeds.values()))) cmd = simple_cmd # gotta trick the lib so it thinks the callback is inside a class cmd.__name__ = name cmd.__qualname__ = f"{cog_class.qualified_name}.{cmd.__name__}" # i figured this was easier than dealing with the multiple attributes for command help cmd.__doc__ = help_desc # this feels _wrong_ but is probably the best way to do this cooldown = commands.cooldown(cooldown[0], cooldown[1], commands.BucketType.channel)(cmd) cmd_obj = namespace.command(name=name, aliases=aliases)(cooldown) return cmd_obj
embed=embed) held = [ "https://cdn.discordapp.com/attachments/741845376314769468/743703038195138580/tenor_1.gif", "https://cdn.discordapp.com/attachments/741845376314769468/743703037914251284/tenor_2.gif", "https://cdn.discordapp.com/attachments/741845376314769468/743703037490626600/tenor_3.gif", "https://cdn.discordapp.com/attachments/741845376314769468/743703037167796324/tenor_4.gif", "https://cdn.discordapp.com/attachments/741845376314769468/743689816985698394/tenor.gif" ] lala = [ 0x1abc9c, 0x9b59b6, 0x99aab5, 0x7289da, 0xa84300, 0xf1c40f, 0xe91e63, 0x546e7a ] t = todoroki.command() cd = commands.cooldown(1, 12, commands.BucketType.user) owner = 552492140270452736 @bot.command() @cd async def bug(ctx, *, msg: str): own = bot.get_user(552492140270452736) lol = bot.get_channel(726671245621592175) serverinvite = await ctx.message.channel.create_invite( reason='Requested by ' + str(ctx.message.author.name)) color = discord.Color(value=0x00ff00) em = discord.Embed(color=color, title="Bug reported!") em.description = f"Bug : {msg}\nBug sent by {ctx.author}\nInvite : [Link]({serverinvite})" await lol.send(embed=em) await own.send(ctx.author.id)
def cooldown(*args): return commands.cooldown(1, int(args[0]), commands.BucketType.user)
def __init__(self, bot): """Procedurablly build reaction commands.""" with open("reactions.json") as fobject: self.data = json.load(fobject) count = 0 # TODO Add a help field to this mess. for key in self.data: # Avoid duplicate commands. if key in bot.all_commands.keys(): continue # Avoid non-dictionary values. # Make sure that there exists a value with key "images", and that it's a list. elif (not isinstance(self.data[key], dict) or not isinstance(self.data[key].get("images"), list)): continue # This signifies the type of message to be sent. message_indicator = self.data[key].get("message") # No message. if message_indicator is None: helptext = f"{key.capitalize()}!" async def callback(self, ctx): await _send_image(ctx, self.data[ctx.command.name]["images"]) # Zero-length string. elif not message_indicator: helptext = f"{key.capitalize()} a user!" async def callback(self, ctx, *, user: str): message = await _generate_message(ctx, ctx.command.name, user) await _send_image(ctx, self.data[ctx.command.name]["images"], message) # Custom message. else: helptext = f"{key.capitalize()}!" async def callback(self, ctx): await _send_image(ctx, self.data[ctx.command.name]["images"], self.data[ctx.command.name]["message"]) # Ew, gross. aliases = self.data[key].get("aliases", []) for alias in aliases: if alias in bot.all_commands.keys(): aliases.remove(alias) command = commands.command(name=key, help=helptext, aliases=aliases)(callback) command = commands.cooldown(6, 12, commands.BucketType.channel)(command) command.instance = self setattr(self, key, command) count += 1
def short_cooldown(f): return commands.cooldown(rate=5, per=20.0, type=commands.BucketType.user)(f)
def wrapper(command) -> commands.Command: if cd: command = commands.cooldown(rate, per, bucket)(command) command.cooldown_after_parsing = True return commands.check(check)(command)
def long_cooldown(f): return commands.cooldown(rate=1, per=20.0, type=commands.BucketType.user)(f)
def default_cooldown(f): return commands.cooldown(rate=5, per=30.0, type=commands.BucketType.user)(f)
import itertools import io import discord import lifesaver from PIL import Image, ImageDraw, ImageFont from discord.ext import commands from .converters import TierList from .utils import image_renderer, draw_word_wrap standard_cooldown = commands.cooldown(1, 3, commands.BucketType.user) brain_heights = [ 155, 181, 188, 165, 179, 190, 210, 194, ] tier_colors = [ (255, 127, 127), (255, 191, 127), (255, 223, 127), (255, 255, 127), (191, 255, 127), (127, 255, 127),
import asyncio import requests from deku import * import deku as todo from discord import Embed import platform import sys from psutil import Process from platform import python_version from discord.ext import commands from discord.ext.commands import command, BucketType, cooldown, Cog from discord import __version__ as discord_version import discord, json, time, datetime, json, psutil, platform cc = commands.command() sm = commands.cooldown(1, 14, commands.BucketType.user) cyan = 0, 255, 255 yell = 255, 255, 0 ung = 191, 0, 255 vi = 143, 0, 255 liyr = os.environ.get("LIYRIK") q = os.environ.get("BRAINLY") k = os.environ.get("KEYEMAS") say = os.environ.get("SS") go = os.environ.get("go") key = os.environ.get("keygo") numkey = os.environ.get("numbertoken") joox = os.environ.get("JOOX") twit = os.environ.get("TWIT") memek = os.environ.get("MEMEK") wea = os.environ.get("WEA")
else: # compose string accordingly breakdown = ( "HackTX 2021 " + ("begins " if start > austin() else "ends ") + "in " + time_left(event) ======= breakdown = "Changeathon has ended. Come back next year :))" else: # compose string accordingly breakdown = ( "Changeathon " + ("begins " if start > austin() else "ends ") + "in " + time_left(event) >>>>>>> fb1d025f3d8eed90f94d9173a47e8da755c3bba1 ) await ctx.send(breakdown) @commands.cooldown(1, 60, commands.BucketType.guild) @in_bot_commands() @commands.command(name="schedule", help_command="!schedule", description="See the hackathon schedule", help="See the hackathon schedule" ) async def schedule(self, ctx): embeds = [] for day, events in sched.items(): if day >= austin().day: <<<<<<< HEAD full_day = ["Saturday", "Sunday"][day - 30] # 30 since that was the first day embed = discord.Embed(