feat: add support for editing our own application information (#1237)

Signed-off-by: arielle <[email protected]>
Co-authored-by: vi <[email protected]>
Co-authored-by: shiftinv <[email protected]>

Author: onerandomusername

changelog/1237.feature.rst

@@ -0,0 +1 @@
+Add support for modifying application info using :meth:`AppInfo.edit`.

disnake/appinfo.py

@@ -2,13 +2,14 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict, List, Optional, cast
+from typing import TYPE_CHECKING, Dict, List, Optional, Sequence, cast
 
 from . import utils
-from .asset import Asset
+from .asset import Asset, AssetBytes
 from .enums import ApplicationEventWebhookStatus, try_enum
 from .flags import ApplicationFlags
 from .permissions import Permissions
+from .utils import MISSING
 
 if TYPE_CHECKING:
     from .guild import Guild
@@ -17,12 +18,14 @@
         AppInfo as AppInfoPayload,
         ApplicationIntegrationType as ApplicationIntegrationTypeLiteral,
         ApplicationIntegrationTypeConfiguration as ApplicationIntegrationTypeConfigurationPayload,
+        EditAppInfo as EditAppInfoPayload,
         InstallParams as InstallParamsPayload,
         PartialAppInfo as PartialAppInfoPayload,
         Team as TeamPayload,
     )
     from .user import User
 
+
 __all__ = (
     "AppInfo",
     "PartialAppInfo",
@@ -36,6 +39,9 @@ class InstallParams:
 
     .. versionadded:: 2.5
 
+    .. versionchanged:: |vnext|
+        This class can now be created by users.
+
     Attributes
     ----------
     scopes: List[:class:`str`]
@@ -53,27 +59,46 @@ class InstallParams:
 
     def __init__(
         self,
+        *,
+        scopes: List[str],
+        permissions: Permissions = MISSING,
+    ) -> None:
+        self.scopes = scopes
+        if permissions is MISSING:
+            permissions = Permissions.none()
+        self.permissions = permissions
+        self._app_id: Optional[int] = None
+        self._install_type: Optional[ApplicationIntegrationTypeLiteral] = None
+
+    @classmethod
+    def _from_data(
+        cls,
         data: InstallParamsPayload,
         parent: AppInfo,
         *,
         install_type: Optional[ApplicationIntegrationTypeLiteral] = None,
-    ) -> None:
-        self._app_id = parent.id
-        self._install_type: Optional[ApplicationIntegrationTypeLiteral] = install_type
-        self.scopes = data["scopes"]
-        self.permissions = Permissions(int(data["permissions"]))
+    ) -> InstallParams:
+        instance = cls(permissions=Permissions(int(data["permissions"])), scopes=data["scopes"])
+        instance._install_type = install_type
+        instance._app_id = parent.id
+        return instance
 
     def __repr__(self) -> str:
         return f"<InstallParams scopes={self.scopes!r} permissions={self.permissions!r}>"
 
     def to_url(self) -> str:
         """Returns a string that can be used to install this application.
 
+        .. note:: This method can only be used on InstallParams that have been created by :meth:`.Client.application_info`
+
         Returns
         -------
         :class:`str`
             The invite url.
         """
+        if self._app_id is None:
+            msg = "This InstallParams instance is not linked to an application."
+            raise ValueError(msg)
         return utils.oauth_url(
             self._app_id,
             scopes=self.scopes,
@@ -83,12 +108,22 @@ def to_url(self) -> str:
             ),
         )
 
