discord.py.logging 0.1.0__py3-none-any.whl

discord/ext/logging/__init__.py

@@ -0,0 +1,12 @@
+from .handlers.channel_log_handler import (
+    ChannelLogHandler,
+    get_channel_log_handler,
+)
+from .handlers.user_log_handler import UserLogHandler, get_user_log_handler
+
+__all__ = [
+    "ChannelLogHandler",
+    "UserLogHandler",
+    "get_channel_log_handler",
+    "get_user_log_handler",
+]

discord/ext/logging/filters/rate_limit_filter.py

@@ -0,0 +1,9 @@
+import logging
+from logging import WARNING
+
+
+class RateLimitFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord):
+        return not (
+            "responded with 429" in record.message and record.levelno == WARNING
+        )

discord/ext/logging/filters/session_resumed_filter.py

@@ -0,0 +1,10 @@
+import logging
+from logging import INFO
+
+
+class SessionResumedFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord):
+        return not (
+            "has successfully RESUMED session" in record.message
+            and record.levelno == INFO
+        )

discord/ext/logging/handlers/base_discord_handler.py

@@ -0,0 +1,79 @@
+import asyncio
+from abc import ABC, abstractmethod
+from logging import Handler, LogRecord, getLogger
+from typing import override
+
+from ratelimit import limits, sleep_and_retry
+
+from discord.ext import logging
+from discord.ext.logging import Embed
+
+
+class BaseDiscordHandler(Handler, ABC):
+    def __init__(self, client: logging.Client, level: int = 0):
+        super().__init__(level=0)
+        self._ready = asyncio.Event()
+        self._successful = False
+        self._client: logging.Client = client
+        self._logger = getLogger(self.__class__.__name__)
+        asyncio.create_task(self.__setup())
+
+    async def __setup(self):
+        await self._client.wait_until_ready()
+        self._successful = await self._setup()
+        self._ready.set()
+
+    @abstractmethod
+    async def _setup(self) -> bool:
+        pass
+
+    @abstractmethod
+    async def _send_message(self, embed: logging.Embed):
+        pass
+
+    @override
+    def emit(self, record: LogRecord) -> None:
+        asyncio.create_task(self._send_record(record))
+
+    async def info(self, title: str, message: str):
+        await self._send_message(
+            Embed(title=title, description=message, color=logging.Color.blue())
+        )
+
+    async def warning(self, title: str, message: str):
+        await self._send_message(
+            Embed(title=title, description=message, color=logging.Color.yellow())
+        )
+
+    async def error(self, title: str, message: str):
+        await self._send_message(
+            Embed(title=title, description=message, color=logging.Color.red())
+        )
+
+    async def critical(self, title: str, message: str):
+        await self._send_message(
+            Embed(title=title, description=message, color=logging.Color.dark_red())
+        )
+
+    @sleep_and_retry
+    @limits(calls=1, period=0.5)
+    async def _send_record(self, record: LogRecord) -> None:
+        await self._ready.wait()
+        if self._successful is None or self._client.is_closed():
+            return
+
+        title = f"{record.name}:{record.levelname}"
+        description = record.message
+
+        if record.exc_text is not None:
+            description += f" -> {record.exc_text}"
+
+        match record.levelname.upper():
+            case "INFO":
+                await self.info(title, description)
+            case "WARNING":
+                await self.warning(title, description)
+            case "ERROR":
+                await self.error(title, description)
+            case "CRITICAL":
+                await self.critical(title, description)

discord/ext/logging/handlers/channel_log_handler.py

