chore: debug the bot so that it starts

Author: rf20008

cogs/debug_cog.py

@@ -326,9 +326,10 @@ async def redis(
                 "This command is restricted to owners only, but you are not an owner"
             )
         if not isinstance(self.bot.cache, RedisCache):
-            raise RuntimeError(
-                "/redis is not supported if the cache is not a RedisCache"
-            )
+            return await inter.send(ErrorEmbed("/redis is not supported if the cache is not a RedisCache"))
+            #raise RuntimeError(
+            #
+            #)
         raise NotImplementedError("This isn't implemented yet")
 
     @commands.is_owner()

cogs/handle_errors.py

@@ -29,7 +29,7 @@
 from disnake.ext.commands import CommandOnCooldown, NotOwner
 
 from helpful_modules._error_logging import log_error
-from helpful_modules.base_on_error import get_git_revision_hash
+from helpful_modules.threads_or_useful_funcs import get_git_revision_hash
 from helpful_modules.cooldowns import OnCooldown
 from helpful_modules.custom_embeds import ErrorEmbed
 

cogs/misc_commands_cog.py

@@ -37,7 +37,7 @@
 from disnake.ext import commands
 
 from helpful_modules import checks, cooldowns, problems_module
-from helpful_modules.base_on_error import get_git_revision_hash
+from helpful_modules.threads_or_useful_funcs import get_git_revision_hash
 from helpful_modules.problems_module.denylistable import DenylistType
 from helpful_modules.custom_bot import TheDiscordMathProblemBot
 from helpful_modules.custom_buttons import *
