disagreement 0.1.0rc1__py3-none-any.whl → 0.1.0rc3__py3-none-any.whl

disagreement/http.py

@@ -5,6 +5,7 @@ HTTP client for interacting with the Discord REST API.
 """
 
 import asyncio
+import logging
 import aiohttp  # pylint: disable=import-error
 import json
 from urllib.parse import quote
@@ -17,15 +18,19 @@ from .errors import (
     DisagreementException,
 )
 from . import __version__  # For User-Agent
+from .rate_limiter import RateLimiter
+from .interactions import InteractionResponsePayload
 
 if TYPE_CHECKING:
     from .client import Client
     from .models import Message, Webhook, File
-    from .interactions import ApplicationCommand, InteractionResponsePayload, Snowflake
+    from .interactions import ApplicationCommand, Snowflake
 
 # Discord API constants
 API_BASE_URL = "https://discord.com/api/v10"  # Using API v10
 
+logger = logging.getLogger(__name__)
+
 
 class HTTPClient:
     """Handles HTTP requests to the Discord API."""
@@ -44,8 +49,7 @@ class HTTPClient:
 
         self.verbose = verbose
 
-        self._global_rate_limit_lock = asyncio.Event()
-        self._global_rate_limit_lock.set()  # Initially unlocked
+        self._rate_limiter = RateLimiter()
 
     async def _ensure_session(self):
         if self._session is None or self._session.closed:
@@ -85,12 +89,18 @@ class HTTPClient:
             final_headers.update(custom_headers)
 
         if self.verbose:
-            print(f"HTTP REQUEST: {method} {url} | payload={payload} params={params}")
+            logger.debug(
+                "HTTP REQUEST: %s %s | payload=%s params=%s",
+                method,
+                url,
+                payload,
+                params,
+            )
 
-        # Global rate limit handling
-        await self._global_rate_limit_lock.wait()
+        route = f"{method.upper()}:{endpoint}"
 
         for attempt in range(5):  # Max 5 retries for rate limits
+            await self._rate_limiter.acquire(route)
             assert self._session is not None, "ClientSession not initialized"
             async with self._session.request(
                 method,
@@ -118,7 +128,11 @@ class HTTPClient:
                     )  # Fallback to text if JSON parsing fails
 
                 if self.verbose:
-                    print(f"HTTP RESPONSE: {response.status} {url} | {data}")
+                    logger.debug(
+                        "HTTP RESPONSE: %s %s | %s", response.status, url, data
+                    )
+
+                self._rate_limiter.release(route, response.headers)
 
                 if 200 <= response.status < 300:
                     if response.status == 204:
@@ -142,16 +156,17 @@ class HTTPClient:
                     if data and isinstance(data, dict) and "message" in data:
                         error_message += f" Discord says: {data['message']}"
 
-                    if is_global:
-                        self._global_rate_limit_lock.clear()
-                        await asyncio.sleep(retry_after)
-                        self._global_rate_limit_lock.set()
-                    else:
-                        await asyncio.sleep(retry_after)
+                    await self._rate_limiter.handle_rate_limit(
+                        route, retry_after, is_global
+                    )
 
                     if attempt < 4:  # Don't log on the last attempt before raising
-                        print(
-                            f"{error_message} Retrying after {retry_after}s (Attempt {attempt + 1}/5). Global: {is_global}"
+                        logger.warning(
+                            "%s Retrying after %ss (Attempt %s/5). Global: %s",
+                            error_message,
+                            retry_after,
+                            attempt + 1,
+                            is_global,
                         )
                         continue  # Retry the request
                     else:  # Last attempt failed
@@ -348,6 +363,16 @@ class HTTPClient:
             f"/channels/{channel_id}/messages/{message_id}/reactions/{encoded}",
         )
 
+    async def clear_reactions(
+        self, channel_id: "Snowflake", message_id: "Snowflake"
+    ) -> None:
+        """Removes all reactions from a message."""
+
+        await self.request(
+            "DELETE",
+            f"/channels/{channel_id}/messages/{message_id}/reactions",
+        )
+
     async def bulk_delete_messages(
         self, channel_id: "Snowflake", messages: List["Snowflake"]
     ) -> List["Snowflake"]:
@@ -411,6 +436,92 @@ class HTTPClient:
 
         await self.request("DELETE", f"/webhooks/{webhook_id}")
 
+    async def execute_webhook(
+        self,
+        webhook_id: "Snowflake",
+        token: str,
+        *,
+        content: Optional[str] = None,
+        tts: bool = False,
+        embeds: Optional[List[Dict[str, Any]]] = None,
+        components: Optional[List[Dict[str, Any]]] = None,
+        allowed_mentions: Optional[dict] = None,
+        attachments: Optional[List[Any]] = None,
+        files: Optional[List[Any]] = None,
+        flags: Optional[int] = None,
+        username: Optional[str] = None,
+        avatar_url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Executes a webhook and returns the created message."""
+
+        payload: Dict[str, Any] = {}
+        if content is not None:
+            payload["content"] = content
+        if tts:
+            payload["tts"] = True
+        if embeds:
+            payload["embeds"] = embeds
+        if components:
+            payload["components"] = components
+        if allowed_mentions:
+            payload["allowed_mentions"] = allowed_mentions
+        if username:
+            payload["username"] = username
+        if avatar_url:
+            payload["avatar_url"] = avatar_url
+
+        all_files: List["File"] = []
+        if attachments is not None:
+            payload["attachments"] = []
+            for a in attachments:
+                if hasattr(a, "data") and hasattr(a, "filename"):
+                    idx = len(all_files)
+                    all_files.append(a)
+                    payload["attachments"].append({"id": idx, "filename": a.filename})
+                else:
+                    payload["attachments"].append(
+                        a.to_dict() if hasattr(a, "to_dict") else a
+                    )
+        if files is not None:
+            for f in files:
+                if hasattr(f, "data") and hasattr(f, "filename"):
+                    idx = len(all_files)
+                    all_files.append(f)
+                    if "attachments" not in payload:
+                        payload["attachments"] = []
+                    payload["attachments"].append({"id": idx, "filename": f.filename})
+                else:
+                    raise TypeError("files must be File objects")
+        if flags:
+            payload["flags"] = flags
+
+        if all_files:
+            form = aiohttp.FormData()
+            form.add_field(
+                "payload_json", json.dumps(payload), content_type="application/json"
+            )
+            for idx, f in enumerate(all_files):
+                form.add_field(
+                    f"files[{idx}]",
+                    f.data,
+                    filename=f.filename,
+                    content_type="application/octet-stream",
+                )
+            return await self.request(
+                "POST",
+                f"/webhooks/{webhook_id}/{token}",
+                payload=form,
+                is_json=False,
+                use_auth_header=False,
+            )
+
+        return await self.request(
+            "POST",
+            f"/webhooks/{webhook_id}/{token}",
+            payload=payload,
+            use_auth_header=False,
+        )
+
     async def get_user(self, user_id: "Snowflake") -> Dict[str, Any]:
         """Fetches a user object for a given user ID."""
         return await self.request("GET", f"/users/{user_id}")
