Python discord.ext.commands 模块，check() 实例源码

def requiredEnabled(**kwargs):
    '''Checks to see if a certain token type's secret exists

    Parameters :: 
        token : str
            The type of token whose secret needs to exist
    '''

    def predicate(ctx):
        token = kwargs.get('enable')
        serverSettings = getServerJson(ctx.message.server.id)
        enabled = serverSettings['Toggles'][token]
        if enabled:
            return True
        else:
            raise CommandDisabled
            return False

    return commands.check(predicate)

def needsToken(**kwargs):
    '''Checks to see if a certain token type's secret exists

    Parameters :: 
        token : str
            The type of token whose secret needs to exist
    '''

    def predicate(ctx):
        token = kwargs.get('token')
        v = getTokens()[token]

        for i, o in v.items():
            if not o:
                raise ThisNeedsAToken
        return True        
    return commands.check(predicate)

def check_last(self, ctx: commands.Context, name):
        """ Shows you how long other users' last session lasted.

            :param name: The name (not the nick) of the person to check.
            Must use the name#discriminator format.
        """
        time_str = printable_time(db_manager.get_user_last_session(name))
        if time_str is None:
            time_str = "None found."

        lib.log("{} queried for {}'s last session time. Result: {}"
                .format(lib.get_author_name(ctx, True),
                        "their" if name == str(ctx.message.author)
                        else (name + "'s"), time_str))

        await self.bot.say("```{}```".format(time_str),
                           delete_after=self.bot.ans_lifespan * 3)

def total(self, ctx: commands.Context, name=None):
        """ Shows you the total time a user has used the timer for.

            :param name: The name (not the nick) of the person to check.
            Must use the name#discriminator format. If none is provided, it will
            check your own record.
        """
        if name is None:
            name = ctx.message.author

        time_str = printable_time(db_manager.get_user_total(name))
        if time_str is None:
            time_str = "None found."

        name = str(name)
        lib.log("{} queried for {}'s last session time. Result: {}"
                .format(lib.get_author_name(ctx, True),
                        "their" if name == str(ctx.message.author)
                        else (name + "'s"), time_str))

        await self.bot.say("```{}```".format(time_str),
                           delete_after=self.bot.ans_lifespan * 3)

def in_channel(name):
    """
    Checks if command is sent in a given channel ignores high roles.
    To be used as a decorator
    :param name: name of the channel
    """
    def predicate(ctx):
        if ctx.message.channel.is_private:
            return False

        # Adapted from discord.ext.core.has_any_role
        user_roles = functools.partial(discordutils.get, ctx.message.author.roles)
        if any(user_roles(name=role) is not None for role in ['Admin', 'Moderator', 'Support']):
            return True

        return ctx.message.channel.name == name

    return commands.check(predicate)

def permcheck(**kwargs):
    def predicate(ctx):
        owners_ = kwargs.get('owners', [])
        check = kwargs.get('check', '')

        if type(owners_) is not list:
            owners_ = [owners_]

        if ctx.message.author.id in [owners[x] for x in owners_]:
            return True

        if check == 'dm_only' and ctx.message.server is None:
            return True

        return False

    return commands.check(predicate)

def progress(self, ctx):
        """Provides the progress of the current song"""

        # Make sure we're playing first
        state = self.get_voice_state(ctx.message.server)
        if not state.is_playing():
            await self.bot.say('Not playing anything.')
        else:
            progress = state.current.progress
            length = state.current.length
            # Another check, just to make sure; this may happen for a very brief amount of time
            # Between when the song was requested, and still downloading to play
            if not progress or not length:
                await self.bot.say('Not playing anything.')
                return

            # Otherwise just format this nicely
            progress = divmod(round(progress, 0), 60)
            length = divmod(round(length, 0), 60)
            fmt = "Current song progress: {0[0]}m {0[1]}s/{1[0]}m {1[1]}s".format(progress, length)
            await self.bot.say(fmt)

def summon(self, ctx):
        """Summons the bot to join your voice channel."""
        # This method will be invoked by other commands, so we should return True or False instead of just returning
        # First check if the author is even in a voice_channel
        summoned_channel = ctx.message.author.voice_channel
        if summoned_channel is None:
            await self.bot.say('You are not in a voice channel.')
            return False

        # Then simply create a voice client
        try:
            success = await self.create_voice_client(summoned_channel)
        except (asyncio.TimeoutError, discord.ConnectionClosed):
            await self.bot.say("I failed to connect! This usually happens if I don't have permission to join the"
                               " channel, but can sometimes be caused by your server region being far away."
                               " Otherwise this is an issue on Discord's end, causing the connect to timeout!")
            await self.remove_voice_client(summoned_channel.server)
            return False

        if success:
            try:
                await self.bot.say('Ready to play audio in ' + summoned_channel.name)
            except discord.Forbidden:
                pass
        return success

def __init__(self, bot):
        super().__init__(bot)

        addr = getattr(bot.config, 'MONGO_LOC', None)
        self.mongo_client = motor.motor_asyncio.AsyncIOMotorClient(addr)
        self.bot.mongo = self.mongo_client

        self.jose_db = self.mongo_client['jose']

        self.config_coll = self.jose_db['config']
        self.block_coll = self.jose_db['block']
        self.bot.block_coll = self.block_coll

        # querying the db every time is not worth it
        self.config_cache = collections.defaultdict(dict)

        # used to check if cache has all defined objects in it
        self.default_keys = None

def can_use_box():
    def pred(ctx):
        if ctx.guild is None:
            return True
        if ctx.author.id == ctx.bot.owner_id:
            return True

        has_perms = ctx.channel.permissions_for(ctx.author).manage_messages
        if not has_perms:
            raise UnableToUseBox()

        return True
    return commands.check(pred)

# The tag data is heavily duplicated (denormalized) and heavily indexed to speed up
# retrieval at the expense of making inserts a little bit slower. This is a fine trade-off
# because tags are retrieved much more often than created.

def is_owner():

    def predicate(ctx):
        if is_owner_check(ctx):
            return True
        else:
            raise errors.NotOwner

    return commands.check(predicate)

def is_server_owner():

    def predicate(ctx):
        if is_server_owner_check(ctx):
            return True
        else:
            raise errors.NotServerOwner

    return commands.check(predicate)

def is_voice_connected():

    def predicate(ctx):
        if not is_voice_connected_check(ctx):
            if is_server_owner_check(ctx) or utilities.get_permission(ctx, "join", id = ctx.message.author.id):
                raise errors.PermittedVoiceNotConnected
            else:
                raise errors.NotPermittedVoiceNotConnected
        return True

    return commands.check(predicate)

def has_permissions(**permissions):

    def predicate(ctx):
        if has_permissions_check(ctx, permissions):
            return True
        else:
            raise errors.MissingPermissions

    return commands.check(predicate)

def dm_or_has_permissions(**permissions):

    def predicate(ctx):
        if ctx.message.channel.is_private or has_permissions_check(ctx, permissions):
            return True
        else:
            raise errors.MissingPermissions

    return commands.check(predicate)

def dm_or_has_capability(*permissions):

    def predicate(ctx):
        if ctx.message.channel.is_private or has_capability_check(ctx, permissions):
            return True
        else:
            raise errors.MissingCapability(permissions)

    return commands.check(predicate)

def has_permissions_and_capability(**permissions):

    def predicate(ctx):
        if ctx.message.channel.is_private:
            return False
        elif not has_permissions_check(ctx, permissions):
            raise errors.MissingPermissions
        elif not has_capability_check(ctx, permissions.keys()):
            raise errors.MissingCapability(permissions.keys())
        else:
            return True

    return commands.check(predicate)

