Chore: Fix the queues & split the error handlers & fix some errors

Author: rf20008

cogs/config_cog.py

@@ -47,17 +47,17 @@ def __init__(self, bot: TheDiscordMathProblemBot):
         self.cache: problems_module.MathProblemCache = bot.cache
 
     async def sync_check(
-        self, inter: GuildCommandInteraction, cache_name: str, role: Role
+        self, inter: GuildCommandInteraction, check_name: str, role: Role
     ):
-        if cache_name not in CHECKS:
+        if check_name not in CHECKS:
             return await inter.send("This is not a valid check!")
 
         # TODO: Refactor - don't use setattr
         data = await self.cache.get_guild_data(
             guild_id=inter.guild_id, default=GuildData.default(inter.guild_id)
         )
         try:
-            check = getattr(data, cache_name)  # Get the check
+            check = getattr(data, check_name)  # Get the check
             role_permissions = role.permissions  # Cache the permissions
             check.permissions = [
                 name

helpful_modules/actual_restarter.py

@@ -45,6 +45,7 @@
 
 
 def start():
+    raise NotImplementedError("This function does not work as written. It should be rewritten to use os.execv()")
     print(f"Hello from my subprocess! My PID is {os.getpid()}")
     print(f"{main_script_path}")
 

helpful_modules/base_on_error.py

@@ -37,155 +37,31 @@
 from .custom_embeds import ErrorEmbed, SimpleEmbed, SuccessEmbed
 from .problems_module.errors import (
     LinearAlgebraUserInputErrorException,
-    LockedCacheException,
+    LockedCacheException
 )
+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
 
 
-def get_git_revision_hash() -> str:
-    """A method that gets the git revision hash. Credit to https://stackoverflow.com/a/21901260 for the code :-)"""
-    return subprocess.check_output(
-        ["git", "rev-parse", "HEAD"], encoding="ascii", errors="ignore"
-    ).strip()[
-        :7
-    ]  # [7:] is here because of the commit hash, the rest of this function is from stack overflow
+
+
+
 
 
 async def base_on_error(
     inter: disnake.ApplicationCommandInteraction, error: BaseException | Exception
 ):
     """The base on_error event. Call this and use the dictionary as keyword arguments to print to the user"""
-    print("OH NO AN ERROR OCCURED!!!!")
+    print("OH NO AN ERROR OCCURRED!!!!")
     if isinstance(error, BaseException) and not isinstance(error, Exception):
         # Errors that do not inherit from Exception are not meant to be caught
         await inter.bot.close()
         if exc_info()[0] is not None:
             raise
         raise error
-    cause = None
-    if error.__context__ is not None:
-        cause = error.__context__
-    print(cause, error, inter)
-    if isinstance(error, LockedCacheException):
-        return {
-            "content": "The bot's cache's lock is currently being held. Please try again later."
-        }
-    # print(isinstance(cause, LinearAlgebraUserInputErrorException))
-    # print(type(cause))
-    if isinstance(error, LinearAlgebraUserInputErrorException):
-        return {"embed": ErrorEmbed(str(cause))}
-    if isinstance(error, (OnCooldown, disnake.ext.commands.CommandOnCooldown)):
-        # This is a cooldown exception
-        content = f"This command is on cooldown; please retry **{disnake.utils.format_dt(disnake.utils.utcnow() + datetime.timedelta(seconds=error.retry_after), style='R')}**."
-        return {"content": content, "delete_after": error.retry_after}
-    if isinstance(error, (disnake.Forbidden,)):
-        extra_content = """There was a 403 error. This means either
-        1) You didn't give me enough permissions to function correctly, or
-        2) There's a bug! If so, please report it!
-
-        The error traceback is below."""
-        error_traceback = "\n".join(traceback.format_exception(error))
-        paginator = PaginatorView.paginate(
-            user_id=inter.author.id,
-            text=extra_content + error_traceback,
-            breaking_chars="\n",
-            max_page_length=1900,
-            special_color=disnake.Color.red(),
-        )
-        return {"embed": paginator.create_embed(), "view": paginator}
-
-    if isinstance(error, commands.NotOwner):
-        return {"embed": ErrorEmbed("You are not the owner of this bot.")}
-    if isinstance(error, disnake.ext.commands.errors.CheckFailure):
-        return {"embed": ErrorEmbed(str(error))}
-
-    # Embed = ErrorEmbed(custom_title="⚠ Oh no! Error: " + str(type(error)), description=("Command raised an exception:" + str(error)))
-    logging.error("Uh oh - an error occurred ", exc_info=exc_info())
-    error_traceback = "\n".join(traceback.format_exception(error))
-    print(
-        "\n".join(traceback.format_exception(error)),  # python 3.10 only!
-        file=stderr,
-    )
-
-    error_msg = """An error occurred!
-
-    Steps you should do:
-    1) Please report this bug to me! (Either create a github issue, or report it in the support server)
-    2) If you are a programmer, please suggest a fix by creating a Pull Request.
-    3) Please don't use this command until it gets fixed in a later update!
-
-    The error traceback is shown below; this may be removed/DMed to the user in the future.
-
-    """  # TODO: update when my support server becomes public & think about providing the traceback to the user
-    traceback_msg = disnake.utils.escape_markdown(error_traceback)
-    additional_error = ""
-    try:
-        await log_error(error)  # Log the error
-    except Exception as log_error_exc:
-        additional_error = (
-            """Additionally, while trying to log this error, the following exception occurred: \n"""
-            + disnake.utils.escape_markdown(
-                "\n".join(traceback.format_exception(log_error_exc))
-            )
-        )
-
-    try:
-        embed = disnake.Embed(
-            colour=disnake.Colour.red(),
-            description=error_msg + traceback_msg + additional_error,
-            title="Oh, no! An error occurred!",
-        )
-    except (TypeError, NameError) as e:
-        # send as plain text
-        plain_text = (
-            """Oh no! An Exception occurred! And it couldn't be sent as an embed!```"""
-        )
-        plain_text += error_msg + traceback_msg + additional_error
-        plain_text += f"```Time: {str(asctime())} Commit hash: {get_git_revision_hash()} The stack trace is shown for debugging purposes. The stack trace is also logged (and pushed), but should not contain identifying information (only code which is on github)"
-
-        plain_text += f"Error that occurred while attempting to send it as an embed:"
-        plain_text += disnake.utils.escape_markdown(
-            "".join(traceback.format_exception(e))
-        )[: -(1650 - len(plain_text))]
-        the_new_exception = deepcopy(e)
-        the_new_exception.__cause__ = error
-        if len(plain_text) > 2000:
-            # uh oh
-            raise RuntimeError(
-                "An error occurred; could not send it as an embed nor as plain text!"
-            ) from the_new_exception
-
-        return {"content": plain_text}
-    footer = f"Time: {str(asctime())} Commit hash: {get_git_revision_hash()} The stack trace is shown for debugging purposes. The stack trace is also logged (and pushed), but should not contain identifying information (only code which is on github)"
-    embed.set_footer(text=footer)
-    if len(embed.description) < 2048:
-        return {"embed": embed}
-    paginator = PaginatorView.paginate(
-        user_id=inter.author.id,
-        text=error_msg,
-        breaking_chars="\n",
-        max_page_length=1900,
-        special_color=disnake.Color.red(),
-    )
-    paginator.add_pages(
-        PaginatorView.break_into_pages(
-            traceback_msg, max_page_length=1900, breaking_chars="\n"
-        )
-    )
-    if additional_error:
-        paginator.add_pages(
-            PaginatorView.break_into_pages(
-                additional_error, max_page_length=1900, breaking_chars="\n"
-            )
-        )
-    accounted_for = len(error_msg) + len(traceback_msg) + len(additional_error)
-    if len(embed.description) != accounted_for:
-        paginator.add_pages(
-            PaginatorView.break_into_pages(
-                embed.description[accounted_for:],
-                max_page_length=1900,
-                breaking_chars="\n",
-            )
-        )
-    first_page = paginator.create_embed()
-    return {"embed": first_page, "view": paginator}
+    known_error_result = handle_known_error(error)
+    if known_error_result is not None:
+        return known_error_result
+    return handle_unexpected_error(error)
+

helpful_modules/changelog.py

@@ -19,6 +19,7 @@
 
 import datetime
 import io
+import asyncio
 import json
 import typing as t
 
@@ -27,7 +28,7 @@ class ChangeLogEntry:
     def __init__(
         self, *, patchNotes: t.List[str], old: str, new: str, date_released: str
     ):
-        self.patchNotes = "\n".join[patchNotes]
+        self.patchNotes = "\n".join(patchNotes)
         self.patch_notes = patchNotes
         self.old_version = old
         self.new_version = new
@@ -41,15 +42,15 @@ def __init__(
     def to_dict(self) -> dict:
         return {
             "patch_notes": "\n".split(self.patchNotes),
-            "old": self.old_verison,
+            "old": self.old_version,
             "new": self.new_version,
             "date_released": self.date_released.totimestamp(
                 tzinfo=datetime.timezone.utc
             ),
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> "ChangelogEntry":
+    def from_dict(cls, data: dict) -> "ChangeLogEntry":
         return cls(
             patchNotes=data["patch_notes"],
             old=data["old"],
@@ -66,7 +67,7 @@ def __init__(self, file_name: str):
             asyncio.run(self._open_file())
         except FileNotFoundError:
             raise ValueError("File not found.")
-        self._changelogs: t.List[ChangelogEntry] = []
+        self._changelogs: t.List[ChangeLogEntry] = []
 
     async def _open_file(
         self,
@@ -88,7 +89,7 @@ def func(file):
             entries = json.load(file)
             changelogs = []
             for entry in entries.values():
-                changelogs.append(ChangelogEntry.from_dict(entry))
+                changelogs.append(ChangeLogEntry.from_dict(entry))
             return changelogs
 
         self._changelogs = await self._open_file(func=func, mode="r")
@@ -100,7 +101,7 @@ def func(file: io.TextIOWrapper, data: dict):
 
         return await self._open_file(func=func, mode="w", args=[new])
 
-    async def add_changelog(self, item: ChangelogEntry):
+    async def add_changelog(self, item: ChangeLogEntry):
         data = await self.load_files()
         data.append(item.to_dict())
 
@@ -113,6 +114,6 @@ def func(file, _data):
     async def create_changelog(self, data: dict):
         # TODO: finish
         try:
-            return ChangelogEntry(*data)
+            return ChangeLogEntry(**data)
         except BaseException as exc:
             raise RuntimeError("Could not convert it to a dictionary") from exc

helpful_modules/checks.py

@@ -272,7 +272,7 @@ async def predicate(inter: disnake.ApplicationCommandInteraction):
                 try:
                     if int(it) >= max_num:
                         return False
-                except:
+                except ValueError:
                     pass
                 for i in it.split():
                     try:
@@ -319,9 +319,9 @@ async def predicate(inter: disnake.ApplicationCommandInteraction):
                 extra_info={},
             )
             return True
-        except:
-            exit()
-
+        except Exception as e:
+            traceback.print_exception(e)
+            return True
     return commands.check(predicate)
 
 

helpful_modules/custom_bot.py

@@ -655,7 +655,7 @@ async def on_connect(self):
         self.log.debug(
             "Deleting data from guilds the bot was kicked from while it was offline"
         )
-        bot_guild_ids = [guild.id for guild in self.guilds]
+        bot_guild_ids = set(guild.id for guild in self.guilds) # we make it a set because checking membership in a set is O(1)
         # The guild_ids of the guilds that the bot is in
         for guild_id in await self.cache.get_guilds():
             # Obtain all guilds the cache stores data (will need to be upgraded.)

helpful_modules/error_handler/__init__.py

@@ -0,0 +1,56 @@
+# This module is licensed under AGPLv3 (This includes everything in this file.)
+
+# You can distribute any version of the Software created and distributed *before* 23:17:55.00 July 28, 2024 GMT-4
+# under the GNU General Public License version 3 or at your option, any  later option.
+# But versions of the code created and/or distributed *on or after* that date must be distributed
+# under the GNU *Affero* General Public License, version 3, or, at your option, any later version.
+#
+# This file and this module are part of The Discord Math Problem Bot Repo
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+# Author: Samuel Guo (64931063+rf20008@users.noreply.github.com)
+import datetime
+
+import disnake
+from disnake.ext import commands
+
+
+from ..threads_or_useful_funcs import get_error_cause
+from ..cooldowns import OnCooldown
+from ..custom_embeds import ErrorEmbed
+from ..problems_module.errors import (
+    LinearAlgebraUserInputErrorException,
+    LockedCacheException,
+)
+def handle_known_error(error: BaseException | Exception) -> dict[str, str | disnake.Embed | int] | None:
+    cause = get_error_cause(error)
+    if isinstance(error, LockedCacheException):
+        return {
+            "content": "The bot's cache's lock is currently held. Please try again later."
+        }
+    # print(isinstance(cause, LinearAlgebraUserInputErrorException))
+    # print(type(cause))
+    if isinstance(error, LinearAlgebraUserInputErrorException):
+        return {"embed": ErrorEmbed(str(cause))}
+    if isinstance(error, (OnCooldown, disnake.ext.commands.CommandOnCooldown)):
+        # This is a cooldown exception
+        content = f"This command is on cooldown; please retry **{disnake.utils.format_dt(disnake.utils.utcnow() + datetime.timedelta(seconds=error.retry_after), style='R')}**."
+        return {"content": content, "delete_after": error.retry_after}
+    if isinstance(error, commands.NotOwner):
+        return {"embed": ErrorEmbed("You are not the owner of this bot.")}
+    if isinstance(error, disnake.ext.commands.errors.CheckFailure):
+        return {"embed": ErrorEmbed(str(error))}
+    return None
+