@@ -657,7 +768,7 @@ class HTTPClient:
         self,
         interaction_id: "Snowflake",
         interaction_token: str,
-        payload: "InteractionResponsePayload",
+        payload: Union["InteractionResponsePayload", Dict[str, Any]],
         *,
         ephemeral: bool = False,
     ) -> None:
@@ -670,10 +781,16 @@ class HTTPClient:
         """
         # Interaction responses do not use the bot token in the Authorization header.
         # They are authenticated by the interaction_token in the URL.
+        payload_data: Dict[str, Any]
+        if isinstance(payload, InteractionResponsePayload):
+            payload_data = payload.to_dict()
+        else:
+            payload_data = payload
+
         await self.request(
             "POST",
             f"/interactions/{interaction_id}/{interaction_token}/callback",
-            payload=payload.to_dict(),
+            payload=payload_data,
             use_auth_header=False,
         )
 

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

@@ -4,12 +4,12 @@
 Data models for Discord objects.
 """
 
-import json
-import asyncio
-import aiohttp  # pylint: disable=import-error
 import asyncio
-from typing import Optional, TYPE_CHECKING, List, Dict, Any, Union
+import json
+from typing import Any, AsyncIterator, Dict, List, Optional, TYPE_CHECKING, Union
 
+import aiohttp  # pylint: disable=import-error
+from .color import Color
 from .errors import DisagreementException, HTTPException
 from .enums import (  # These enums will need to be defined in disagreement/enums.py
     VerificationLevel,
@@ -201,6 +201,21 @@ 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|
 
@@ -312,7 +327,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
@@ -342,7 +357,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:
@@ -528,6 +543,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")
@@ -1065,6 +1086,19 @@ 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,
@@ -1224,6 +1258,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}'>"
@@ -1317,6 +1381,57 @@ class Webhook:
 
         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 ---
 