@@ -159,7 +159,7 @@ async def list_trusted_users(self, inter):
         try:
             result = await self.cache.run_sql(
                 "SELECT * FROM user_data"
-            )  # TODO: support redis + other caches
+            )  # TODO: implement a method called get_all_trusted_users, that is independent of the database
         except problems_module.SQLNotSupportedInRedisException as err:
             raise NotImplementedError(
                 "Redis cache implementation is not yet implemented"
@@ -185,7 +185,7 @@ async def list_trusted_users(self, inter):
                 # A user with this ID does not exist
                 self.bot.trusted_users.remove(user_id)  # delete the user!
                 try:
-                    f = FileSaver(name=4, enabled=True)
+                    f = FileSaver(name=4, enabled=True) # do we even need to do this? we just need to tell the cache to not save it
                     f.save_files(
                         self.bot.cache,
                         vote_threshold=self.bot.vote_threshold,

helpful_modules/base_on_error.py

@@ -39,8 +39,8 @@
     LinearAlgebraUserInputErrorException,
     LockedCacheException
 )
-from error_handler.handle_known_errors import handle_known_error
-from error_handler.handle_unexpected_error import handle_unexpected_error
+from .error_handler.handle_known_errors import handle_known_error
+from .error_handler.handle_unexpected_error import handle_unexpected_error
 from .the_documentation_file_loader import DocumentationFileLoader
 
 
@@ -63,5 +63,5 @@ async def base_on_error(
     known_error_result = handle_known_error(error)
     if known_error_result is not None:
         return known_error_result
-    return handle_unexpected_error(error)
+    return await handle_unexpected_error(inter, error)
 

helpful_modules/custom_bot.py

@@ -45,6 +45,7 @@
 from helpful_modules.restart_the_bot import RestartTheBot
 from helpful_modules.save_files import FileSaver
 from helpful_modules.file_log import AuditLog
+from .rate_limit import RateLimiter
 
 from ._error_logging import log_error
 from .errors import (
@@ -81,10 +82,13 @@ class TheDiscordMathProblemBot(disnake.ext.commands.Bot):
     total_stats: CommandStats | None
     queue: MessageQueue
     closing_things: list[typing.Callable]
-    rate_limiters: list["RateLimiters"]
+    rate_limiters: list["RateLimiter"]
+    global_rate_limiter: RateLimiter
+    appeal_rate_limiter: RateLimiter
 
     def __init__(self, *args, **kwargs):
         self.is_closing = False
+
         self.file_saver = None
         self.appeal_questions = {}
         self.tasks = kwargs.pop("tasks")
@@ -120,6 +124,8 @@ def __init__(self, *args, **kwargs):
         self.total_stats = None
         self.this_session = None
         self.queue = MessageQueue()
+        self.appeal_rate_limiter = RateLimiter(self)
+        self.global_rate_limiter = RateLimiter(self)
         self.initialize_stats()
         # self.trusted_users = kwargs.get("trusted_users", None)
         # if not self.trusted_users and self.trusted_users != []:
@@ -185,7 +191,7 @@ async def on_ready(self):
             await log_error(begroup)
         except Exception as e:
             self.log.exception(
-                "The following exception happened while trying to register appeal views:",
+                f"The following exception happened while trying to register appeal views: {traceback.format_exc()}",
                 e,
             )
             await log_error(e)
@@ -600,32 +606,35 @@ async def on_slash_command_error(self, inter, error):
         if isinstance(error, KeyboardInterrupt):
             raise error
         try:
-            dict_args = await base_on_error(inter, error)
-        except Exception as e:
-            print(traceback.format_exception(e))
-            raise e
-
-        # print(dict_args)
-        try:
-            await inter.send(**dict_args)
-            return
-        except BaseException as be:
-            await log_error(be)
-            # os._exit(1)
-        try:
-            if inter.response.is_done():
-                await inter.followup.send(**dict_args)
-            else:
-                await inter.response.send_message(**dict_args)
-        except AttributeError as err:
-            print(error, err)
-            await log_error(error, f"error_logs/{str(datetime.datetime.now())}")
-            await inter.send(
-                "An error occurred, and the error message couldn't be sent. However, it has been saved!"
-            )
+            try:
+                dict_args = await base_on_error(inter, error)
+            except Exception as e:
+                print(traceback.format_exception(e))
+                raise e
 
+            print(dict_args)
+            try:
+                await inter.send(**dict_args)
+                return
+            except BaseException as be:
+                await log_error(be)
+                # os._exit(1)
+            try:
+                if inter.response.is_done():
+                    await inter.followup.send(**dict_args)
+                else:
+                    await inter.response.send_message(**dict_args)
+            except AttributeError as err:
+                print(error, err)
+                await log_error(error, f"error_logs/{str(datetime.datetime.now())}")
+                await inter.send(
+                    "An error occurred, and the error message couldn't be sent. However, it has been saved!"
+                )
             raise ExceptionGroup(error, err)
-
+        except Exception as e:
+            await inter.send("An unexpected error occurred.")
+            await log_error(e, f"error_logs/{str(datetime.datetime.now())}")
+            print("\n".join(traceback.format_exception(e)))
     async def on_error(self, event, *args, **kwargs):
         print(f"Error in {event}... uh oh", file=stderr)
         error = sys.exc_info()

helpful_modules/problems_module/cache/problems_related_cache.py

@@ -74,7 +74,7 @@ def __init__(
         # make_sql_table([], db_name = sql_dict_db_name)
         # make_sql_table([], db_name = "MathProblemCache1.db", table_name="kv_store")
         if use_sqlite:
-            warnings.warn("Sqlite has been deprecated. Use MySQL instead.")
+            warnings.warn("Sqlite has been deprecated. Use MySQL instead.", stacklevel=2)
         self.db_name = db_name
         self.db = db_name
         if warnings_or_errors not in ["warnings", "errors"]:

helpful_modules/rate_limit.py

@@ -11,7 +11,7 @@
 
 from .circular_deque import CircularDeque
 from .problems_module import UserData, DenylistType
-from .custom_bot import TheDiscordMathProblemBot
+#from .custom_bot import TheDiscordMathProblemBot
 from .threads_or_useful_funcs import first_true, last_true
 
 ONE_SECOND = 1
@@ -36,7 +36,7 @@ def get_command_name(inter: disnake.ApplicationCommandInteraction):
 
 async def autoban(
     user: disnake.User,
-    bot: TheDiscordMathProblemBot,
+    bot: "TheDiscordMathProblemBot",
     duration: float = 30.0,
     reason: str = "You've been temporarily denylisted for using the bot too much recently. ",
 ):
@@ -87,12 +87,13 @@ class RateLimiter:  # todo: more rate limits
 
     def __init__(
         self,
-        bot: TheDiscordMathProblemBot,
+        bot: "TheDiscordMathProblemBot",
         *,
         global_limit: RateLimit | None = None,
         user_limits: list[RateLimit] | None = None,
         does_user_bypass: typing.Callable[[int], bool] | None = None,
     ):
+        from .custom_bot import TheDiscordMathProblemBot # avoid circular import
         if not isinstance(bot, TheDiscordMathProblemBot):
             raise TypeError("Bot must be of type TheDiscordMathProblemBot.")
         self.bot = bot
@@ -154,6 +155,7 @@ async def maybe_await(self, func, *args, **kwargs):
 
     async def __call__(self, inter) -> str:
         """Return whether inter causes the user to be denylisted. If False, means"""
+        from .custom_bot import TheDiscordMathProblemBot # avoid circular import
         author_id = inter.author.id
         cur_time = time.time()
         if await self.will_bypass(author_id):
@@ -214,9 +216,10 @@ async def __call__(self, inter) -> str:
         return ""
 
 
-global_rate_limiter = RateLimiter()
-appeal_rate_limiter = RateLimiter()
-
+#global_rate_limiter = RateLimiter()
+#appeal_rate_limiter = RateLimiter()
+global_rate_limiter = None
+appeal_rate_limiter = None
 
 class RateLimitedException(disnake.ext.commands.CheckFailure):
     """Raised when someone tries to run a command, but they're rate limited"""
@@ -226,6 +229,7 @@ class RateLimitedException(disnake.ext.commands.CheckFailure):
 
 def rate_limit_check():
     async def predicate(inter: disnake.ApplicationCommandInteraction):
+        from .custom_bot import TheDiscordMathProblemBot
         if not isinstance(inter.bot, TheDiscordMathProblemBot):
             await inter.send("The bot ran into an error.")
             raise TypeError()
@@ -259,11 +263,11 @@ async def predicate(inter: disnake.ApplicationCommandInteraction):
             )
             raise e
         if "appeal" not in command_name:
-            global_rate_limited_msg = global_rate_limiter(inter)
+            global_rate_limited_msg = await inter.bot.global_rate_limiter(inter)
             if global_rate_limited_msg:
-                raise RateLimitedException(global_rate_limited_msg)  # type: ignore
+                raise RateLimitedException(str(global_rate_limited_msg))  # type: ignore
         else:
-            appeal_rate_limited_msg = appeal_rate_limiter(inter)
+            appeal_rate_limited_msg = await inter.bot.appeal_rate_limiter(inter)
             if appeal_rate_limited_msg:
                 raise RateLimitedException(appeal_rate_limited_msg)  # type: ignore
         return True

helpful_modules/the_documentation_file_loader.py

@@ -44,14 +44,14 @@ def __init__(self):
         # this is deprecated
         warnings.warn(
             category=DeprecationWarning,
-            stacklevel=-1,
+            stacklevel=2,
             message="The DocumentationFileLoader is being deprecated",
         )
 
     def _load_documentation_file(self):
         warnings.warn(
             category=DeprecationWarning,
-            stacklevel=-1,
+            stacklevel=2,
             message="The DocumentationFileLoader is being deprecated",
         )
         with open("docs/documentation.json", "r") as file:
@@ -60,7 +60,7 @@ def _load_documentation_file(self):
     def load_documentation_into_readable_files(self):
         warnings.warn(
             category=DeprecationWarning,
-            stacklevel=-1,
+            stacklevel=2,
             message="The DocumentationFileLoader is being deprecated",
         )
         dictToStoreFileContent = {}