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

disagreement/interactions.py

@@ -395,17 +395,14 @@ class Interaction:
 
     async def respond_modal(self, modal: "Modal") -> None:
         """|coro| Send a modal in response to this interaction."""
-
-        from typing import Any, cast
-
-        payload = {
-            "type": InteractionCallbackType.MODAL.value,
-            "data": modal.to_dict(),
-        }
+        payload = InteractionResponsePayload(
+            type=InteractionCallbackType.MODAL,
+            data=modal.to_dict(),
+        )
         await self._client._http.create_interaction_response(
             interaction_id=self.id,
             interaction_token=self.token,
-            payload=cast(Any, payload),
+            payload=payload,
         )
 
     async def edit(
@@ -489,7 +486,7 @@ class InteractionResponse:
         """Sends a modal response."""
         payload = InteractionResponsePayload(
             type=InteractionCallbackType.MODAL,
-            data=InteractionCallbackData(modal.to_dict()),
+            data=modal.to_dict(),
         )
         await self._interaction._client._http.create_interaction_response(
             self._interaction.id,
@@ -510,7 +507,7 @@ class InteractionCallbackData:
         )
         self.allowed_mentions: Optional[AllowedMentions] = (
             AllowedMentions(data["allowed_mentions"])
-            if data.get("allowed_mentions")
+            if "allowed_mentions" in data
             else None
         )
         self.flags: Optional[int] = data.get("flags")  # MessageFlags enum could be used
@@ -557,16 +554,22 @@ class InteractionResponsePayload:
     def __init__(
         self,
         type: InteractionCallbackType,
-        data: Optional[InteractionCallbackData] = None,
+        data: Optional[Union[InteractionCallbackData, Dict[str, Any]]] = None,
     ):
-        self.type: InteractionCallbackType = type
-        self.data: Optional[InteractionCallbackData] = data
+        self.type = type
+        self.data = data
 
     def to_dict(self) -> Dict[str, Any]:
         payload: Dict[str, Any] = {"type": self.type.value}
         if self.data:
-            payload["data"] = self.data.to_dict()
+            if isinstance(self.data, dict):
+                payload["data"] = self.data
+            else:
+                payload["data"] = self.data.to_dict()
         return payload
 
     def __repr__(self) -> str:
         return f"<InteractionResponsePayload type={self.type!r}>"
+
+    def __getitem__(self, key: str) -> Any:
+        return self.to_dict()[key]

disagreement/models.py

@@ -5,7 +5,10 @@ Data models for Discord objects.
 """
 
 import json
-from typing import Optional, TYPE_CHECKING, List, Dict, Any, Union
+import asyncio
+import aiohttp  # pylint: disable=import-error
+import asyncio
+from typing import Any, AsyncIterator, Dict, List, Optional, TYPE_CHECKING, Union
 
 from .errors import DisagreementException, HTTPException
 from .enums import (  # These enums will need to be defined in disagreement/enums.py
@@ -21,12 +24,15 @@ from .enums import (  # These enums will need to be defined in disagreement/enum
     ButtonStyle,  # Added for Button
     # SelectMenuType will be part of ComponentType or a new enum if needed
 )
+from .permissions import Permissions
+from .color import Color
 
 
 if TYPE_CHECKING:
     from .client import Client  # For type hinting to avoid circular imports
     from .enums import OverwriteType  # For PermissionOverwrite model
     from .ui.view import View
+    from .interactions import Snowflake
 
     # Forward reference Message if it were used in type hints before its definition
     # from .models import Message # Not needed as Message is defined before its use in TextChannel.send etc.
@@ -72,6 +78,7 @@ class Message:
         timestamp (str): When this message was sent (ISO8601 timestamp).
         components (Optional[List[ActionRow]]): Structured components attached
             to the message if present.
+        attachments (List[Attachment]): Attachments included with the message.
     """
 
     def __init__(self, data: dict, client_instance: "Client"):
@@ -92,6 +99,9 @@ class Message:
             ]
         else:
             self.components = None
+        self.attachments: List[Attachment] = [
+            Attachment(a) for a in data.get("attachments", [])
+        ]
         # Add other fields as needed, e.g., attachments, embeds, reactions, etc.
         # self.mentions: List[User] = [User(u) for u in data.get("mentions", [])]
         # self.mention_roles: List[str] = data.get("mention_roles", [])
@@ -192,6 +202,37 @@ class Message:
             view=view,
         )
 
