fixed all the bugs

AbstractUmbra · AbstractUmbra · commit 39fb0ee46b1b · 2023-06-03T12:36:12.000+01:00
diff --git a/bot.py b/bot.py
@@ -20,11 +20,14 @@
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 """
+from __future__ import annotations
+
+import asyncio
 import json
 import pathlib
 from asyncio import Queue
 from collections import deque
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import aiohttp
 import asyncpg
@@ -38,12 +41,16 @@
 from modules import EXTENSIONS
 
 
+if TYPE_CHECKING:
+    from logging import LogRecord
+
+
 class Bot(commands.Bot):
     session: aiohttp.ClientSession
     pool: asyncpg.Pool[asyncpg.Record]
     log_handler: LogHandler
     mb_client: mystbin.Client
-    logging_queue: Queue[str]
+    logging_queue: Queue[LogRecord]
 
     __slots__ = (
         "session",
@@ -67,15 +74,12 @@ async def get_context(self, message: discord.Message | discord.Interaction) -> C
     async def on_ready(self) -> None:
         """On Bot ready - cache is built."""
         assert self.user
-        print(f"Online. Logged in as {self.user.name} || {self.user.id}")
+        self.log_handler.info("Online. Logged in as %s || %s", self.user.name, self.user.id)
 
     async def on_socket_response(self, message: Any) -> None:
         """Quick override to log websocket events."""
         self._previous_websocket_events.append(message)
 
-    async def setup_hook(self) -> None:
-        self.session = aiohttp.ClientSession()
-
     async def start(self, token: str, *, reconnect: bool = True) -> None:
         try:
             await super().start(token=token, reconnect=reconnect)
@@ -99,7 +103,7 @@ async def close(self) -> None:
 async def main() -> None:
     async with Bot() as bot, aiohttp.ClientSession() as session, asyncpg.create_pool(
         dsn=CONFIG["DATABASE"]["dsn"]
-    ) as pool, LogHandler() as handler:
+    ) as pool, LogHandler(bot=bot) as handler:
         bot.logging_queue = Queue()
         bot.session = session
         bot.pool = pool
@@ -117,3 +121,6 @@ async def main() -> None:
             )
 
         await bot.start(CONFIG["TOKENS"]["bot"])
+
+
+asyncio.run(main())
diff --git a/core/context.py b/core/context.py
@@ -5,6 +5,7 @@
 import discord
 from discord.ext import commands
 
+
 if TYPE_CHECKING:
     from bot import Bot
 
@@ -13,8 +14,8 @@
     "Interaction",
 )
 
-Interaction: TypeAlias = discord.Interaction[Bot]
+Interaction: TypeAlias = discord.Interaction["Bot"]
 
 
-class Context(commands.Context[Bot]):
+class Context(commands.Context["Bot"]):
     pass
diff --git a/core/utils/logging.py b/core/utils/logging.py
@@ -3,26 +3,39 @@
 import logging
 import pathlib
 from logging.handlers import RotatingFileHandler
-from typing import TYPE_CHECKING, Any, Mapping
+from typing import TYPE_CHECKING, Any
 
-from discord.utils import (
-    _ColourFormatter as ColourFormatter,  # type: ignore # shh, I need it
-)
-from discord.utils import stream_supports_colour
+from discord.utils import _ColourFormatter as ColourFormatter, stream_supports_colour  # type: ignore # shh, I need it
 
-if TYPE_CHECKING:
-    from logging import _ExcInfoType  # type: ignore # shh, I need it
 
+if TYPE_CHECKING:
     from typing_extensions import Self
 
+    from bot import Bot
+
+
+class QueueEmitHandler(logging.Handler):
+    def __init__(self, bot: Bot, /) -> None:
+        self.bot: Bot = bot
+        super().__init__(logging.INFO)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        self.bot.logging_queue.put_nowait(record)
+
 
 class LogHandler:
-    def __init__(self, *, stream: bool = True) -> None:
+    def __init__(self, *, bot: Bot, stream: bool = True) -> None:
         self.log: logging.Logger = logging.getLogger()
         self.max_bytes: int = 32 * 1024 * 1024
         self.logging_path = pathlib.Path("./logs/")
         self.logging_path.mkdir(exist_ok=True)
         self.stream: bool = stream
+        self.bot: Bot = bot
+        self.debug = self.log.debug
+        self.info = self.log.info
+        self.warning = self.log.warning
+        self.error = self.log.error
+        self.critical = self.log.critical
 
     async def __aenter__(self) -> Self:
         return self.__enter__()
@@ -40,9 +53,7 @@ def __enter__(self: Self) -> Self:
             backupCount=5,
         )
         dt_fmt = "%Y-%m-%d %H:%M:%S"
-        fmt = logging.Formatter(
-            "[{asctime}] [{levelname:<7}] {name}: {message}", dt_fmt, style="{"
-        )
+        fmt = logging.Formatter("[{asctime}] [{levelname:<7}] {name}: {message}", dt_fmt, style="{")
         handler.setFormatter(fmt)
         self.log.addHandler(handler)
 
@@ -51,6 +62,7 @@ def __enter__(self: Self) -> Self:
             if stream_supports_colour(stream_handler):
                 stream_handler.setFormatter(ColourFormatter())
             self.log.addHandler(stream_handler)
+            self.log.addHandler(QueueEmitHandler(self.bot))
 
         return self
 
@@ -62,93 +74,3 @@ def __exit__(self, *args: Any) -> None:
         for hdlr in handlers:
             hdlr.close()
             self.log.removeHandler(hdlr)
-
-    def debug(
-        self,
-        message: object,
-        *args: Any,
-        exc_info: _ExcInfoType,
-        stack_info: bool = False,
-        stack_level: int = 1,
-        extra: Mapping[str, Any] | None = None,
-    ) -> None:
-        self.log.debug(
-            msg=message,
-            *args,
-            exc_info=exc_info,
-            stack_info=stack_info,
-            stacklevel=stack_level,
-            extra=extra,
-        )
-
-    def info(
-        self,
-        message: object,
-        *args: Any,
-        exc_info: _ExcInfoType,
-        stack_info: bool = False,
-        stack_level: int = 1,
-        extra: Mapping[str, Any] | None = None,
-    ) -> None:
-        self.log.info(
-            msg=message,
-            *args,
-            exc_info=exc_info,
-            stack_info=stack_info,
-            stacklevel=stack_level,
-            extra=extra,
-        )
-
-    def warning(
-        self,
-        message: object,
-        *args: Any,
-        exc_info: _ExcInfoType,
-        stack_info: bool = False,
-        stack_level: int = 1,
-        extra: Mapping[str, Any] | None = None,
-    ) -> None:
-        self.log.warning(
-            msg=message,
-            *args,
-            exc_info=exc_info,
-            stack_info=stack_info,
-            stacklevel=stack_level,
-            extra=extra,
-        )
-
-    def error(
-        self,
-        message: object,
-        *args: Any,
-        exc_info: _ExcInfoType,
-        stack_info: bool = False,
-        stack_level: int = 1,
-        extra: Mapping[str, Any] | None = None,
-    ) -> None:
-        self.log.warning(
-            msg=message,
-            *args,
-            exc_info=exc_info,
-            stack_info=stack_info,
-            stacklevel=stack_level,
-            extra=extra,
-        )
-
-    def critical(
-        self,
-        message: object,
-        *args: Any,
-        exc_info: _ExcInfoType,
-        stack_info: bool = False,
-        stack_level: int = 1,
-        extra: Mapping[str, Any] | None = None,
-    ) -> None:
-        self.log.critical(
-            msg=message,
-            *args,
-            exc_info=exc_info,
-            stack_info=stack_info,
-            stacklevel=stack_level,
-            extra=extra,
-        )
diff --git a/dev-requirements.txt b/dev-requirements.txt
@@ -0,0 +1,2 @@
+black
+isort
diff --git a/modules/eval.py b/modules/eval.py
@@ -47,6 +47,15 @@ def __init__(self, bot: Bot, endpoint_url: str) -> None:
         self.bot: Bot = bot
         self.eval_endpoint: str = endpoint_url
 
+    async def perform_eval(self, code: Codeblock) -> str:
+        async with self.bot.session.post(self.eval_endpoint, json={"input": code.content[1]}) as eval_response:
+            if eval_response.status != 200:
+                raise InvalidEval(eval_response.status, "There was an issue running this eval command.")
+
+            eval_data = await eval_response.json()
+
+            return eval_data["stdout"]
+
     @commands.command()
     @commands.max_concurrency(1, per=commands.BucketType.user, wait=False)
     @commands.cooldown(rate=1, per=10.0, type=commands.BucketType.user)
@@ -58,21 +67,20 @@ async def eval(self, ctx: Context, *, code: Codeblock = commands.param(converter
         code_body: :class:`Codeblock`
             This will attempt to convert your current passed parameter into proper Python code.
         """
+        reaction = "\U00002705"
         async with ctx.typing():
-            async with self.bot.session.post(self.eval_endpoint, json={"input": code.content[1]}) as eval_response:
-                if eval_response.status != 200:
-                    # TODO: error logging? Error handler and webhook post. Global or local?
-                    raise InvalidEval(eval_response.status, "There was an issue running this eval command.")
-
-                eval_data = await eval_response.json()
-
-            stdout = eval_data["stdout"]
-
-            if len(stdout) > 500:
-                codeblock = await self.bot.mb_client.create_paste(content=stdout, filename="eval.py")
+            try:
+                output = await self.perform_eval(code)
+            except InvalidEval:
+                reaction = "\U0000274c"
+                return await ctx.message.add_reaction(reaction)
+
+            if len(output) > 1000:
+                codeblock = await self.bot.mb_client.create_paste(content=output, filename="eval.py")
             else:
-                codeblock = formatters.to_codeblock(stdout, escape_md=False)
+                codeblock = formatters.to_codeblock(output, escape_md=False)
 
+            await ctx.message.add_reaction(reaction)
             await ctx.send(f"Hey {ctx.author.display_name}, here is your eval output:\n{codeblock}")
 
     @eval.error
diff --git a/modules/logging.py b/modules/logging.py
@@ -22,10 +22,13 @@
 """
 from __future__ import annotations
 
+import datetime
+import textwrap
 from typing import TYPE_CHECKING
 
 import discord
 from discord.ext import commands, tasks
+from discord.utils import format_dt
 
 import core
 
@@ -37,13 +40,19 @@
 class Logging(commands.Cog):
     def __init__(self, bot: Bot) -> None:
         self.bot: Bot = bot
-        self.webhook = discord.Webhook.from_url(core.CONFIG["LOGGING"]["webhook_url"], client=bot)
+        self.webhook = discord.Webhook.from_url(core.CONFIG["LOGGING"]["webhook_url"], session=bot.session, client=bot)
 
     @tasks.loop(seconds=0)
     async def logging_loop(self) -> None:
         to_log = await self.bot.logging_queue.get()
+        attributes = {"INFO": "\U00002139\U0000fe0f", "WARNING": "\U000026a0\U0000fe0f"}
 
-        await self.webhook.send(to_log, username="PythonistaBot Logging")
+        emoji = attributes.get(to_log.levelname, "\N{CROSS MARK}")
+        dt = datetime.datetime.utcfromtimestamp(to_log.created)
+
+        message = textwrap.shorten(f"{emoji} {format_dt(dt)}\n{to_log.message}", width=1990)
+
+        await self.webhook.send(message, username="PythonistaBot Logging")
 
 
 async def setup(bot: Bot) -> None:
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml
diff --git a/requirements.txt b/requirements.txt
