Python commands.MissingRequiredArgument方法代码示例

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def on_command_error(self, ctx, exception):
        self.stats.increment("RPGBot.errors", tags=["RPGBot:errors"], host="scw-8112e8")
        logging.info(f"Exception in {ctx.command} {ctx.guild}:{ctx.channel} {exception}")
        exception = getattr(exception, "original", exception)
        traceback.print_tb(exception.__traceback__)
        print(exception)
        try:
            if isinstance(exception, commands.MissingRequiredArgument):
                await ctx.send(f"```{exception}```")
            elif isinstance(exception, TimeoutError):
                await ctx.send(await _(ctx, "This operation ran out of time! Please try again"))
            elif isinstance(exception, discord.Forbidden):
                await ctx.send(await _(ctx, "Error: This command requires the bot to have permission to send links."))
            else:
                await ctx.send(f"`{exception} If this is unexpected, please report this to the bot creator`")
        except discord.Forbidden:
            pass 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def on_command_error(ctx, error):

    send_help = (commands.MissingRequiredArgument, commands.BadArgument, commands.TooManyArguments, commands.UserInputError)

    if isinstance(error, commands.CommandNotFound):  # fails silently
        pass

    elif isinstance(error, send_help):
        _help = await send_cmd_help(ctx)
        await ctx.send(embed=_help)

    elif isinstance(error, commands.CommandOnCooldown):
        await ctx.send(f'This command is on cooldown. Please wait {error.retry_after:.2f}s')

    elif isinstance(error, commands.MissingPermissions):
        await ctx.send('You do not have the permissions to use this command.')
    # If any other error occurs, prints to console.
    else:
        print(''.join(traceback.format_exception(type(error), error, error.__traceback__))) 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def on_command_error(self, ctx, exception):
        exc_class = exception.__class__
        if exc_class in (commands.CommandNotFound, commands.NotOwner):
            return

        exc_table = {
            commands.MissingRequiredArgument: f"{WARNING} The required arguments are missing for this command!",
            commands.NoPrivateMessage: f"{WARNING} This command cannot be used in PM's!",
            commands.BadArgument: f"{WARNING} A bad argument was passed, please check if your arguments are correct!",
            IllegalAction: f"{WARNING} A node error has occurred: `{getattr(exception, 'msg', None)}`",
            CustomCheckFailure: getattr(exception, "msg", None) or "None"
        }

        if exc_class in exc_table.keys():
            await ctx.send(exc_table[exc_class])
        else:
            await super().on_command_error(ctx, exception) 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def setclass_error(self, ctx, error):
        if isinstance(error, commands.MissingRequiredArgument):
            manager = MessageManager(ctx)
            await manager.send_message("Oops! You didn't include your Destiny 2 class.")
            await manager.clean_messages() 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def settimezone_error(self, ctx, error):
        if isinstance(error, commands.MissingRequiredArgument):
            manager = MessageManager(ctx)
            await manager.send_message("Oops! You didn't include your timezone.")
            await manager.clean_messages() 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def setprefix_error(self, ctx, error):
        if isinstance(error, commands.MissingRequiredArgument):
            manager = MessageManager(ctx)
            await manager.send_message("Oops! You didn't provide a new prefix.")
            await manager.clean_messages() 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def seteventrole_error(self, ctx, error):
        if isinstance(error, commands.MissingRequiredArgument):
            manager = MessageManager(ctx)
            event_role = get_event_role(ctx)

            if not event_role:
                role_display = 'None (anyone can make events)'
            else:
                role_display = format_role_name(event_role)

            await manager.send_message("The current event role is: **{}**\n\n".format(role_display)
                            + "To change the event role, use '{}settings seteventrole <role_name>'".format(ctx.prefix))
            await manager.clean_messages() 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def seteventdeleterole_error(self, ctx, error):
        if isinstance(error, commands.MissingRequiredArgument):
            manager = MessageManager(ctx)
            event_role = get_event_delete_role(ctx)

            if not event_role:
                role_display = '**None** (only Manage Sever members can delete events)'
            else:
                role_display = format_role_name(event_role)

            await manager.send_message("The current event delete role is: {}\n\n".format(role_display)
                            + "To change the event delete role, use '{}settings seteventdeleterole <role_name>'".format(ctx.prefix))
            await manager.clean_messages() 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def feedback_error(self, ctx, error):
        if isinstance(error, commands.MissingRequiredArgument):
            manager = MessageManager(ctx)
            await manager.send_message("You forgot to include your feedback!")
            await manager.clean_messages() 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def item_error(self, ctx, error):
        if isinstance(error, commands.MissingRequiredArgument):
            manager = MessageManager(ctx)
            await manager.send_message("Oops! You didn't specify a search term.")
            await manager.clean_messages() 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def on_command_error(self, ctx, error):
        if self.check_test_environment(ctx):
            if isinstance(error, commands.MissingRequiredArgument):
                logger.error('[ManageCog on_command_error()] Missing argument: {0}'.format(error.param))
                e_obj = await imported_embed(
                    ctx,
                    author=self.config.get_config_value('bot_profile', 'BOT_NAME'),
                    avatar=self.config.get_config_value('bot_profile', 'BOT_AVATAR'),
                    description="Missing argument: {}".format(error.param)
                )
                if e_obj is not False:
                    await ctx.send(embed=e_obj)
            else:
                # only prints out an error to the log if the string that was entered doesnt contain just "."
                pattern = r'[^\.]'
                if re.search(pattern, str(error)[9:-14]):
                    # author = ctx.author.nick or ctx.author.name
                    # await ctx.send('Error:\n```Sorry '+author+', seems like the command
                    # \"'+str(error)[9:-14]+'\"" doesn\'t exist :(```')
                    if type(error) is discord.ext.commands.errors.CheckFailure:
                        logger.warning(
                            "[ManageCog on_command_error()] user {} "
                            "probably tried to access a command they arent supposed to".format(ctx.author)
                        )
                    else:
                        traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)
                        return

    # this command is used by the TEST guild to create the channel from which this TEST container will process
    # commands 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def on_command_error(ctx, error):
    error_to_skip = [CommandNotFound, MissingRequiredArgument]

    for error_type in error_to_skip:
        if isinstance(error, error_type):
            return

    raise error