@@ -1708,13 +1823,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
 
@@ -1722,7 +1837,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:

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,

disagreement/utils.py

@@ -3,8 +3,71 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
+from typing import Any, AsyncIterator, Dict, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover - for type hinting only
+    from .models import Message, TextChannel
 
 
 def utcnow() -> datetime:
     """Return the current timezone-aware UTC time."""
     return datetime.now(timezone.utc)
+
+
+async def message_pager(
+    channel: "TextChannel",
+    *,
+    limit: Optional[int] = None,
+    before: Optional[str] = None,
+    after: Optional[str] = None,
+) -> AsyncIterator["Message"]:
+    """Asynchronously paginate a channel's messages.
+
+    Parameters
+    ----------
+    channel:
+        The :class:`TextChannel` to fetch messages from.
+    limit:
+        The maximum number of messages to yield. ``None`` fetches until no
+        more messages are returned.
+    before:
+        Fetch messages with IDs less than this snowflake.
+    after:
+        Fetch messages with IDs greater than this snowflake.
+
+    Yields
+    ------
+    Message
+        Messages in the channel, oldest first.
+    """
+
+    remaining = limit
+    last_id = before
+    while remaining is None or remaining > 0:
+        fetch_limit = 100
+        if remaining is not None:
+            fetch_limit = min(fetch_limit, remaining)
+
+        params: Dict[str, Any] = {"limit": fetch_limit}
+        if last_id is not None:
+            params["before"] = last_id
+        if after is not None:
+            params["after"] = after
+
+        data = await channel._client._http.request(  # type: ignore[attr-defined]
+            "GET",
+            f"/channels/{channel.id}/messages",
+            params=params,
+        )
+
+        if not data:
+            break
+
+        for raw in data:
+            msg = channel._client.parse_message(raw)  # type: ignore[attr-defined]
+            yield msg
+            last_id = msg.id
+            if remaining is not None:
+                remaining -= 1
+                if remaining == 0:
+                    return

{disagreement-0.1.0rc1.dist-info → disagreement-0.1.0rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: disagreement
-Version: 0.1.0rc1
+Version: 0.1.0rc3
 Summary: A Python library for the Discord API.
 Author-email: Slipstream <me@slipstreamm.dev>
 License: BSD 3-Clause
@@ -12,22 +12,23 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Internet
-Requires-Python: >=3.11
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp<4.0.0,>=3.9.0
 Provides-Extra: test
 Requires-Dist: pytest>=8.0.0; extra == "test"
 Requires-Dist: pytest-asyncio>=1.0.0; extra == "test"
-Requires-Dist: hypothesis>=6.89.0; extra == "test"
+Requires-Dist: hypothesis>=6.132.0; extra == "test"
 Provides-Extra: dev
-Requires-Dist: dotenv>=0.0.5; extra == "dev"
+Requires-Dist: python-dotenv>=1.0.0; extra == "dev"
 Dynamic: license-file
 
 # Disagreement
@@ -53,7 +54,7 @@ pip install disagreement
 pip install -e .
 ```
 
-Requires Python 3.11 or newer.
+Requires Python 3.10 or newer.
 
 ## Basic Usage