Josh
2 years ago
98 changed files with 7917 additions and 3629 deletions
@ -0,0 +1,200 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import Optional, TYPE_CHECKING |
|||
|
|||
from . import utils |
|||
from .app_commands import MissingApplicationID |
|||
from .enums import try_enum, SKUType, EntitlementType |
|||
from .flags import SKUFlags |
|||
|
|||
if TYPE_CHECKING: |
|||
from datetime import datetime |
|||
|
|||
from .guild import Guild |
|||
from .state import ConnectionState |
|||
from .types.sku import ( |
|||
SKU as SKUPayload, |
|||
Entitlement as EntitlementPayload, |
|||
) |
|||
from .user import User |
|||
|
|||
__all__ = ( |
|||
'SKU', |
|||
'Entitlement', |
|||
) |
|||
|
|||
|
|||
class SKU: |
|||
"""Represents a premium offering as a stock-keeping unit (SKU). |
|||
|
|||
.. versionadded:: 2.4 |
|||
|
|||
Attributes |
|||
----------- |
|||
id: :class:`int` |
|||
The SKU's ID. |
|||
type: :class:`SKUType` |
|||
The type of the SKU. |
|||
application_id: :class:`int` |
|||
The ID of the application that the SKU belongs to. |
|||
name: :class:`str` |
|||
The consumer-facing name of the premium offering. |
|||
slug: :class:`str` |
|||
A system-generated URL slug based on the SKU name. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'_state', |
|||
'id', |
|||
'type', |
|||
'application_id', |
|||
'name', |
|||
'slug', |
|||
'_flags', |
|||
) |
|||
|
|||
def __init__(self, *, state: ConnectionState, data: SKUPayload): |
|||
self._state: ConnectionState = state |
|||
self.id: int = int(data['id']) |
|||
self.type: SKUType = try_enum(SKUType, data['type']) |
|||
self.application_id: int = int(data['application_id']) |
|||
self.name: str = data['name'] |
|||
self.slug: str = data['slug'] |
|||
self._flags: int = data['flags'] |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<SKU id={self.id} name={self.name!r} slug={self.slug!r}>' |
|||
|
|||
@property |
|||
def flags(self) -> SKUFlags: |
|||
""":class:`SKUFlags`: Returns the flags of the SKU.""" |
|||
return SKUFlags._from_value(self._flags) |
|||
|
|||
@property |
|||
def created_at(self) -> datetime: |
|||
""":class:`datetime.datetime`: Returns the sku's creation time in UTC.""" |
|||
return utils.snowflake_time(self.id) |
|||
|
|||
|
|||
class Entitlement: |
|||
"""Represents an entitlement from user or guild which has been granted access to a premium offering. |
|||
|
|||
.. versionadded:: 2.4 |
|||
|
|||
Attributes |
|||
----------- |
|||
id: :class:`int` |
|||
The entitlement's ID. |
|||
sku_id: :class:`int` |
|||
The ID of the SKU that the entitlement belongs to. |
|||
application_id: :class:`int` |
|||
The ID of the application that the entitlement belongs to. |
|||
user_id: Optional[:class:`int`] |
|||
The ID of the user that is granted access to the entitlement. |
|||
type: :class:`EntitlementType` |
|||
The type of the entitlement. |
|||
deleted: :class:`bool` |
|||
Whether the entitlement has been deleted. |
|||
starts_at: Optional[:class:`datetime.datetime`] |
|||
A UTC start date which the entitlement is valid. Not present when using test entitlements. |
|||
ends_at: Optional[:class:`datetime.datetime`] |
|||
A UTC date which entitlement is no longer valid. Not present when using test entitlements. |
|||
guild_id: Optional[:class:`int`] |
|||
The ID of the guild that is granted access to the entitlement |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'_state', |
|||
'id', |
|||
'sku_id', |
|||
'application_id', |
|||
'user_id', |
|||
'type', |
|||
'deleted', |
|||
'starts_at', |
|||
'ends_at', |
|||
'guild_id', |
|||
) |
|||
|
|||
def __init__(self, state: ConnectionState, data: EntitlementPayload): |
|||
self._state: ConnectionState = state |
|||
self.id: int = int(data['id']) |
|||
self.sku_id: int = int(data['sku_id']) |
|||
self.application_id: int = int(data['application_id']) |
|||
self.user_id: Optional[int] = utils._get_as_snowflake(data, 'user_id') |
|||
self.type: EntitlementType = try_enum(EntitlementType, data['type']) |
|||
self.deleted: bool = data['deleted'] |
|||
self.starts_at: Optional[datetime] = utils.parse_time(data.get('starts_at', None)) |
|||
self.ends_at: Optional[datetime] = utils.parse_time(data.get('ends_at', None)) |
|||
self.guild_id: Optional[int] = utils._get_as_snowflake(data, 'guild_id') |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<Entitlement id={self.id} type={self.type!r} user_id={self.user_id}>' |
|||
|
|||
@property |
|||
def user(self) -> Optional[User]: |
|||
"""Optional[:class:`User`]: The user that is granted access to the entitlement.""" |
|||
if self.user_id is None: |
|||
return None |
|||
return self._state.get_user(self.user_id) |
|||
|
|||
@property |
|||
def guild(self) -> Optional[Guild]: |
|||
"""Optional[:class:`Guild`]: The guild that is granted access to the entitlement.""" |
|||
return self._state._get_guild(self.guild_id) |
|||
|
|||
@property |
|||
def created_at(self) -> datetime: |
|||
""":class:`datetime.datetime`: Returns the entitlement's creation time in UTC.""" |
|||
return utils.snowflake_time(self.id) |
|||
|
|||
def is_expired(self) -> bool: |
|||
""":class:`bool`: Returns ``True`` if the entitlement is expired. Will be always False for test entitlements.""" |
|||
if self.ends_at is None: |
|||
return False |
|||
return utils.utcnow() >= self.ends_at |
|||
|
|||
async def delete(self) -> None: |
|||
"""|coro| |
|||
|
|||
Deletes the entitlement. |
|||
|
|||
Raises |
|||
------- |
|||
MissingApplicationID |
|||
The application ID could not be found. |
|||
NotFound |
|||
The entitlement could not be found. |
|||
HTTPException |
|||
Deleting the entitlement failed. |
|||
""" |
|||
|
|||
if self.application_id is None: |
|||
raise MissingApplicationID |
|||
|
|||
await self._state.http.delete_entitlement(self.application_id, self.id) |
|||
@ -0,0 +1,52 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import TypedDict, Optional, Literal |
|||
from typing_extensions import NotRequired |
|||
|
|||
|
|||
class SKU(TypedDict): |
|||
id: str |
|||
type: int |
|||
application_id: str |
|||
name: str |
|||
slug: str |
|||
flags: int |
|||
|
|||
|
|||
class Entitlement(TypedDict): |
|||
id: str |
|||
sku_id: str |
|||
application_id: str |
|||
user_id: Optional[str] |
|||
type: int |
|||
deleted: bool |
|||
starts_at: NotRequired[str] |
|||
ends_at: NotRequired[str] |
|||
guild_id: Optional[str] |
|||
|
|||
|
|||
EntitlementOwnerType = Literal[1, 2] |
|||
@ -0,0 +1,209 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
from typing import ClassVar, Dict, Generic, Optional, Tuple, Type, TypeVar, TYPE_CHECKING, Any, Union |
|||
import re |
|||
|
|||
from .item import Item |
|||
from .._types import ClientT |
|||
|
|||
__all__ = ('DynamicItem',) |
|||
|
|||
BaseT = TypeVar('BaseT', bound='Item[Any]', covariant=True) |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import TypeVar, Self |
|||
from ..interactions import Interaction |
|||
from ..components import Component |
|||
from ..enums import ComponentType |
|||
from .view import View |
|||
|
|||
V = TypeVar('V', bound='View', covariant=True, default=View) |
|||
else: |
|||
V = TypeVar('V', bound='View', covariant=True) |
|||
|
|||
|
|||
class DynamicItem(Generic[BaseT], Item['View']): |
|||
"""Represents an item with a dynamic ``custom_id`` that can be used to store state within |
|||
that ``custom_id``. |
|||
|
|||
The ``custom_id`` parsing is done using the ``re`` module by passing a ``template`` |
|||
parameter to the class parameter list. |
|||
|
|||
This item is generated every time the component is dispatched. This means that |
|||
any variable that holds an instance of this class will eventually be out of date |
|||
and should not be used long term. Their only purpose is to act as a "template" |
|||
for the actual dispatched item. |
|||
|
|||
When this item is generated, :attr:`view` is set to a regular :class:`View` instance |
|||
from the original message given from the interaction. This means that custom view |
|||
subclasses cannot be accessed from this item. |
|||
|
|||
.. versionadded:: 2.4 |
|||
|
|||
Parameters |
|||
------------ |
|||
item: :class:`Item` |
|||
The item to wrap with dynamic custom ID parsing. |
|||
template: Union[:class:`str`, ``re.Pattern``] |
|||
The template to use for parsing the ``custom_id``. This can be a string or a compiled |
|||
regular expression. This must be passed as a keyword argument to the class creation. |
|||
row: Optional[:class:`int`] |
|||
The relative row this button belongs to. A Discord component can only have 5 |
|||
rows. By default, items are arranged automatically into those 5 rows. If you'd |
|||
like to control the relative positioning of the row then passing an index is advised. |
|||
For example, row=1 will show up before row=2. Defaults to ``None``, which is automatic |
|||
ordering. The row number must be between 0 and 4 (i.e. zero indexed). |
|||
|
|||
Attributes |
|||
----------- |
|||
item: :class:`Item` |
|||
The item that is wrapped with dynamic custom ID parsing. |
|||
""" |
|||
|
|||
__item_repr_attributes__: Tuple[str, ...] = ( |
|||
'item', |
|||
'template', |
|||
) |
|||
|
|||
__discord_ui_compiled_template__: ClassVar[re.Pattern[str]] |
|||
|
|||
def __init_subclass__(cls, *, template: Union[str, re.Pattern[str]]) -> None: |
|||
super().__init_subclass__() |
|||
cls.__discord_ui_compiled_template__ = re.compile(template) if isinstance(template, str) else template |
|||
if not isinstance(cls.__discord_ui_compiled_template__, re.Pattern): |
|||
raise TypeError('template must be a str or a re.Pattern') |
|||
|
|||
def __init__( |
|||
self, |
|||
item: BaseT, |
|||
*, |
|||
row: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
self.item: BaseT = item |
|||
self.row = row |
|||
|
|||
if not self.item.is_dispatchable(): |
|||
raise TypeError('item must be dispatchable, e.g. not a URL button') |
|||
|
|||
if not self.template.match(self.custom_id): |
|||
raise ValueError(f'item custom_id {self.custom_id!r} must match the template {self.template.pattern!r}') |
|||
|
|||
@property |
|||
def template(self) -> re.Pattern[str]: |
|||
"""``re.Pattern``: The compiled regular expression that is used to parse the ``custom_id``.""" |
|||
return self.__class__.__discord_ui_compiled_template__ |
|||
|
|||
def to_component_dict(self) -> Dict[str, Any]: |
|||
return self.item.to_component_dict() |
|||
|
|||
def _refresh_component(self, component: Component) -> None: |
|||
self.item._refresh_component(component) |
|||
|
|||
def _refresh_state(self, interaction: Interaction, data: Dict[str, Any]) -> None: |
|||
self.item._refresh_state(interaction, data) |
|||
|
|||
@classmethod |
|||
def from_component(cls: Type[Self], component: Component) -> Self: |
|||
raise TypeError('Dynamic items cannot be created from components') |
|||
|
|||
@property |
|||
def type(self) -> ComponentType: |
|||
return self.item.type |
|||
|
|||
def is_dispatchable(self) -> bool: |
|||
return self.item.is_dispatchable() |
|||
|
|||
def is_persistent(self) -> bool: |
|||
return True |
|||
|
|||
@property |
|||
def custom_id(self) -> str: |
|||
""":class:`str`: The ID of the dynamic item that gets received during an interaction.""" |
|||
return self.item.custom_id # type: ignore # This attribute exists for dispatchable items |
|||
|
|||
@custom_id.setter |
|||
def custom_id(self, value: str) -> None: |
|||
if not isinstance(value, str): |
|||
raise TypeError('custom_id must be a str') |
|||
|
|||
if not self.template.match(value): |
|||
raise ValueError(f'custom_id must match the template {self.template.pattern!r}') |
|||
|
|||
self.item.custom_id = value # type: ignore # This attribute exists for dispatchable items |
|||
self._provided_custom_id = True |
|||
|
|||
@property |
|||
def row(self) -> Optional[int]: |
|||
return self.item._row |
|||
|
|||
@row.setter |
|||
def row(self, value: Optional[int]) -> None: |
|||
self.item.row = value |
|||
|
|||
@property |
|||
def width(self) -> int: |
|||
return self.item.width |
|||
|
|||
@classmethod |
|||
async def from_custom_id( |
|||
cls: Type[Self], interaction: Interaction[ClientT], item: Item[Any], match: re.Match[str], / |
|||
) -> Self: |
|||
"""|coro| |
|||
|
|||
A classmethod that is called when the ``custom_id`` of a component matches the |
|||
``template`` of the class. This is called when the component is dispatched. |
|||
|
|||
It must return a new instance of the :class:`DynamicItem`. |
|||
|
|||
Subclasses *must* implement this method. |
|||
|
|||
Exceptions raised in this method are logged and ignored. |
|||
|
|||
.. warning:: |
|||
|
|||
This method is called before the callback is dispatched, therefore |
|||
it means that it is subject to the same timing restrictions as the callback. |
|||
Ergo, you must reply to an interaction within 3 seconds of it being |
|||
dispatched. |
|||
|
|||
Parameters |
|||
------------ |
|||
interaction: :class:`~discord.Interaction` |
|||
The interaction that the component belongs to. |
|||
item: :class:`~discord.ui.Item` |
|||
The base item that is being dispatched. |
|||
match: ``re.Match`` |
|||
The match object that was created from the ``template`` |
|||
matching the ``custom_id``. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`DynamicItem` |
|||
The new instance of the :class:`DynamicItem` with information |
|||
from the ``match`` object. |
|||
""" |
|||
raise NotImplementedError |
|||
@ -0,0 +1,615 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
|
|||
|
|||
Some documentation to refer to: |
|||
|
|||
- Our main web socket (mWS) sends opcode 4 with a guild ID and channel ID. |
|||
- The mWS receives VOICE_STATE_UPDATE and VOICE_SERVER_UPDATE. |
|||
- We pull the session_id from VOICE_STATE_UPDATE. |
|||
- We pull the token, endpoint and server_id from VOICE_SERVER_UPDATE. |
|||
- Then we initiate the voice web socket (vWS) pointing to the endpoint. |
|||
- We send opcode 0 with the user_id, server_id, session_id and token using the vWS. |
|||
- The vWS sends back opcode 2 with an ssrc, port, modes(array) and heartbeat_interval. |
|||
- We send a UDP discovery packet to endpoint:port and receive our IP and our port in LE. |
|||
- Then we send our IP and port via vWS with opcode 1. |
|||
- When that's all done, we receive opcode 4 from the vWS. |
|||
- Finally we can transmit data to endpoint:port. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
import select |
|||
import socket |
|||
import asyncio |
|||
import logging |
|||
import threading |
|||
|
|||
try: |
|||
from asyncio import timeout as atimeout # type: ignore |
|||
except ImportError: |
|||
from async_timeout import timeout as atimeout # type: ignore |
|||
|
|||
from typing import TYPE_CHECKING, Optional, Dict, List, Callable, Coroutine, Any, Tuple |
|||
|
|||
from .enums import Enum |
|||
from .utils import MISSING, sane_wait_for |
|||
from .errors import ConnectionClosed |
|||
from .backoff import ExponentialBackoff |
|||
from .gateway import DiscordVoiceWebSocket |
|||
|
|||
if TYPE_CHECKING: |
|||
from . import abc |
|||
from .guild import Guild |
|||
from .user import ClientUser |
|||
from .member import VoiceState |
|||
from .voice_client import VoiceClient |
|||
|
|||
from .types.voice import ( |
|||
GuildVoiceState as GuildVoiceStatePayload, |
|||
VoiceServerUpdate as VoiceServerUpdatePayload, |
|||
SupportedModes, |
|||
) |
|||
|
|||
WebsocketHook = Optional[Callable[[DiscordVoiceWebSocket, Dict[str, Any]], Coroutine[Any, Any, Any]]] |
|||
SocketReaderCallback = Callable[[bytes], Any] |
|||
|
|||
|
|||
__all__ = ('VoiceConnectionState',) |
|||
|
|||
_log = logging.getLogger(__name__) |
|||
|
|||
|
|||
class SocketReader(threading.Thread): |
|||
def __init__(self, state: VoiceConnectionState) -> None: |
|||
super().__init__(daemon=True, name=f'voice-socket-reader:{id(self):#x}') |
|||
self.state: VoiceConnectionState = state |
|||
self._callbacks: List[SocketReaderCallback] = [] |
|||
self._running = threading.Event() |
|||
self._end = threading.Event() |
|||
# If we have paused reading due to having no callbacks |
|||
self._idle_paused: bool = True |
|||
|
|||
def register(self, callback: SocketReaderCallback) -> None: |
|||
self._callbacks.append(callback) |
|||
if self._idle_paused: |
|||
self._idle_paused = False |
|||
self._running.set() |
|||
|
|||
def unregister(self, callback: SocketReaderCallback) -> None: |
|||
try: |
|||
self._callbacks.remove(callback) |
|||
except ValueError: |
|||
pass |
|||
else: |
|||
if not self._callbacks and self._running.is_set(): |
|||
# If running is not set, we are either explicitly paused and |
|||
# should be explicitly resumed, or we are already idle paused |
|||
self._idle_paused = True |
|||
self._running.clear() |
|||
|
|||
def pause(self) -> None: |
|||
self._idle_paused = False |
|||
self._running.clear() |
|||
|
|||
def resume(self, *, force: bool = False) -> None: |
|||
if self._running.is_set(): |
|||
return |
|||
# Don't resume if there are no callbacks registered |
|||
if not force and not self._callbacks: |
|||
# We tried to resume but there was nothing to do, so resume when ready |
|||
self._idle_paused = True |
|||
return |
|||
self._idle_paused = False |
|||
self._running.set() |
|||
|
|||
def stop(self) -> None: |
|||
self._end.set() |
|||
self._running.set() |
|||
|
|||
def run(self) -> None: |
|||
self._end.clear() |
|||
self._running.set() |
|||
try: |
|||
self._do_run() |
|||
except Exception: |
|||
_log.exception('Error in %s', self) |
|||
finally: |
|||
self.stop() |
|||
self._running.clear() |
|||
self._callbacks.clear() |
|||
|
|||
def _do_run(self) -> None: |
|||
while not self._end.is_set(): |
|||
if not self._running.is_set(): |
|||
self._running.wait() |
|||
continue |
|||
|
|||
# Since this socket is a non blocking socket, select has to be used to wait on it for reading. |
|||
try: |
|||
readable, _, _ = select.select([self.state.socket], [], [], 30) |
|||
except (ValueError, TypeError): |
|||
# The socket is either closed or doesn't exist at the moment |
|||
continue |
|||
|
|||
if not readable: |
|||
continue |
|||
|
|||
try: |
|||
data = self.state.socket.recv(2048) |
|||
except OSError: |
|||
_log.debug('Error reading from socket in %s, this should be safe to ignore', self, exc_info=True) |
|||
else: |
|||
for cb in self._callbacks: |
|||
try: |
|||
cb(data) |
|||
except Exception: |
|||
_log.exception('Error calling %s in %s', cb, self) |
|||
|
|||
|
|||
class ConnectionFlowState(Enum): |
|||
"""Enum representing voice connection flow state.""" |
|||
|
|||
# fmt: off |
|||
disconnected = 0 |
|||
set_guild_voice_state = 1 |
|||
got_voice_state_update = 2 |
|||
got_voice_server_update = 3 |
|||
got_both_voice_updates = 4 |
|||
websocket_connected = 5 |
|||
got_websocket_ready = 6 |
|||
got_ip_discovery = 7 |
|||
connected = 8 |
|||
# fmt: on |
|||
|
|||
|
|||
class VoiceConnectionState: |
|||
"""Represents the internal state of a voice connection.""" |
|||
|
|||
def __init__(self, voice_client: VoiceClient, *, hook: Optional[WebsocketHook] = None) -> None: |
|||
self.voice_client = voice_client |
|||
self.hook = hook |
|||
|
|||
self.timeout: float = 30.0 |
|||
self.reconnect: bool = True |
|||
self.self_deaf: bool = False |
|||
self.self_mute: bool = False |
|||
self.token: Optional[str] = None |
|||
self.session_id: Optional[str] = None |
|||
self.endpoint: Optional[str] = None |
|||
self.endpoint_ip: Optional[str] = None |
|||
self.server_id: Optional[int] = None |
|||
self.ip: Optional[str] = None |
|||
self.port: Optional[int] = None |
|||
self.voice_port: Optional[int] = None |
|||
self.secret_key: List[int] = MISSING |
|||
self.ssrc: int = MISSING |
|||
self.mode: SupportedModes = MISSING |
|||
self.socket: socket.socket = MISSING |
|||
self.ws: DiscordVoiceWebSocket = MISSING |
|||
|
|||
self._state: ConnectionFlowState = ConnectionFlowState.disconnected |
|||
self._expecting_disconnect: bool = False |
|||
self._connected = threading.Event() |
|||
self._state_event = asyncio.Event() |
|||
self._runner: Optional[asyncio.Task] = None |
|||
self._connector: Optional[asyncio.Task] = None |
|||
self._socket_reader = SocketReader(self) |
|||
self._socket_reader.start() |
|||
|
|||
@property |
|||
def state(self) -> ConnectionFlowState: |
|||
return self._state |
|||
|
|||
@state.setter |
|||
def state(self, state: ConnectionFlowState) -> None: |
|||
if state is not self._state: |
|||
_log.debug('Connection state changed to %s', state.name) |
|||
self._state = state |
|||
self._state_event.set() |
|||
self._state_event.clear() |
|||
|
|||
if state is ConnectionFlowState.connected: |
|||
self._connected.set() |
|||
else: |
|||
self._connected.clear() |
|||
|
|||
@property |
|||
def guild(self) -> Guild: |
|||
return self.voice_client.guild |
|||
|
|||
@property |
|||
def user(self) -> ClientUser: |
|||
return self.voice_client.user |
|||
|
|||
@property |
|||
def supported_modes(self) -> Tuple[SupportedModes, ...]: |
|||
return self.voice_client.supported_modes |
|||
|
|||
@property |
|||
def self_voice_state(self) -> Optional[VoiceState]: |
|||
return self.guild.me.voice |
|||
|
|||
async def voice_state_update(self, data: GuildVoiceStatePayload) -> None: |
|||
channel_id = data['channel_id'] |
|||
|
|||
if channel_id is None: |
|||
# If we know we're going to get a voice_state_update where we have no channel due to |
|||
# being in the reconnect flow, we ignore it. Otherwise, it probably wasn't from us. |
|||
if self._expecting_disconnect: |
|||
self._expecting_disconnect = False |
|||
else: |
|||
_log.debug('We were externally disconnected from voice.') |
|||
await self.disconnect() |
|||
|
|||
return |
|||
|
|||
self.session_id = data['session_id'] |
|||
|
|||
# we got the event while connecting |
|||
if self.state in (ConnectionFlowState.set_guild_voice_state, ConnectionFlowState.got_voice_server_update): |
|||
if self.state is ConnectionFlowState.set_guild_voice_state: |
|||
self.state = ConnectionFlowState.got_voice_state_update |
|||
else: |
|||
self.state = ConnectionFlowState.got_both_voice_updates |
|||
return |
|||
|
|||
if self.state is ConnectionFlowState.connected: |
|||
self.voice_client.channel = channel_id and self.guild.get_channel(int(channel_id)) # type: ignore |
|||
|
|||
elif self.state is not ConnectionFlowState.disconnected: |
|||
if channel_id != self.voice_client.channel.id: |
|||
# For some unfortunate reason we were moved during the connection flow |
|||
_log.info('Handling channel move while connecting...') |
|||
|
|||
self.voice_client.channel = channel_id and self.guild.get_channel(int(channel_id)) # type: ignore |
|||
|
|||
await self.soft_disconnect(with_state=ConnectionFlowState.got_voice_state_update) |
|||
await self.connect( |
|||
reconnect=self.reconnect, |
|||
timeout=self.timeout, |
|||
self_deaf=(self.self_voice_state or self).self_deaf, |
|||
self_mute=(self.self_voice_state or self).self_mute, |
|||
resume=False, |
|||
wait=False, |
|||
) |
|||
else: |
|||
_log.debug('Ignoring unexpected voice_state_update event') |
|||
|
|||
async def voice_server_update(self, data: VoiceServerUpdatePayload) -> None: |
|||
self.token = data['token'] |
|||
self.server_id = int(data['guild_id']) |
|||
endpoint = data.get('endpoint') |
|||
|
|||
if self.token is None or endpoint is None: |
|||
_log.warning( |
|||
'Awaiting endpoint... This requires waiting. ' |
|||
'If timeout occurred considering raising the timeout and reconnecting.' |
|||
) |
|||
return |
|||
|
|||
self.endpoint, _, _ = endpoint.rpartition(':') |
|||
if self.endpoint.startswith('wss://'): |
|||
# Just in case, strip it off since we're going to add it later |
|||
self.endpoint = self.endpoint[6:] |
|||
|
|||
# we got the event while connecting |
|||
if self.state in (ConnectionFlowState.set_guild_voice_state, ConnectionFlowState.got_voice_state_update): |
|||
# This gets set after READY is received |
|||
self.endpoint_ip = MISSING |
|||
self._create_socket() |
|||
|
|||
if self.state is ConnectionFlowState.set_guild_voice_state: |
|||
self.state = ConnectionFlowState.got_voice_server_update |
|||
else: |
|||
self.state = ConnectionFlowState.got_both_voice_updates |
|||
|
|||
elif self.state is ConnectionFlowState.connected: |
|||
_log.debug('Voice server update, closing old voice websocket') |
|||
await self.ws.close(4014) |
|||
self.state = ConnectionFlowState.got_voice_server_update |
|||
|
|||
elif self.state is not ConnectionFlowState.disconnected: |
|||
_log.debug('Unexpected server update event, attempting to handle') |
|||
|
|||
await self.soft_disconnect(with_state=ConnectionFlowState.got_voice_server_update) |
|||
await self.connect( |
|||
reconnect=self.reconnect, |
|||
timeout=self.timeout, |
|||
self_deaf=(self.self_voice_state or self).self_deaf, |
|||
self_mute=(self.self_voice_state or self).self_mute, |
|||
resume=False, |
|||
wait=False, |
|||
) |
|||
self._create_socket() |
|||
|
|||
async def connect( |
|||
self, *, reconnect: bool, timeout: float, self_deaf: bool, self_mute: bool, resume: bool, wait: bool = True |
|||
) -> None: |
|||
if self._connector: |
|||
self._connector.cancel() |
|||
self._connector = None |
|||
|
|||
if self._runner: |
|||
self._runner.cancel() |
|||
self._runner = None |
|||
|
|||
self.timeout = timeout |
|||
self.reconnect = reconnect |
|||
self._connector = self.voice_client.loop.create_task( |
|||
self._wrap_connect(reconnect, timeout, self_deaf, self_mute, resume), name='Voice connector' |
|||
) |
|||
if wait: |
|||
await self._connector |
|||
|
|||
async def _wrap_connect(self, *args: Any) -> None: |
|||
try: |
|||
await self._connect(*args) |
|||
except asyncio.CancelledError: |
|||
_log.debug('Cancelling voice connection') |
|||
await self.soft_disconnect() |
|||
raise |
|||
except asyncio.TimeoutError: |
|||
_log.info('Timed out connecting to voice') |
|||
await self.disconnect() |
|||
raise |
|||
except Exception: |
|||
_log.exception('Error connecting to voice... disconnecting') |
|||
await self.disconnect() |
|||
raise |
|||
|
|||
async def _connect(self, reconnect: bool, timeout: float, self_deaf: bool, self_mute: bool, resume: bool) -> None: |
|||
_log.info('Connecting to voice...') |
|||
|
|||
async with atimeout(timeout): |
|||
for i in range(5): |
|||
_log.info('Starting voice handshake... (connection attempt %d)', i + 1) |
|||
|
|||
await self._voice_connect(self_deaf=self_deaf, self_mute=self_mute) |
|||
# Setting this unnecessarily will break reconnecting |
|||
if self.state is ConnectionFlowState.disconnected: |
|||
self.state = ConnectionFlowState.set_guild_voice_state |
|||
|
|||
await self._wait_for_state(ConnectionFlowState.got_both_voice_updates) |
|||
|
|||
_log.info('Voice handshake complete. Endpoint found: %s', self.endpoint) |
|||
|
|||
try: |
|||
self.ws = await self._connect_websocket(resume) |
|||
await self._handshake_websocket() |
|||
break |
|||
except ConnectionClosed: |
|||
if reconnect: |
|||
wait = 1 + i * 2.0 |
|||
_log.exception('Failed to connect to voice... Retrying in %ss...', wait) |
|||
await self.disconnect(cleanup=False) |
|||
await asyncio.sleep(wait) |
|||
continue |
|||
else: |
|||
await self.disconnect() |
|||
raise |
|||
|
|||
_log.info('Voice connection complete.') |
|||
|
|||
if not self._runner: |
|||
self._runner = self.voice_client.loop.create_task(self._poll_voice_ws(reconnect), name='Voice websocket poller') |
|||
|
|||
async def disconnect(self, *, force: bool = True, cleanup: bool = True) -> None: |
|||
if not force and not self.is_connected(): |
|||
return |
|||
|
|||
try: |
|||
if self.ws: |
|||
await self.ws.close() |
|||
await self._voice_disconnect() |
|||
except Exception: |
|||
_log.debug('Ignoring exception disconnecting from voice', exc_info=True) |
|||
finally: |
|||
self.ip = MISSING |
|||
self.port = MISSING |
|||
self.state = ConnectionFlowState.disconnected |
|||
self._socket_reader.pause() |
|||
|
|||
# Flip the connected event to unlock any waiters |
|||
self._connected.set() |
|||
self._connected.clear() |
|||
|
|||
if cleanup: |
|||
self._socket_reader.stop() |
|||
self.voice_client.cleanup() |
|||
|
|||
if self.socket: |
|||
self.socket.close() |
|||
|
|||
async def soft_disconnect(self, *, with_state: ConnectionFlowState = ConnectionFlowState.got_both_voice_updates) -> None: |
|||
_log.debug('Soft disconnecting from voice') |
|||
# Stop the websocket reader because closing the websocket will trigger an unwanted reconnect |
|||
if self._runner: |
|||
self._runner.cancel() |
|||
self._runner = None |
|||
|
|||
try: |
|||
if self.ws: |
|||
await self.ws.close() |
|||
except Exception: |
|||
_log.debug('Ignoring exception soft disconnecting from voice', exc_info=True) |
|||
finally: |
|||
self.ip = MISSING |
|||
self.port = MISSING |
|||
self.state = with_state |
|||
self._socket_reader.pause() |
|||
|
|||
if self.socket: |
|||
self.socket.close() |
|||
|
|||
async def move_to(self, channel: Optional[abc.Snowflake], timeout: Optional[float]) -> None: |
|||
if channel is None: |
|||
await self.disconnect() |
|||
return |
|||
|
|||
previous_state = self.state |
|||
# this is only an outgoing ws request |
|||
# if it fails, nothing happens and nothing changes (besides self.state) |
|||
await self._move_to(channel) |
|||
|
|||
last_state = self.state |
|||
try: |
|||
await self.wait_async(timeout) |
|||
except asyncio.TimeoutError: |
|||
_log.warning('Timed out trying to move to channel %s in guild %s', channel.id, self.guild.id) |
|||
if self.state is last_state: |
|||
_log.debug('Reverting to previous state %s', previous_state.name) |
|||
|
|||
self.state = previous_state |
|||
|
|||
def wait(self, timeout: Optional[float] = None) -> bool: |
|||
return self._connected.wait(timeout) |
|||
|
|||
async def wait_async(self, timeout: Optional[float] = None) -> None: |
|||
await self._wait_for_state(ConnectionFlowState.connected, timeout=timeout) |
|||
|
|||
def is_connected(self) -> bool: |
|||
return self.state is ConnectionFlowState.connected |
|||
|
|||
def send_packet(self, packet: bytes) -> None: |
|||
self.socket.sendall(packet) |
|||
|
|||
def add_socket_listener(self, callback: SocketReaderCallback) -> None: |
|||
_log.debug('Registering socket listener callback %s', callback) |
|||
self._socket_reader.register(callback) |
|||
|
|||
def remove_socket_listener(self, callback: SocketReaderCallback) -> None: |
|||
_log.debug('Unregistering socket listener callback %s', callback) |
|||
self._socket_reader.unregister(callback) |
|||
|
|||
async def _wait_for_state( |
|||
self, state: ConnectionFlowState, *other_states: ConnectionFlowState, timeout: Optional[float] = None |
|||
) -> None: |
|||
states = (state, *other_states) |
|||
while True: |
|||
if self.state in states: |
|||
return |
|||
await sane_wait_for([self._state_event.wait()], timeout=timeout) |
|||
|
|||
async def _voice_connect(self, *, self_deaf: bool = False, self_mute: bool = False) -> None: |
|||
channel = self.voice_client.channel |
|||
await channel.guild.change_voice_state(channel=channel, self_deaf=self_deaf, self_mute=self_mute) |
|||
|
|||
async def _voice_disconnect(self) -> None: |
|||
_log.info( |
|||
'The voice handshake is being terminated for Channel ID %s (Guild ID %s)', |
|||
self.voice_client.channel.id, |
|||
self.voice_client.guild.id, |
|||
) |
|||
self.state = ConnectionFlowState.disconnected |
|||
await self.voice_client.channel.guild.change_voice_state(channel=None) |
|||
self._expecting_disconnect = True |
|||
|
|||
async def _connect_websocket(self, resume: bool) -> DiscordVoiceWebSocket: |
|||
ws = await DiscordVoiceWebSocket.from_connection_state(self, resume=resume, hook=self.hook) |
|||
self.state = ConnectionFlowState.websocket_connected |
|||
return ws |
|||
|
|||
async def _handshake_websocket(self) -> None: |
|||
while not self.ip: |
|||
await self.ws.poll_event() |
|||
self.state = ConnectionFlowState.got_ip_discovery |
|||
while self.ws.secret_key is None: |
|||
await self.ws.poll_event() |
|||
self.state = ConnectionFlowState.connected |
|||
|
|||
def _create_socket(self) -> None: |
|||
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) |
|||
self.socket.setblocking(False) |
|||
self._socket_reader.resume() |
|||
|
|||
async def _poll_voice_ws(self, reconnect: bool) -> None: |
|||
backoff = ExponentialBackoff() |
|||
while True: |
|||
try: |
|||
await self.ws.poll_event() |
|||
except asyncio.CancelledError: |
|||
return |
|||
except (ConnectionClosed, asyncio.TimeoutError) as exc: |
|||
if isinstance(exc, ConnectionClosed): |
|||
# The following close codes are undocumented so I will document them here. |
|||
# 1000 - normal closure (obviously) |
|||
# 4014 - we were externally disconnected (voice channel deleted, we were moved, etc) |
|||
# 4015 - voice server has crashed |
|||
if exc.code in (1000, 4015): |
|||
_log.info('Disconnecting from voice normally, close code %d.', exc.code) |
|||
await self.disconnect() |
|||
break |
|||
|
|||
if exc.code == 4014: |
|||
_log.info('Disconnected from voice by force... potentially reconnecting.') |
|||
successful = await self._potential_reconnect() |
|||
if not successful: |
|||
_log.info('Reconnect was unsuccessful, disconnecting from voice normally...') |
|||
await self.disconnect() |
|||
break |
|||
else: |
|||
continue |
|||
|
|||
_log.debug('Not handling close code %s (%s)', exc.code, exc.reason or 'no reason') |
|||
|
|||
if not reconnect: |
|||
await self.disconnect() |
|||
raise |
|||
|
|||
retry = backoff.delay() |
|||
_log.exception('Disconnected from voice... Reconnecting in %.2fs.', retry) |
|||
await asyncio.sleep(retry) |
|||
await self.disconnect(cleanup=False) |
|||
|
|||
try: |
|||
await self._connect( |
|||
reconnect=reconnect, |
|||
timeout=self.timeout, |
|||
self_deaf=(self.self_voice_state or self).self_deaf, |
|||
self_mute=(self.self_voice_state or self).self_mute, |
|||
resume=False, |
|||
) |
|||
except asyncio.TimeoutError: |
|||
# at this point we've retried 5 times... let's continue the loop. |
|||
_log.warning('Could not connect to voice... Retrying...') |
|||
continue |
|||
|
|||
async def _potential_reconnect(self) -> bool: |
|||
try: |
|||
await self._wait_for_state( |
|||
ConnectionFlowState.got_voice_server_update, ConnectionFlowState.got_both_voice_updates, timeout=self.timeout |
|||
) |
|||
except asyncio.TimeoutError: |
|||
return False |
|||
try: |
|||
self.ws = await self._connect_websocket(False) |
|||
await self._handshake_websocket() |
|||
except (ConnectionClosed, asyncio.TimeoutError): |
|||
return False |
|||
else: |
|||
return True |
|||
|
|||
async def _move_to(self, channel: abc.Snowflake) -> None: |
|||
await self.voice_client.channel.guild.change_voice_state(channel=channel) |
|||
self.state = ConnectionFlowState.set_guild_voice_state |
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,98 @@ |
|||
from __future__ import annotations |
|||
|
|||
from discord.ext import commands |
|||
import discord |
|||
import re |
|||
|
|||
# Complicated use cases for persistent views can be difficult to achieve when dealing |
|||
# with state changes or dynamic items. In order to facilitate these complicated use cases, |
|||
# the library provides DynamicItem which allows you to define an item backed by a regular |
|||
# expression that can parse state out of the custom_id. |
|||
|
|||
# The following example showcases a dynamic item that implements a counter. |
|||
# The `template` class parameter is used to give the library a regular expression to parse |
|||
# the custom_id. In this case we're parsing out custom_id in the form of e.g. |
|||
# `counter:5:user:80088516616269824` where the first number is the current count and the |
|||
# second number is the user ID who owns the button. |
|||
|
|||
# Note that custom_ids can only be up to 100 characters long. |
|||
class DynamicCounter( |
|||
discord.ui.DynamicItem[discord.ui.Button], |
|||
template=r'counter:(?P<count>[0-9]+):user:(?P<id>[0-9]+)', |
|||
): |
|||
def __init__(self, user_id: int, count: int = 0) -> None: |
|||
self.user_id: int = user_id |
|||
self.count: int = count |
|||
super().__init__( |
|||
discord.ui.Button( |
|||
label=f'Total: {count}', |
|||
style=self.style, |
|||
custom_id=f'counter:{count}:user:{user_id}', |
|||
emoji='\N{THUMBS UP SIGN}', |
|||
) |
|||
) |
|||
|
|||
# We want the style of the button to be dynamic depending on the count. |
|||
@property |
|||
def style(self) -> discord.ButtonStyle: |
|||
if self.count < 10: |
|||
return discord.ButtonStyle.grey |
|||
if self.count < 15: |
|||
return discord.ButtonStyle.red |
|||
if self.count < 20: |
|||
return discord.ButtonStyle.blurple |
|||
return discord.ButtonStyle.green |
|||
|
|||
# This method actually extracts the information from the custom ID and creates the item. |
|||
@classmethod |
|||
async def from_custom_id(cls, interaction: discord.Interaction, item: discord.ui.Button, match: re.Match[str], /): |
|||
count = int(match['count']) |
|||
user_id = int(match['id']) |
|||
return cls(user_id, count=count) |
|||
|
|||
# We want to ensure that our button is only called by the user who created it. |
|||
async def interaction_check(self, interaction: discord.Interaction) -> bool: |
|||
return interaction.user.id == self.user_id |
|||
|
|||
async def callback(self, interaction: discord.Interaction) -> None: |
|||
# When the button is invoked, we want to increase the count and update the button's |
|||
# styling and label. |
|||
# In order to actually persist these changes we need to also update the custom_id |
|||
# to match the new information. |
|||
# Note that the custom ID *must* match the template. |
|||
self.count += 1 |
|||
self.item.label = f'Total: {self.count}' |
|||
self.custom_id = f'counter:{self.count}:user:{self.user_id}' |
|||
self.item.style = self.style |
|||
# In here, self.view is the view given by the interaction's message. |
|||
# It cannot be a custom subclass due to limitations. |
|||
await interaction.response.edit_message(view=self.view) |
|||
|
|||
|
|||
class DynamicCounterBot(commands.Bot): |
|||
def __init__(self): |
|||
intents = discord.Intents.default() |
|||
super().__init__(command_prefix=commands.when_mentioned, intents=intents) |
|||
|
|||
async def setup_hook(self) -> None: |
|||
# For dynamic items, we must register the classes instead of the views. |
|||
self.add_dynamic_items(DynamicCounter) |
|||
|
|||
async def on_ready(self): |
|||
print(f'Logged in as {self.user} (ID: {self.user.id})') |
|||
print('------') |
|||
|
|||
|
|||
bot = DynamicCounterBot() |
|||
|
|||
|
|||
@bot.command() |
|||
async def counter(ctx: commands.Context): |
|||
"""Starts a dynamic counter.""" |
|||
|
|||
view = discord.ui.View(timeout=None) |
|||
view.add_item(DynamicCounter(ctx.author.id)) |
|||
await ctx.send('Here is your very own button!', view=view) |
|||
|
|||
|
|||
bot.run('token') |
|||
@ -1 +1,2 @@ |
|||
aiohttp>=3.7.4,<4 |
|||
async-timeout>=4.0,<5.0; python_version<"3.11" |
|||
|
|||
Loading…
Reference in new issue