+    async def add_reaction(self, emoji: str) -> None:
+        """|coro| Add a reaction to this message."""
+
+        await self._client.add_reaction(self.channel_id, self.id, emoji)
+
+    async def remove_reaction(self, emoji: str) -> None:
+        """|coro| Remove the bot's reaction from this message."""
+
+        await self._client.remove_reaction(self.channel_id, self.id, emoji)
+
+    async def clear_reactions(self) -> None:
+        """|coro| Remove all reactions from this message."""
+
+        await self._client.clear_reactions(self.channel_id, self.id)
+
+    async def delete(self, delay: Optional[float] = None) -> None:
+        """|coro|
+
+        Deletes this message.
+
+        Parameters
+        ----------
+        delay:
+            If provided, wait this many seconds before deleting.
+        """
+
+        if delay is not None:
+            await asyncio.sleep(delay)
+
+        await self._client._http.delete_message(self.channel_id, self.id)
+
     def __repr__(self) -> str:
         return f"<Message id='{self.id}' channel_id='{self.channel_id}' author='{self.author!r}'>"
 
@@ -287,7 +328,7 @@ class Embed:
         self.description: Optional[str] = data.get("description")
         self.url: Optional[str] = data.get("url")
         self.timestamp: Optional[str] = data.get("timestamp")  # ISO8601 timestamp
-        self.color: Optional[int] = data.get("color")
+        self.color = Color.parse(data.get("color"))
 
         self.footer: Optional[EmbedFooter] = (
             EmbedFooter(data["footer"]) if data.get("footer") else None
@@ -317,7 +358,7 @@ class Embed:
         if self.timestamp:
             payload["timestamp"] = self.timestamp
         if self.color is not None:
-            payload["color"] = self.color
+            payload["color"] = self.color.value
         if self.footer:
             payload["footer"] = self.footer.to_dict()
         if self.image:
@@ -373,6 +414,14 @@ class Attachment:
         return payload
 
 
+class File:
+    """Represents a file to be uploaded."""
+
+    def __init__(self, filename: str, data: bytes):
+        self.filename = filename
+        self.data = data
+
+
 class AllowedMentions:
     """Represents allowed mentions for a message or interaction response."""
 
@@ -495,6 +544,12 @@ class Member(User):  # Member inherits from User
     def __repr__(self) -> str:
         return f"<Member id='{self.id}' username='{self.username}' nick='{self.nick}'>"
 
+    @property
+    def display_name(self) -> str:
+        """Return the nickname if set, otherwise the username."""
+
+        return self.nick or self.username
+
     async def kick(self, *, reason: Optional[str] = None) -> None:
         if not self.guild_id or not self._client:
             raise DisagreementException("Member.kick requires guild_id and client")
@@ -527,6 +582,34 @@ class Member(User):  # Member inherits from User
             reason=reason,
         )
 
