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

disagreement/ext/tasks.py

@@ -1,4 +1,5 @@
 import asyncio
+import datetime
 from typing import Any, Awaitable, Callable, Optional
 
 __all__ = ["loop", "Task"]
@@ -7,18 +8,73 @@ __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,
+        before_loop: Optional[Callable[[], Awaitable[None] | None]] = None,
+        after_loop: Optional[Callable[[], Awaitable[None] | 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
+        self._before_loop = before_loop
+        self._after_loop = after_loop
+
+    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:
+            if self._before_loop is not None:
+                await _maybe_call_no_args(self._before_loop)
+
+            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
+        finally:
+            if self._after_loop is not None:
+                await _maybe_call_no_args(self._after_loop)
 
     def start(self, *args: Any, **kwargs: Any) -> asyncio.Task[None]:
         if self._task is None or self._task.done():
@@ -35,12 +91,43 @@ 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
+
+
+async def _maybe_call_no_args(func: Callable[[], Awaitable[None] | None]) -> None:
+    result = func()
+    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
+        self._before_loop: Optional[Callable[..., Awaitable[Any]]] = None
+        self._after_loop: Optional[Callable[..., Awaitable[Any]]] = None
 
     def __get__(self, obj: Any, objtype: Any) -> "_BoundLoop":
         return _BoundLoop(self, obj)
@@ -50,8 +137,44 @@ class _Loop:
             return self.func(*args, **kwargs)
         return self.func(self._owner, *args, **kwargs)
 
+    def before_loop(
+        self, func: Callable[..., Awaitable[Any]]
+    ) -> Callable[..., Awaitable[Any]]:
+        self._before_loop = func
+        return func
+
+    def after_loop(
+        self, func: Callable[..., Awaitable[Any]]
+    ) -> Callable[..., Awaitable[Any]]:
+        self._after_loop = func
+        return func
+
     def start(self, *args: Any, **kwargs: Any) -> asyncio.Task[None]:
-        self._task = Task(self._coro, seconds=self.seconds)
+        def call_before() -> Awaitable[None] | None:
+            if self._before_loop is None:
+                return None
+            if self._owner is not None:
+                return self._before_loop(self._owner)
+            return self._before_loop()
+
+        def call_after() -> Awaitable[None] | None:
+            if self._after_loop is None:
+                return None
+            if self._owner is not None:
+                return self._after_loop(self._owner)
+            return self._after_loop()
+
+        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,
+            before_loop=call_before,
+            after_loop=call_after,
+        )
         return self._task.start(*args, **kwargs)
 
     def stop(self) -> None:
@@ -80,10 +203,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

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

@@ -17,11 +17,13 @@ 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
-    from .interactions import ApplicationCommand, InteractionResponsePayload, Snowflake
+    from .models import Message, Webhook, File
+    from .interactions import ApplicationCommand, Snowflake
 
 # Discord API constants
 API_BASE_URL = "https://discord.com/api/v10"  # Using API v10
@@ -44,8 +46,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:
@@ -60,7 +61,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,
@@ -85,10 +88,10 @@ class HTTPClient:
         if self.verbose:
             print(f"HTTP REQUEST: {method} {url} | payload={payload} params={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,6 +121,8 @@ class HTTPClient:
                 if self.verbose:
                     print(f"HTTP RESPONSE: {response.status} {url} | {data}")
 
+                self._rate_limiter.release(route, response.headers)
+
                 if 200 <= response.status < 300:
                     if response.status == 204:
                         return None
@@ -140,12 +145,9 @@ 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(
@@ -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,28 @@ 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"]:
+        """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 +394,119 @@ 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 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}")
@@ -556,7 +753,7 @@ class HTTPClient:
         self,
         interaction_id: "Snowflake",
         interaction_token: str,
-        payload: "InteractionResponsePayload",
+        payload: Union["InteractionResponsePayload", Dict[str, Any]],
         *,
         ephemeral: bool = False,
     ) -> None:
@@ -569,10 +766,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,
         )