disagreement 0.0.2__py3-none-any.whl → 0.1.0rc2__py3-none-any.whl

disagreement/event_dispatcher.py

@@ -47,10 +47,20 @@ class EventDispatcher:
         # Pre-defined parsers for specific event types to convert raw data to models
         self._event_parsers: Dict[str, Callable[[Dict[str, Any]], Any]] = {
             "MESSAGE_CREATE": self._parse_message_create,
+            "MESSAGE_UPDATE": self._parse_message_update,
+            "MESSAGE_DELETE": self._parse_message_delete,
+            "MESSAGE_REACTION_ADD": self._parse_message_reaction,
+            "MESSAGE_REACTION_REMOVE": self._parse_message_reaction,
             "INTERACTION_CREATE": self._parse_interaction_create,
             "GUILD_CREATE": self._parse_guild_create,
             "CHANNEL_CREATE": self._parse_channel_create,
+            "CHANNEL_UPDATE": self._parse_channel_update,
             "PRESENCE_UPDATE": self._parse_presence_update,
+            "GUILD_MEMBER_ADD": self._parse_guild_member_add,
+            "GUILD_MEMBER_REMOVE": self._parse_guild_member_remove,
+            "GUILD_BAN_ADD": self._parse_guild_ban_add,
+            "GUILD_BAN_REMOVE": self._parse_guild_ban_remove,
+            "GUILD_ROLE_UPDATE": self._parse_guild_role_update,
             "TYPING_START": self._parse_typing_start,
         }
 
@@ -58,6 +68,21 @@ class EventDispatcher:
         """Parses raw MESSAGE_CREATE data into a Message object."""
         return self._client.parse_message(data)
 