+    @property
+    def top_role(self) -> Optional["Role"]:
+        """Return the member's highest role from the guild cache."""
+
+        if not self.guild_id or not self._client:
+            return None
+
+        guild = self._client.get_guild(self.guild_id)
+        if not guild:
+            return None
+
+        if not guild.roles and hasattr(self._client, "fetch_roles"):
+            try:
+                self._client.loop.run_until_complete(
+                    self._client.fetch_roles(self.guild_id)
+                )
+            except RuntimeError:
+                future = asyncio.run_coroutine_threadsafe(
+                    self._client.fetch_roles(self.guild_id), self._client.loop
+                )
+                future.result()
+
+        role_objects = [r for r in guild.roles if r.id in self.roles]
+        if not role_objects:
+            return None
+
+        return max(role_objects, key=lambda r: r.position)
+
 
 class PartialEmoji:
     """Represents a partial emoji, often used in components or reactions.
@@ -853,6 +936,31 @@ class Guild:
     def get_member(self, user_id: str) -> Optional[Member]:
         return self._members.get(user_id)
 
+    def get_member_named(self, name: str) -> Optional[Member]:
+        """Retrieve a cached member by username or nickname.
+
+        The lookup is case-insensitive and searches both the username and
+        guild nickname for a match.
+
+        Parameters
+        ----------
+        name: str
+            The username or nickname to search for.
+
+        Returns
+        -------
+        Optional[Member]
+            The matching member if found, otherwise ``None``.
+        """
+
+        lowered = name.lower()
+        for member in self._members.values():
+            if member.username.lower() == lowered:
+                return member
+            if member.nick and member.nick.lower() == lowered:
+                return member
+        return None
+
     def get_role(self, role_id: str) -> Optional[Role]:
         return next((role for role in self.roles if role.id == role_id), None)
 
@@ -893,6 +1001,78 @@ class Channel:
     def __repr__(self) -> str:
         return f"<Channel id='{self.id}' name='{self.name}' type='{self.type.name if hasattr(self.type, 'name') else self._type_val}'>"
 
+    def permission_overwrite_for(
+        self, target: Union["Role", "Member", str]
+    ) -> Optional["PermissionOverwrite"]:
+        """Return the :class:`PermissionOverwrite` for ``target`` if present."""
+
+        if isinstance(target, str):
+            target_id = target
+        else:
+            target_id = target.id
+        for overwrite in self.permission_overwrites:
+            if overwrite.id == target_id:
+                return overwrite
+        return None
+
+    @staticmethod
+    def _apply_overwrite(
+        perms: Permissions, overwrite: Optional["PermissionOverwrite"]
+    ) -> Permissions:
+        if overwrite is None:
+            return perms
+
+        perms &= ~Permissions(int(overwrite.deny))
+        perms |= Permissions(int(overwrite.allow))
+        return perms
+
+    def permissions_for(self, member: "Member") -> Permissions:
+        """Resolve channel permissions for ``member``."""
+
+        if self.guild_id is None:
+            return Permissions(~0)
+
+        if not hasattr(self._client, "get_guild"):
+            return Permissions(0)
+
+        guild = self._client.get_guild(self.guild_id)
+        if guild is None:
+            return Permissions(0)
+
+        base = Permissions(0)
+
+        everyone = guild.get_role(guild.id)
+        if everyone is not None:
+            base |= Permissions(int(everyone.permissions))
+
+        for rid in member.roles:
+            role = guild.get_role(rid)
+            if role is not None:
+                base |= Permissions(int(role.permissions))
+
+        if base & Permissions.ADMINISTRATOR:
+            return Permissions(~0)
+
+        # Apply @everyone overwrite
+        base = self._apply_overwrite(base, self.permission_overwrite_for(guild.id))
+
+        # Role overwrites
+        role_allow = Permissions(0)
+        role_deny = Permissions(0)
+        for rid in member.roles:
+            ow = self.permission_overwrite_for(rid)
+            if ow is not None:
+                role_allow |= Permissions(int(ow.allow))
+                role_deny |= Permissions(int(ow.deny))
+
+        base &= ~role_deny
+        base |= role_allow
+
+        # Member overwrite
+        base = self._apply_overwrite(base, self.permission_overwrite_for(member.id))
+
+        return base
+
 
 class TextChannel(Channel):
     """Represents a guild text channel or announcement channel."""
@@ -907,6 +1087,20 @@ class TextChannel(Channel):
         )
         self.last_pin_timestamp: Optional[str] = data.get("last_pin_timestamp")
 
+
+    def history(
+        self,
+        *,
+        limit: Optional[int] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+    ) -> AsyncIterator["Message"]:
+        """Return an async iterator over this channel's messages."""
+
+        from .utils import message_pager
+
+        return message_pager(self, limit=limit, before=before, after=after)
+
     async def send(
         self,
         content: Optional[str] = None,
@@ -928,6 +1122,28 @@ class TextChannel(Channel):
             components=components,
         )
 
+    async def purge(
+        self, limit: int, *, before: "Snowflake | None" = None
+    ) -> List["Snowflake"]:
+        """Bulk delete messages from this channel."""
+
+        params: Dict[str, Union[int, str]] = {"limit": limit}
+        if before is not None:
+            params["before"] = before
+
+        messages = await self._client._http.request(
+            "GET", f"/channels/{self.id}/messages", params=params
+        )
+        ids = [m["id"] for m in messages]
+        if not ids:
+            return []
+
+        await self._client._http.bulk_delete_messages(self.id, ids)
+        for mid in ids:
+            self._client._messages.pop(mid, None)
+        return ids
+
+
     def __repr__(self) -> str:
         return f"<TextChannel id='{self.id}' name='{self.name}' guild_id='{self.guild_id}'>"
 
@@ -1045,6 +1261,36 @@ class DMChannel(Channel):
             components=components,
         )
 
+    async def history(
+        self,
+        *,
+        limit: Optional[int] = 100,
+        before: "Snowflake | None" = None,
+    ):
+        """An async iterator over messages in this DM."""
+
+        params: Dict[str, Union[int, str]] = {}
+        if before is not None:
+            params["before"] = before
+
+        fetched = 0
+        while True:
+            to_fetch = 100 if limit is None else min(100, limit - fetched)
+            if to_fetch <= 0:
+                break
+            params["limit"] = to_fetch
+            messages = await self._client._http.request(
+                "GET", f"/channels/{self.id}/messages", params=params.copy()
+            )
+            if not messages:
+                break
+            params["before"] = messages[-1]["id"]
+            for msg in messages:
+                yield Message(msg, self._client)
+                fetched += 1
+                if limit is not None and fetched >= limit:
+                    return
+
     def __repr__(self) -> str:
         recipient_repr = self.recipient.username if self.recipient else "Unknown"
         return f"<DMChannel id='{self.id}' recipient='{recipient_repr}'>"
@@ -1090,6 +1336,106 @@ class PartialChannel:
         return f"<PartialChannel id='{self.id}' name='{self.name}' type='{type_name}'>"
 
 
+class Webhook:
+    """Represents a Discord Webhook."""
+
+    def __init__(
+        self, data: Dict[str, Any], client_instance: Optional["Client"] = None
+    ):
+        self._client: Optional["Client"] = client_instance
+        self.id: str = data["id"]
+        self.type: int = int(data.get("type", 1))
+        self.guild_id: Optional[str] = data.get("guild_id")
+        self.channel_id: Optional[str] = data.get("channel_id")
+        self.name: Optional[str] = data.get("name")
+        self.avatar: Optional[str] = data.get("avatar")
+        self.token: Optional[str] = data.get("token")
+        self.application_id: Optional[str] = data.get("application_id")
+        self.url: Optional[str] = data.get("url")
+        self.user: Optional[User] = User(data["user"]) if data.get("user") else None
+
+    def __repr__(self) -> str:
+        return f"<Webhook id='{self.id}' name='{self.name}'>"
+
+    @classmethod
+    def from_url(
+        cls, url: str, session: Optional[aiohttp.ClientSession] = None
+    ) -> "Webhook":
+        """Create a minimal :class:`Webhook` from a webhook URL.
+
+        Parameters
+        ----------
+        url:
+            The full Discord webhook URL.
+        session:
+            Unused for now. Present for API compatibility.
+
+        Returns
+        -------
+        Webhook
+            A webhook instance containing only the ``id``, ``token`` and ``url``.
+        """
+
+        parts = url.rstrip("/").split("/")
+        if len(parts) < 2:
+            raise ValueError("Invalid webhook URL")
+        token = parts[-1]
+        webhook_id = parts[-2]
+
+        return cls({"id": webhook_id, "token": token, "url": url})
+
+    async def send(
+        self,
+        content: Optional[str] = None,
+        *,
+        username: Optional[str] = None,
+        avatar_url: Optional[str] = None,
+        tts: bool = False,
+        embed: Optional["Embed"] = None,
+        embeds: Optional[List["Embed"]] = None,
+        components: Optional[List["ActionRow"]] = None,
+        allowed_mentions: Optional[Dict[str, Any]] = None,
+        attachments: Optional[List[Any]] = None,
+        files: Optional[List[Any]] = None,
+        flags: Optional[int] = None,
+    ) -> "Message":
+        """Send a message using this webhook."""
+
+        if not self._client:
+            raise DisagreementException("Webhook is not bound to a Client")
+        assert self.token is not None, "Webhook token missing"
+
+        if embed and embeds:
+            raise ValueError("Cannot provide both embed and embeds.")
+
+        final_embeds_payload: Optional[List[Dict[str, Any]]] = None
+        if embed:
+            final_embeds_payload = [embed.to_dict()]
+        elif embeds:
+            final_embeds_payload = [e.to_dict() for e in embeds]
+
+        components_payload: Optional[List[Dict[str, Any]]] = None
+        if components:
+            components_payload = [c.to_dict() for c in components]
+
+        message_data = await self._client._http.execute_webhook(
+            self.id,
+            self.token,
+            content=content,
+            tts=tts,
+            embeds=final_embeds_payload,
+            components=components_payload,
+            allowed_mentions=allowed_mentions,
+            attachments=attachments,
+            files=files,
+            flags=flags,
+            username=username,
+            avatar_url=avatar_url,
+        )
+
+        return self._client.parse_message(message_data)
+
+
 # --- Message Components ---
 
 
@@ -1433,7 +1779,7 @@ class MediaGallery(Component):
         return payload
 
 
