Merge: v5.2.0

5.2.0

Author: LordOfPolls

.pre-commit-config.yaml

@@ -30,12 +30,12 @@ repos:
     - id: check-merge-conflict
       name: Merge Conflicts
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: 'v0.0.254'
+    rev: 'v0.0.261'
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
   - repo: https://github.com/psf/black
-    rev: 23.1.0
+    rev: 23.3.0
     hooks:
       - id: black
         name: Black Formatting

docs/src/Guides/22 Live Patching.md

@@ -17,3 +17,12 @@ That's it! The extension will handle all of the leg work, and all you'll notice
 ## How is this useful?
 
 interactions.py takes advantage of jurigged to reload any and all commands that were edited whenever a change is made, allowing you to have more uptime with while still adding/improving features of your bot.
+
+## It's not working inside Docker!
+To make `jurigged` work inside Docker container, you need to mount the directory you're working in as a volume in the container (pointing to the code directory inside the container).
+
+Additionally, you need to initialize the `jurigged` extension with the `poll` keyword argument set to `True`:
+
+```py
+bot.load_extension("interactions.ext.jurigged", poll=True)
+```

docs/src/Guides/25 Error Tracking.md

@@ -15,7 +15,7 @@ from interactions.api.events import Error
 
 @listen()
 async def on_error(error: Error):
-    await bot.get_channel(LOGGING_CHANNEL_ID).send(f"```\n{error.source}\n{error.error}\n```)
+    await bot.get_channel(LOGGING_CHANNEL_ID).send(f"```\n{error.source}\n{error.error}\n```")
 ```
 
 And this is great when debugging.  But it consumes your rate limit, can run into the 2000 character message limit, and won't work on shards that don't contain your personal server.  It's also very hard to notice patterns and can be noisy.

interactions/api/gateway/websocket.py

@@ -164,7 +164,7 @@ async def send_json(self, data: dict, bypass=False) -> None:
         serialized = FastJson.dumps(data)
         await self.send(serialized, bypass)
 
-    async def receive(self, force: bool = False) -> str:
+    async def receive(self, force: bool = False) -> str:  # noqa: C901
         """
         Receive a full event payload from the WebSocket.
 

interactions/api/http/http_client.py

@@ -334,7 +334,7 @@ def _process_payload(
         form_data.add_field("payload_json", FastJson.dumps(payload))
         return form_data
 
-    async def request(
+    async def request(  # noqa: C901
         self,
         route: Route,
         payload: list | dict | None = None,
@@ -403,7 +403,7 @@ async def request(
                                 # resource ratelimit is reached
                                 self.log_ratelimit(
                                     self.logger.warning,
-                                    f"{route.endpoint} The resource is being rate limited! "
+                                    f"{route.resolved_endpoint} The resource is being rate limited! "
                                     f"Reset in {result.get('retry_after')} seconds",
                                 )
                                 # lock this resource and wait for unlock
@@ -414,15 +414,15 @@ async def request(
                                 # so long as these are infrequent we're doing well
                                 self.log_ratelimit(
                                     self.logger.warning,
-                                    f"{route.endpoint} Has exceeded it's ratelimit ({lock.limit})! Reset in {lock.delta} seconds",
+                                    f"{route.resolved_endpoint} Has exceeded its ratelimit ({lock.limit})! Reset in {lock.delta} seconds",
                                 )
                                 await lock.lock_for_duration(lock.delta, block=True)
                             continue
                         if lock.remaining == 0:
                             # Last call available in the bucket, lock until reset
                             self.log_ratelimit(
                                 self.logger.debug,
-                                f"{route.endpoint} Has exhausted its ratelimit ({lock.limit})! Locking route for {lock.delta} seconds",
+                                f"{route.resolved_endpoint} Has exhausted its ratelimit ({lock.limit})! Locking route for {lock.delta} seconds",
                             )
                             await lock.lock_for_duration(
                                 lock.delta
@@ -431,7 +431,7 @@ async def request(
                         elif response.status in {500, 502, 504}:
                             # Server issues, retry
                             self.logger.warning(
-                                f"{route.endpoint} Received {response.status}... retrying in {1 + attempt * 2} seconds"
+                                f"{route.resolved_endpoint} Received {response.status}... retrying in {1 + attempt * 2} seconds"
                             )
                             await asyncio.sleep(1 + attempt * 2)
                             continue
@@ -440,7 +440,7 @@ async def request(
                             await self._raise_exception(response, route, result)
 
                         self.logger.debug(
-                            f"{route.endpoint} Received {response.status} :: [{lock.remaining}/{lock.limit} calls remaining]"
+                            f"{route.resolved_endpoint} Received {response.status} :: [{lock.remaining}/{lock.limit} calls remaining]"
                         )
                         return result
                 except OSError as e:

interactions/api/http/http_requests/channels.py

@@ -376,7 +376,7 @@ async def get_invite(
         }
         params = dict_filter_none(params)
 
-        result = await self.request(Route("GET", "/invites/{invite_code}", params=params))
+        result = await self.request(Route("GET", "/invites/{invite_code}", invite_code=invite_code, params=params))
         return cast(discord_typings.InviteData, result)
 
     async def delete_invite(self, invite_code: str, reason: str | None = None) -> discord_typings.InviteData:

interactions/api/http/http_requests/threads.py

@@ -180,6 +180,7 @@ async def create_thread(
         auto_archive_duration: int,
         thread_type: Absent[int] = MISSING,
         invitable: Absent[bool] = MISSING,
+        rate_limit_per_user: Absent[int] = MISSING,
         message_id: Absent["Snowflake_Type"] = MISSING,
         reason: Absent[str] = MISSING,
     ) -> discord_typings.ThreadChannelData:
@@ -191,15 +192,20 @@ async def create_thread(
             name: The name of the thread
             auto_archive_duration: duration in minutes to automatically archive the thread after recent activity, can be set to: 60, 1440, 4320, 10080
             thread_type: The type of thread, defaults to public. ignored if creating thread from a message
-            invitable:
+            invitable: Whether non-moderators can add other non-moderators to a thread; only available when creating a private thread
+            rate_limit_per_user: The time users must wait between sending messages (0-21600)
             message_id: An optional message to create a thread from.
             reason: An optional reason for the audit log
 
         Returns:
             The created thread
 
         """
-        payload = {"name": name, "auto_archive_duration": auto_archive_duration}
+        payload = {
+            "name": name,
+            "auto_archive_duration": auto_archive_duration,
+            "rate_limit_per_user": rate_limit_per_user,
+        }
         if message_id:
             return await self.request(
                 Route(

interactions/api/http/route.py

@@ -55,14 +55,36 @@ def rl_bucket(self) -> str:
             return f"{self.webhook_id}{self.webhook_token}:{self.channel_id}:{self.guild_id}:{self.endpoint}"
         return f"{self.channel_id}:{self.guild_id}:{self.endpoint}"
 
+    @property
+    def major_params(self) -> dict[str, str | int]:
+        """The major parameters for this route"""
+        return {
+            "channel_id": self.channel_id,
+            "guild_id": self.guild_id,
+            "webhook_id": self.webhook_id,
+            "webhook_token": self.webhook_token,
+        }
+
+    @property
+    def resolved_path(self) -> str:
+        """The endpoint for this route, with all parameters resolved"""
+        return self.path.format_map({k: _uriquote(v) if isinstance(v, str) else v for k, v in self.params.items()})
+
     @property
     def endpoint(self) -> str:
         """The endpoint for this route"""
         return f"{self.method} {self.path}"
 
+    @property
+    def resolved_endpoint(self) -> str:
+        """The endpoint for this route, with all major parameters resolved"""
+        path = self.path
+        for key, value in self.major_params.items():
+            path = path.replace(f"{{{key}}}", str(value))
+
+        return f"{self.method} {path}"
+
     @property
     def url(self) -> str:
         """The full url for this route"""
-        return f"{self.BASE}{self.path}".format_map(
-            {k: _uriquote(v) if isinstance(v, str) else v for k, v in self.params.items()}
-        )
+        return f"{self.BASE}{self.resolved_path}"

interactions/api/voice/voice_gateway.py

@@ -100,7 +100,7 @@ async def run(self) -> None:
             # possible race conditions to consider.
             await self.dispatch_opcode(data, op)
 
-    async def receive(self, force=False) -> str:
+    async def receive(self, force=False) -> str:  # noqa: C901
         buffer = bytearray()
 
         while True:

interactions/client/client.py

@@ -1598,12 +1598,14 @@ def get_application_cmd_by_id(
             The command, if one with the given ID exists internally, otherwise None
 
         """
+        cmd_id = to_snowflake(cmd_id)
+        scope = to_snowflake(scope) if scope is not None else None
+
         if scope is not None:
-            return self.interactions_by_scope.get(scope, {}).get(cmd_id)
-        return next(
-            (scope[cmd_id] for scope in self.interactions_by_scope.values() if cmd_id in scope),
-            None,
-        )
+            return next(
+                (cmd for cmd in self.interactions_by_scope[scope].values() if cmd.get_cmd_id(scope) == cmd_id), None
+            )
+        return next(cmd for cmd in self._interaction_lookup.values() if cmd_id in cmd.cmd_id.values())
 
     def _raise_sync_exception(self, e: HTTPException, cmds_json: dict, cmd_scope: "Snowflake_Type") -> NoReturn:
         try:
@@ -1691,7 +1693,7 @@ async def _run_slash_command(self, command: SlashCommand, ctx: "InteractionConte
         return await command(ctx, **ctx.kwargs)
 
     @processors.Processor.define("raw_interaction_create")
-    async def _dispatch_interaction(self, event: RawGatewayEvent) -> None:
+    async def _dispatch_interaction(self, event: RawGatewayEvent) -> None:  # noqa: C901
         """
         Identify and dispatch interaction of slash commands or components.
 
@@ -1701,6 +1703,10 @@ async def _dispatch_interaction(self, event: RawGatewayEvent) -> None:
         """
         interaction_data = event.data
 
+        if not self._startup:
+            self.logger.warning("Received interaction before startup completed, ignoring")
+            return
+
         if interaction_data["type"] in (
             InteractionType.APPLICATION_COMMAND,
             InteractionType.AUTOCOMPLETE,