+    def _parse_message_update(self, data: Dict[str, Any]) -> Message:
+        """Parses raw MESSAGE_UPDATE data into a Message object."""
+        return self._client.parse_message(data)
+
+    def _parse_message_delete(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Parses MESSAGE_DELETE and updates message cache."""
+        message_id = data.get("id")
+        if message_id:
+            self._client._messages.pop(message_id, None)
+        return data
+
+    def _parse_message_reaction_raw(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Returns the raw reaction payload."""
+        return data
+
     def _parse_interaction_create(self, data: Dict[str, Any]) -> "Interaction":
         """Parses raw INTERACTION_CREATE data into an Interaction object."""
         from .interactions import Interaction
@@ -88,6 +113,52 @@ class EventDispatcher:
 
         return TypingStart(data, client_instance=self._client)
 
+    def _parse_message_reaction(self, data: Dict[str, Any]):
+        """Parses raw reaction data into a Reaction object."""
+
+        from .models import Reaction
+
+        return Reaction(data, client_instance=self._client)
+
+    def _parse_guild_member_add(self, data: Dict[str, Any]):
+        """Parses GUILD_MEMBER_ADD into a Member object."""
+
+        guild_id = str(data.get("guild_id"))
+        return self._client.parse_member(data, guild_id)
+
+    def _parse_guild_member_remove(self, data: Dict[str, Any]):
+        """Parses GUILD_MEMBER_REMOVE into a GuildMemberRemove model."""
+
+        from .models import GuildMemberRemove
+
+        return GuildMemberRemove(data, client_instance=self._client)
+
+    def _parse_guild_ban_add(self, data: Dict[str, Any]):
+        """Parses GUILD_BAN_ADD into a GuildBanAdd model."""
+
+        from .models import GuildBanAdd
+
+        return GuildBanAdd(data, client_instance=self._client)
+
+    def _parse_guild_ban_remove(self, data: Dict[str, Any]):
+        """Parses GUILD_BAN_REMOVE into a GuildBanRemove model."""
+
+        from .models import GuildBanRemove
+
+        return GuildBanRemove(data, client_instance=self._client)
+
+    def _parse_channel_update(self, data: Dict[str, Any]):
+        """Parses CHANNEL_UPDATE into a Channel object."""
+
+        return self._client.parse_channel(data)
+
+    def _parse_guild_role_update(self, data: Dict[str, Any]):
+        """Parses GUILD_ROLE_UPDATE into a GuildRoleUpdate model."""
+
+        from .models import GuildRoleUpdate
+
+        return GuildRoleUpdate(data, client_instance=self._client)
+
     # Potentially add _parse_user for events that directly provide a full user object
     # def _parse_user_update(self, data: Dict[str, Any]) -> User:
     #     return User(data=data)
@@ -169,75 +240,61 @@ class EventDispatcher:
         if not waiters:
             self._waiters.pop(event_name, None)
 
-    async def dispatch(self, event_name: str, raw_data: Dict[str, Any]):
-        """
-        Dispatches an event to all registered listeners.
-
-        Args:
-            event_name (str): The name of the event (e.g., 'MESSAGE_CREATE').
-            raw_data (Dict[str, Any]): The raw data payload from the Discord Gateway for this event.
-        """
-        event_name_upper = event_name.upper()
-        listeners = self._listeners.get(event_name_upper)
-
+    async def _dispatch_to_listeners(self, event_name: str, data: Any) -> None:
+        listeners = self._listeners.get(event_name)
         if not listeners:
-            # print(f"No listeners for event {event_name_upper}")
             return
 
-        parsed_data: Any = raw_data
-        if event_name_upper in self._event_parsers:
-            try:
-                parser = self._event_parsers[event_name_upper]
-                parsed_data = parser(raw_data)
-            except Exception as e:
-                print(f"Error parsing event data for {event_name_upper}: {e}")
-                # Optionally, dispatch with raw_data or raise, or log more formally
-                # For now, we'll proceed to dispatch with raw_data if parsing fails,
-                # or just log and return if parsed_data is critical.
-                # Let's assume if a parser exists, its output is critical.
-                return
+        self._resolve_waiters(event_name, data)
 
-        self._resolve_waiters(event_name_upper, parsed_data)
-        # print(f"Dispatching event {event_name_upper} with data: {parsed_data} to {len(listeners)} listeners.")
         for listener in listeners:
             try:
-                # Inspect the listener to see how many arguments it expects
                 sig = inspect.signature(listener)
                 num_params = len(sig.parameters)
 
-                if num_params == 0:  # Listener takes no arguments
+                if num_params == 0:
                     await listener()
-                elif (
-                    num_params == 1
-                ):  # Listener takes one argument (the parsed data or model)
-                    await listener(parsed_data)
-                # elif num_params == 2 and event_name_upper == "MESSAGE_CREATE": # Special case for (client, message)
-                # await listener(self._client, parsed_data) # This might be too specific here
+                elif num_params == 1:
+                    await listener(data)
                 else:
-                    # Fallback or error if signature doesn't match expected patterns
-                    # For now, assume one arg is the most common for parsed data.
-                    # Or, if you want to be strict:
                     print(
-                        f"Warning: Listener {listener.__name__} for {event_name_upper} has an unhandled number of parameters ({num_params}). Skipping or attempting with one arg."
+                        f"Warning: Listener {listener.__name__} for {event_name} has an unhandled number of parameters ({num_params}). Skipping or attempting with one arg."
                     )
-                    if num_params > 0:  # Try with one arg if it takes any
-                        await listener(parsed_data)
+                    if num_params > 0:
+                        await listener(data)
 
             except Exception as e:
                 callback = self.on_dispatch_error
                 if callback is not None:
                     try:
-                        await callback(event_name_upper, e, listener)
-
+                        await callback(event_name, e, listener)
                     except Exception as hook_error:
                         print(f"Error in on_dispatch_error hook itself: {hook_error}")
                 else:
-                    # Default error handling if no hook is set
                     print(
-                        f"Error in event listener {listener.__name__} for {event_name_upper}: {e}"
+                        f"Error in event listener {listener.__name__} for {event_name}: {e}"
                     )
                     if hasattr(self._client, "on_error"):
                         try:
-                            await self._client.on_error(event_name_upper, e, listener)
+                            await self._client.on_error(event_name, e, listener)
                         except Exception as client_err_e:
                             print(f"Error in client.on_error itself: {client_err_e}")
+
+    async def dispatch(self, event_name: str, raw_data: Dict[str, Any]):
+        """Dispatch an event and its raw counterpart to all listeners."""
+
+        event_name_upper = event_name.upper()
+        raw_event_name = f"RAW_{event_name_upper}"
+
+        await self._dispatch_to_listeners(raw_event_name, raw_data)
+
+        parsed_data: Any = raw_data
+        if event_name_upper in self._event_parsers:
+            try:
+                parser = self._event_parsers[event_name_upper]
+                parsed_data = parser(raw_data)
+            except Exception as e:
+                print(f"Error parsing event data for {event_name_upper}: {e}")
+                return
+
+        await self._dispatch_to_listeners(event_name_upper, parsed_data)

disagreement/ext/app_commands/__init__.py

@@ -44,3 +44,5 @@ __all__ = [
     "OptionMetadata",
     "AppCommandContext",  # To be defined
 ]
+
+from .hybrid import *

disagreement/ext/app_commands/commands.py

@@ -1,58 +1,25 @@
 # disagreement/ext/app_commands/commands.py
 
 import inspect
-from typing import Callable, Optional, List, Dict, Any, Union, TYPE_CHECKING
+from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
 
+from disagreement.enums import (
+    ApplicationCommandType,
+    ApplicationCommandOptionType,
+    IntegrationType,
+    InteractionContextType,
+)
+from disagreement.interactions import ApplicationCommandOption, Snowflake
 
 if TYPE_CHECKING:
-    from disagreement.ext.commands.core import (
-        Command as PrefixCommand,
-    )  # Alias to avoid name clash
-    from disagreement.interactions import ApplicationCommandOption, Snowflake
-    from disagreement.enums import (
-        ApplicationCommandType,
-        IntegrationType,
-        InteractionContextType,
-        ApplicationCommandOptionType,  # Added
-    )
-    from disagreement.ext.commands.cog import Cog  # Corrected import path
-
-# Placeholder for Cog if not using the existing one or if it needs adaptation
+    from disagreement.ext.commands.core import Command as PrefixCommand
+    from disagreement.ext.commands.cog import Cog
+
 if not TYPE_CHECKING:
-    # This dynamic Cog = Any might not be ideal if Cog is used in runtime type checks.
-    # However, for type hinting purposes when TYPE_CHECKING is false, it avoids import.
-    # If Cog is needed at runtime by this module (it is, for AppCommand.cog type hint),
-    # it should be imported directly.
-    # For now, the TYPE_CHECKING block handles the proper import for static analysis.
-    # Let's ensure Cog is available at runtime if AppCommand.cog is accessed.
-    # A simple way is to import it outside TYPE_CHECKING too, if it doesn't cause circularity.
-    # Given its usage, a forward reference string 'Cog' might be better in AppCommand.cog type hint.
-    # Let's try importing it directly for runtime, assuming no circularity with this specific module.
-    try:
-        from disagreement.ext.commands.cog import Cog
-    except ImportError:
-        Cog = Any  # Fallback if direct import fails (e.g. during partial builds/tests)
-    # Import PrefixCommand at runtime for HybridCommand
     try:
         from disagreement.ext.commands.core import Command as PrefixCommand
-    except Exception:  # pragma: no cover - safeguard against unusual import issues
-        PrefixCommand = Any  # type: ignore
-    # Import enums used at runtime
-    try:
-        from disagreement.enums import (
-            ApplicationCommandType,
-            IntegrationType,
-            InteractionContextType,
-            ApplicationCommandOptionType,
-        )
-        from disagreement.interactions import ApplicationCommandOption, Snowflake
-    except Exception:  # pragma: no cover
-        ApplicationCommandType = ApplicationCommandOptionType = IntegrationType = (
-            InteractionContextType
-        ) = Any  # type: ignore
-        ApplicationCommandOption = Snowflake = Any  # type: ignore
-else:  # When TYPE_CHECKING is true, Cog and PrefixCommand are already imported above.
-    pass
+    except ImportError:
+        PrefixCommand = Any
 
 
 class AppCommand:
@@ -235,59 +202,6 @@ class MessageCommand(AppCommand):
         super().__init__(callback, type=ApplicationCommandType.MESSAGE, **kwargs)
 
 
-class HybridCommand(SlashCommand, PrefixCommand):  # Inherit from both
-    """
-    Represents a command that can be invoked as both a slash command
-    and a traditional prefix-based command.
-    """
-
-    def __init__(self, callback: Callable[..., Any], **kwargs: Any):
-        # Initialize SlashCommand part (which calls AppCommand.__init__)
-        # We need to ensure 'type' is correctly passed for AppCommand
-        # kwargs for SlashCommand: name, description, guild_ids, default_member_permissions, nsfw, parent, cog, etc.
-        # kwargs for PrefixCommand: name, aliases, brief, description, cog
-
-        # Pop prefix-specific args before passing to SlashCommand constructor
-        prefix_aliases = kwargs.pop("aliases", [])
-        prefix_brief = kwargs.pop("brief", None)
-        # Description is used by both, AppCommand's constructor will handle it.
-        # Name is used by both. Cog is used by both.
-
-        # Call SlashCommand's __init__
-        # This will set up name, description, callback, type=CHAT_INPUT, options, etc.
-        super().__init__(callback, **kwargs)  # This is SlashCommand.__init__
-
-        # Now, explicitly initialize the PrefixCommand parts that SlashCommand didn't cover
-        # or that need specific values for the prefix version.
-        # PrefixCommand.__init__(self, callback, name=self.name, aliases=prefix_aliases, brief=prefix_brief, description=self.description, cog=self.cog)
-        # However, PrefixCommand.__init__ also sets self.params, which AppCommand already did.
-        # We need to be careful not to re-initialize things unnecessarily or incorrectly.
-        # Let's manually set the distinct attributes for the PrefixCommand aspect.
-
-        # Attributes from PrefixCommand:
-        # self.callback is already set by AppCommand
-        # self.name is already set by AppCommand
-        self.aliases: List[str] = (
-            prefix_aliases  # This was specific to HybridCommand before, now aligns with PrefixCommand
-        )
-        self.brief: Optional[str] = prefix_brief
-        # self.description is already set by AppCommand (SlashCommand ensures it exists)
-        # self.cog is already set by AppCommand
-        # self.params is already set by AppCommand
-
-        # Ensure the MRO is handled correctly. Python's MRO (C3 linearization)
-        # should call SlashCommand's __init__ then AppCommand's __init__.
-        # PrefixCommand.__init__ won't be called automatically unless we explicitly call it.
-        # By setting attributes directly, we avoid potential issues with multiple __init__ calls
-        # if their logic overlaps too much (e.g., both trying to set self.params).
-
-    # We might need to override invoke if the context or argument passing differs significantly
-    # between app command invocation and prefix command invocation.
-    # For now, SlashCommand.invoke and PrefixCommand.invoke are separate.
-    # The correct one will be called depending on how the command is dispatched.
-    # The AppCommandHandler will use AppCommand.invoke (via SlashCommand).
-    # The prefix CommandHandler will use PrefixCommand.invoke.
-    # This seems acceptable.
 
 
 class AppCommandGroup:

disagreement/ext/app_commands/decorators.py

@@ -26,8 +26,8 @@ from .commands import (
     MessageCommand,
     AppCommand,
     AppCommandGroup,
-    HybridCommand,
 )
+from .hybrid import HybridCommand
 from disagreement.interactions import (
     ApplicationCommandOption,
     ApplicationCommandOptionChoice,

disagreement/ext/app_commands/hybrid.py

@@ -0,0 +1,61 @@
+# disagreement/ext/app_commands/hybrid.py
+
+from typing import Any, Callable, List, Optional
+
+from .commands import SlashCommand
+from disagreement.ext.commands.core import PrefixCommand
+
+
+class HybridCommand(SlashCommand, PrefixCommand):  # Inherit from both
+    """
+    Represents a command that can be invoked as both a slash command
+    and a traditional prefix-based command.
+    """
+
+    def __init__(self, callback: Callable[..., Any], **kwargs: Any):
+        # Initialize SlashCommand part (which calls AppCommand.__init__)
+        # We need to ensure 'type' is correctly passed for AppCommand
+        # kwargs for SlashCommand: name, description, guild_ids, default_member_permissions, nsfw, parent, cog, etc.
+        # kwargs for PrefixCommand: name, aliases, brief, description, cog
+
+        # Pop prefix-specific args before passing to SlashCommand constructor
+        prefix_aliases = kwargs.pop("aliases", [])
+        prefix_brief = kwargs.pop("brief", None)
+        # Description is used by both, AppCommand's constructor will handle it.
+        # Name is used by both. Cog is used by both.
+
+        # Call SlashCommand's __init__
+        # This will set up name, description, callback, type=CHAT_INPUT, options, etc.
+        super().__init__(callback, **kwargs)  # This is SlashCommand.__init__
+
+        # Now, explicitly initialize the PrefixCommand parts that SlashCommand didn't cover
+        # or that need specific values for the prefix version.
+        # PrefixCommand.__init__(self, callback, name=self.name, aliases=prefix_aliases, brief=prefix_brief, description=self.description, cog=self.cog)
+        # However, PrefixCommand.__init__ also sets self.params, which AppCommand already did.
+        # We need to be careful not to re-initialize things unnecessarily or incorrectly.
+        # Let's manually set the distinct attributes for the PrefixCommand aspect.
+
+        # Attributes from PrefixCommand:
+        # self.callback is already set by AppCommand
+        # self.name is already set by AppCommand
+        self.aliases: List[str] = (
+            prefix_aliases  # This was specific to HybridCommand before, now aligns with PrefixCommand
+        )
+        self.brief: Optional[str] = prefix_brief
+        # self.description is already set by AppCommand (SlashCommand ensures it exists)
+        # self.cog is already set by AppCommand
+        # self.params is already set by AppCommand
+
+        # Ensure the MRO is handled correctly. Python's MRO (C3 linearization)
+        # should call SlashCommand's __init__ then AppCommand's __init__.
+        # PrefixCommand.__init__ won't be called automatically unless we explicitly call it.
+        # By setting attributes directly, we avoid potential issues with multiple __init__ calls
+        # if their logic overlaps too much (e.g., both trying to set self.params).
+
+    # We might need to override invoke if the context or argument passing differs significantly
+    # between app command invocation and prefix command invocation.
+    # For now, SlashCommand.invoke and PrefixCommand.invoke are separate.
+    # The correct one will be called depending on how the command is dispatched.
+    # The AppCommandHandler will use AppCommand.invoke (via SlashCommand).
+    # The prefix CommandHandler will use PrefixCommand.invoke.
+    # This seems acceptable.

disagreement/ext/commands/__init__.py

@@ -10,7 +10,14 @@ from .core import (
     CommandContext,
     CommandHandler,
 )  # CommandHandler might be internal
-from .decorators import command, listener, check, check_any, cooldown
+from .decorators import (
+    command,
+    listener,
+    check,
+    check_any,
+    cooldown,
+    requires_permissions,
+)
 from .errors import (
     CommandError,
     CommandNotFound,
@@ -36,6 +43,7 @@ __all__ = [
     "check",
     "check_any",
     "cooldown",
+    "requires_permissions",
     # Errors
     "CommandError",
     "CommandNotFound",

disagreement/ext/commands/core.py

@@ -1,5 +1,7 @@
 # disagreement/ext/commands/core.py
 
+from __future__ import annotations
+
 import asyncio
 import inspect
 from typing import (
@@ -27,10 +29,10 @@ from .errors import (
     CommandInvokeError,
 )
 from .converters import run_converters, DEFAULT_CONVERTERS, Converter
-from .cog import Cog
 from disagreement.typing import Typing
 
 if TYPE_CHECKING:
+    from .cog import Cog
     from disagreement.client import Client
     from disagreement.models import Message, User
 
@@ -86,6 +88,9 @@ class Command:
             await self.callback(ctx, *args, **kwargs)
 
 
+PrefixCommand = Command  # Alias for clarity in hybrid commands
+
+
 class CommandContext:
     """
     Represents the context in which a command is being invoked.
@@ -114,9 +119,16 @@ class CommandContext:
 
         self.author: "User" = message.author
 
+    @property
+    def guild(self):
+        """The guild this command was invoked in."""
+        if self.message.guild_id and hasattr(self.bot, "get_guild"):
+            return self.bot.get_guild(self.message.guild_id)
+        return None
+
     async def reply(
         self,
-        content: str,
+        content: Optional[str] = None,
         *,
         mention_author: Optional[bool] = None,
         **kwargs: Any,
@@ -228,6 +240,7 @@ class CommandHandler:
         return self.commands.get(name.lower())
 
     def add_cog(self, cog_to_add: "Cog") -> None:
+        from .cog import Cog
         if not isinstance(cog_to_add, Cog):
             raise TypeError("Argument must be a subclass of Cog.")
 

disagreement/ext/commands/decorators.py

@@ -1,4 +1,5 @@
 # disagreement/ext/commands/decorators.py
+from __future__ import annotations
 
 import asyncio
 import inspect
@@ -6,9 +7,9 @@ import time
 from typing import Callable, Any, Optional, List, TYPE_CHECKING, Awaitable
 
 if TYPE_CHECKING:
-    from .core import Command, CommandContext  # For type hinting return or internal use
-
-    # from .cog import Cog # For Cog specific decorators
+    from .core import Command, CommandContext
+    from disagreement.permissions import Permissions
+    from disagreement.models import Member, Guild, Channel
 
 
 def command(
@@ -33,32 +34,16 @@ def command(
         if not asyncio.iscoroutinefunction(func):
             raise TypeError("Command callback must be a coroutine function.")
 
-        from .core import (
-            Command,
-        )  # Late import to avoid circular dependencies at module load time
-
-        # The actual registration will happen when a Cog is added or if commands are global.
-        # For now, this decorator creates a Command instance and attaches it to the function,
-        # or returns a Command instance that can be collected.
+        from .core import Command
 
         cmd_name = name or func.__name__
 
-        # Store command attributes on the function itself for later collection by Cog or Client
-        # This is a common pattern.
         if hasattr(func, "__command_attrs__"):
-            # This case might occur if decorators are stacked in an unusual way,
-            # or if a function is decorated multiple times (which should be disallowed or handled).
-            # For now, let's assume one @command decorator per function.
             raise TypeError("Function is already a command or has command attributes.")
 
-        # Create the command object. It will be registered by the Cog or Client.
         cmd = Command(callback=func, name=cmd_name, aliases=aliases or [], **attrs)
-
-        # We can attach the command object to the function, so Cogs can find it.
-        func.__command_object__ = cmd  # type: ignore # type: ignore[attr-defined]
-        return func  # Return the original function, now marked.
-        # Or return `cmd` if commands are registered globally immediately.
-        # For Cogs, returning `func` and letting Cog collect is cleaner.
+        func.__command_object__ = cmd  # type: ignore
+        return func
 
     return decorator
 
@@ -68,11 +53,6 @@ def listener(
 ) -> Callable[[Callable[..., Awaitable[None]]], Callable[..., Awaitable[None]]]:
     """
     A decorator that marks a function as an event listener within a Cog.
-    The actual registration happens when the Cog is added to the client.
-
-    Args:
-        name (Optional[str]): The name of the event to listen to.
-                              Defaults to the function name (e.g., `on_message`).
     """
 
     def decorator(
@@ -81,13 +61,11 @@ def listener(
         if not asyncio.iscoroutinefunction(func):
             raise TypeError("Listener callback must be a coroutine function.")
 
-        # 'name' here is from the outer 'listener' scope (closure)
         actual_event_name = name or func.__name__
-        # Store listener info on the function for Cog to collect
         setattr(func, "__listener_name__", actual_event_name)
         return func
 
-    return decorator  # This must be correctly indented under 'listener'
+    return decorator
 
 
 def check(
@@ -148,3 +126,67 @@ def cooldown(
         return True
 
     return check(predicate)
+
+
+def _compute_permissions(
+    member: "Member", channel: "Channel", guild: "Guild"
+) -> "Permissions":
+    """Compute the effective permissions for a member in a channel."""
+    return channel.permissions_for(member)
+
+
+def requires_permissions(
+    *perms: "Permissions",
+) -> Callable[[Callable[..., Awaitable[None]]], Callable[..., Awaitable[None]]]:
+    """Check that the invoking member has the given permissions in the channel."""
+
+    async def predicate(ctx: "CommandContext") -> bool:
+        from .errors import CheckFailure
+        from disagreement.permissions import (
+            has_permissions,
+            missing_permissions,
+        )
+        from disagreement.models import Member
+
+        channel = getattr(ctx, "channel", None)
+        if channel is None and hasattr(ctx.bot, "get_channel"):
+            channel = ctx.bot.get_channel(ctx.message.channel_id)
+        if channel is None and hasattr(ctx.bot, "fetch_channel"):
+            channel = await ctx.bot.fetch_channel(ctx.message.channel_id)
+
+        if channel is None:
+            raise CheckFailure("Channel for permission check not found.")
+
+        guild = getattr(channel, "guild", None)
+        if not guild and hasattr(channel, "guild_id") and channel.guild_id:
+            if hasattr(ctx.bot, "get_guild"):
+                guild = ctx.bot.get_guild(channel.guild_id)
+            if not guild and hasattr(ctx.bot, "fetch_guild"):
+                guild = await ctx.bot.fetch_guild(channel.guild_id)
+
+        if not guild:
+            is_dm = not hasattr(channel, "guild_id") or not channel.guild_id
+            if is_dm:
+                if perms:
+                    raise CheckFailure("Permission checks are not supported in DMs.")
+                return True
+            raise CheckFailure("Guild for permission check not found.")
+
+        member = ctx.author
+        if not isinstance(member, Member):
+            member = guild.get_member(ctx.author.id)
+            if not member and hasattr(ctx.bot, "fetch_member"):
+                member = await ctx.bot.fetch_member(guild.id, ctx.author.id)
+
+        if not member:
+            raise CheckFailure("Could not resolve author to a guild member.")
+
+        perms_value = _compute_permissions(member, channel, guild)
+
+        if not has_permissions(perms_value, *perms):
+            missing = missing_permissions(perms_value, *perms)
+            missing_names = ", ".join(p.name for p in missing if p.name)
+            raise CheckFailure(f"Missing permissions: {missing_names}")
+        return True
+
+    return check(predicate)

disagreement/ext/loader.py

@@ -5,7 +5,7 @@ import sys
 from types import ModuleType
 from typing import Dict
 
-__all__ = ["load_extension", "unload_extension"]
+__all__ = ["load_extension", "unload_extension", "reload_extension"]
 
 _loaded_extensions: Dict[str, ModuleType] = {}
 
@@ -41,3 +41,14 @@ def unload_extension(name: str) -> None:
         module.teardown()
 
     sys.modules.pop(name, None)
+
+
+def reload_extension(name: str) -> ModuleType:
+    """Reload an extension by name.
+
+    This is a convenience wrapper around :func:`unload_extension` followed by
+    :func:`load_extension`.
+    """
+
+    unload_extension(name)
+    return load_extension(name)