+    def to_dict(self) -> InstallParamsPayload:
+        return {
+            "scopes": self.scopes,
+            "permissions": str(self.permissions.value),
+        }
+
 
 class InstallTypeConfiguration:
     """Represents the configuration for a particular application installation type.
 
     .. versionadded:: 2.10
 
+    .. versionchanged:: |vnext|
+
+        This class can now be created by users.
+
     Attributes
     ----------
     install_params: Optional[:class:`InstallParams`]
@@ -97,19 +132,31 @@ class InstallTypeConfiguration:
 
     __slots__ = ("install_params",)
 
-    def __init__(
-        self,
+    def __init__(self, *, install_params: Optional[InstallParams] = None) -> None:
+        self.install_params: Optional[InstallParams] = install_params
+
+    @classmethod
+    def _from_data(
+        cls,
         data: ApplicationIntegrationTypeConfigurationPayload,
         *,
         parent: AppInfo,
         install_type: ApplicationIntegrationTypeLiteral,
-    ) -> None:
-        self.install_params: Optional[InstallParams] = (
-            InstallParams(install_params, parent=parent, install_type=install_type)
+    ) -> InstallTypeConfiguration:
+        return cls(
+            install_params=InstallParams._from_data(
+                install_params, parent=parent, install_type=install_type
+            )
             if (install_params := data.get("oauth2_install_params"))
             else None
         )
 
+    def to_dict(self) -> ApplicationIntegrationTypeConfigurationPayload:
+        payload: ApplicationIntegrationTypeConfigurationPayload = {}
+        if self.install_params:
+            payload["oauth2_install_params"] = self.install_params.to_dict()
+        return payload
+
     def __repr__(self) -> str:
         return f"<InstallTypeConfiguration install_params={self.install_params!r}>"
 
@@ -310,7 +357,9 @@ def __init__(self, state: ConnectionState, data: AppInfoPayload) -> None:
         )
         self.tags: Optional[List[str]] = data.get("tags")
         self.install_params: Optional[InstallParams] = (
-            InstallParams(data["install_params"], parent=self) if "install_params" in data else None
+            InstallParams._from_data(data["install_params"], parent=self)
+            if "install_params" in data
+            else None
         )
         self.custom_install_url: Optional[str] = data.get("custom_install_url")
         self.redirect_uris: Optional[List[str]] = data.get("redirect_uris")
@@ -335,7 +384,7 @@ def __init__(self, state: ConnectionState, data: AppInfoPayload) -> None:
         ] = {}
         for type_str, config in (data.get("integration_types_config") or {}).items():
             install_type = cast("ApplicationIntegrationTypeLiteral", int(type_str))
-            self._install_types_config[install_type] = InstallTypeConfiguration(
+            self._install_types_config[install_type] = InstallTypeConfiguration._from_data(
                 config or {},
                 parent=self,
                 install_type=install_type,
@@ -405,6 +454,193 @@ def user_install_type_config(self) -> Optional[InstallTypeConfiguration]:
         """
         return self._install_types_config.get(1)
 
