fix: channel object without a guild derives the guild instead of silently dropping (dpylogger-1)

DPYLogger(guild=None, channel=<TextChannel>) passed initialize() (both int-guards skipped)
but then every send failed at _get_guild(None) and got swallowed — logs never reached
discord, no loud setup signal. now derive self.guild from the channel it already carries,
or raise loud at setup for a truly guild-less channel (mirroring the int-channel guard).
verified vs discord.py 2.7.1. bump v0.1.2 -> v0.1.3

Signed-off-by: disqualifier <dev@disqualifier.me>

.gitignore

@@ -1,5 +1,5 @@
 # claude
-CLAUDE.md
+.claude/
 
 # python
 __pycache__/

README.md

@@ -10,17 +10,19 @@ live from `bot.settings` so it can change at runtime via a command.
 `requirements.txt`:
 
 ```
-dpy_logger @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_logger.git@v0.1.0
+dpy_logger @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_logger.git@v0.1.3
 ```
 
 Direct:
 
 ```bash
-pip install "dpy_logger @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_logger.git@v0.1.0"
+pip install "dpy_logger @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_logger.git@v0.1.3"
 ```
 
 Requires `discord.py` (pulled transitively).
 
+Drop the `@v0.1.3` suffix from the line above to install the latest unpinned.
+
 ## Usage
 
 ```python
@@ -70,10 +72,13 @@ await bot.log.debug("noisy", log_to_file=False)   # -> Discord only
 
 ## Errors
 
-Resolution failures (unresolvable guild/channel, bad config) raise `ValueError` at
-`initialize`/call time — a misconfigured logger should fail loudly at setup. Per-call
-**send** failures do **not** propagate: they fall back to the stdlib logger so a
-transient Discord failure never breaks the caller's command.
+Resolution failures (unresolvable guild/channel, bad config, a non-text channel) raise
+`ValueError` from `initialize()` — a misconfigured logger should fail loudly at setup.
+Underlying `discord` exceptions (`NotFound` / `Forbidden` / `HTTPException`) from
+`fetch_guild`/`fetch_channel` are normalized to that `ValueError` so callers see one
+error type. On a **per-call** send, neither resolution nor send failures propagate: they
+fall back to the stdlib logger so a transient Discord failure (or a per-call `guild=`
+that doesn't resolve) never breaks the caller's command.
 
 ## Construction contract
 
@@ -136,4 +141,4 @@ class FeedLogger(DPYLogger):
 
 ## Versioning
 
-Tagged `vX.Y.Z`. Pin the tag in `requirements.txt`.
+Releases are tagged `vX.Y.Z`. The install line above pins a release; drop the `@vX.Y.Z` suffix to install the latest unpinned. Pin deliberately for reproducible installs.

pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dpy_logger"
+version = "0.1.3"
+description = "Leveled Discord channel logger for discord.py — config-free, injectable, installable."
+requires-python = ">=3.10"
+dependencies = [
+    "discord.py>=2.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dpy_logger"]

src/dpy_logger/__init__.py

@@ -0,0 +1,3 @@
+from .dpy_logger import DPYLogger, DEFAULT_COLORS
+
+__all__ = ["DPYLogger", "DEFAULT_COLORS"]

src/dpy_logger/dpy_logger.py

@@ -0,0 +1,265 @@
+"""
+discord channel logger
+
+leveled logging to a discord channel via embeds. attach to your bot
+(e.g. bot.log) and call bot.log.info(...), bot.log.critical(...), etc.
+
+config-free: all static identity is injected at construction; dynamic
+per-guild channel routing is read live from bot.settings at call time, so a
+command that mutates bot.settings changes routing without a restart.
+
+    from dpy_logger import DPYLogger
+
+    bot.log = DPYLogger(
+        bot, guild_id, channel_id,
+        colors=log_colors,            # optional, falls back to defaults
+        pings=authorized_devs,        # mentioned on critical()
+        timezone=tz,
+        footer=bot_footer,
+        avatar=bot_avatar,
+    )
+    await bot.log.initialize()        # resolves ids -> objects
+    await bot.log.success("user promoted", action="promote", actor=ctx.author)
+
+levels: debug, info, success, fail (alias failure), task, critical.
+
+dynamic routing: a per-call guild= argument logs to that guild's configured
+channel via bot.settings[guild.id]['channels']['logs']; omit it to use the
+channel this logger was constructed with.
+
+custom embeds: pass embed_builder=fn to restyle without subclassing, where
+fn(logger, level, action, actor, details) -> discord.Embed. every level
+(including critical) routes through it. for complex cases override the
+build_embed method in a subclass instead.
+
+dual sink: every call also mirrors to the stdlib logger (getLogger(__name__)),
+which the app routes to file/console. set log_to_file=False at construction to
+disable, or pass log_to_file=True/False per call to override. the stdlib emit
+happens before the discord send, so the record survives even if discord fails.
+
+extending: this base has no feed/announcement method by design. a project
+that wants one subclasses DPYLogger and adds it, reusing _resolve.
+
+errors: resolution failures (unresolvable guild/channel, bad config) raise
+ValueError from `initialize()` — a misconfigured logger should fail loudly at
+setup. on a per-call send, resolution AND send failures do NOT propagate: they
+fall back to the stdlib logger so a transient discord failure (or a per-call
+`guild=` that doesn't resolve) never breaks the caller's command.
+"""
+
+import logging
+import discord
+from datetime import datetime
+from typing import Callable, Optional
+
+_log = logging.getLogger(__name__)
+
+DEFAULT_COLORS = {
+    "debug": 0x808080,
+    "info": 0x709288,
+    "success": 0x00E27D,
+    "fail": 0xD93025,
+    "task": 0x5AC6E1,
+    "critical": 0x000000,
+}
+
+LEVEL_MAP = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "success": logging.INFO,
+    "task": logging.INFO,
+    "fail": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+
+class DPYLogger:
+    """leveled discord channel logger; attach to the bot as bot.log"""
+
+    def __init__(
+        self,
+        bot,
+        guild=None,
+        channel=None,
+        *,
+        colors: Optional[dict] = None,
+        pings: Optional[list] = None,
+        timezone: Optional[object] = None,
+        footer: str = "",
+        avatar: Optional[str] = None,
+        alert_here: bool = False,
+        embed_builder: Optional[Callable] = None,
+        log_to_file: bool = True,
+    ):
+        self.bot = bot
+        self.guild = guild
+        self.channel = channel
+        self.pings = pings or []
+        self.timezone = timezone
+        self.footer = footer
+        self.avatar = avatar
+        self.alert_here = alert_here
+        self.colors = {**DEFAULT_COLORS, **(colors or {})}
+        self._embed_builder = embed_builder
+        self.log_to_file = log_to_file
+
+    async def initialize(self):
+        """resolve guild/channel from ids to objects; call once after construction"""
+        if isinstance(self.guild, int):
+            self.guild = await self._get_guild(self.guild)
+        if isinstance(self.channel, int):
+            if not self.guild:
+                raise ValueError(f"[dpy_logger] cannot resolve channel {self.channel} without a guild")
+            self.channel = await self._get_channel(self.guild)
+        # a channel object passed with no guild (e.g. bot.get_channel(id)) would pass
+        # setup silently but then fail every send at _get_guild(None) — swallowed, so
+        # nothing reaches discord. derive the guild from the channel it already carries,
+        # or fail loud at setup (matching the int-channel guard above) rather than later.
+        if self.guild is None and isinstance(self.channel, discord.TextChannel):
+            self.guild = self.channel.guild
+        if self.guild is None and self.channel is not None:
+            raise ValueError("[dpy_logger] channel provided without a resolvable guild")
+
+    async def _get_guild(self, guild):
+        """resolve a guild from id-or-object, raising if unresolvable"""
+        if guild:
+            if isinstance(guild, int):
+                resolved = self.bot.get_guild(guild)
+                if resolved is not None:
+                    return resolved
+                # fetch_guild never returns None — it raises NotFound/Forbidden/
+                # HTTPException; normalize those to the lib's ValueError so callers see
+                # one error type at setup
+                try:
+                    return await self.bot.fetch_guild(guild)
+                except discord.HTTPException as error:
+                    raise ValueError(f"[dpy_logger] failed to fetch guild {guild}: {error}") from error
+            if isinstance(guild, discord.Guild):
+                return guild
+        raise ValueError("[dpy_logger] no guild available for logging")
+
+    async def _get_channel(self, guild, override=False):
+        """resolve the log channel, preferring self.channel when the guild matches"""
+        if not guild:
+            raise ValueError("[dpy_logger] cannot resolve channel without a guild")
+
+        if not override and getattr(guild, "id", guild) == getattr(self.guild, "id", self.guild):
+            if isinstance(self.channel, discord.TextChannel):
+                return self.channel
+            if isinstance(self.channel, int):
+                channel = await guild.fetch_channel(self.channel)
+                if not isinstance(channel, discord.TextChannel):
+                    # fetch_channel can return a Voice/Category/Forum channel; fail loud
+                    # at setup like the settings path, not later via an AttributeError on .send
+                    raise ValueError(f"[dpy_logger] channel {self.channel} is not a text channel")
+                return channel
+
+        try:
+            channel_id = self.bot.settings[guild.id]["channels"]["logs"]
+        except KeyError:
+            raise ValueError(f"[dpy_logger] no log channel configured for guild {guild.id}")
+        try:
+            channel = await guild.fetch_channel(channel_id)
+        except discord.HTTPException as error:
+            # fetch_channel raises NotFound/Forbidden/HTTPException; normalize to the
+            # lib's ValueError so a bad configured id fails loud with one error type
+            raise ValueError(f"[dpy_logger] could not fetch channel {channel_id}: {error}") from error
+        if not isinstance(channel, discord.TextChannel):
+            raise ValueError(f"[dpy_logger] configured channel {channel_id} is not a text channel")
+        return channel
+
+    def build_embed(self, level, action, actor, details):
+        """build the embed for a log call
+
+        if an `embed_builder` callable was passed at construction, it is used:
+            embed_builder(logger, level, action, actor, details) -> discord.Embed
+        otherwise the default structure is built. subclasses may also override
+        this method directly instead of passing a callable.
+        """
+        if self._embed_builder is not None:
+            return self._embed_builder(self, level, action, actor, details)
+        em = discord.Embed(color=self.colors[level])
+        if action:
+            em.add_field(name="Action", value=f"`{action}`", inline=True)
+        if actor:
+            em.add_field(name="Actor", value=f"`{actor}`", inline=True)
+        # discord rejects an empty field value (50035) and truncates nothing itself, so
+        # an empty or >1024-char message would 400 the send; substitute + cap to keep
+        # every logging call producing a valid embed
+        log_value = str(details) if details else "(no message)"
+        if len(log_value) > 1024:
+            log_value = log_value[:1021] + "..."
+        em.add_field(name="Log", value=log_value, inline=False)
+        em.timestamp = datetime.now(self.timezone)
+        em.set_footer(text=f"{self.footer} Logging".strip(), icon_url=self.avatar)
+        return em
+
+    async def _resolve(self, guild):
+        """resolve the target channel for a call, honoring a per-call guild override"""
+        return await self._get_channel(await self._get_guild(guild or self.guild), bool(guild))
+
+    def _emit_stdlib(self, level, action, actor, log_msg):
+        """mirror the log line to the stdlib logger (routed to file/console by the app)"""
+        parts = [p for p in (action, str(actor) if actor else None, log_msg) if p]
+        _log.log(LEVEL_MAP.get(level, logging.INFO), f"[{level}] " + " | ".join(parts))
+
+    async def _send(self, level, log_msg, action=None, actor=None, guild=None, log_to_file=None):
+        """resolve channel and dispatch a leveled embed; mirror to stdlib unless opted out
+
+        stdlib emit happens first so the record survives even if the discord send fails.
+        a failed send falls back to stdlib rather than propagating into the caller.
+        """
+        if self.log_to_file if log_to_file is None else log_to_file:
+            self._emit_stdlib(level, action, actor, log_msg)
+        try:
+            channel = await self._resolve(guild)
+            return await channel.send(embed=self.build_embed(level, action, actor, log_msg))
+        except Exception:
+            _log.exception(f"[dpy_logger] failed to send {level} log: {log_msg}")
+            return None
+
+    async def debug(self, log, action=None, actor=None, guild=None, log_to_file=None):
+        """log a debug-level message"""
+        return await self._send("debug", log, action, actor, guild, log_to_file)
+
+    async def info(self, log, action=None, actor=None, guild=None, log_to_file=None):
+        """log an info-level message"""
+        return await self._send("info", log, action, actor, guild, log_to_file)
+
+    async def success(self, log, action=None, actor=None, guild=None, log_to_file=None):
+        """log a success-level message"""
+        return await self._send("success", log, action, actor, guild, log_to_file)
+
+    async def fail(self, log, action=None, actor=None, guild=None, log_to_file=None):
+        """log a fail-level message"""
+        return await self._send("fail", log, action, actor, guild, log_to_file)
+
+    failure = fail
+
+    async def task(self, log, action=None, actor=None, guild=None, log_to_file=None):
+        """log a task-level message with SYSTEM/TASK as the actor
+
+        actor is accepted for caller compatibility and ignored — task actions are
+        always attributed to SYSTEM/TASK regardless of the caller-supplied actor
+        """
+        return await self._send("task", log, action, "SYSTEM/TASK", guild, log_to_file)
+
+    async def critical(self, log, action=None, actor=None, guild=None, log_to_file=None):
+        """log a critical-level message and ping configured devs"""
+        if self.log_to_file if log_to_file is None else log_to_file:
+            self._emit_stdlib("critical", action, actor, log)
+        if self.pings:
+            content = "alert: " + " ".join(f"<@{u}>" for u in self.pings)
+        elif self.alert_here:
+            content = "alert: @here"
+        else:
+            content = None
+        try:
+            channel = await self._resolve(guild)
+            return await channel.send(
+                content=content,
+                embed=self.build_embed("critical", action, actor, log),
+            )
+        except Exception:
+            _log.exception(f"[dpy_logger] failed to send critical log: {log}")
+            return None