-class File(Component):
+class FileComponent(Component):
     """Represents a file component."""
 
     def __init__(
@@ -1480,13 +1826,13 @@ class Container(Component):
     def __init__(
         self,
         components: List[Component],
-        accent_color: Optional[int] = None,
+        accent_color: Color | int | str | None = None,
         spoiler: bool = False,
         id: Optional[int] = None,
     ):
         super().__init__(ComponentType.CONTAINER)
         self.components = components
-        self.accent_color = accent_color
+        self.accent_color = Color.parse(accent_color)
         self.spoiler = spoiler
         self.id = id
 
@@ -1494,7 +1840,7 @@ class Container(Component):
         payload = super().to_dict()
         payload["components"] = [c.to_dict() for c in self.components]
         if self.accent_color:
-            payload["accent_color"] = self.accent_color
+            payload["accent_color"] = self.accent_color.value
         if self.spoiler:
             payload["spoiler"] = self.spoiler
         if self.id is not None:
@@ -1614,6 +1960,85 @@ class TypingStart:
         return f"<TypingStart channel_id='{self.channel_id}' user_id='{self.user_id}'>"
 
 
+class Reaction:
+    """Represents a message reaction event."""
+
+    def __init__(
+        self, data: Dict[str, Any], client_instance: Optional["Client"] = None
+    ):
+        self._client = client_instance
+        self.user_id: str = data["user_id"]
+        self.channel_id: str = data["channel_id"]
+        self.message_id: str = data["message_id"]
+        self.guild_id: Optional[str] = data.get("guild_id")
+        self.member: Optional[Member] = (
+            Member(data["member"], client_instance) if data.get("member") else None
+        )
+        self.emoji: Dict[str, Any] = data.get("emoji", {})
+
+    def __repr__(self) -> str:
+        emoji_value = self.emoji.get("name") or self.emoji.get("id")
+        return f"<Reaction message_id='{self.message_id}' user_id='{self.user_id}' emoji='{emoji_value}'>"
+
+
+class GuildMemberRemove:
+    """Represents a GUILD_MEMBER_REMOVE event."""
+
+    def __init__(
+        self, data: Dict[str, Any], client_instance: Optional["Client"] = None
+    ):
+        self._client = client_instance
+        self.guild_id: str = data["guild_id"]
+        self.user: User = User(data["user"])
+
+    def __repr__(self) -> str:
+        return (
+            f"<GuildMemberRemove guild_id='{self.guild_id}' user_id='{self.user.id}'>"
+        )
+
+
+class GuildBanAdd:
+    """Represents a GUILD_BAN_ADD event."""
+
+    def __init__(
+        self, data: Dict[str, Any], client_instance: Optional["Client"] = None
+    ):
+        self._client = client_instance
+        self.guild_id: str = data["guild_id"]
+        self.user: User = User(data["user"])
+
+    def __repr__(self) -> str:
+        return f"<GuildBanAdd guild_id='{self.guild_id}' user_id='{self.user.id}'>"
+
+
+class GuildBanRemove:
+    """Represents a GUILD_BAN_REMOVE event."""
+
+    def __init__(
+        self, data: Dict[str, Any], client_instance: Optional["Client"] = None
+    ):
+        self._client = client_instance
+        self.guild_id: str = data["guild_id"]
+        self.user: User = User(data["user"])
+
+    def __repr__(self) -> str:
+        return f"<GuildBanRemove guild_id='{self.guild_id}' user_id='{self.user.id}'>"
+
+
+class GuildRoleUpdate:
+    """Represents a GUILD_ROLE_UPDATE event."""
+
+    def __init__(
+        self, data: Dict[str, Any], client_instance: Optional["Client"] = None
+    ):
+        self._client = client_instance
+        self.guild_id: str = data["guild_id"]
+        self.role: Role = Role(data["role"])
+
+    def __repr__(self) -> str:
+        return f"<GuildRoleUpdate guild_id='{self.guild_id}' role_id='{self.role.id}'>"
+
+
 def channel_factory(data: Dict[str, Any], client: "Client") -> Channel:
     """Create a channel object from raw API data."""
     channel_type = data.get("type")

disagreement/shard_manager.py

@@ -51,6 +51,8 @@ class ShardManager:
                 verbose=self.client.verbose,
                 shard_id=shard_id,
                 shard_count=self.shard_count,
+                max_retries=self.client.gateway_max_retries,
+                max_backoff=self.client.gateway_max_backoff,
             )
             self.shards.append(Shard(shard_id, self.shard_count, gateway))
 

disagreement/ui/modal.py

@@ -74,7 +74,7 @@ def text_input(
 
         item = TextInput(
             label=label,
-            custom_id=custom_id,
+            custom_id=custom_id or func.__name__,
             style=style,
             placeholder=placeholder,
             required=required,