+    async def edit(
+        self,
+        *,
+        custom_install_url: Optional[str] = MISSING,
+        description: Optional[str] = MISSING,
+        role_connections_verification_url: Optional[str] = MISSING,
+        install_params: Optional[InstallParams] = MISSING,
+        guild_install_type_config: Optional[InstallTypeConfiguration] = MISSING,
+        user_install_type_config: Optional[InstallTypeConfiguration] = MISSING,
+        flags: ApplicationFlags = MISSING,
+        icon: Optional[AssetBytes] = MISSING,
+        cover_image: Optional[AssetBytes] = MISSING,
+        interactions_endpoint_url: Optional[str] = MISSING,
+        tags: Sequence[str] = MISSING,
+        event_webhooks_url: Optional[str] = MISSING,
+        event_webhooks_status: ApplicationEventWebhookStatus = MISSING,
+        event_webhooks_types: Sequence[str] = MISSING,
+    ) -> AppInfo:
+        """|coro|
+
+        Edit's the application's information.
+
+        All parameters are optional.
+
+        .. versionadded:: |vnext|
+
+        Parameters
+        ----------
+        custom_install_url: Optional[:class:`str`]
+            The custom installation url for this application.
+        description: Optional[:class:`str`]
+            The application's description.
+        role_connections_verification_url: Optional[:class:`str`]
+            The application's role connection verification entry point,
+            which when configured will render the app as a verification method
+            in the guild role verification configuration.
+        install_params: Optional[:class:`InstallParams`]
+            The installation parameters for this application.
+
+            If provided with ``custom_install_url``, must be set to ``None``.
+
+            It's recommended to use :attr:`guild_install_type_config` and :attr:`user_install_type_config`
+            instead of this parameter, as this parameter is soft-deprecated by Discord.
+
+            :attr:`bot_public` **must** be ``True`` if this parameter is provided.
+        guild_install_type_config: Optional[:class:`InstallTypeConfiguration`]
+            The guild installation type configuration for this application.
+            If set to ``None``, guild installations will be disabled.
+            You cannot disable both user and guild installations.
+
+            Note the only valid scopes for guild installations are ``applications.commands`` and ``bot``.
+
+        user_install_type_config: Optional[:class:`InstallTypeConfiguration`]
+            The user installation type configuration for this application.
+            If set to ``None``, user installations will be disabled.
+            You cannot disable both user and guild installations.
+
+            Note the only valid scopes for user installations are ``applications.commands``.
+        flags: :class:`ApplicationFlags`
+            The application's public flags.
+
+            This is restricted to only affecting the limited intent flags:
+            :attr:`~ApplicationFlags.gateway_guild_members_limited`,
+            :attr:`~ApplicationFlags.gateway_presence_limited`, and
+            :attr:`~ApplicationFlags.gateway_message_content_limited`.
+
+            .. warning::
+                Disabling an intent that you are currently requesting during your current session
+                will cause you to be disconnected from the gateway. Take caution when providing this parameter.
+
+        icon: Optional[|resource_type|]
+            Update the application's icon asset, if any.
+        cover_image: Optional[|resource_type|]
+            Update the cover_image for rich presence integrations.
+        interactions_endpoint_url: Optional[:class:`str`]
+            The application's interactions endpoint URL.
+        tags: List[:class:`str`]
+            The application's tags.
+        event_webhooks_url: Optional[:class:`str`]
+            The application's event webhooks URL.
+        event_webhooks_status: :class:`ApplicationEventWebhookStatus`
+            The application's event webhooks status.
+        event_webhooks_types: Optional[List[:class:`str`]]
+            The application's event webhook types. See `webhook event types <https://discord.com/developers/docs/events/webhook-events#event-types>`_
+            for a list of valid events.
+
+        Raises
+        ------
+        HTTPException
+            Editing the application information failed.
+
+        Returns
+        -------
+        :class:`.AppInfo`
+            The new application information.
+
+        Examples
+        --------
+
+        .. code-block:: python
+
+            >>> app_info = await client.application_info()
+            >>> await app_info.edit(description="A new description!")
+
+        To enable user installations while using custom install URL.
+
+        .. code-block:: python
+
+            >>> from disnake import InstallTypeConfiguration
+            >>> await app_info.edit(
+            ...     user_install_type_config=InstallTypeConfiguration()
+            ... )
+
+        To disable user installations and guild installations.
+        Note, both cannot be disabled simultaneously.
+
+        .. code-block:: python
+
+            >>> await app_info.edit(
+            ...     custom_install_url="https://example.com/install",
+            ...     # to disable user installations
+            ...     user_install_type_config=None,
+            ...     # to disable guild installations
+            ...     guild_install_type_config=None,
+            ... )
+        """
+        fields: EditAppInfoPayload = {}
+
+        if custom_install_url is not MISSING:
+            fields["custom_install_url"] = custom_install_url
+
+        if description is not MISSING:
+            fields["description"] = description or ""
+
+        if role_connections_verification_url is not MISSING:
+            fields["role_connections_verification_url"] = role_connections_verification_url
+
+        if install_params is not MISSING:
+            fields["install_params"] = install_params.to_dict() if install_params else None
+
+        if guild_install_type_config is not MISSING or user_install_type_config is not MISSING:
+            integration_types_config: Dict[str, ApplicationIntegrationTypeConfigurationPayload] = {}
+
+            if guild_install_type_config is MISSING:
+                guild_install_type_config = self.guild_install_type_config
+            if guild_install_type_config:
+                integration_types_config["0"] = guild_install_type_config.to_dict()
+
+            if user_install_type_config is MISSING:
+                user_install_type_config = self.user_install_type_config
+            if user_install_type_config:
+                integration_types_config["1"] = user_install_type_config.to_dict()
+
+            fields["integration_types_config"] = integration_types_config
+
+        if flags is not MISSING:
+            fields["flags"] = flags.value
+
+        if icon is not MISSING:
+            fields["icon"] = await utils._assetbytes_to_base64_data(icon)
+
+        if cover_image is not MISSING:
+            fields["cover_image"] = await utils._assetbytes_to_base64_data(cover_image)
+
+        if interactions_endpoint_url is not MISSING:
+            fields["interactions_endpoint_url"] = interactions_endpoint_url
+
+        if tags is not MISSING:
+            fields["tags"] = list(tags) if tags else None
+
+        if event_webhooks_url is not MISSING:
+            fields["event_webhooks_url"] = event_webhooks_url
+
+        if event_webhooks_status is not MISSING:
+            if event_webhooks_status is ApplicationEventWebhookStatus.disabled_by_discord:
+                msg = f"cannot set 'event_webhooks_status' to {event_webhooks_status!r}"
+                raise ValueError(msg)
+            fields["event_webhooks_status"] = event_webhooks_status.value
+
+        if event_webhooks_types is not MISSING:
+            fields["event_webhooks_types"] = (
+                list(event_webhooks_types) if event_webhooks_types else None
+            )
+
+        data = await self._state.http.edit_application_info(**fields)
+        return AppInfo(self._state, data)
+
 
 class PartialAppInfo:
     """Represents a partial AppInfo given by :func:`~disnake.abc.GuildChannel.create_invite`.

disnake/http.py

@@ -3059,6 +3059,9 @@ def get_voice_regions(self) -> Response[List[voice.VoiceRegion]]:
     def application_info(self) -> Response[appinfo.AppInfo]:
         return self.request(Route("GET", "/oauth2/applications/@me"))
 
+    def edit_application_info(self, **fields: Any) -> Response[appinfo.AppInfo]:
+        return self.request(Route("PATCH", "/applications/@me"), json=fields)
+
     def get_application_role_connection_metadata_records(
         self, application_id: Snowflake
     ) -> Response[List[application_role_connection.ApplicationRoleConnectionMetadata]]: