Merge branch 'master' into search

Signed-off-by: Nelo <41271523+NeloBlivion@users.noreply.github.com>

Author: NeloBlivion

.github/workflows/release.yml

@@ -129,7 +129,7 @@ jobs:
           git fetch origin
           if ! git show-ref --verify --quiet refs/heads/$VERSION_BRANCH; then
             git checkout -b $VERSION_BRANCH
-            git push origin $VERSION_BRANCH
+            git push origin $VERSION_BRANCH -f
           fi
           git checkout $VERSION_BRANCH
       - name: "Setup Python"

CHANGELOG.md

@@ -18,6 +18,8 @@ These changes are available on the `master` branch, but have not yet been releas
 ### Changed
 
 - Changed that `read_only` team members aren't considered as owner.
+- `read_only` team members aren't considered as owners anymore when checking for app
+  ownership permissions.
 
 ### Fixed
 
@@ -32,6 +34,10 @@ These changes are available on the `master` branch, but have not yet been releas
 - Fixed incorrect type hints for `MessagePinIterator`.
   ([#3178](https://github.com/Pycord-Development/pycord/pull/3178))
 - Fixed team `permissions` keyerror by replacing deprecated permissions with `role`.
+- Fixed a `KeyError` when fetching an app's information or checking for app ownership
+  with `is_owner`.
+- Fixed certain scenarios where received components could crash the app.
+  ([#3059](https://github.com/Pycord-Development/pycord/pull/3059))
 
 ### Deprecated
 

discord/abc.py

@@ -1735,7 +1735,7 @@ async def send(
             if view.is_dispatchable():
                 state.store_view(view, ret.id)
             view.message = ret
-            view.refresh(ret.components)
+            view._refresh(ret.components)
 
         if delete_after is not None:
             await ret.delete(delay=delete_after)

discord/bot.py

@@ -57,7 +57,7 @@
     UserCommand,
     command,
 )
-from .enums import IntegrationType, InteractionContextType, InteractionType
+from .enums import IntegrationType, InteractionContextType, InteractionType, TeamRole
 from .errors import CheckFailure, DiscordException
 from .interactions import Interaction
 from .shard import AutoShardedClient
@@ -66,7 +66,13 @@
 from .utils import MISSING, async_all, find, get
 
 if TYPE_CHECKING:
+    from typing_extensions import Never
+
+    from .cog import Cog
+    from .commands import Option
+    from .ext.commands import Cooldown
     from .member import Member
+    from .permissions import Permissions
 
 C = TypeVar("C", bound=MessageCommand | SlashCommand | UserCommand)
 CoroFunc = Callable[..., Coroutine[Any, Any, Any]]
@@ -909,7 +915,26 @@ async def callback() -> None:
             if not autocomplete_task.done():
                 autocomplete_task.cancel()
 
-    def slash_command(self, **kwargs):
+    def slash_command(
+        self,
+        *,
+        checks: list[Callable[[ApplicationContext], bool]] | None = MISSING,
+        cog: Cog | None = MISSING,
+        contexts: set[InteractionContextType] | None = MISSING,
+        cooldown: Cooldown | None = MISSING,
+        default_member_permissions: Permissions | None = MISSING,
+        description: str | None = MISSING,
+        description_localizations: dict[str, str] | None = MISSING,
+        guild_ids: list[int] | None = MISSING,
+        guild_only: bool | None = MISSING,
+        integration_types: set[IntegrationType] | None = MISSING,
+        name: str | None = MISSING,
+        name_localizations: dict[str, str] | None = MISSING,
+        nsfw: bool | None = MISSING,
+        options: list[Option] | None = MISSING,
+        parent: SlashCommandGroup | None = MISSING,
+        **kwargs: Never,
+    ) -> Callable[..., SlashCommand]:
         """A shortcut decorator for adding a slash command to the bot.
         This is equivalent to using :meth:`application_command`, providing
         the :class:`SlashCommand` class.
@@ -922,9 +947,42 @@ def slash_command(self, **kwargs):
             A decorator that converts the provided function into a :class:`.SlashCommand`,
             adds it to the bot, and returns it.
         """
-        return self.application_command(cls=SlashCommand, **kwargs)
+        return self.application_command(
+            cls=SlashCommand,
+            checks=checks,
+            cog=cog,
+            contexts=contexts,
+            cooldown=cooldown,
+            default_member_permissions=default_member_permissions,
+            description=description,
+            description_localizations=description_localizations,
+            guild_ids=guild_ids,
+            guild_only=guild_only,
+            integration_types=integration_types,
+            name=name,
+            name_localizations=name_localizations,
+            nsfw=nsfw,
+            options=options,
+            parent=parent,
+            **kwargs,
+        )
 
-    def user_command(self, **kwargs):
+    def user_command(
+        self,
+        *,
+        checks: list[Callable[[ApplicationContext], bool]] | None = MISSING,
+        cog: Cog | None = MISSING,
+        contexts: set[InteractionContextType] | None = MISSING,
+        cooldown: Cooldown | None = MISSING,
+        default_member_permissions: Permissions | None = MISSING,
+        guild_ids: list[int] | None = MISSING,
+        guild_only: bool | None = MISSING,
+        integration_types: set[IntegrationType] | None = MISSING,
+        name: str | None = MISSING,
+        name_localizations: dict[str, str] | None = MISSING,
+        nsfw: bool | None = MISSING,
+        **kwargs: Never,
+    ) -> Callable[..., UserCommand]:
         """A shortcut decorator for adding a user command to the bot.
         This is equivalent to using :meth:`application_command`, providing
         the :class:`UserCommand` class.
@@ -937,9 +995,38 @@ def user_command(self, **kwargs):
             A decorator that converts the provided function into a :class:`.UserCommand`,
             adds it to the bot, and returns it.
         """
-        return self.application_command(cls=UserCommand, **kwargs)
+        return self.application_command(
+            cls=UserCommand,
+            checks=checks,
+            cog=cog,
+            contexts=contexts,
+            cooldown=cooldown,
+            default_member_permissions=default_member_permissions,
+            guild_ids=guild_ids,
+            guild_only=guild_only,
+            integration_types=integration_types,
+            name=name,
+            name_localizations=name_localizations,
+            nsfw=nsfw,
+            **kwargs,
+        )
 
-    def message_command(self, **kwargs):
+    def message_command(
+        self,
+        *,
+        checks: list[Callable[[ApplicationContext], bool]] | None = MISSING,
+        cog: Cog | None = MISSING,
+        contexts: set[InteractionContextType] | None = MISSING,
+        cooldown: Cooldown | None = MISSING,
+        default_member_permissions: Permissions | None = MISSING,
+        guild_ids: list[int] | None = MISSING,
+        guild_only: bool | None = MISSING,
+        integration_types: set[IntegrationType] | None = MISSING,
+        name: str | None = MISSING,
+        name_localizations: dict[str, str] | None = MISSING,
+        nsfw: bool | None = MISSING,
+        **kwargs: Never,
+    ) -> Callable[..., MessageCommand]:
         """A shortcut decorator for adding a message command to the bot.
         This is equivalent to using :meth:`application_command`, providing
         the :class:`MessageCommand` class.
@@ -952,9 +1039,43 @@ def message_command(self, **kwargs):
             A decorator that converts the provided function into a :class:`.MessageCommand`,
             adds it to the bot, and returns it.
         """
-        return self.application_command(cls=MessageCommand, **kwargs)
+        return self.application_command(
+            cls=MessageCommand,
+            checks=checks,
+            cog=cog,
+            contexts=contexts,
+            cooldown=cooldown,
+            default_member_permissions=default_member_permissions,
+            guild_ids=guild_ids,
+            guild_only=guild_only,
+            integration_types=integration_types,
+            name=name,
+            name_localizations=name_localizations,
+            nsfw=nsfw,
+            **kwargs,
+        )
 
-    def application_command(self, cls: type[C] = SlashCommand, **kwargs):
+    def application_command(
+        self,
+        *,
+        cls: type[C] = SlashCommand,
+        checks: list[Callable[[ApplicationContext], bool]] | None = MISSING,
+        cog: Cog | None = MISSING,
+        contexts: set[InteractionContextType] | None = MISSING,
+        cooldown: Cooldown | None = MISSING,
+        default_member_permissions: Permissions | None = MISSING,
+        description: str | None = MISSING,
+        description_localizations: dict[str, str] | None = MISSING,
+        guild_ids: list[int] | None = MISSING,
+        guild_only: bool | None = MISSING,
+        integration_types: set[IntegrationType] | None = MISSING,
+        name: str | None = MISSING,
+        name_localizations: dict[str, str] | None = MISSING,
+        nsfw: bool | None = MISSING,
+        options: list[Option] | None = MISSING,
+        parent: SlashCommandGroup | None = MISSING,
+        **kwargs: Any,
+    ) -> Callable[..., C]:
         """A shortcut decorator that converts the provided function into
         an application command via :func:`command` and adds it to
         the internal command list via :meth:`~.Bot.add_application_command`.
@@ -976,6 +1097,26 @@ class be provided, it must be a subclass of either
             adds it to the bot, and returns it.
         """
 
+        params = {
+            "checks": checks,
+            "cog": cog,
+            "contexts": contexts,
+            "cooldown": cooldown,
+            "default_member_permissions": default_member_permissions,
+            "description": description,
+            "description_localizations": description_localizations,
+            "guild_ids": guild_ids,
+            "guild_only": guild_only,
+            "integration_types": integration_types,
+            "name": name,
+            "name_localizations": name_localizations,
+            "nsfw": nsfw,
+            "options": options,
+            "parent": parent,
+            **kwargs,
+        }
+        kwargs = {k: v for k, v in params.items() if v is not MISSING}
+
         def decorator(func) -> C:
             result = command(cls=cls, **kwargs)(func)
             self.add_application_command(result)
@@ -1467,7 +1608,7 @@ async def is_owner(self, user: User | Member) -> bool:
             app = await self.application_info()  # type: ignore
             if app.team:
                 self.owner_ids = ids = {
-                    m.id for m in app.team.members if m.role != "read_only"
+                    m.id for m in app.team.members if m.role is not TeamRole.read_only
                 }
                 return user.id in ids
             else: