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

disagreement/gateway.py

@@ -10,6 +10,7 @@ import aiohttp
 import json
 import zlib
 import time
+import random
 from typing import Optional, TYPE_CHECKING, Any, Dict
 
 from .enums import GatewayOpcode, GatewayIntent
@@ -43,6 +44,8 @@ class GatewayClient:
         *,
         shard_id: Optional[int] = None,
         shard_count: Optional[int] = None,
+        max_retries: int = 5,
+        max_backoff: float = 60.0,
     ):
         self._http: "HTTPClient" = http_client
         self._dispatcher: "EventDispatcher" = event_dispatcher
@@ -52,6 +55,8 @@ class GatewayClient:
         self.verbose: bool = verbose
         self._shard_id: Optional[int] = shard_id
         self._shard_count: Optional[int] = shard_count
+        self._max_retries: int = max_retries
+        self._max_backoff: float = max_backoff
 
         self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
         self._loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
@@ -63,10 +68,33 @@ class GatewayClient:
         self._keep_alive_task: Optional[asyncio.Task] = None
         self._receive_task: Optional[asyncio.Task] = None
 
+        self._last_heartbeat_sent: Optional[float] = None
+        self._last_heartbeat_ack: Optional[float] = None
+
         # For zlib decompression
         self._buffer = bytearray()
         self._inflator = zlib.decompressobj()
 
+    async def _reconnect(self) -> None:
+        """Attempts to reconnect using exponential backoff with jitter."""
+        delay = 1.0
+        for attempt in range(self._max_retries):
+            try:
+                await self.connect()
+                return
+            except Exception as e:  # noqa: BLE001
+                if attempt >= self._max_retries - 1:
+                    print(f"Reconnect failed after {attempt + 1} attempts: {e}")
+                    raise
+                jitter = random.uniform(0, delay)
+                wait_time = min(delay + jitter, self._max_backoff)
+                print(
+                    f"Reconnect attempt {attempt + 1} failed: {e}. "
+                    f"Retrying in {wait_time:.2f} seconds..."
+                )
+                await asyncio.sleep(wait_time)
+                delay = min(delay * 2, self._max_backoff)
+
     async def _decompress_message(
         self, message_bytes: bytes
     ) -> Optional[Dict[str, Any]]:
@@ -103,6 +131,7 @@ class GatewayClient:
 
     async def _heartbeat(self):
         """Sends a heartbeat to the Gateway."""
+        self._last_heartbeat_sent = time.monotonic()
         payload = {"op": GatewayOpcode.HEARTBEAT, "d": self._last_sequence}
         await self._send_json(payload)
         # print("Sent heartbeat.")
@@ -350,7 +379,7 @@ class GatewayClient:
             await self._heartbeat()
         elif op == GatewayOpcode.RECONNECT:  # Server requests a reconnect
             print("Gateway requested RECONNECT. Closing and will attempt to reconnect.")
-            await self.close(code=4000)  # Use a non-1000 code to indicate reconnect
+            await self.close(code=4000, reconnect=True)
         elif op == GatewayOpcode.INVALID_SESSION:
             # The 'd' payload for INVALID_SESSION is a boolean indicating resumability
             can_resume = data.get("d") is True
@@ -359,9 +388,7 @@ class GatewayClient:
                 self._session_id = None  # Clear session_id to force re-identify
                 self._last_sequence = None
             # Close and reconnect. The connect logic will decide to resume or identify.
-            await self.close(
-                code=4000 if can_resume else 4009
-            )  # 4009 for non-resumable
+            await self.close(code=4000 if can_resume else 4009, reconnect=True)
         elif op == GatewayOpcode.HELLO:
             hello_d_payload = data.get("d")
             if (
@@ -388,6 +415,7 @@ class GatewayClient:
                 print("Performing initial IDENTIFY.")
                 await self._identify()
         elif op == GatewayOpcode.HEARTBEAT_ACK:
+            self._last_heartbeat_ack = time.monotonic()
             # print("Received heartbeat ACK.")
             pass  # Good, connection is alive
         else:
@@ -406,13 +434,11 @@ class GatewayClient:
             print("Receive_loop task cancelled.")
         except aiohttp.ClientConnectionError as e:
             print(f"ClientConnectionError in receive_loop: {e}. Attempting reconnect.")
-            # This might be handled by an outer reconnect loop in the Client class
-            await self.close(code=1006)  # Abnormal closure
+            await self.close(code=1006, reconnect=True)  # Abnormal closure
         except Exception as e:
             print(f"Unexpected error in receive_loop: {e}")
             traceback.print_exc()
-            # Consider specific error types for more granular handling
-            await self.close(code=1011)  # Internal error
+            await self.close(code=1011, reconnect=True)
         finally:
             print("Receive_loop ended.")
             # If the loop ends unexpectedly (not due to explicit close),
@@ -460,7 +486,7 @@ class GatewayClient:
                 f"An unexpected error occurred during Gateway connection: {e}"
             ) from e
 
-    async def close(self, code: int = 1000):
+    async def close(self, code: int = 1000, *, reconnect: bool = False):
         """Closes the Gateway connection."""
         print(f"Closing Gateway connection with code {code}...")
         if self._keep_alive_task and not self._keep_alive_task.done():
@@ -471,11 +497,13 @@ class GatewayClient:
                 pass  # Expected
 
         if self._receive_task and not self._receive_task.done():
+            current = asyncio.current_task(loop=self._loop)
             self._receive_task.cancel()
-            try:
-                await self._receive_task
-            except asyncio.CancelledError:
-                pass  # Expected
+            if self._receive_task is not current:
+                try:
+                    await self._receive_task
+                except asyncio.CancelledError:
+                    pass  # Expected
 
         if self._ws and not self._ws.closed:
             await self._ws.close(code=code)
@@ -491,3 +519,18 @@ class GatewayClient:
             self._session_id = None
             self._last_sequence = None
             self._resume_gateway_url = None  # This might be re-fetched anyway
+
+    @property
+    def latency(self) -> Optional[float]:
+        """Returns the latency between heartbeat and ACK in seconds."""
+        if self._last_heartbeat_sent is None or self._last_heartbeat_ack is None:
+            return None
+        return self._last_heartbeat_ack - self._last_heartbeat_sent
+
+    @property
+    def last_heartbeat_sent(self) -> Optional[float]:
+        return self._last_heartbeat_sent
+
+    @property
+    def last_heartbeat_ack(self) -> Optional[float]:
+        return self._last_heartbeat_ack

disagreement/http.py

@@ -20,7 +20,7 @@ from . import __version__  # For User-Agent
 
 if TYPE_CHECKING:
     from .client import Client
-    from .models import Message
+    from .models import Message, Webhook, File
     from .interactions import ApplicationCommand, InteractionResponsePayload, Snowflake
 
 # Discord API constants
@@ -60,7 +60,9 @@ class HTTPClient:
         self,
         method: str,
         endpoint: str,
-        payload: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None,
+        payload: Optional[
+            Union[Dict[str, Any], List[Dict[str, Any]], aiohttp.FormData]
+        ] = None,
         params: Optional[Dict[str, Any]] = None,
         is_json: bool = True,
         use_auth_header: bool = True,
@@ -204,11 +206,23 @@ class HTTPClient:
         components: Optional[List[Dict[str, Any]]] = None,
         allowed_mentions: Optional[dict] = None,
         message_reference: Optional[Dict[str, Any]] = None,
+        attachments: Optional[List[Any]] = None,
+        files: Optional[List[Any]] = None,
         flags: Optional[int] = None,
     ) -> Dict[str, Any]:
         """Sends a message to a channel.
 
-        Returns the created message data as a dict.
+        Parameters
+        ----------
+        attachments:
+            A list of attachment payloads to include with the message.
+        files:
+            A list of :class:`File` objects containing binary data to upload.
+
+        Returns
+        -------
+        Dict[str, Any]
+            The created message data.
         """
         payload: Dict[str, Any] = {}
         if content is not None:  # Content is optional if embeds/components are present
@@ -221,6 +235,28 @@ class HTTPClient:
             payload["components"] = components
         if allowed_mentions:
             payload["allowed_mentions"] = allowed_mentions
+        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 message_reference:
@@ -229,6 +265,25 @@ class HTTPClient:
         if not payload:
             raise ValueError("Message must have content, embeds, or components.")
 
+        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"/channels/{channel_id}/messages",
+                payload=form,
+                is_json=False,
+            )
+
         return await self.request(
             "POST", f"/channels/{channel_id}/messages", payload=payload
         )
@@ -256,6 +311,13 @@ class HTTPClient:
             "GET", f"/channels/{channel_id}/messages/{message_id}"
         )
 
+    async def delete_message(
+        self, channel_id: "Snowflake", message_id: "Snowflake"
+    ) -> None:
+        """Deletes a message in a channel."""
+
+        await self.request("DELETE", f"/channels/{channel_id}/messages/{message_id}")
+
     async def create_reaction(
         self, channel_id: "Snowflake", message_id: "Snowflake", emoji: str
     ) -> None:
@@ -286,6 +348,18 @@ class HTTPClient:
             f"/channels/{channel_id}/messages/{message_id}/reactions/{encoded}",
         )
 
+    async def bulk_delete_messages(
+        self, channel_id: "Snowflake", messages: List["Snowflake"]
+    ) -> List["Snowflake"]:
+        """Bulk deletes messages in a channel and returns their IDs."""
+
+        await self.request(
+            "POST",
+            f"/channels/{channel_id}/messages/bulk-delete",
+            payload={"messages": messages},
+        )
+        return messages
+
     async def delete_channel(
         self, channel_id: str, reason: Optional[str] = None
     ) -> None:
@@ -310,6 +384,33 @@ class HTTPClient:
         """Fetches a channel by ID."""
         return await self.request("GET", f"/channels/{channel_id}")
 
+    async def create_webhook(
+        self, channel_id: "Snowflake", payload: Dict[str, Any]
+    ) -> "Webhook":
+        """Creates a webhook in the specified channel."""
+
+        data = await self.request(
+            "POST", f"/channels/{channel_id}/webhooks", payload=payload
+        )
+        from .models import Webhook
+
+        return Webhook(data)
+
+    async def edit_webhook(
+        self, webhook_id: "Snowflake", payload: Dict[str, Any]
+    ) -> "Webhook":
+        """Edits an existing webhook."""
+
+        data = await self.request("PATCH", f"/webhooks/{webhook_id}", payload=payload)
+        from .models import Webhook
+
+        return Webhook(data)
+
+    async def delete_webhook(self, webhook_id: "Snowflake") -> None:
+        """Deletes a webhook."""
+
+        await self.request("DELETE", f"/webhooks/{webhook_id}")
+
     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}")