disagreement 0.0.2__py3-none-any.whl → 0.1.0rc1__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/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

@@ -114,6 +114,13 @@ 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,

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)

disagreement/ext/tasks.py

@@ -1,4 +1,5 @@
 import asyncio
+import datetime
 from typing import Any, Awaitable, Callable, Optional
 
 __all__ = ["loop", "Task"]
@@ -7,16 +8,61 @@ __all__ = ["loop", "Task"]
 class Task:
     """Simple repeating task."""
 
-    def __init__(self, coro: Callable[..., Awaitable[Any]], *, seconds: float) -> None:
+    def __init__(
+        self,
+        coro: Callable[..., Awaitable[Any]],
+        *,
+        seconds: float = 0.0,
+        minutes: float = 0.0,
+        hours: float = 0.0,
+        delta: Optional[datetime.timedelta] = None,
+        time_of_day: Optional[datetime.time] = None,
+        on_error: Optional[Callable[[Exception], Awaitable[None]]] = None,
+    ) -> None:
         self._coro = coro
-        self._seconds = float(seconds)
         self._task: Optional[asyncio.Task[None]] = None
+        if time_of_day is not None and (
+            seconds or minutes or hours or delta is not None
+        ):
+            raise ValueError("time_of_day cannot be used with an interval")
+
+        if delta is not None:
+            if not isinstance(delta, datetime.timedelta):
+                raise TypeError("delta must be a datetime.timedelta")
+            interval_seconds = delta.total_seconds()
+        else:
+            interval_seconds = seconds + minutes * 60.0 + hours * 3600.0
+
+        self._seconds = float(interval_seconds)
+        self._time_of_day = time_of_day
+        self._on_error = on_error
+
+    def _seconds_until_time(self) -> float:
+        assert self._time_of_day is not None
+        now = datetime.datetime.now()
+        target = datetime.datetime.combine(now.date(), self._time_of_day)
+        if target <= now:
+            target += datetime.timedelta(days=1)
+        return (target - now).total_seconds()
 
     async def _run(self, *args: Any, **kwargs: Any) -> None:
         try:
+            first = True
             while True:
-                await self._coro(*args, **kwargs)
-                await asyncio.sleep(self._seconds)
+                if self._time_of_day is not None:
+                    await asyncio.sleep(self._seconds_until_time())
+                elif not first:
+                    await asyncio.sleep(self._seconds)
+
+                try:
+                    await self._coro(*args, **kwargs)
+                except Exception as exc:  # noqa: BLE001
+                    if self._on_error is not None:
+                        await _maybe_call(self._on_error, exc)
+                    else:
+                        raise
+
+                first = False
         except asyncio.CancelledError:
             pass
 
@@ -35,10 +81,33 @@ class Task:
         return self._task is not None and not self._task.done()
 
 
+async def _maybe_call(
+    func: Callable[[Exception], Awaitable[None] | None], exc: Exception
+) -> None:
+    result = func(exc)
+    if asyncio.iscoroutine(result):
+        await result
+
+
 class _Loop:
-    def __init__(self, func: Callable[..., Awaitable[Any]], seconds: float) -> None:
+    def __init__(
+        self,
+        func: Callable[..., Awaitable[Any]],
+        *,
+        seconds: float = 0.0,
+        minutes: float = 0.0,
+        hours: float = 0.0,
+        delta: Optional[datetime.timedelta] = None,
+        time_of_day: Optional[datetime.time] = None,
+        on_error: Optional[Callable[[Exception], Awaitable[None]]] = None,
+    ) -> None:
         self.func = func
         self.seconds = seconds
+        self.minutes = minutes
+        self.hours = hours
+        self.delta = delta
+        self.time_of_day = time_of_day
+        self.on_error = on_error
         self._task: Optional[Task] = None
         self._owner: Any = None
 
@@ -51,7 +120,15 @@ class _Loop:
         return self.func(self._owner, *args, **kwargs)
 
     def start(self, *args: Any, **kwargs: Any) -> asyncio.Task[None]:
-        self._task = Task(self._coro, seconds=self.seconds)
+        self._task = Task(
+            self._coro,
+            seconds=self.seconds,
+            minutes=self.minutes,
+            hours=self.hours,
+            delta=self.delta,
+            time_of_day=self.time_of_day,
+            on_error=self.on_error,
+        )
         return self._task.start(*args, **kwargs)
 
     def stop(self) -> None:
@@ -80,10 +157,26 @@ class _BoundLoop:
         return self._parent.running
 
 
-def loop(*, seconds: float) -> Callable[[Callable[..., Awaitable[Any]]], _Loop]:
+def loop(
+    *,
+    seconds: float = 0.0,
+    minutes: float = 0.0,
+    hours: float = 0.0,
+    delta: Optional[datetime.timedelta] = None,
+    time_of_day: Optional[datetime.time] = None,
+    on_error: Optional[Callable[[Exception], Awaitable[None]]] = None,
+) -> Callable[[Callable[..., Awaitable[Any]]], _Loop]:
     """Decorator to create a looping task."""
 
     def decorator(func: Callable[..., Awaitable[Any]]) -> _Loop:
-        return _Loop(func, seconds)
+        return _Loop(
+            func,
+            seconds=seconds,
+            minutes=minutes,
+            hours=hours,
+            delta=delta,
+            time_of_day=time_of_day,
+            on_error=on_error,
+        )
 
     return decorator