I’m working on a Discord bot and I’m stuck on error handling. I want to send error messages to users from lower-level functions that don’t have access to the context object. These functions mainly deal with data processing.
I’ve tried using CommandError, but it stops the execution flow. I also don’t want to pass the context through every function as it feels messy.
Here’s a simplified version of what I’ve tried:
def process_data(data):
if data_is_invalid(data):
raise CustomError('Invalid data')
# More processing...
@bot.command()
async def my_command(ctx, data):
try:
process_data(data)
except CustomError as e:
await ctx.send(str(e))
@bot.event
aasync def on_error(event, *args, **kwargs):
if isinstance(error, CustomError):
# How to send message to the right user/channel?
Is there a clean way to handle errors and send messages without context in lower-level functions? Any ideas would be appreciated!
yo, have u tried using a global variable for error messages? like, make a dict or smthin to store errors with unique IDs. then ur lower funcs can add to it without needing context. in ur command func, u can check if theres any errors for that command and send em. its pretty simple and keeps things clean
I’ve encountered a similar issue with my Discord bots. My solution was to set up a global error queue where lower-level functions can add error messages without needing direct access to the context. Instead of throwing exceptions that disrupt the flow, the lower functions simply append any error information to the queue. Then, inside the command function, I check the queue after the data processing finishes. If there are errors, I send their messages and clear the queue. This approach keeps the code modular and avoids cluttering function signatures with context parameters.
One approach I’ve found effective is using a custom error handler decorator. You can create a decorator that wraps your command functions and catches specific exceptions. This way, your lower-level functions can raise custom exceptions, and the decorator handles sending the error message to the user.
Here’s a basic implementation:
def error_handler():
def decorator(func):
async def wrapper(ctx, *args, **kwargs):
try:
return await func(ctx, *args, **kwargs)
except CustomError as e:
await ctx.send(str(e))
return wrapper
return decorator
@bot.command()
@error_handler()
async def my_command(ctx, data):
process_data(data)
This keeps your code clean and allows lower-level functions to raise exceptions without worrying about context. The error handling logic stays centralized in the decorator.