@@ -0,0 +1,38 @@
+from discord.ext import logging
+
+from ..filters.rate_limit_filter import RateLimitFilter
+from ..filters.session_resumed_filter import SessionResumedFilter
+from .base_discord_handler import BaseDiscordHandler
+
+
+class ChannelLogHandler(BaseDiscordHandler):
+    def __init__(self, discord_client: logging.Client, target_channel_id: int):
+        self._target_channel_id: int = target_channel_id
+        self._target_channel: logging.User | None = None
+
+        super().__init__(discord_client)
+
+    async def _setup(self) -> bool:
+        try:
+            self._target_channel = self._client.fetch_channel(self.target_channel_id)
+            return True
+        except logging.NotFound:
+            self._logger.error(
+                f"Channel : {self.target_channel_id} could not be found for logging!"
+            )
+            return False
+        except logging.HTTPException:
+            self._logger.error("Failed to fetch channel for logger!")
+            return False
+
+    async def _send_message(self, embed: logging.Embed):
+        await self._target_channel.send(embed=embed)
+
+
+def get_channel_log_handler(
+    discord_client: logging.Client, target_channel_id: int
+) -> ChannelLogHandler:
+    handler = ChannelLogHandler(discord_client, target_channel_id)
+    handler.addFilter(RateLimitFilter())
+    handler.addFilter(SessionResumedFilter())
+    return handler

discord/ext/logging/handlers/user_log_handler.py

@@ -0,0 +1,40 @@
+from typing import override
+
+from discord.ext import logging
+
+from ..filters.rate_limit_filter import RateLimitFilter
+from ..filters.session_resumed_filter import SessionResumedFilter
+from .base_discord_handler import BaseDiscordHandler
+
+
+class UserLogHandler(BaseDiscordHandler):
+    def __init__(self, discord_client: logging.Client, target_user_id: int):
+        self._target_user_id: int = target_user_id
+        self._target_user: logging.User | None = None
+
+        super().__init__(discord_client)
+
+    @override
+    async def _setup(self) -> bool:
+        try:
+            self._target_user = await self._client.fetch_user(self.target_user_id)
+            return True
+        except logging.NotFound:
+            self._logger.error(
+                f"User : {self.target_user_id} could not be found for logging!"
+            )
+            return False
+        except logging.HTTPException:
+            self._logger.error("Failed to fetch user for logger!")
+            return False
+
+    @override
+    async def _send_message(self, embed: logging.Embed):
+        await self._target_user.send(embed=embed)
+
+
+def get_user_log_handler(discord_client: logging.Client, target_user_id: int):
+    handler = UserLogHandler(discord_client, target_user_id)
+    handler.addFilter(RateLimitFilter())
+    handler.addFilter(SessionResumedFilter())
+    return handler

discord_py_logging-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.5
+Name: discord.py.logging
+Version: 0.1.0
+Summary: A logger handle that uses discord
+Author-email: Wildbush <75509166+Wildbush76@users.noreply.github.com>
+Requires-Python: >=3.13
+Requires-Dist: discord-py>=2.7.1
+Requires-Dist: ratelimit>=2.2.1

discord_py_logging-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+discord/ext/logging/__init__.py,sha256=CietN_zM_m79JnOadGAwnNAs5mr3vgITU-JjCrsPRSM,295
+discord/ext/logging/filters/rate_limit_filter.py,sha256=xDhdcAcP5YjxkTIPX8JUaKS4XYFEABJzkovuSpZtUL8,254
+discord/ext/logging/filters/session_resumed_filter.py,sha256=5lx4wCxmQqiuchncQGwoCqvW6BxvN7aa4fNnBHpQpng,280
+discord/ext/logging/handlers/base_discord_handler.py,sha256=r84u1RTDAT2iuxp0pGKJln0ZYmaWLgkq9KBj8oUpC1E,2614
+discord/ext/logging/handlers/channel_log_handler.py,sha256=NzYWj3kcPzNxVRjMve1i5GqrVOuv32Kug4xWLEbQlqE,1410
+discord/ext/logging/handlers/user_log_handler.py,sha256=CltaSnXQ2dgiJUZs-VxYi6RjiRC4-dVkv0yq8_KwpKc,1400
+discord_py_logging-0.1.0.dist-info/METADATA,sha256=GG0deG9ugqHe9gBLIr47FvxDE889lzzxe9JYfCYpc2s,264
+discord_py_logging-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+discord_py_logging-0.1.0.dist-info/RECORD,,

discord_py_logging-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any