Bug Command Tests, small cleanup, discord webhook for errors.

Author: MrChuw

bot/bot.py

@@ -1,9 +1,7 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 
-import asyncio
 import datetime
-from asyncio import Task
 from collections import defaultdict
 from logging import Logger
 from typing import TYPE_CHECKING, Callable
@@ -24,12 +22,11 @@
     LifecycleHandler,
     TokensHandler,
 )
-from bot.utils import Cache, Config, MarkovProcessor, MemCache, TimeTools
+from bot.utils import Cache, Config, MemCache, TimeTools
 
 if TYPE_CHECKING:
     # from bot.api import api, api_start
-    from bot.ext import Context, Routine
-    from bot.models import Channel as ChannelModel
+    from bot.ext import Context
 
 
 class Gorenmu(TypesBot):
@@ -43,37 +40,20 @@ def __init__(self, configs: Config, case_insensitive: bool, log: Logger, adapter
             adapter=adapter,
         )
         self.boot: datetime.datetime = datetime.datetime.now(datetime.timezone.utc)
-        self.lottery_lock: asyncio.Lock = asyncio.Lock()
-        self.channels: dict[str, ChannelModel] = {}
-        self.routines: list[Routine] = []
-        self.bots_ids: list[int] = []
         self.manual_events: defaultdict[str, dict[str, dict[str, Callable]]] = defaultdict(lambda: defaultdict(dict))
         # self.api: api | None = None
         # self.api_start: api_start = None
-        self.MarkovProcessor: MarkovProcessor | None = None
-        self.MarkovTask: Task[None] | None = None
-        self.dev_name: str | None = None
-        self.bot_nick: str | None = None
         self.log: Logger = log
         self.config: Config = configs
         self.memcache: MemCache = MemCache()
-        # self.StringTools: StringTools = StringTools()
         self.cache: RedisCache | MemcachedCache | SimpleMemoryCache = Cache.cache_load(bot=self)
-        # self.docs_handler: DynamicDescriptions = DynamicDescriptions(self)
-        # self.UploadThings: UploadThings = UploadThings(self)
-        self.docs: defaultdict = defaultdict(dict)
-
-        # self.SessionsCaches: SessionsCaches = SessionsCaches(self)
-        # self.TranslationManager: TranslationManager = TranslationManager()
-        # self.Emotes: Emotes = Emotes(bot=self)
         self.TokensHandler: TokensHandler = TokensHandler(bot=self)
         self.DatabaseHandler: DatabaseHandler = DatabaseHandler(bot=self)
         self.ChannelHandler: ChannelHandler = ChannelHandler(bot=self)
         self.CommandHandler: CommandHandler = CommandHandler(bot=self)
         self.LifecycleHandler: LifecycleHandler = LifecycleHandler(bot=self)
         self.ContextHandler: ContextHandler = ContextHandler(bot=self)
         self.TimeTools: TimeTools = TimeTools()
-        self.mock: bool = False
 
     async def add_token(self, token: str, refresh: str) -> twitchio.authentication.ValidateTokenPayload:
         return await self.TokensHandler.add_token(token, refresh)

bot/cogs/admin/commands/admin.py

@@ -92,18 +92,6 @@ async def reload(self, ctx: Context, command: str, *, extras=False) -> Response:
                 "class": "CommandHandler",
                 "args": [self.bot],
             },
-            "session_caches": {
-                "attr": "SessionsCaches",
-                "module": "bot.utils.cache_sessions",
-                "class": "SessionsCaches",
-                "args": [self.bot],
-            },
-            "string_mani": {
-                "attr": "StringTools",
-                "module": "bot.utils.string_manipulation",
-                "class": "StringTools",
-                "args": [],
-            },
         }
 
         if command == "commands":

bot/cogs/admin/commands/translations.py

@@ -53,6 +53,8 @@ def deco_commands(self, ctx: Context, *args, **kwargs) -> CommandExemples:  # NO
         def deco_admonitions(self, ctx: Context, *args, **kwargs) -> Admonitions:  # NOQA
             return Admonitions([])
 
+    Nada: Nada
+
     class Restart(TBase):
         def __init__(self):
             super().__init__()
@@ -96,6 +98,8 @@ def deco_admonitions(self, ctx: Context, *args, **kwargs) -> Admonitions:
                 self.lang_dict.add_with(["pt_br", "pt"], Admonitions([]))
             return self._untangle_admonitions(ctx, "admonitions")
 
+    Restart: Restart
+
     class Reload(TBase):
         def __init__(self):
             super().__init__()
@@ -220,3 +224,5 @@ def deco_admonitions(self, ctx: Context, *args, **kwargs) -> Admonitions:
                 self.lang_dict.add_with("en", Admonitions([]))
                 self.lang_dict.add_with(["pt_br", "pt"], Admonitions([]))
             return self._untangle_admonitions(ctx, "admonitions")