def dm_or_has_permissions_and_capability(**permissions):

    def predicate(ctx):
        if ctx.message.channel.is_private:
            return True
        elif not has_permissions_check(ctx, permissions):
            raise errors.MissingPermissions
        elif not has_capability_check(ctx, permissions.keys()):
            raise errors.MissingCapability(permissions.keys())
        else:
            return True

    return commands.check(predicate)

def not_forbidden():

    def predicate(ctx):
        if not_forbidden_check(ctx):
            return True
        else:
            raise errors.NotPermitted

    return commands.check(predicate)

def is_permitted():

    def predicate(ctx):
        if is_permitted_check(ctx):
            return True
        else:
            raise errors.NotPermitted

    return commands.check(predicate)

def is_owner():
    return commands.check(is_owner_check)

# The permission system of the bot is based on a "just works" basis
# You have permissions and the bot has permissions. If you meet the permissions
# required to execute the command (and the bot does as well) then it goes through
# and you can execute the command.
# If these checks fail, then there are two fallbacks.
# A role with the name of Bot Mod and a role with the name of Bot Admin.
# Having these roles provides you access to certain commands without actually having
# the permissions required for them.
# Of course, the owner will always be able to execute commands.

def role_or_permissions(ctx, check, **perms):
    if check_permissions(ctx, perms):
        return True

    ch = ctx.message.channel
    author = ctx.message.author
    if ch.is_private:
        return False # can't have roles in PMs

    role = discord.utils.find(check, author.roles)
    return role is not None

def serverowner_or_permissions(**perms):
    def predicate(ctx):
        if ctx.message.guild is None:
            return False
        guild = ctx.message.guild
        owner = guild.owner

        if ctx.message.author.id == owner.id:
            return True

        return check_permissions(ctx,perms)
    return commands.check(predicate)

def is_owner():
    return commands.check(lambda ctx: is_owner_check(ctx.message))

def owner():
    return commands.check(is_owner_check)

def admin():
    return commands.check(is_admin_check)

def serverowner():
    def predicate(ctx):
        if ctx.message.server is None:
            return False

        if ctx.message.author.id == ctx.message.server.owner.id:
            return True

        # return check_permissions(ctx, perms)
        return False
    return commands.check(predicate)

def need_db(command):
    """Decorator, not check, to mark the command as needing a DB connection."""
    command._db = True
    return command

def config_attr(attr):
    return commands.check(lambda _: getattr(config, attr, None) is not None)

def owner_or_permissions(**perms):
    return commands.check(lambda ctx: check_permissions(ctx, perms))

def dm_only():
    return commands.check(lambda ctx: ctx.guild is None)

def is_owner():
    return commands.check(lambda ctx: is_owner_check(ctx.message))

def is_authorized_staff():
    return commands.check(lambda ctx: is_authorized_staff_check(ctx.message))

def is_owner():
    return commands.check(lambda ctx: is_owner_check(ctx.message))

def role_or_permissions(ctx, check, **perms):
    if check_permissions(ctx, perms):
        return True

    ch = ctx.message.channel
    author = ctx.message.author
    if ch.is_private:
        return False  # can't have roles in PMs

    role = discord.utils.find(check, author.roles)
    return role is not None

def mod_or_permissions(**perms):
    def predicate(ctx):
        return role_or_permissions(ctx, lambda r: r.name in ('Luna Mod', 'Luna Admin', 'Bot Commander', 'Master Assassin'), **perms)

    return commands.check(predicate)

def admin_or_permissions(**perms):
    def predicate(ctx):
        return role_or_permissions(ctx, lambda r: r.name in ('Luna Admin', 'Master Assassin'), **perms)
    return commands.check(predicate)

# These two roles are for a specific server, just use 'Luna mod' and 'Luna
# admin'

