diff options
Diffstat (limited to 'discord/http.py')
| -rw-r--r-- | discord/http.py | 763 |
1 files changed, 518 insertions, 245 deletions
diff --git a/discord/http.py b/discord/http.py index 1419acb6..c3525451 100644 --- a/discord/http.py +++ b/discord/http.py @@ -28,7 +28,21 @@ import asyncio import json import logging import sys -from typing import Any, Coroutine, List, Optional, TYPE_CHECKING, TypeVar +from typing import ( + Any, + ClassVar, + Coroutine, + Dict, + Final, + Iterable, + List, + Optional, + Sequence, + TYPE_CHECKING, + Tuple, + Type, + TypeVar, +) from urllib.parse import quote as _uriquote import weakref @@ -41,20 +55,45 @@ from . import __version__, utils log = logging.getLogger(__name__) if TYPE_CHECKING: + from .file import File + from .enums import ( + AuditLogAction, + InteractionResponseType, + ) + from .types import ( + appinfo, + audit_log, + channel, + components, + emoji, + embed, + guild, + integration, interactions, invite, + member, + message, + template, + role, + user, + webhook, channel, widget, threads, + voice, ) - from .types.snowflake import Snowflake + from .types.snowflake import Snowflake, SnowflakeList + + from types import TracebackType T = TypeVar('T') + BE = TypeVar('BE', bound=BaseException) + MU = TypeVar('MU', bound='MaybeUnlock') Response = Coroutine[Any, Any, T] -async def json_or_text(response): +async def json_or_text(response: aiohttp.ClientResponse) -> Any: text = await response.text(encoding='utf-8') try: if response.headers['content-type'] == 'application/json': @@ -67,79 +106,90 @@ async def json_or_text(response): class Route: - BASE = 'https://discord.com/api/v8' + BASE: ClassVar[str] = 'https://discord.com/api/v8' - def __init__(self, method, path, **parameters): - self.path = path - self.method = method + def __init__(self, method: str, path: str, **parameters: Any) -> None: + self.path: str = path + self.method: str = method url = self.BASE + self.path if parameters: - self.url = url.format_map({k: _uriquote(v) if isinstance(v, str) else v for k, v in parameters.items()}) - else: - self.url = url + url = url.format_map({k: _uriquote(v) if isinstance(v, str) else v for k, v in parameters.items()}) + self.url: str = url # major parameters: - self.channel_id = parameters.get('channel_id') - self.guild_id = parameters.get('guild_id') - self.webhook_id = parameters.get('webhook_id') - self.webhook_token = parameters.get('webhook_token') + self.channel_id: Optional[Snowflake] = parameters.get('channel_id') + self.guild_id: Optional[Snowflake] = parameters.get('guild_id') + self.webhook_id: Optional[Snowflake] = parameters.get('webhook_id') + self.webhook_token: Optional[str] = parameters.get('webhook_token') @property - def bucket(self): + def bucket(self) -> str: # the bucket is just method + path w/ major parameters return f'{self.channel_id}:{self.guild_id}:{self.path}' class MaybeUnlock: - def __init__(self, lock): - self.lock = lock - self._unlock = True + def __init__(self, lock: asyncio.Lock) -> None: + self.lock: asyncio.Lock = lock + self._unlock: bool = True - def __enter__(self): + def __enter__(self: MU) -> MU: return self - def defer(self): + def defer(self) -> None: self._unlock = False - def __exit__(self, type, value, traceback): + def __exit__(self, + exc_type: Optional[Type[BE]], + exc: Optional[BE], + traceback: Optional[TracebackType], + ) -> None: if self._unlock: self.lock.release() # For some reason, the Discord voice websocket expects this header to be # completely lowercase while aiohttp respects spec and does it as case-insensitive -aiohttp.hdrs.WEBSOCKET = 'websocket' +aiohttp.hdrs.WEBSOCKET = 'websocket' #type: ignore class HTTPClient: """Represents an HTTP client sending HTTP requests to the Discord API.""" - SUCCESS_LOG = '{method} {url} has received {text}' - REQUEST_LOG = '{method} {url} with {json} has returned {status}' + SUCCESS_LOG: Final[ClassVar[str]] = '{method} {url} has received {text}' + REQUEST_LOG: Final[ClassVar[str]] = '{method} {url} with {json} has returned {status}' - def __init__(self, connector=None, *, proxy=None, proxy_auth=None, loop=None, unsync_clock=True): - self.loop = asyncio.get_event_loop() if loop is None else loop + def __init__( + self, + connector: Optional[aiohttp.BaseConnector] = None, + *, + proxy: Optional[str] = None, + proxy_auth: Optional[aiohttp.BasicAuth] = None, + loop: Optional[asyncio.AbstractEventLoop] = None, + unsync_clock: bool = True + ) -> None: + self.loop: asyncio.AbstractEventLoop = asyncio.get_event_loop() if loop is None else loop self.connector = connector - self.__session = None # filled in static_login - self._locks = weakref.WeakValueDictionary() - self._global_over = asyncio.Event() + self.__session: Optional[aiohttp.ClientSession] = None # filled in static_login + self._locks: weakref.WeakValueDictionary = weakref.WeakValueDictionary() + self._global_over: asyncio.Event = asyncio.Event() self._global_over.set() - self.token = None - self.bot_token = False - self.proxy = proxy - self.proxy_auth = proxy_auth - self.use_clock = not unsync_clock + self.token: Optional[str] = None + self.bot_token: bool = False + self.proxy: Optional[str] = proxy + self.proxy_auth: Optional[aiohttp.BasicAuth] = proxy_auth + self.use_clock: bool = not unsync_clock user_agent = 'DiscordBot (https://github.com/Rapptz/discord.py {0}) Python/{1[0]}.{1[1]} aiohttp/{2}' - self.user_agent = user_agent.format(__version__, sys.version_info, aiohttp.__version__) + self.user_agent: str = user_agent.format(__version__, sys.version_info, aiohttp.__version__) - def recreate(self): + def recreate(self) -> None: if self.__session.closed: self.__session = aiohttp.ClientSession( connector=self.connector, ws_response_class=DiscordClientWebSocketResponse ) - async def ws_connect(self, url, *, compress=0): + async def ws_connect(self, url: str, *, compress: int = 0) -> Any: kwargs = { 'proxy_auth': self.proxy_auth, 'proxy': self.proxy, @@ -154,7 +204,14 @@ class HTTPClient: return await self.__session.ws_connect(url, **kwargs) - async def request(self, route, *, files=None, form=None, **kwargs) -> Any: + async def request( + self, + route: Route, + *, + files: Optional[Sequence[File]] = None, + form: Optional[Iterable[Dict[str, Any]]] = None, + **kwargs: Any + ) -> Any: bucket = route.bucket method = route.method url = route.url @@ -289,7 +346,7 @@ class HTTPClient: raise HTTPException(r, data) - async def get_from_cdn(self, url): + async def get_from_cdn(self, url: str) -> bytes: async with self.__session.get(url) as resp: if resp.status == 200: return await resp.read() @@ -302,13 +359,13 @@ class HTTPClient: # state management - async def close(self): + async def close(self) -> None: if self.__session: await self.__session.close() # login management - async def static_login(self, token): + async def static_login(self, token: str) -> user.User: # Necessary to get aiohttp to stop complaining about session creation self.__session = aiohttp.ClientSession(connector=self.connector, ws_response_class=DiscordClientWebSocketResponse) old_token = self.token @@ -324,24 +381,24 @@ class HTTPClient: return data - def logout(self): + def logout(self) -> Response[None]: return self.request(Route('POST', '/auth/logout')) # Group functionality - def start_group(self, user_id, recipients): + def start_group(self, user_id: Snowflake, recipients: List[int]) -> Response[channel.GroupDMChannel]: payload = { 'recipients': recipients, } return self.request(Route('POST', '/users/{user_id}/channels', user_id=user_id), json=payload) - def leave_group(self, channel_id): + def leave_group(self, channel_id) -> Response[None]: return self.request(Route('DELETE', '/channels/{channel_id}', channel_id=channel_id)) # Message management - def start_private_message(self, user_id): + def start_private_message(self, user_id: Snowflake) -> Response[channel.DMChannel]: payload = { 'recipient_id': user_id, } @@ -350,16 +407,16 @@ class HTTPClient: def send_message( self, - channel_id, - content, + channel_id: Snowflake, + content: str, *, - tts=False, - embed=None, - nonce=None, - allowed_mentions=None, - message_reference=None, - components=None, - ): + tts: bool = False, + embed: Optional[embed.Embed] = None, + nonce: Optional[str] = None, + allowed_mentions: bool = None, + message_reference: bool = None, + components: Optional[List[components.Component]] = None, + ) -> Response[message.Message]: r = Route('POST', '/channels/{channel_id}/messages', channel_id=channel_id) payload = {} @@ -386,26 +443,26 @@ class HTTPClient: return self.request(r, json=payload) - def send_typing(self, channel_id): + def send_typing(self, channel_id: Snowflake) -> Response[None]: return self.request(Route('POST', '/channels/{channel_id}/typing', channel_id=channel_id)) def send_multipart_helper( self, - route, + route: Route, *, - files, - content=None, - tts=False, - embed=None, - embeds=None, - nonce=None, - allowed_mentions=None, - message_reference=None, - components=None, - ): + files: Sequence[File], + content: Optional[str] = None, + tts: bool = False, + embed: Optional[embed.Embed] = None, + embeds: Iterable[Optional[embed.Embed]] = None, + nonce: Optional[str] = None, + allowed_mentions: Optional[message.AllowedMentions] = None, + message_reference: Optional[message.MessageReference] = None, + components: Optional[List[components.Component]] = None, + ) -> Response[message.Message]: form = [] - payload = {'tts': tts} + payload: Dict[str, Any] = {'tts': tts} if content: payload['content'] = content if embed: @@ -447,17 +504,17 @@ class HTTPClient: def send_files( self, - channel_id, + channel_id: Snowflake, *, - files, - content=None, - tts=False, - embed=None, - nonce=None, - allowed_mentions=None, - message_reference=None, - components=None, - ): + files: Sequence[File], + content: Optional[str] = None, + tts: bool = False, + embed: Optional[embed.Embed] = None, + nonce: Optional[str] = None, + allowed_mentions: Optional[message.AllowedMentions] = None, + message_reference: Optional[message.MessageReference] = None, + components: Optional[List[components.Component]] = None, + ) -> Response[message.Message]: r = Route('POST', '/channels/{channel_id}/messages', channel_id=channel_id) return self.send_multipart_helper( r, @@ -471,11 +528,11 @@ class HTTPClient: components=components, ) - def delete_message(self, channel_id, message_id, *, reason=None): + def delete_message(self, channel_id: Snowflake, message_id: Snowflake, *, reason: Optional[str] = None) -> Response[None]: r = Route('DELETE', '/channels/{channel_id}/messages/{message_id}', channel_id=channel_id, message_id=message_id) return self.request(r, reason=reason) - def delete_messages(self, channel_id, message_ids, *, reason=None): + def delete_messages(self, channel_id: Snowflake, message_ids: SnowflakeList, *, reason: Optional[str] = None) -> Response[None]: r = Route('POST', '/channels/{channel_id}/messages/bulk-delete', channel_id=channel_id) payload = { 'messages': message_ids, @@ -483,11 +540,11 @@ class HTTPClient: return self.request(r, json=payload, reason=reason) - def edit_message(self, channel_id, message_id, **fields): + def edit_message(self, channel_id: Snowflake, message_id: Snowflake, **fields: Any) -> Response[message.Message]: r = Route('PATCH', '/channels/{channel_id}/messages/{message_id}', channel_id=channel_id, message_id=message_id) return self.request(r, json=fields) - def add_reaction(self, channel_id, message_id, emoji): + def add_reaction(self, channel_id: Snowflake, message_id: Snowflake, emoji: str) -> Response[None]: r = Route( 'PUT', '/channels/{channel_id}/messages/{message_id}/reactions/{emoji}/@me', @@ -497,7 +554,7 @@ class HTTPClient: ) return self.request(r) - def remove_reaction(self, channel_id, message_id, emoji, member_id): + def remove_reaction(self, channel_id: Snowflake, message_id: Snowflake, emoji: str, member_id: Snowflake) -> Response[None]: r = Route( 'DELETE', '/channels/{channel_id}/messages/{message_id}/reactions/{emoji}/{member_id}', @@ -508,7 +565,7 @@ class HTTPClient: ) return self.request(r) - def remove_own_reaction(self, channel_id, message_id, emoji): + def remove_own_reaction(self, channel_id: Snowflake, message_id: Snowflake, emoji: str) -> Response[None]: r = Route( 'DELETE', '/channels/{channel_id}/messages/{message_id}/reactions/{emoji}/@me', @@ -518,7 +575,14 @@ class HTTPClient: ) return self.request(r) - def get_reaction_users(self, channel_id, message_id, emoji, limit, after=None): + def get_reaction_users( + self, + channel_id: Snowflake, + message_id: Snowflake, + emoji: str, + limit: int, + after: Optional[Snowflake] = None, + ) -> Response[List[user.User]]: r = Route( 'GET', '/channels/{channel_id}/messages/{message_id}/reactions/{emoji}', @@ -534,7 +598,7 @@ class HTTPClient: params['after'] = after return self.request(r, params=params) - def clear_reactions(self, channel_id, message_id): + def clear_reactions(self, channel_id: Snowflake, message_id: Snowflake) -> Response[None]: r = Route( 'DELETE', '/channels/{channel_id}/messages/{message_id}/reactions', @@ -544,7 +608,7 @@ class HTTPClient: return self.request(r) - def clear_single_reaction(self, channel_id, message_id, emoji): + def clear_single_reaction(self, channel_id: Snowflake, message_id: Snowflake, emoji: str) -> Response[None]: r = Route( 'DELETE', '/channels/{channel_id}/messages/{message_id}/reactions/{emoji}', @@ -554,16 +618,23 @@ class HTTPClient: ) return self.request(r) - def get_message(self, channel_id, message_id): + def get_message(self, channel_id: Snowflake, message_id: Snowflake) -> Response[message.Message]: r = Route('GET', '/channels/{channel_id}/messages/{message_id}', channel_id=channel_id, message_id=message_id) return self.request(r) - def get_channel(self, channel_id): + def get_channel(self, channel_id: Snowflake) -> Response[channel.Channel]: r = Route('GET', '/channels/{channel_id}', channel_id=channel_id) return self.request(r) - def logs_from(self, channel_id, limit, before=None, after=None, around=None): - params = { + def logs_from( + self, + channel_id: Snowflake, + limit: int, + before: Optional[Snowflake] = None, + after: Optional[Snowflake] = None, + around: Optional[Snowflake] = None, + ) -> Response[List[message.Message]]: + params: Dict[str, Any] = { 'limit': limit, } @@ -576,7 +647,7 @@ class HTTPClient: return self.request(Route('GET', '/channels/{channel_id}/messages', channel_id=channel_id), params=params) - def publish_message(self, channel_id, message_id): + def publish_message(self, channel_id: Snowflake, message_id: Snowflake) -> Response[message.Message]: return self.request( Route( 'POST', @@ -586,7 +657,7 @@ class HTTPClient: ) ) - def pin_message(self, channel_id, message_id, reason=None): + def pin_message(self, channel_id: Snowflake, message_id: Snowflake, reason: Optional[str] = None) -> Response[None]: r = Route( 'PUT', '/channels/{channel_id}/pins/{message_id}', @@ -595,7 +666,7 @@ class HTTPClient: ) return self.request(r, reason=reason) - def unpin_message(self, channel_id, message_id, reason=None): + def unpin_message(self, channel_id: Snowflake, message_id: Snowflake, reason: Optional[str] = None) -> Response[None]: r = Route( 'DELETE', '/channels/{channel_id}/pins/{message_id}', @@ -604,12 +675,12 @@ class HTTPClient: ) return self.request(r, reason=reason) - def pins_from(self, channel_id): + def pins_from(self, channel_id: Snowflake) -> Response[List[message.Message]]: return self.request(Route('GET', '/channels/{channel_id}/pins', channel_id=channel_id)) # Member management - def kick(self, user_id, guild_id, reason=None): + def kick(self, user_id: Snowflake, guild_id: Snowflake, reason: Optional[str] = None) -> Response[None]: r = Route('DELETE', '/guilds/{guild_id}/members/{user_id}', guild_id=guild_id, user_id=user_id) if reason: # thanks aiohttp @@ -617,7 +688,13 @@ class HTTPClient: return self.request(r) - def ban(self, user_id, guild_id, delete_message_days=1, reason=None): + def ban( + self, + user_id: Snowflake, + guild_id: Snowflake, + delete_message_days: int = 1, + reason: Optional[str] = None, + ) -> Response[None]: r = Route('PUT', '/guilds/{guild_id}/bans/{user_id}', guild_id=guild_id, user_id=user_id) params = { 'delete_message_days': delete_message_days, @@ -629,11 +706,19 @@ class HTTPClient: return self.request(r, params=params) - def unban(self, user_id, guild_id, *, reason=None): + def unban(self, user_id: Snowflake, guild_id: Snowflake, *, reason: Optional[str] = None) -> Response[None]: r = Route('DELETE', '/guilds/{guild_id}/bans/{user_id}', guild_id=guild_id, user_id=user_id) return self.request(r, reason=reason) - def guild_voice_state(self, user_id, guild_id, *, mute=None, deafen=None, reason=None): + def guild_voice_state( + self, + user_id: Snowflake, + guild_id: Snowflake, + *, + mute: Optional[bool] = None, + deafen: Optional[bool] = None, + reason: Optional[str] = None, + ) -> Response[member.Member]: r = Route('PATCH', '/guilds/{guild_id}/members/{user_id}', guild_id=guild_id, user_id=user_id) payload = {} if mute is not None: @@ -644,7 +729,7 @@ class HTTPClient: return self.request(r, json=payload, reason=reason) - def edit_profile(self, username, avatar): + def edit_profile(self, username: Optional[str], avatar: Optional[bytes]) -> Response[user.User]: payload = {} if avatar is not None: payload['avatar'] = avatar @@ -653,35 +738,61 @@ class HTTPClient: return self.request(Route('PATCH', '/users/@me'), json=payload) - def change_my_nickname(self, guild_id, nickname, *, reason=None): + def change_my_nickname( + self, + guild_id: Snowflake, + nickname: str, + *, + reason: Optional[str] = None, + ) -> Response[member.Nickname]: r = Route('PATCH', '/guilds/{guild_id}/members/@me/nick', guild_id=guild_id) payload = { 'nick': nickname, } return self.request(r, json=payload, reason=reason) - def change_nickname(self, guild_id, user_id, nickname, *, reason=None): + def change_nickname( + self, + guild_id: Snowflake, + user_id: Snowflake, + nickname: str, + *, + reason: Optional[str] = None, + ) -> Response[member.Member]: r = Route('PATCH', '/guilds/{guild_id}/members/{user_id}', guild_id=guild_id, user_id=user_id) payload = { 'nick': nickname, } return self.request(r, json=payload, reason=reason) - def edit_my_voice_state(self, guild_id, payload): + def edit_my_voice_state(self, guild_id: Snowflake, payload: voice.VoiceState) -> Response[None]: r = Route('PATCH', '/guilds/{guild_id}/voice-states/@me', guild_id=guild_id) return self.request(r, json=payload) - def edit_voice_state(self, guild_id, user_id, payload): + def edit_voice_state(self, guild_id: Snowflake, user_id: Snowflake, payload: voice.VoiceState) -> Response[None]: r = Route('PATCH', '/guilds/{guild_id}/voice-states/{user_id}', guild_id=guild_id, user_id=user_id) return self.request(r, json=payload) - def edit_member(self, guild_id, user_id, *, reason=None, **fields): + def edit_member( + self, + guild_id: Snowflake, + user_id: Snowflake, + *, + reason: Optional[str] = None, + **fields: Any, + ) -> Response[member.Member]: r = Route('PATCH', '/guilds/{guild_id}/members/{user_id}', guild_id=guild_id, user_id=user_id) return self.request(r, json=fields, reason=reason) # Channel management - def edit_channel(self, channel_id, *, reason=None, **options): + def edit_channel( + self, + channel_id: Snowflake, + *, + reason: Optional[str] = None, + **options: Any, + ) -> Response[channel.Channel]: r = Route('PATCH', '/channels/{channel_id}', channel_id=channel_id) valid_keys = ( 'name', @@ -703,11 +814,24 @@ class HTTPClient: payload = {k: v for k, v in options.items() if k in valid_keys} return self.request(r, reason=reason, json=payload) - def bulk_channel_update(self, guild_id, data, *, reason=None): + def bulk_channel_update( + self, + guild_id: Snowflake, + data: List[guild.ChannelPositionUpdate], + *, + reason: Optional[str] = None, + ) -> Response[None]: r = Route('PATCH', '/guilds/{guild_id}/channels', guild_id=guild_id) return self.request(r, json=data, reason=reason) - def create_channel(self, guild_id, channel_type, *, reason=None, **options): + def create_channel( + self, + guild_id: Snowflake, + channel_type: channel.ChannelType, + *, + reason: Optional[str] = None, + **options: Any, + ) -> Response[channel.GuildChannel]: payload = { 'type': channel_type, } @@ -730,19 +854,24 @@ class HTTPClient: return self.request(Route('POST', '/guilds/{guild_id}/channels', guild_id=guild_id), json=payload, reason=reason) - def delete_channel(self, channel_id, *, reason=None): + def delete_channel( + self, + channel_id: Snowflake, + *, + reason: Optional[str] = None, + ) -> Response[None]: return self.request(Route('DELETE', '/channels/{channel_id}', channel_id=channel_id), reason=reason) # Thread management def start_public_thread( self, - channel_id: int, - message_id: int, + channel_id: Snowflake, + message_id: Snowflake, *, name: str, - auto_archive_duration: int, - type: int, + auto_archive_duration: threads.ThreadArchiveDuration, + type: threads.ThreadType, ) -> Response[threads.Thread]: payload = { 'name': name, @@ -757,11 +886,11 @@ class HTTPClient: def start_private_thread( self, - channel_id: int, + channel_id: Snowflake, *, name: str, - auto_archive_duration: int, - type: int, + auto_archive_duration: threads.ThreadArchiveDuration, + type: threads.ThreadType, ) -> Response[threads.Thread]: payload = { 'name': name, @@ -772,23 +901,23 @@ class HTTPClient: route = Route('POST', '/channels/{channel_id}/threads', channel_id=channel_id) return self.request(route, json=payload) - def join_thread(self, channel_id: int): + def join_thread(self, channel_id: Snowflake) -> Response[None]: return self.request(Route('POST', '/channels/{channel_id}/thread-members/@me', channel_id=channel_id)) - def add_user_to_thread(self, channel_id: int, user_id: int): + def add_user_to_thread(self, channel_id: Snowflake, user_id: Snowflake) -> Response[None]: return self.request( Route('PUT', '/channels/{channel_id}/thread-members/{user_id}', channel_id=channel_id, user_id=user_id) ) - def leave_thread(self, channel_id: int): + def leave_thread(self, channel_id: Snowflake) -> Response[None]: return self.request(Route('DELETE', '/channels/{channel_id}/thread-members/@me', channel_id=channel_id)) - def remove_user_from_thread(self, channel_id: int, user_id: int): + def remove_user_from_thread(self, channel_id: Snowflake, user_id: Snowflake) -> Response[None]: route = Route('DELETE', '/channels/{channel_id}/thread-members/{user_id}', channel_id=channel_id, user_id=user_id) return self.request(route) def get_public_archived_threads( - self, channel_id: int, before=None, limit: int = 50 + self, channel_id: Snowflake, before: Optional[Snowflake] = None, limit: int = 50 ) -> Response[threads.ThreadPaginationPayload]: route = Route('GET', '/channels/{channel_id}/threads/archived/public', channel_id=channel_id) @@ -799,7 +928,7 @@ class HTTPClient: return self.request(route, params=params) def get_private_archived_threads( - self, channel_id: int, before=None, limit: int = 50 + self, channel_id: Snowflake, before: Optional[Snowflake] = None, limit: int = 50 ) -> Response[threads.ThreadPaginationPayload]: route = Route('GET', '/channels/{channel_id}/threads/archived/private', channel_id=channel_id) @@ -810,7 +939,7 @@ class HTTPClient: return self.request(route, params=params) def get_joined_private_archived_threads( - self, channel_id: int, before=None, limit: int = 50 + self, channel_id: Snowflake, before: Optional[Snowflake] = None, limit: int = 50 ) -> Response[threads.ThreadPaginationPayload]: route = Route('GET', '/channels/{channel_id}/users/@me/threads/archived/private', channel_id=channel_id) params = {} @@ -819,18 +948,25 @@ class HTTPClient: params['limit'] = limit return self.request(route, params=params) - def get_active_threads(self, channel_id: int) -> Response[threads.ThreadPaginationPayload]: + def get_active_threads(self, channel_id: Snowflake) -> Response[threads.ThreadPaginationPayload]: route = Route('GET', '/channels/{channel_id}/threads/active', channel_id=channel_id) return self.request(route) - def get_thread_members(self, channel_id: int) -> Response[List[threads.ThreadMember]]: + def get_thread_members(self, channel_id: Snowflake) -> Response[List[threads.ThreadMember]]: route = Route('GET', '/channels/{channel_id}/thread-members', channel_id=channel_id) return self.request(route) # Webhook management - def create_webhook(self, channel_id, *, name, avatar=None, reason=None): - payload = { + def create_webhook( + self, + channel_id: Snowflake, + *, + name: str, + avatar: Optional[bytes] = None, + reason: Optional[str] = None, + ) -> Response[webhook.Webhook]: + payload: Dict[str, Any] = { 'name': name, } if avatar is not None: @@ -839,16 +975,21 @@ class HTTPClient: r = Route('POST', '/channels/{channel_id}/webhooks', channel_id=channel_id) return self.request(r, json=payload, reason=reason) - def channel_webhooks(self, channel_id): + def channel_webhooks(self, channel_id: Snowflake) -> Response[List[webhook.Webhook]]: return self.request(Route('GET', '/channels/{channel_id}/webhooks', channel_id=channel_id)) - def guild_webhooks(self, guild_id): + def guild_webhooks(self, guild_id: Snowflake) -> Response[List[webhook.Webhook]]: return self.request(Route('GET', '/guilds/{guild_id}/webhooks', guild_id=guild_id)) - def get_webhook(self, webhook_id): + def get_webhook(self, webhook_id: Snowflake) -> Response[webhook.Webhook]: return self.request(Route('GET', '/webhooks/{webhook_id}', webhook_id=webhook_id)) - def follow_webhook(self, channel_id, webhook_channel_id, reason=None): + def follow_webhook( + self, + channel_id: Snowflake, + webhook_channel_id: Snowflake, + reason: Optional[str] = None, + ) -> Response[None]: payload = { 'webhook_channel_id': str(webhook_channel_id), } @@ -858,8 +999,13 @@ class HTTPClient: # Guild management - def get_guilds(self, limit, before=None, after=None): - params = { + def get_guilds( + self, + limit: int, + before: Optional[Snowflake] = None, + after: Optional[Snowflake] = None, + ) -> Response[List[guild.Guild]]: + params: Dict[str, Any] = { 'limit': limit, } @@ -870,16 +1016,16 @@ class HTTPClient: return self.request(Route('GET', '/users/@me/guilds'), params=params) - def leave_guild(self, guild_id): + def leave_guild(self, guild_id: Snowflake) -> Response[None]: return self.request(Route('DELETE', '/users/@me/guilds/{guild_id}', guild_id=guild_id)) - def get_guild(self, guild_id): + def get_guild(self, guild_id: Snowflake) -> Response[guild.Guild]: return self.request(Route('GET', '/guilds/{guild_id}', guild_id=guild_id)) - def delete_guild(self, guild_id): + def delete_guild(self, guild_id: Snowflake) -> Response[None]: return self.request(Route('DELETE', '/guilds/{guild_id}', guild_id=guild_id)) - def create_guild(self, name, region, icon): + def create_guild(self, name: str, region: str, icon: bytes) -> Response[guild.Guild]: payload = { 'name': name, 'icon': icon, @@ -888,7 +1034,7 @@ class HTTPClient: return self.request(Route('POST', '/guilds'), json=payload) - def edit_guild(self, guild_id, *, reason=None, **fields): + def edit_guild(self, guild_id: Snowflake, *, reason: Optional[str] = None, **fields: Any) -> Response[guild.Guild]: valid_keys = ( 'name', 'region', @@ -915,19 +1061,19 @@ class HTTPClient: return self.request(Route('PATCH', '/guilds/{guild_id}', guild_id=guild_id), json=payload, reason=reason) - def get_template(self, code): + def get_template(self, code: str) -> Response[template.Template]: return self.request(Route('GET', '/guilds/templates/{code}', code=code)) - def guild_templates(self, guild_id): + def guild_templates(self, guild_id: Snowflake) -> Response[List[template.Template]]: return self.request(Route('GET', '/guilds/{guild_id}/templates', guild_id=guild_id)) - def create_template(self, guild_id, payload): + def create_template(self, guild_id: Snowflake, payload: template.CreateTemplate) -> Response[template.Template]: return self.request(Route('POST', '/guilds/{guild_id}/templates', guild_id=guild_id), json=payload) - def sync_template(self, guild_id, code): + def sync_template(self, guild_id: Snowflake, code: str) -> Response[template.Template]: return self.request(Route('PUT', '/guilds/{guild_id}/templates/{code}', guild_id=guild_id, code=code)) - def edit_template(self, guild_id, code, payload): + def edit_template(self, guild_id: Snowflake, code: str, payload) -> Response[template.Template]: valid_keys = ( 'name', 'description', @@ -937,10 +1083,10 @@ class HTTPClient: Route('PATCH', '/guilds/{guild_id}/templates/{code}', guild_id=guild_id, code=code), json=payload ) - def delete_template(self, guild_id, code): + def delete_template(self, guild_id: Snowflake, code: str) -> Response[None]: return self.request(Route('DELETE', '/guilds/{guild_id}/templates/{code}', guild_id=guild_id, code=code)) - def create_from_template(self, code, name, region, icon): + def create_from_template(self, code: str, name: str, region: str, icon: bytes) -> Response[guild.Guild]: payload = { 'name': name, 'icon': icon, @@ -948,24 +1094,24 @@ class HTTPClient: } return self.request(Route('POST', '/guilds/templates/{code}', code=code), json=payload) - def get_bans(self, guild_id): + def get_bans(self, guild_id: Snowflake) -> Response[List[guild.Ban]]: return self.request(Route('GET', '/guilds/{guild_id}/bans', guild_id=guild_id)) - def get_ban(self, user_id, guild_id): + def get_ban(self, user_id: Snowflake, guild_id: Snowflake) -> Response[guild.Ban]: return self.request(Route('GET', '/guilds/{guild_id}/bans/{user_id}', guild_id=guild_id, user_id=user_id)) - def get_vanity_code(self, guild_id): + def get_vanity_code(self, guild_id: Snowflake) -> Response[invite.VanityInvite]: return self.request(Route('GET', '/guilds/{guild_id}/vanity-url', guild_id=guild_id)) - def change_vanity_code(self, guild_id, code, *, reason=None): - payload = {'code': code} + def change_vanity_code(self, guild_id: Snowflake, code: str, *, reason: Optional[str] = None) -> Response[None]: + payload: Dict[str, Any] = {'code': code} return self.request(Route('PATCH', '/guilds/{guild_id}/vanity-url', guild_id=guild_id), json=payload, reason=reason) - def get_all_guild_channels(self, guild_id): + def get_all_guild_channels(self, guild_id: Snowflake) -> Response[List[guild.GuildChannel]]: return self.request(Route('GET', '/guilds/{guild_id}/channels', guild_id=guild_id)) - def get_members(self, guild_id, limit, after): - params = { + def get_members(self, guild_id: Snowflake, limit: int, after: Optional[Snowflake]) -> Response[List[member.Member]]: + params: Dict[str, Any] = { 'limit': limit, } if after: @@ -974,11 +1120,19 @@ class HTTPClient: r = Route('GET', '/guilds/{guild_id}/members', guild_id=guild_id) return self.request(r, params=params) - def get_member(self, guild_id, member_id): + def get_member(self, guild_id: Snowflake, member_id: Snowflake) -> Response[member.Member]: return self.request(Route('GET', '/guilds/{guild_id}/members/{member_id}', guild_id=guild_id, member_id=member_id)) - def prune_members(self, guild_id, days, compute_prune_count, roles, *, reason=None): - payload = { + def prune_members( + self, + guild_id: Snowflake, + days: int, + compute_prune_count: bool, + roles: List[str], + *, + reason: Optional[str] = None, + ) -> Response[guild.GuildPrune]: + payload: Dict[str, Any] = { 'days': days, 'compute_prune_count': 'true' if compute_prune_count else 'false', } @@ -987,8 +1141,13 @@ class HTTPClient: return self.request(Route('POST', '/guilds/{guild_id}/prune', guild_id=guild_id), json=payload, reason=reason) - def estimate_pruned_members(self, guild_id, days, roles): - params = { + def estimate_pruned_members( + self, + guild_id: Snowflake, + days: int, + roles: List[str], + ) -> Response[guild.GuildPrune]: + params: Dict[str, Any] = { 'days': days, } if roles: @@ -996,13 +1155,21 @@ class HTTPClient: return self.request(Route('GET', '/guilds/{guild_id}/prune', guild_id=guild_id), params=params) - def get_all_custom_emojis(self, guild_id): + def get_all_custom_emojis(self, guild_id: Snowflake) -> Response[List[emoji.Emoji]]: return self.request(Route('GET', '/guilds/{guild_id}/emojis', guild_id=guild_id)) - def get_custom_emoji(self, guild_id, emoji_id): + def get_custom_emoji(self, guild_id: Snowflake, emoji_id: Snowflake) -> Response[emoji.Emoji]: return self.request(Route('GET', '/guilds/{guild_id}/emojis/{emoji_id}', guild_id=guild_id, emoji_id=emoji_id)) - def create_custom_emoji(self, guild_id, name, image, *, roles=None, reason=None): + def create_custom_emoji( + self, + guild_id: Snowflake, + name: str, + image: bytes, + *, + roles: Optional[SnowflakeList] = None, + reason: Optional[str] = None, + ) -> Response[emoji.Emoji]: payload = { 'name': name, 'image': image, @@ -1012,20 +1179,33 @@ class HTTPClient: r = Route('POST', '/guilds/{guild_id}/emojis', guild_id=guild_id) return self.request(r, json=payload, reason=reason) - def delete_custom_emoji(self, guild_id, emoji_id, *, reason=None): + def delete_custom_emoji( + self, + guild_id: Snowflake, + emoji_id: Snowflake, + *, + reason: Optional[str] = None, + ) -> Response[None]: r = Route('DELETE', '/guilds/{guild_id}/emojis/{emoji_id}', guild_id=guild_id, emoji_id=emoji_id) return self.request(r, reason=reason) - def edit_custom_emoji(self, guild_id: int, emoji_id: int, *, payload, reason: Optional[str] = None): + def edit_custom_emoji( + self, + guild_id: Snowflake, + emoji_id: Snowflake, + *, + payload: Dict[str, Any], + reason: Optional[str] = None, + ) -> Response[emoji.Emoji]: r = Route('PATCH', '/guilds/{guild_id}/emojis/{emoji_id}', guild_id=guild_id, emoji_id=emoji_id) return self.request(r, json=payload, reason=reason) - def get_all_integrations(self, guild_id): + def get_all_integrations(self, guild_id: Snowflake) -> Response[List[integration.Integration]]: r = Route('GET', '/guilds/{guild_id}/integrations', guild_id=guild_id) return self.request(r) - def create_integration(self, guild_id, type, id): + def create_integration(self, guild_id: Snowflake, type: integration.IntegrationType, id: int) -> Response[None]: payload = { 'type': type, 'id': id, @@ -1034,29 +1214,37 @@ class HTTPClient: r = Route('POST', '/guilds/{guild_id}/integrations', guild_id=guild_id) return self.request(r, json=payload) - def edit_integration(self, guild_id, integration_id, **payload): + def edit_integration(self, guild_id: Snowflake, integration_id: Snowflake, **payload: Any) -> Response[None]: r = Route( 'PATCH', '/guilds/{guild_id}/integrations/{integration_id}', guild_id=guild_id, integration_id=integration_id ) return self.request(r, json=payload) - def sync_integration(self, guild_id, integration_id): + def sync_integration(self, guild_id: Snowflake, integration_id: Snowflake) -> Response[None]: r = Route( 'POST', '/guilds/{guild_id}/integrations/{integration_id}/sync', guild_id=guild_id, integration_id=integration_id ) return self.request(r) - def delete_integration(self, guild_id, integration_id): + def delete_integration(self, guild_id: Snowflake, integration_id: Snowflake) -> Response[None]: r = Route( 'DELETE', '/guilds/{guild_id}/integrations/{integration_id}', guild_id=guild_id, integration_id=integration_id ) return self.request(r) - def get_audit_logs(self, guild_id, limit=100, before=None, after=None, user_id=None, action_type=None): - params = {'limit': limit} + def get_audit_logs( + self, + guild_id: Snowflake, + limit: int = 100, + before: Optional[Snowflake] = None, + after: Optional[Snowflake] = None, + user_id: Optional[Snowflake] = None, + action_type: Optional[AuditLogAction] = None, + ) -> Response[audit_log.AuditLog]: + params: Dict[str, Any] = {'limit': limit} if before: params['before'] = before if after: @@ -1079,16 +1267,16 @@ class HTTPClient: def create_invite( self, - channel_id: int, + channel_id: Snowflake, *, reason: Optional[str] = None, max_age: int = 0, max_uses: int = 0, temporary: bool = False, unique: bool = True, - target_type: Optional[int] = None, - target_user_id: Optional[int] = None, - target_application_id: Optional[int] = None + target_type: Optional[invite.InviteTargetType] = None, + target_user_id: Optional[Snowflake] = None, + target_application_id: Optional[Snowflake] = None ) -> Response[invite.Invite]: r = Route('POST', '/channels/{channel_id}/invites', channel_id=channel_id) payload = { @@ -1122,36 +1310,49 @@ class HTTPClient: def invites_from_channel(self, channel_id: Snowflake) -> Response[List[invite.Invite]]: return self.request(Route('GET', '/channels/{channel_id}/invites', channel_id=channel_id)) - def delete_invite(self, invite_id: str, *, reason: bool = None) -> Response[None]: + def delete_invite(self, invite_id: str, *, reason: Optional[str] = None) -> Response[None]: return self.request(Route('DELETE', '/invites/{invite_id}', invite_id=invite_id), reason=reason) # Role management - def get_roles(self, guild_id): + def get_roles(self, guild_id: Snowflake) -> Response[List[role.Role]]: return self.request(Route('GET', '/guilds/{guild_id}/roles', guild_id=guild_id)) - def edit_role(self, guild_id, role_id, *, reason=None, **fields): + def edit_role(self, guild_id: Snowflake, role_id: Snowflake, *, reason: Optional[str] = None, **fields: Any) -> Response[role.Role]: r = Route('PATCH', '/guilds/{guild_id}/roles/{role_id}', guild_id=guild_id, role_id=role_id) valid_keys = ('name', 'permissions', 'color', 'hoist', 'mentionable') payload = {k: v for k, v in fields.items() if k in valid_keys} return self.request(r, json=payload, reason=reason) - def delete_role(self, guild_id, role_id, *, reason=None): + def delete_role(self, guild_id: Snowflake, role_id: Snowflake, *, reason: Optional[str] = None) -> Response[None]: r = Route('DELETE', '/guilds/{guild_id}/roles/{role_id}', guild_id=guild_id, role_id=role_id) return self.request(r, reason=reason) - def replace_roles(self, user_id, guild_id, role_ids, *, reason=None): + def replace_roles( + self, + user_id: Snowflake, + guild_id: Snowflake, + role_ids: List[int], + *, + reason: Optional[str] = None, + ) -> Response[member.Member]: return self.edit_member(guild_id=guild_id, user_id=user_id, roles=role_ids, reason=reason) - def create_role(self, guild_id, *, reason=None, **fields): + def create_role(self, guild_id: Snowflake, *, reason: Optional[str] = None, **fields: Any) -> Response[role.Role]: r = Route('POST', '/guilds/{guild_id}/roles', guild_id=guild_id) return self.request(r, json=fields, reason=reason) - def move_role_position(self, guild_id, positions, *, reason=None): + def move_role_position( + self, + guild_id: Snowflake, + positions: List[guild.RolePositionUpdate], + *, + reason: Optional[str] = None, + ) -> Response[List[role.Role]]: r = Route('PATCH', '/guilds/{guild_id}/roles', guild_id=guild_id) return self.request(r, json=positions, reason=reason) - def add_role(self, guild_id, user_id, role_id, *, reason=None): + def add_role(self, guild_id: Snowflake, user_id: Snowflake, role_id: Snowflake, *, reason: Optional[str] = None) -> Response[None]: r = Route( 'PUT', '/guilds/{guild_id}/members/{user_id}/roles/{role_id}', @@ -1161,7 +1362,7 @@ class HTTPClient: ) return self.request(r, reason=reason) - def remove_role(self, guild_id, user_id, role_id, *, reason=None): + def remove_role(self, guild_id: Snowflake, user_id: Snowflake, role_id: Snowflake, *, reason: Optional[str] = None) -> Response[None]: r = Route( 'DELETE', '/guilds/{guild_id}/members/{user_id}/roles/{role_id}', @@ -1171,18 +1372,40 @@ class HTTPClient: ) return self.request(r, reason=reason) - def edit_channel_permissions(self, channel_id, target, allow, deny, type, *, reason=None): + def edit_channel_permissions( + self, + channel_id: Snowflake, + target: Snowflake, + allow: str, + deny: str, + type: channel.OverwriteType, + *, + reason: Optional[str] = None, + ) -> Response[None]: payload = {'id': target, 'allow': allow, 'deny': deny, 'type': type} r = Route('PUT', '/channels/{channel_id}/permissions/{target}', channel_id=channel_id, target=target) return self.request(r, json=payload, reason=reason) - def delete_channel_permissions(self, channel_id, target, *, reason=None): + def delete_channel_permissions( + self, + channel_id: Snowflake, + target: channel.OverwriteType, + *, + reason: Optional[str] = None + ) -> Response[None]: r = Route('DELETE', '/channels/{channel_id}/permissions/{target}', channel_id=channel_id, target=target) return self.request(r, reason=reason) # Voice management - def move_member(self, user_id, guild_id, channel_id, *, reason=None): + def move_member( + self, + user_id: Snowflake, + guild_id: Snowflake, + channel_id: Snowflake, + *, + reason: Optional[str] = None, + ) -> Response[member.Member]: return self.edit_member(guild_id=guild_id, user_id=user_id, channel_id=channel_id, reason=reason) # Stage instance management @@ -1214,10 +1437,10 @@ class HTTPClient: # Application commands (global) - def get_global_commands(self, application_id) -> Response[List[interactions.ApplicationCommand]]: + def get_global_commands(self, application_id: Snowflake) -> Response[List[interactions.ApplicationCommand]]: return self.request(Route('GET', '/applications/{application_id}/commands', application_id=application_id)) - def get_global_command(self, application_id, command_id) -> Response[interactions.ApplicationCommand]: + def get_global_command(self, application_id: Snowflake, command_id: Snowflake) -> Response[interactions.ApplicationCommand]: r = Route( 'GET', '/applications/{application_id}/commands/{command_id}', @@ -1226,17 +1449,21 @@ class HTTPClient: ) return self.request(r) - def upsert_global_command(self, application_id, payload) -> Response[interactions.ApplicationCommand]: + def upsert_global_command(self, application_id: Snowflake, payload) -> Response[interactions.ApplicationCommand]: r = Route('POST', '/applications/{application_id}/commands', application_id=application_id) return self.request(r, json=payload) - def edit_global_command(self, application_id, command_id, payload) -> Response[interactions.ApplicationCommand]: + def edit_global_command(self, + application_id: Snowflake, + command_id: Snowflake, + payload: interactions.EditApplicationCommand, + ) -> Response[interactions.ApplicationCommand]: valid_keys = ( 'name', 'description', 'options', ) - payload = {k: v for k, v in payload.items() if k in valid_keys} + payload = {k: v for k, v in payload.items() if k in valid_keys} # type: ignore r = Route( 'PATCH', '/applications/{application_id}/commands/{command_id}', @@ -1245,7 +1472,7 @@ class HTTPClient: ) return self.request(r, json=payload) - def delete_global_command(self, application_id, command_id): + def delete_global_command(self, application_id: Snowflake, command_id: Snowflake) -> Response[None]: r = Route( 'DELETE', '/applications/{application_id}/commands/{command_id}', @@ -1254,13 +1481,13 @@ class HTTPClient: ) return self.request(r) - def bulk_upsert_global_commands(self, application_id, payload) -> Response[List[interactions.ApplicationCommand]]: + def bulk_upsert_global_commands(self, application_id: Snowflake, payload) -> Response[List[interactions.ApplicationCommand]]: r = Route('PUT', '/applications/{application_id}/commands', application_id=application_id) return self.request(r, json=payload) # Application commands (guild) - def get_guild_commands(self, application_id, guild_id) -> Response[List[interactions.ApplicationCommand]]: + def get_guild_commands(self, application_id: Snowflake, guild_id: Snowflake) -> Response[List[interactions.ApplicationCommand]]: r = Route( 'GET', '/applications/{application_id}/guilds/{guild_id}/commands', @@ -1269,7 +1496,12 @@ class HTTPClient: ) return self.request(r) - def get_guild_command(self, application_id, guild_id, command_id) -> Response[interactions.ApplicationCommand]: + def get_guild_command( + self, + application_id: Snowflake, + guild_id: Snowflake, + command_id: Snowflake, + ) -> Response[interactions.ApplicationCommand]: r = Route( 'GET', '/applications/{application_id}/guilds/{guild_id}/commands/{command_id}', @@ -1279,7 +1511,12 @@ class HTTPClient: ) return self.request(r) - def upsert_guild_command(self, application_id, guild_id, payload) -> Response[interactions.ApplicationCommand]: + def upsert_guild_command( + self, + application_id: Snowflake, + guild_id: Snowflake, + payload: interactions.EditApplicationCommand, + ) -> Response[interactions.ApplicationCommand]: r = Route( 'POST', '/applications/{application_id}/guilds/{guild_id}/commands', @@ -1288,13 +1525,18 @@ class HTTPClient: ) return self.request(r, json=payload) - def edit_guild_command(self, application_id, guild_id, command_id, payload) -> Response[interactions.ApplicationCommand]: + def edit_guild_command(self, + application_id: Snowflake, + guild_id: Snowflake, + command_id: Snowflake, + payload: interactions.EditApplicationCommand, + ) -> Response[interactions.ApplicationCommand]: valid_keys = ( 'name', 'description', 'options', ) - payload = {k: v for k, v in payload.items() if k in valid_keys} + payload = {k: v for k, v in payload.items() if k in valid_keys} # type: ignore r = Route( 'PATCH', '/applications/{application_id}/guilds/{guild_id}/commands/{command_id}', @@ -1304,7 +1546,12 @@ class HTTPClient: ) return self.request(r, json=payload) - def delete_guild_command(self, application_id, guild_id, command_id): + def delete_guild_command( + self, + application_id: Snowflake, + guild_id: Snowflake, + command_id: Snowflake, + ) -> Response[None]: r = Route( 'DELETE', '/applications/{application_id}/guilds/{guild_id}/commands/{command_id}', @@ -1315,7 +1562,10 @@ class HTTPClient: return self.request(r) def bulk_upsert_guild_commands( - self, application_id, guild_id, payload + self, + application_id: Snowflake, + guild_id: Snowflake, + payload: List[interactions.EditApplicationCommand], ) -> Response[List[interactions.ApplicationCommand]]: r = Route( 'PUT', @@ -1329,14 +1579,14 @@ class HTTPClient: def _edit_webhook_helper( self, - route, - file=None, - content=None, - embeds=None, - allowed_mentions=None, + route: Route, + file: Optional[File] = None, + content: Optional[str] = None, + embeds: Optional[List[embed.Embed]] = None, + allowed_mentions: Optional[message.AllowedMentions] = None, ): - payload = {} + payload: Dict[str, Any] = {} if content: payload['content'] = content if embeds: @@ -1344,7 +1594,7 @@ class HTTPClient: if allowed_mentions: payload['allowed_mentions'] = allowed_mentions - form = [ + form: List[Dict[str, Any]] = [ { 'name': 'payload_json', 'value': utils.to_json(payload), @@ -1361,16 +1611,23 @@ class HTTPClient: } ) - return self.request(route, form=form, files=[file]) + return self.request(route, form=form, files=[file] if file else None) - def create_interaction_response(self, interaction_id, token, *, type, data=None): + def create_interaction_response( + self, + interaction_id: Snowflake, + token: str, + *, + type: InteractionResponseType, + data: Optional[interactions.InteractionApplicationCommandCallbackData] = None + ) -> Response[None]: r = Route( 'POST', '/interactions/{interaction_id}/{interaction_token}/callback', interaction_id=interaction_id, interaction_token=token, ) - payload = { + payload: Dict[str, Any] = { 'type': type, } @@ -1381,9 +1638,9 @@ class HTTPClient: def get_original_interaction_response( self, - application_id, - token, - ): + application_id: Snowflake, + token: str, + ) -> Response[message.Message]: r = Route( 'GET', '/webhooks/{application_id}/{interaction_token}/messages/@original', @@ -1394,13 +1651,13 @@ class HTTPClient: def edit_original_interaction_response( self, - application_id, - token, - file=None, - content=None, - embeds=None, - allowed_mentions=None, - ): + application_id: Snowflake, + token: str, + file: Optional[File] = None, + content: Optional[str] = None, + embeds: Optional[List[embed.Embed]] = None, + allowed_mentions: Optional[message.AllowedMentions] = None, + ) -> Response[message.Message]: r = Route( 'PATCH', '/webhooks/{application_id}/{interaction_token}/messages/@original', @@ -1409,7 +1666,7 @@ class HTTPClient: ) return self._edit_webhook_helper(r, file=file, content=content, embeds=embeds, allowed_mentions=allowed_mentions) - def delete_original_interaction_response(self, application_id, token): + def delete_original_interaction_response(self, application_id: Snowflake, token: str) -> Response[None]: r = Route( 'DELETE', '/webhooks/{application_id}/{interaction_token}/messages/@original', @@ -1420,14 +1677,14 @@ class HTTPClient: def create_followup_message( self, - application_id, - token, - files=None, - content=None, - tts=False, - embeds=None, - allowed_mentions=None, - ): + application_id: Snowflake, + token: str, + files: List[File] = [], + content: Optional[str] = None, + tts: bool = False, + embeds: Optional[List[embed.Embed]] = None, + allowed_mentions: Optional[message.AllowedMentions] = None, + ) -> Response[message.Message]: r = Route( 'POST', '/webhooks/{application_id}/{interaction_token}', @@ -1445,14 +1702,14 @@ class HTTPClient: def edit_followup_message( self, - application_id, - token, - message_id, - file=None, - content=None, - embeds=None, - allowed_mentions=None, - ): + application_id: Snowflake, + token: str, + message_id: Snowflake, + file: Optional[File] = None, + content: Optional[str] = None, + embeds: Optional[List[embed.Embed]] = None, + allowed_mentions: Optional[message.AllowedMentions] = None, + )-> Response[message.Message]: r = Route( 'PATCH', '/webhooks/{application_id}/{interaction_token}/messages/{message_id}', @@ -1462,7 +1719,7 @@ class HTTPClient: ) return self._edit_webhook_helper(r, file=file, content=content, embeds=embeds, allowed_mentions=allowed_mentions) - def delete_followup_message(self, application_id, token, message_id): + def delete_followup_message(self, application_id: Snowflake, token: str, message_id: Snowflake) -> Response[None]: r = Route( 'DELETE', '/webhooks/{application_id}/{interaction_token}/messages/{message_id}', @@ -1473,7 +1730,9 @@ class HTTPClient: return self.request(r) def get_guild_application_command_permissions( - self, application_id, guild_id + self, + application_id: Snowflake, + guild_id: Snowflake, ) -> Response[List[interactions.GuildApplicationCommandPermissions]]: r = Route( 'GET', @@ -1484,7 +1743,10 @@ class HTTPClient: return self.request(r) def get_application_command_permissions( - self, application_id, guild_id, command_id + self, + application_id: Snowflake, + guild_id: Snowflake, + command_id: Snowflake, ) -> Response[interactions.GuildApplicationCommandPermissions]: r = Route( 'GET', @@ -1495,7 +1757,13 @@ class HTTPClient: ) return self.request(r) - def edit_application_command_permissions(self, application_id, guild_id, command_id, payload): + def edit_application_command_permissions( + self, + application_id: Snowflake, + guild_id: Snowflake, + command_id: Snowflake, + payload: interactions.BaseGuildApplicationCommandPermissions, + ) -> Response[None]: r = Route( 'PUT', '/applications/{application_id}/guilds/{guild_id}/commands/{command_id}/permissions', @@ -1505,7 +1773,12 @@ class HTTPClient: ) return self.request(r, json=payload) - def bulk_edit_guild_application_command_permissions(self, application_id, guild_id, payload): + def bulk_edit_guild_application_command_permissions( + self, + application_id: Snowflake, + guild_id: Snowflake, + payload: List[interactions.PartialGuildApplicationCommandPermissions], + ) -> Response[None]: r = Route( 'PUT', '/applications/{application_id}/guilds/{guild_id}/commands/permissions', @@ -1516,10 +1789,10 @@ class HTTPClient: # Misc - def application_info(self): + def application_info(self) -> Response[appinfo.AppInfo]: return self.request(Route('GET', '/oauth2/applications/@me')) - async def get_gateway(self, *, encoding='json', zlib=True): + async def get_gateway(self, *, encoding: str = 'json', zlib: bool = True) -> str: try: data = await self.request(Route('GET', '/gateway')) except HTTPException as exc: @@ -1530,7 +1803,7 @@ class HTTPClient: value = '{0}?encoding={1}&v=9' return value.format(data['url'], encoding) - async def get_bot_gateway(self, *, encoding='json', zlib=True): + async def get_bot_gateway(self, *, encoding: str = 'json', zlib: bool = True) -> Tuple[int, str]: try: data = await self.request(Route('GET', '/gateway/bot')) except HTTPException as exc: @@ -1542,5 +1815,5 @@ class HTTPClient: value = '{0}?encoding={1}&v=9' return data['shards'], value.format(data['url'], encoding) - def get_user(self, user_id): + def get_user(self, user_id: Snowflake) -> Response[user.User]: return self.request(Route('GET', '/users/{user_id}', user_id=user_id)) |