# Starting the bot. 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def on_command_error(ctx, error):
    if isinstance(error, commands.CommandNotFound):
        return
    if isinstance(error, commands.MissingRequiredArgument):
        await ctx.send("Missing a required argument.  Do >help")
    if isinstance(error, commands.MissingPermissions):
        await ctx.send("You do not have the appropriate permissions to run this command.")
    if isinstance(error, commands.BotMissingPermissions):
        await ctx.send("I don't have sufficient permissions!")
    else:
        print("error not caught")
        print(error) 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def logs(self, ctx, *, user: User = None):
        """
        Get previous Modmail thread logs of a member.

        Leave `user` blank when this command is used within a
        thread channel to show logs for the current recipient.
        `user` may be a user ID, mention, or name.
        """

        await ctx.trigger_typing()

        if not user:
            thread = ctx.thread
            if not thread:
                raise commands.MissingRequiredArgument(SimpleNamespace(name="member"))
            user = thread.recipient

        default_avatar = "https://cdn.discordapp.com/embed/avatars/0.png"
        icon_url = getattr(user, "avatar_url", default_avatar)

        logs = await self.bot.api.get_user_logs(user.id)

        if not any(not log["open"] for log in logs):
            embed = discord.Embed(
                color=self.bot.error_color,
                description="This user does not have any previous logs.",
            )
            return await ctx.send(embed=embed)

        logs = reversed([log for log in logs if not log["open"]])

        embeds = self.format_log_embeds(logs, avatar_url=icon_url)

        session = EmbedPaginatorSession(ctx, *embeds)
        await session.run() 

# 需要导入模块: from discord.ext import commands [as 别名]
# 或者: from discord.ext.commands import MissingRequiredArgument [as 别名]
def status(self, ctx, *, status_type: str.lower):
        """
        Set a status for the bot.

        Possible status types:
            - `online`
            - `idle`
            - `dnd` or `do not disturb`
            - `invisible` or `offline`

        To remove the current status:
        - `{prefix}status clear`
        """
        if status_type == "clear":
            self.bot.config.remove("status")
            await self.bot.config.update()
            await self.set_presence()
            embed = discord.Embed(title="Status Removed", color=self.bot.main_color)
            return await ctx.send(embed=embed)

        status_type = status_type.replace(" ", "_")
        try:
            status = Status[status_type]
        except KeyError:
            raise commands.MissingRequiredArgument(SimpleNamespace(name="status"))

        _, status = await self.set_presence(status=status)

        self.bot.config["status"] = status.value
        await self.bot.config.update()

        msg = f"Status set to: {status.value}."
        embed = discord.Embed(title="Status Changed", description=msg, color=self.bot.main_color)
        return await ctx.send(embed=embed)