def bot_main(token, queue, channel, prefix, desc):
    """Run bot."""
    bot = AutomaBot(get=queue, update_channel=channel,
                    command_prefix=prefix,
                    description=desc, self_bot=False)

    @bot.command(pass_context=True)
    @commands.check(is_owner)
    async def sleep(ctx):
        await bot.change_presence(status=discord.Status.dnd, afk=True)
        msg = 'Going to sleep. See you :wave:'
        for comm in bot.commands:
            if comm is not "wakeup":
                bot.commands[comm].enabled = False
        await bot.say(msg)

    @bot.command(pass_context=True, hidden=True)
    @commands.check(is_owner)
    async def wakeup(ctx):
        for comm in bot.commands:
            if comm is not "wakeup":
                bot.commands[comm].enabled = True
        await bot.change_presence(status=discord.Status.online, afk=False)
        msg = 'Goooooooooood morniiing vietnammmmmm :bomb:'
        await bot.say(msg)

    await bot.start(token)

def is_owner():
    return commands.check(lambda ctx: is_owner_check(ctx.message))

# The permission system of the bot is based on a "just works" basis
# You have permissions and the bot has permissions. If you meet the permissions
# required to execute the command (and the bot does as well) then it goes through
# and you can execute the command.
# If these checks fail, then there are two fallbacks.
# A role with the name of Bot Mod and a role with the name of Bot Admin.
# Having these roles provides you access to certain commands without actually having
# the permissions required for them.
# Of course, the owner will always be able to execute commands.

def role_or_permissions(ctx, check, **perms):
    if check_permissions(ctx, perms):
        return True

    ch = ctx.message.channel
    author = ctx.message.author
    if ch.is_private:
        return False # can't have roles in PMs

    role = discord.utils.find(check, author.roles)
    return role is not None

def mod_or_permissions(**perms):
    def predicate(ctx):
        return role_or_permissions(ctx, lambda r: r.name == 'Bot Commander', **perms)
    return commands.check(predicate)

def admin_or_permissions(**perms):
    def predicate(ctx):
        return role_or_permissions(ctx, lambda r: r.name == 'Bot Commander', **perms)
    return commands.check(predicate)

def TO_or_permissions(**perms):
    def predicate(ctx):
        return role_or_permissions(ctx, lambda r: r.name in ('TO_Crew', 'Head TO', 'Staff'), **perms) #these roles are needed if you're a TO
    return commands.check(predicate)

def gay_only():
    return commands.check(lambda m: m.author.id in \
        (162819866682851329, 97104885337575424, 150745989836308480))

def is_owner():
    return commands.check(lambda ctx: is_owner_check(ctx.message))

# The permission system of the bot is based on a "just works" basis
# You have permissions and the bot has permissions. If you meet the permissions
# required to execute the command (and the bot does as well) then it goes through
# and you can execute the command.
# If these checks fail, then there are two fallbacks.
# A role with the name of Bot Mod and a role with the name of Bot Admin.
# Having these roles provides you access to certain commands without actually having
# the permissions required for them.
# Of course, the owner will always be able to execute commands.

def role_or_permissions(ctx, check, **perms):
    if check_permissions(ctx, perms):
        return True

    ch = ctx.message.channel
    author = ctx.message.author
    if ch.is_private:
        return False # can't have roles in PMs

    role = discord.utils.find(check, author.roles)
    return role is not None

def mod_or_permissions(**perms):
    def predicate(ctx):
        return role_or_permissions(ctx, lambda r: r.name in ('Bot Mod', 'Bot Admin'), **perms)

    return commands.check(predicate)

def admin_or_permissions(**perms):
    def predicate(ctx):
        return role_or_permissions(ctx, lambda r: r.name == 'Bot Admin', **perms)

    return commands.check(predicate)

def is_in_servers(*server_ids):
    def predicate(ctx):
        server = ctx.message.server
        if server is None:
            return False
        return server.id in server_ids
    return commands.check(predicate)

def bot_owner(ctx):
    def check():
        return ctx.author.id == 125435062127820800
    return check()