+
+    Reload: Reload

bot/ext/bot.py

@@ -1,15 +1,31 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 
+import asyncio
+from asyncio import Task
 from typing import TYPE_CHECKING, Optional
 
 from twitchio.ext import commands
 
 if TYPE_CHECKING:
-    from bot.ext import commands
+    from bot.ext import Routine, commands
     from bot.ext.commands import Command, Group
+    from bot.models import Channel as ChannelModel
+    from bot.utils import MarkovProcessor
 
 
 class TypesBot(commands.AutoBot):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.MarkovProcessor: MarkovProcessor | None = None
+        self.MarkovTask: Task[None] | None = None
+        self.dev_name: str | None = None
+        self.bot_nick: str | None = None
+        self.mock: bool = False
+        self.lottery_lock: asyncio.Lock = asyncio.Lock()
+        self.channels: dict[str, ChannelModel] = {}
+        self.routines: list[Routine] = []
+        self.bots_ids: list[int] = []
+
     def get_command(self, name: str, /) -> Optional[Command | Group]:
         return super().get_command(name)

bot/ext/commands.py

@@ -98,33 +98,20 @@ def __new__(cls, *args, **kwargs) -> Self:
         rate = getattr(self, "cooldown_rate", 10)
         per = getattr(self, "cooldown_per", 3)
         key = getattr(self, "cooldown_key", BucketType.user)
-        bucket_: Bucket[Context] = Bucket.from_cooldown(base=Cooldown, key=key, **{"per": per, "rate": rate})
+        bucket_: Bucket[Context] = Bucket.from_cooldown(base=Cooldown, key=key, **{"per": per, "rate": rate})  # NOQA
         category_name: str = getattr(self, "name", self.__class__.__name__)
         category_name = category_name.removesuffix("Cmd").removesuffix("Cmds")
         self.inject_events(bot, cls, self, category_name)
         for command_name in self.__all_commands__:
             command_: Command = self.__all_commands__[command_name]
             if hasattr(command_, "commands"):
                 for name in command_.commands:
-                    self._extras(command_.commands[name], bucket_, bot)
-                    bot.docs[category_name][command_.commands[name].name] = command_.commands[name].docs
-            self._extras(command_, bucket_, bot)
-            bot.docs[category_name][command_.name] = command_.docs
+                    if len(command_.commands[name]._buckets) == 0:  # NOQA
+                        command_.commands[name]._buckets.append(bucket_)  # NOQA
+            if len(command_._buckets) == 0:  # NOQA
+                command_._buckets.append(bucket_)  # NOQA
         return self
 
-    @staticmethod
-    def _extras(new_command: Command, bucket_, bot: Gorenmu):
-        if len(new_command._buckets) == 0:  # NOQA
-            new_command._buckets.append(bucket_)  # NOQA
-
-        def docs():
-            if new_command.template:
-                return bot.docs_handler.template_description(new_command)
-            else:
-                return bot.docs_handler.normal_description(new_command)
-
-        new_command.docs = docs
-
     @staticmethod
     def inject_events(bot, cls, self, category_name):
         if category_name in bot.manual_events:
@@ -137,15 +124,6 @@ def inject_events(bot, cls, self, category_name):
             bot.manual_events[category_name][event_name][name] = injected
 
 
-def base_decorator(base: str, template=False) -> Callable[[Command], Command]:
-    def decorator(command: Command) -> Command:  # NOQA
-        command.decorator_path = base
-        command.template = template
-        return command
-
-    return decorator
-
-
 def command(
     name: str | None = None,
     aliases: list[str] | None = None,
@@ -239,12 +217,3 @@ def decorator(func: Callable):
         return func
 
     return decorator
-
-
-# def event_handler(event_name: str):
-#     def decorator(func: Callable):
-#         async def wrapper(self, *args, **kwargs):
-#             return await func(self, *args, **kwargs)
-#         wrapper._event_info = event_name
-#         return wrapper
-#     return decorator

bot/handlers/command_handler.py

@@ -3,9 +3,10 @@
 
 import os
 import pathlib
+import traceback
 import types
 from importlib import import_module
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from loguru import logger
 from twitchio.ext.commands import CommandErrorPayload
@@ -15,6 +16,7 @@
 
 if TYPE_CHECKING:
     from bot.bot import Gorenmu
+    from bot.cogs.bug.command.bug import BugCmd
     from bot.ext import Context
 
 
@@ -103,6 +105,29 @@ def _get_module(path: pathlib.Path, filename: pathlib.Path) -> tuple[types.Modul
         module: types.ModuleType = import_module(name, package=package)
         return module, name
 
+    async def send_bug(self, ctx: Context, error: Exception):
+        command = self.bot.get_command("bug")
+        url = self.bot.config.Discord.log_webhook
+        component: BugCmd = command.component  # NOQA
+        session = component.SessionsCaches.Bug.session
+        discord_webhook = component.DiscordWebHook
+        tb_str = "".join(traceback.format_exception(type(error), error, error.__traceback__))
+        user_url = f"[@{ctx.author.name}](<https://twitch.tv/{ctx.author.name}>)"
+        channel_url = f"[#{ctx.channel.name}](<https://twitch.tv/{ctx.channel.name}>)"
+        await discord_webhook.send_discord_webhook(
+            session,
+            url,
+            ctx,
+            f"**Args used in the command:** **```{ctx.message.text}```**\n```py\n{tb_str}\n```",
+            f"Error occurred while user {user_url} "
+            f"was running the command: {ctx.command.name} "
+            f"in {channel_url} channel.",
+            f"https://twitch.tv/{ctx.author.name}",
+            title2=f"Error occurred while user @{ctx.author.name} "
+            f"was running the command: {ctx.command.name} "
+            f"in #{ctx.channel.name} channel.",
+        )
+
     async def event_command_error(self, payload: CommandErrorPayload) -> None:
         command = payload.context.command
         if command and command.has_error and payload.context.error_dispatched:
@@ -115,6 +140,10 @@ async def event_command_error(self, payload: CommandErrorPayload) -> None:
         if ctx.prefix != self.bot.channels[ctx.channel.name].prefix:
             return None
         translations = ctx.command.component.translations
+
+        if not isinstance(error, InvalidArgument):
+            await self.send_bug(ctx, error)
+
         if isinstance(error, CommandNotFound):
             return None
         if isinstance(error, DevRequired):

bot/utils/discord_webhook.py

@@ -23,6 +23,7 @@ async def send_discord_webhook(
         title: str,
         author_url: str,
         embeds: list[DiscordEmbed] = None,
+        title2: str = None,
     ) -> aiohttp.ClientResponse:
         to_mark = ctx.bot.config.Discord.to_mark
         avatar_webhook = ctx.bot.config.Discord.webhook_avatar
@@ -40,7 +41,7 @@ async def send_discord_webhook(
         )
         embed = DiscordEmbed()
         embed.set_author(name=display_name, url=author_url, icon_url=profile_image)
-        embed.set_title(title)
+        embed.set_title(title2 or title)
         embed.set_description(f"{content}\n\n{log_url1}\n{log_url2}\n{log_url3}")
         embed.set_timestamp(ctx.message.timestamp)
         embed.set_color(ctx.author.color.hex or "03b2f8")

tests/tests/cogs/bug/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

tests/tests/cogs/bug/bug/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

tests/tests/cogs/bug/bug/test_bug.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+import pytest_asyncio
+
+from bot.cogs.bug.command.bug import BugCmd
+from tests.helpers.mock_classes import MockContext
+
+from .test_params import Params
+
+
+@pytest_asyncio.fixture
+async def interact(mock_bot):
+    return BugCmd(bot=mock_bot)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("lang, helper, usage", Params.decorators)
+async def test_decorators(interact, mock_context: MockContext, lang: str, helper: str, usage: str):
+    await mock_context.prepare_context(lang)
+    mock_context.Asserter.assert_string(interact.translations.Bug.deco_usage(mock_context, "+"), usage, strict=True)
+    mock_context.Asserter.assert_string(interact.translations.Bug.deco_helper(mock_context, "+"), helper, strict=True)
+
+
+# To lazy to make this tests too.
+
+# async def base_bug(
+#     interact, mock_context: MockContext, lang: str, content: str, expected: str = None, re_expected: str = None, success: bool = False
+# ):
+#     await mock_context.prepare_context(lang)
+#     response: Response = await interact.bug._callback(interact, mock_context, content=content)  # NOQA
+#     mock_context.Asserter.assert_string(response.response_string, expected=expected, re_expected=re_expected)
+#     mock_context.Asserter.assert_boolean(response.success, success)
+#
+#
+# @pytest.mark.asyncio
+# @pytest.mark.parametrize("lang, expected", Params.no_content)
+# async def test_no_content(interact, mock_context: MockContext, lang: str, expected: str):
+#     await base_bug(
+#         interact,
+#         mock_context,
+#         lang=lang,
+#         content="",
+#         expected=expected,
+#         success=True
+#     )
+#
+#
+# @pytest.mark.asyncio
+# @pytest.mark.parametrize("lang, expected", Params.no_content)
+# async def test_(interact, mock_context: MockContext, lang: str, expected: str):
+#     await base_bug(
+#         interact,
+#         mock_context,
+#         lang=lang,
+#         content="",
+#         expected=expected,
+#         success=True
+#     )