Soheab_
2 weeks ago
162 changed files with 21283 additions and 5554 deletions
@ -1,5 +1,5 @@ |
|||
include README.rst |
|||
include LICENSE |
|||
include requirements.txt |
|||
include discord/bin/*.dll |
|||
include discord/bin/* |
|||
include discord/py.typed |
|||
|
|||
@ -0,0 +1,213 @@ |
|||
""" |
|||
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 TYPE_CHECKING, ClassVar, List, Optional, Sequence |
|||
|
|||
__all__ = ( |
|||
'AppInstallationType', |
|||
'AppCommandContext', |
|||
) |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
from ..types.interactions import InteractionContextType, InteractionInstallationType |
|||
|
|||
|
|||
class AppInstallationType: |
|||
r"""Represents the installation location of an application command. |
|||
|
|||
.. versionadded:: 2.4 |
|||
|
|||
Parameters |
|||
----------- |
|||
guild: Optional[:class:`bool`] |
|||
Whether the integration is a guild install. |
|||
user: Optional[:class:`bool`] |
|||
Whether the integration is a user install. |
|||
""" |
|||
|
|||
__slots__ = ('_guild', '_user') |
|||
|
|||
GUILD: ClassVar[int] = 0 |
|||
USER: ClassVar[int] = 1 |
|||
|
|||
def __init__(self, *, guild: Optional[bool] = None, user: Optional[bool] = None): |
|||
self._guild: Optional[bool] = guild |
|||
self._user: Optional[bool] = user |
|||
|
|||
def __repr__(self): |
|||
return f'<AppInstallationType guild={self.guild!r} user={self.user!r}>' |
|||
|
|||
@property |
|||
def guild(self) -> bool: |
|||
""":class:`bool`: Whether the integration is a guild install.""" |
|||
return bool(self._guild) |
|||
|
|||
@guild.setter |
|||
def guild(self, value: bool) -> None: |
|||
self._guild = bool(value) |
|||
|
|||
@property |
|||
def user(self) -> bool: |
|||
""":class:`bool`: Whether the integration is a user install.""" |
|||
return bool(self._user) |
|||
|
|||
@user.setter |
|||
def user(self, value: bool) -> None: |
|||
self._user = bool(value) |
|||
|
|||
def merge(self, other: AppInstallationType) -> AppInstallationType: |
|||
# Merging is similar to AllowedMentions where `self` is the base |
|||
# and the `other` is the override preference |
|||
guild = self._guild if other._guild is None else other._guild |
|||
user = self._user if other._user is None else other._user |
|||
return AppInstallationType(guild=guild, user=user) |
|||
|
|||
def _is_unset(self) -> bool: |
|||
return all(x is None for x in (self._guild, self._user)) |
|||
|
|||
def _merge_to_array(self, other: Optional[AppInstallationType]) -> Optional[List[InteractionInstallationType]]: |
|||
result = self.merge(other) if other is not None else self |
|||
if result._is_unset(): |
|||
return None |
|||
return result.to_array() |
|||
|
|||
@classmethod |
|||
def _from_value(cls, value: Sequence[InteractionInstallationType]) -> Self: |
|||
self = cls() |
|||
for x in value: |
|||
if x == cls.GUILD: |
|||
self._guild = True |
|||
elif x == cls.USER: |
|||
self._user = True |
|||
return self |
|||
|
|||
def to_array(self) -> List[InteractionInstallationType]: |
|||
values = [] |
|||
if self._guild: |
|||
values.append(self.GUILD) |
|||
if self._user: |
|||
values.append(self.USER) |
|||
return values |
|||
|
|||
|
|||
class AppCommandContext: |
|||
r"""Wraps up the Discord :class:`~discord.app_commands.Command` execution context. |
|||
|
|||
.. versionadded:: 2.4 |
|||
|
|||
Parameters |
|||
----------- |
|||
guild: Optional[:class:`bool`] |
|||
Whether the context allows usage in a guild. |
|||
dm_channel: Optional[:class:`bool`] |
|||
Whether the context allows usage in a DM channel. |
|||
private_channel: Optional[:class:`bool`] |
|||
Whether the context allows usage in a DM or a GDM channel. |
|||
""" |
|||
|
|||
GUILD: ClassVar[int] = 0 |
|||
DM_CHANNEL: ClassVar[int] = 1 |
|||
PRIVATE_CHANNEL: ClassVar[int] = 2 |
|||
|
|||
__slots__ = ('_guild', '_dm_channel', '_private_channel') |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
guild: Optional[bool] = None, |
|||
dm_channel: Optional[bool] = None, |
|||
private_channel: Optional[bool] = None, |
|||
): |
|||
self._guild: Optional[bool] = guild |
|||
self._dm_channel: Optional[bool] = dm_channel |
|||
self._private_channel: Optional[bool] = private_channel |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<AppCommandContext guild={self.guild!r} dm_channel={self.dm_channel!r} private_channel={self.private_channel!r}>' |
|||
|
|||
@property |
|||
def guild(self) -> bool: |
|||
""":class:`bool`: Whether the context allows usage in a guild.""" |
|||
return bool(self._guild) |
|||
|
|||
@guild.setter |
|||
def guild(self, value: bool) -> None: |
|||
self._guild = bool(value) |
|||
|
|||
@property |
|||
def dm_channel(self) -> bool: |
|||
""":class:`bool`: Whether the context allows usage in a DM channel.""" |
|||
return bool(self._dm_channel) |
|||
|
|||
@dm_channel.setter |
|||
def dm_channel(self, value: bool) -> None: |
|||
self._dm_channel = bool(value) |
|||
|
|||
@property |
|||
def private_channel(self) -> bool: |
|||
""":class:`bool`: Whether the context allows usage in a DM or a GDM channel.""" |
|||
return bool(self._private_channel) |
|||
|
|||
@private_channel.setter |
|||
def private_channel(self, value: bool) -> None: |
|||
self._private_channel = bool(value) |
|||
|
|||
def merge(self, other: AppCommandContext) -> AppCommandContext: |
|||
guild = self._guild if other._guild is None else other._guild |
|||
dm_channel = self._dm_channel if other._dm_channel is None else other._dm_channel |
|||
private_channel = self._private_channel if other._private_channel is None else other._private_channel |
|||
return AppCommandContext(guild=guild, dm_channel=dm_channel, private_channel=private_channel) |
|||
|
|||
def _is_unset(self) -> bool: |
|||
return all(x is None for x in (self._guild, self._dm_channel, self._private_channel)) |
|||
|
|||
def _merge_to_array(self, other: Optional[AppCommandContext]) -> Optional[List[InteractionContextType]]: |
|||
result = self.merge(other) if other is not None else self |
|||
if result._is_unset(): |
|||
return None |
|||
return result.to_array() |
|||
|
|||
@classmethod |
|||
def _from_value(cls, value: Sequence[InteractionContextType]) -> Self: |
|||
self = cls() |
|||
for x in value: |
|||
if x == cls.GUILD: |
|||
self._guild = True |
|||
elif x == cls.DM_CHANNEL: |
|||
self._dm_channel = True |
|||
elif x == cls.PRIVATE_CHANNEL: |
|||
self._private_channel = True |
|||
return self |
|||
|
|||
def to_array(self) -> List[InteractionContextType]: |
|||
values = [] |
|||
if self._guild: |
|||
values.append(self.GUILD) |
|||
if self._dm_channel: |
|||
values.append(self.DM_CHANNEL) |
|||
if self._private_channel: |
|||
values.append(self.PRIVATE_CHANNEL) |
|||
return values |
|||
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,672 @@ |
|||
""" |
|||
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, List, TYPE_CHECKING, Union, AsyncIterator, Dict |
|||
|
|||
import datetime |
|||
|
|||
from .enums import PollLayoutType, try_enum, MessageType |
|||
from . import utils |
|||
from .emoji import PartialEmoji, Emoji |
|||
from .user import User |
|||
from .object import Object |
|||
from .errors import ClientException |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .message import Message |
|||
from .abc import Snowflake |
|||
from .state import ConnectionState |
|||
from .member import Member |
|||
|
|||
from .types.poll import ( |
|||
PollCreate as PollCreatePayload, |
|||
PollMedia as PollMediaPayload, |
|||
PollAnswerCount as PollAnswerCountPayload, |
|||
Poll as PollPayload, |
|||
PollAnswerWithID as PollAnswerWithIDPayload, |
|||
PollResult as PollResultPayload, |
|||
PollAnswer as PollAnswerPayload, |
|||
) |
|||
|
|||
|
|||
__all__ = ( |
|||
'Poll', |
|||
'PollAnswer', |
|||
'PollMedia', |
|||
) |
|||
|
|||
MISSING = utils.MISSING |
|||
PollMediaEmoji = Union[PartialEmoji, Emoji, str] |
|||
|
|||
|
|||
class PollMedia: |
|||
"""Represents the poll media for a poll item. |
|||
|
|||
.. versionadded:: 2.4 |
|||
|
|||
Attributes |
|||
---------- |
|||
text: :class:`str` |
|||
The displayed text. |
|||
emoji: Optional[Union[:class:`PartialEmoji`, :class:`Emoji`]] |
|||
The attached emoji for this media. This is only valid for poll answers. |
|||
""" |
|||
|
|||
__slots__ = ('text', 'emoji') |
|||
|
|||
def __init__(self, /, text: str, emoji: Optional[PollMediaEmoji] = None) -> None: |
|||
self.text: str = text |
|||
self.emoji: Optional[Union[PartialEmoji, Emoji]] = PartialEmoji.from_str(emoji) if isinstance(emoji, str) else emoji |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<PollMedia text={self.text!r} emoji={self.emoji!r}>' |
|||
|
|||
def to_dict(self) -> PollMediaPayload: |
|||
payload: PollMediaPayload = {'text': self.text} |
|||
|
|||
if self.emoji is not None: |
|||
payload['emoji'] = self.emoji._to_partial().to_dict() |
|||
|
|||
return payload |
|||
|
|||
@classmethod |
|||
def from_dict(cls, *, data: PollMediaPayload) -> Self: |
|||
emoji = data.get('emoji') |
|||
|
|||
if emoji: |
|||
return cls(text=data['text'], emoji=PartialEmoji.from_dict(emoji)) |
|||
return cls(text=data['text']) |
|||
|
|||
|
|||
class PollAnswer: |
|||
"""Represents a poll's answer. |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: str(x) |
|||
|
|||
Returns this answer's text, if any. |
|||
|
|||
.. versionadded:: 2.4 |
|||
|
|||
Attributes |
|||
---------- |
|||
id: :class:`int` |
|||
The ID of this answer. |
|||
media: :class:`PollMedia` |
|||
The display data for this answer. |
|||
self_voted: :class:`bool` |
|||
Whether the current user has voted to this answer or not. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'media', |
|||
'id', |
|||
'_state', |
|||
'_message', |
|||
'_vote_count', |
|||
'self_voted', |
|||
'_poll', |
|||
'_victor', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
message: Optional[Message], |
|||
poll: Poll, |
|||
data: PollAnswerWithIDPayload, |
|||
) -> None: |
|||
self.media: PollMedia = PollMedia.from_dict(data=data['poll_media']) |
|||
self.id: int = int(data['answer_id']) |
|||
self._message: Optional[Message] = message |
|||
self._state: Optional[ConnectionState] = message._state if message else None |
|||
self._vote_count: int = 0 |
|||
self.self_voted: bool = False |
|||
self._poll: Poll = poll |
|||
self._victor: bool = False |
|||
|
|||
def _handle_vote_event(self, added: bool, self_voted: bool) -> None: |
|||
if added: |
|||
self._vote_count += 1 |
|||
else: |
|||
self._vote_count -= 1 |
|||
self.self_voted = self_voted |
|||
|
|||
def _update_with_results(self, payload: PollAnswerCountPayload) -> None: |
|||
self._vote_count = int(payload['count']) |
|||
self.self_voted = payload['me_voted'] |
|||
|
|||
def __str__(self) -> str: |
|||
return self.media.text |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<PollAnswer id={self.id} media={self.media!r}>' |
|||
|
|||
@classmethod |
|||
def from_params( |
|||
cls, |
|||
id: int, |
|||
text: str, |
|||
emoji: Optional[PollMediaEmoji] = None, |
|||
*, |
|||
poll: Poll, |
|||
message: Optional[Message], |
|||
) -> Self: |
|||
poll_media: PollMediaPayload = {'text': text} |
|||
if emoji is not None: |
|||
emoji = PartialEmoji.from_str(emoji) if isinstance(emoji, str) else emoji._to_partial() |
|||
emoji_data = emoji.to_dict() |
|||
# No need to remove animated key as it will be ignored |
|||
poll_media['emoji'] = emoji_data |
|||
|
|||
payload: PollAnswerWithIDPayload = {'answer_id': id, 'poll_media': poll_media} |
|||
|
|||
return cls(data=payload, message=message, poll=poll) |
|||
|
|||
@property |
|||
def text(self) -> str: |
|||
""":class:`str`: Returns this answer's displayed text.""" |
|||
return self.media.text |
|||
|
|||
@property |
|||
def emoji(self) -> Optional[Union[PartialEmoji, Emoji]]: |
|||
"""Optional[Union[:class:`Emoji`, :class:`PartialEmoji`]]: Returns this answer's displayed |
|||
emoji, if any. |
|||
""" |
|||
return self.media.emoji |
|||
|
|||
@property |
|||
def vote_count(self) -> int: |
|||
""":class:`int`: Returns an approximate count of votes for this answer. |
|||
|
|||
If the poll is finished, the count is exact. |
|||
""" |
|||
return self._vote_count |
|||
|
|||
@property |
|||
def poll(self) -> Poll: |
|||
""":class:`Poll`: Returns the parent poll of this answer.""" |
|||
return self._poll |
|||
|
|||
def _to_dict(self) -> PollAnswerPayload: |
|||
return { |
|||
'poll_media': self.media.to_dict(), |
|||
} |
|||
|
|||
@property |
|||
def victor(self) -> bool: |
|||
""":class:`bool`: Whether the answer is the one that had the most |
|||
votes when the poll ended. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
.. note:: |
|||
|
|||
If the poll has not ended, this will always return ``False``. |
|||
""" |
|||
return self._victor |
|||
|
|||
async def voters( |
|||
self, *, limit: Optional[int] = None, after: Optional[Snowflake] = None |
|||
) -> AsyncIterator[Union[User, Member]]: |
|||
"""Returns an :term:`asynchronous iterator` representing the users that have voted on this answer. |
|||
|
|||
The ``after`` parameter must represent a user |
|||
and meet the :class:`abc.Snowflake` abc. |
|||
|
|||
This can only be called when the parent poll was sent to a message. |
|||
|
|||
Examples |
|||
-------- |
|||
|
|||
Usage :: |
|||
|
|||
async for voter in poll_answer.voters(): |
|||
print(f'{voter} has voted for {poll_answer}!') |
|||
|
|||
Flattening into a list: :: |
|||
|
|||
voters = [voter async for voter in poll_answer.voters()] |
|||
# voters is now a list of User |
|||
|
|||
Parameters |
|||
---------- |
|||
limit: Optional[:class:`int`] |
|||
The maximum number of results to return. |
|||
If not provided, returns all the users who |
|||
voted on this poll answer. |
|||
after: Optional[:class:`abc.Snowflake`] |
|||
For pagination, voters are sorted by member. |
|||
|
|||
Raises |
|||
------ |
|||
HTTPException |
|||
Retrieving the users failed. |
|||
|
|||
Yields |
|||
------ |
|||
Union[:class:`User`, :class:`Member`] |
|||
The member (if retrievable) or the user that has voted |
|||
on this poll answer. The case where it can be a :class:`Member` |
|||
is in a guild message context. Sometimes it can be a :class:`User` |
|||
if the member has left the guild or if the member is not cached. |
|||
""" |
|||
|
|||
if not self._message or not self._state: # Make type checker happy |
|||
raise ClientException('You cannot fetch users to a poll not sent with a message') |
|||
|
|||
if limit is None: |
|||
if not self._message.poll: |
|||
limit = 100 |
|||
else: |
|||
limit = self.vote_count or 100 |
|||
|
|||
while limit > 0: |
|||
retrieve = min(limit, 100) |
|||
|
|||
message = self._message |
|||
guild = self._message.guild |
|||
state = self._state |
|||
after_id = after.id if after else None |
|||
|
|||
data = await state.http.get_poll_answer_voters( |
|||
message.channel.id, message.id, self.id, after=after_id, limit=retrieve |
|||
) |
|||
users = data['users'] |
|||
|
|||
if len(users) == 0: |
|||
# No more voters to fetch, terminate loop |
|||
break |
|||
|
|||
limit -= len(users) |
|||
after = Object(id=int(users[-1]['id'])) |
|||
|
|||
if not guild or isinstance(guild, Object): |
|||
for raw_user in reversed(users): |
|||
yield User(state=self._state, data=raw_user) |
|||
continue |
|||
|
|||
for raw_member in reversed(users): |
|||
member_id = int(raw_member['id']) |
|||
member = guild.get_member(member_id) |
|||
|
|||
yield member or User(state=self._state, data=raw_member) |
|||
|
|||
|
|||
class Poll: |
|||
"""Represents a message's Poll. |
|||
|
|||
.. versionadded:: 2.4 |
|||
|
|||
Parameters |
|||
---------- |
|||
question: Union[:class:`PollMedia`, :class:`str`] |
|||
The poll's displayed question. The text can be up to 300 characters. |
|||
duration: :class:`datetime.timedelta` |
|||
The duration of the poll. Duration must be in hours. |
|||
multiple: :class:`bool` |
|||
Whether users are allowed to select more than one answer. |
|||
Defaults to ``False``. |
|||
layout_type: :class:`PollLayoutType` |
|||
The layout type of the poll. Defaults to :attr:`PollLayoutType.default`. |
|||
|
|||
Attributes |
|||
----------- |
|||
duration: :class:`datetime.timedelta` |
|||
The duration of the poll. |
|||
multiple: :class:`bool` |
|||
Whether users are allowed to select more than one answer. |
|||
layout_type: :class:`PollLayoutType` |
|||
The layout type of the poll. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'multiple', |
|||
'_answers', |
|||
'duration', |
|||
'layout_type', |
|||
'_question_media', |
|||
'_message', |
|||
'_expiry', |
|||
'_finalized', |
|||
'_state', |
|||
'_total_votes', |
|||
'_victor_answer_id', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
question: Union[PollMedia, str], |
|||
duration: datetime.timedelta, |
|||
*, |
|||
multiple: bool = False, |
|||
layout_type: PollLayoutType = PollLayoutType.default, |
|||
) -> None: |
|||
self._question_media: PollMedia = PollMedia(text=question, emoji=None) if isinstance(question, str) else question |
|||
self._answers: Dict[int, PollAnswer] = {} |
|||
self.duration: datetime.timedelta = duration |
|||
|
|||
self.multiple: bool = multiple |
|||
self.layout_type: PollLayoutType = layout_type |
|||
|
|||
# NOTE: These attributes are set manually when calling |
|||
# _from_data, so it should be ``None`` now. |
|||
self._message: Optional[Message] = None |
|||
self._state: Optional[ConnectionState] = None |
|||
self._finalized: bool = False |
|||
self._expiry: Optional[datetime.datetime] = None |
|||
self._total_votes: Optional[int] = None |
|||
self._victor_answer_id: Optional[int] = None |
|||
|
|||
def _update(self, message: Message) -> None: |
|||
self._state = message._state |
|||
self._message = message |
|||
|
|||
if not message.poll: |
|||
return |
|||
|
|||
# The message's poll contains the more up to date data. |
|||
self._expiry = message.poll.expires_at |
|||
self._finalized = message.poll._finalized |
|||
self._answers = message.poll._answers |
|||
self._update_results_from_message(message) |
|||
|
|||
def _update_results_from_message(self, message: Message) -> None: |
|||
if message.type != MessageType.poll_result or not message.embeds: |
|||
return |
|||
|
|||
result_embed = message.embeds[0] # Will always have 1 embed |
|||
fields: Dict[str, str] = {field.name: field.value for field in result_embed.fields} # type: ignore |
|||
|
|||
total_votes = fields.get('total_votes') |
|||
|
|||
if total_votes is not None: |
|||
self._total_votes = int(total_votes) |
|||
|
|||
victor_answer = fields.get('victor_answer_id') |
|||
|
|||
if victor_answer is None: |
|||
return # Can't do anything else without the victor answer |
|||
|
|||
self._victor_answer_id = int(victor_answer) |
|||
|
|||
victor_answer_votes = fields['victor_answer_votes'] |
|||
|
|||
answer = self._answers[self._victor_answer_id] |
|||
answer._victor = True |
|||
answer._vote_count = int(victor_answer_votes) |
|||
self._answers[answer.id] = answer # Ensure update |
|||
|
|||
def _update_results(self, data: PollResultPayload) -> None: |
|||
self._finalized = data['is_finalized'] |
|||
|
|||
for count in data['answer_counts']: |
|||
answer = self.get_answer(int(count['id'])) |
|||
if not answer: |
|||
continue |
|||
|
|||
answer._update_with_results(count) |
|||
|
|||
def _handle_vote(self, answer_id: int, added: bool, self_voted: bool = False): |
|||
answer = self.get_answer(answer_id) |
|||
if not answer: |
|||
return |
|||
|
|||
answer._handle_vote_event(added, self_voted) |
|||
|
|||
@classmethod |
|||
def _from_data(cls, *, data: PollPayload, message: Message, state: ConnectionState) -> Self: |
|||
multiselect = data.get('allow_multiselect', False) |
|||
layout_type = try_enum(PollLayoutType, data.get('layout_type', 1)) |
|||
question_data = data.get('question') |
|||
question = question_data.get('text') |
|||
expiry = utils.parse_time(data['expiry']) # If obtained via API, then expiry is set. |
|||
# expiry - message.created_at may be a few nanos away from the actual duration |
|||
duration = datetime.timedelta(hours=round((expiry - message.created_at).total_seconds() / 3600)) |
|||
# self.created_at = message.created_at |
|||
|
|||
self = cls( |
|||
duration=duration, |
|||
multiple=multiselect, |
|||
layout_type=layout_type, |
|||
question=question, |
|||
) |
|||
self._answers = { |
|||
int(answer['answer_id']): PollAnswer(data=answer, message=message, poll=self) for answer in data['answers'] |
|||
} |
|||
self._message = message |
|||
self._state = state |
|||
self._expiry = expiry |
|||
|
|||
try: |
|||
self._update_results(data['results']) |
|||
except KeyError: |
|||
pass |
|||
|
|||
return self |
|||
|
|||
def _to_dict(self) -> PollCreatePayload: |
|||
data: PollCreatePayload = { |
|||
'allow_multiselect': self.multiple, |
|||
'question': self._question_media.to_dict(), |
|||
'duration': self.duration.total_seconds() / 3600, |
|||
'layout_type': self.layout_type.value, |
|||
'answers': [answer._to_dict() for answer in self.answers], |
|||
} |
|||
return data |
|||
|
|||
def __repr__(self) -> str: |
|||
return f"<Poll duration={self.duration} question=\"{self.question}\" answers={self.answers}>" |
|||
|
|||
@property |
|||
def question(self) -> str: |
|||
""":class:`str`: Returns this poll's question string.""" |
|||
return self._question_media.text |
|||
|
|||
@property |
|||
def answers(self) -> List[PollAnswer]: |
|||
"""List[:class:`PollAnswer`]: Returns a read-only copy of the answers.""" |
|||
return list(self._answers.values()) |
|||
|
|||
@property |
|||
def victor_answer_id(self) -> Optional[int]: |
|||
"""Optional[:class:`int`]: The victor answer ID. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
.. note:: |
|||
|
|||
This will **always** be ``None`` for polls that have not yet finished. |
|||
""" |
|||
return self._victor_answer_id |
|||
|
|||
@property |
|||
def victor_answer(self) -> Optional[PollAnswer]: |
|||
"""Optional[:class:`PollAnswer`]: The victor answer. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
.. note:: |
|||
|
|||
This will **always** be ``None`` for polls that have not yet finished. |
|||
""" |
|||
if self.victor_answer_id is None: |
|||
return None |
|||
return self.get_answer(self.victor_answer_id) |
|||
|
|||
@property |
|||
def expires_at(self) -> Optional[datetime.datetime]: |
|||
"""Optional[:class:`datetime.datetime`]: A datetime object representing the poll expiry. |
|||
|
|||
.. note:: |
|||
|
|||
This will **always** be ``None`` for stateless polls. |
|||
""" |
|||
return self._expiry |
|||
|
|||
@property |
|||
def created_at(self) -> Optional[datetime.datetime]: |
|||
"""Optional[:class:`datetime.datetime`]: Returns the poll's creation time. |
|||
|
|||
.. note:: |
|||
|
|||
This will **always** be ``None`` for stateless polls. |
|||
""" |
|||
|
|||
if not self._message: |
|||
return |
|||
return self._message.created_at |
|||
|
|||
@property |
|||
def message(self) -> Optional[Message]: |
|||
"""Optional[:class:`Message`]: The message this poll is from.""" |
|||
return self._message |
|||
|
|||
@property |
|||
def total_votes(self) -> int: |
|||
""":class:`int`: Returns the sum of all the answer votes. |
|||
|
|||
If the poll has not yet finished, this is an approximate vote count. |
|||
|
|||
.. versionchanged:: 2.5 |
|||
This now returns an exact vote count when updated from its poll results message. |
|||
""" |
|||
if self._total_votes is not None: |
|||
return self._total_votes |
|||
return sum([answer.vote_count for answer in self.answers]) |
|||
|
|||
def is_finalised(self) -> bool: |
|||
""":class:`bool`: Returns whether the poll has finalised. |
|||
|
|||
This always returns ``False`` for stateless polls. |
|||
""" |
|||
return self._finalized |
|||
|
|||
is_finalized = is_finalised |
|||
|
|||
def copy(self) -> Self: |
|||
"""Returns a stateless copy of this poll. |
|||
|
|||
This is meant to be used when you want to edit a stateful poll. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`Poll` |
|||
The copy of the poll. |
|||
""" |
|||
|
|||
new = self.__class__(question=self.question, duration=self.duration) |
|||
|
|||
# We want to return a stateless copy of the poll, so we should not |
|||
# override new._answers as our answers may contain a state |
|||
for answer in self.answers: |
|||
new.add_answer(text=answer.text, emoji=answer.emoji) |
|||
|
|||
return new |
|||
|
|||
def add_answer( |
|||
self, |
|||
*, |
|||
text: str, |
|||
emoji: Optional[Union[PartialEmoji, Emoji, str]] = None, |
|||
) -> Self: |
|||
"""Appends a new answer to this poll. |
|||
|
|||
Parameters |
|||
---------- |
|||
text: :class:`str` |
|||
The text label for this poll answer. Can be up to 55 |
|||
characters. |
|||
emoji: Union[:class:`PartialEmoji`, :class:`Emoji`, :class:`str`] |
|||
The emoji to display along the text. |
|||
|
|||
Raises |
|||
------ |
|||
ClientException |
|||
Cannot append answers to a poll that is active. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`Poll` |
|||
This poll with the new answer appended. This allows fluent-style chaining. |
|||
""" |
|||
|
|||
if self._message: |
|||
raise ClientException('Cannot append answers to a poll that is active') |
|||
|
|||
answer = PollAnswer.from_params(id=len(self.answers) + 1, text=text, emoji=emoji, message=self._message, poll=self) |
|||
self._answers[answer.id] = answer |
|||
return self |
|||
|
|||
def get_answer( |
|||
self, |
|||
/, |
|||
id: int, |
|||
) -> Optional[PollAnswer]: |
|||
"""Returns the answer with the provided ID or ``None`` if not found. |
|||
|
|||
Parameters |
|||
---------- |
|||
id: :class:`int` |
|||
The ID of the answer to get. |
|||
|
|||
Returns |
|||
------- |
|||
Optional[:class:`PollAnswer`] |
|||
The answer. |
|||
""" |
|||
|
|||
return self._answers.get(id) |
|||
|
|||
async def end(self) -> Self: |
|||
"""|coro| |
|||
|
|||
Ends the poll. |
|||
|
|||
Raises |
|||
------ |
|||
ClientException |
|||
This poll has no attached message. |
|||
HTTPException |
|||
Ending the poll failed. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`Poll` |
|||
The updated poll. |
|||
""" |
|||
|
|||
if not self._message or not self._state: # Make type checker happy |
|||
raise ClientException('This poll has no attached message.') |
|||
|
|||
message = await self._message.end_poll() |
|||
self._update(message) |
|||
|
|||
return self |
|||
@ -0,0 +1,150 @@ |
|||
""" |
|||
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 TYPE_CHECKING, Optional, Tuple |
|||
|
|||
from .activity import create_activity |
|||
from .enums import Status, try_enum |
|||
from .utils import MISSING, _get_as_snowflake, _RawReprMixin |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .activity import ActivityTypes |
|||
from .guild import Guild |
|||
from .state import ConnectionState |
|||
from .types.activity import ClientStatus as ClientStatusPayload, PartialPresenceUpdate |
|||
|
|||
|
|||
__all__ = ( |
|||
'RawPresenceUpdateEvent', |
|||
'ClientStatus', |
|||
) |
|||
|
|||
|
|||
class ClientStatus: |
|||
"""Represents the :ddocs:`Client Status Object <events/gateway-events#client-status-object>` from Discord, |
|||
which holds information about the status of the user on various clients/platforms, with additional helpers. |
|||
|
|||
.. versionadded:: 2.5 |
|||
""" |
|||
|
|||
__slots__ = ('_status', 'desktop', 'mobile', 'web') |
|||
|
|||
def __init__(self, *, status: str = MISSING, data: ClientStatusPayload = MISSING) -> None: |
|||
self._status: str = status or 'offline' |
|||
|
|||
data = data or {} |
|||
self.desktop: Optional[str] = data.get('desktop') |
|||
self.mobile: Optional[str] = data.get('mobile') |
|||
self.web: Optional[str] = data.get('web') |
|||
|
|||
def __repr__(self) -> str: |
|||
attrs = [ |
|||
('_status', self._status), |
|||
('desktop', self.desktop), |
|||
('mobile', self.mobile), |
|||
('web', self.web), |
|||
] |
|||
inner = ' '.join('%s=%r' % t for t in attrs) |
|||
return f'<{self.__class__.__name__} {inner}>' |
|||
|
|||
def _update(self, status: str, data: ClientStatusPayload, /) -> None: |
|||
self._status = status |
|||
|
|||
self.desktop = data.get('desktop') |
|||
self.mobile = data.get('mobile') |
|||
self.web = data.get('web') |
|||
|
|||
@classmethod |
|||
def _copy(cls, client_status: Self, /) -> Self: |
|||
self = cls.__new__(cls) # bypass __init__ |
|||
|
|||
self._status = client_status._status |
|||
|
|||
self.desktop = client_status.desktop |
|||
self.mobile = client_status.mobile |
|||
self.web = client_status.web |
|||
|
|||
return self |
|||
|
|||
@property |
|||
def status(self) -> Status: |
|||
""":class:`Status`: The user's overall status. If the value is unknown, then it will be a :class:`str` instead.""" |
|||
return try_enum(Status, self._status) |
|||
|
|||
@property |
|||
def raw_status(self) -> str: |
|||
""":class:`str`: The user's overall status as a string value.""" |
|||
return self._status |
|||
|
|||
@property |
|||
def mobile_status(self) -> Status: |
|||
""":class:`Status`: The user's status on a mobile device, if applicable.""" |
|||
return try_enum(Status, self.mobile or 'offline') |
|||
|
|||
@property |
|||
def desktop_status(self) -> Status: |
|||
""":class:`Status`: The user's status on the desktop client, if applicable.""" |
|||
return try_enum(Status, self.desktop or 'offline') |
|||
|
|||
@property |
|||
def web_status(self) -> Status: |
|||
""":class:`Status`: The user's status on the web client, if applicable.""" |
|||
return try_enum(Status, self.web or 'offline') |
|||
|
|||
def is_on_mobile(self) -> bool: |
|||
""":class:`bool`: A helper function that determines if a user is active on a mobile device.""" |
|||
return self.mobile is not None |
|||
|
|||
|
|||
class RawPresenceUpdateEvent(_RawReprMixin): |
|||
"""Represents the payload for a :func:`on_raw_presence_update` event. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
Attributes |
|||
---------- |
|||
user_id: :class:`int` |
|||
The ID of the user that triggered the presence update. |
|||
guild_id: Optional[:class:`int`] |
|||
The guild ID for the users presence update. Could be ``None``. |
|||
guild: Optional[:class:`Guild`] |
|||
The guild associated with the presence update and user. Could be ``None``. |
|||
client_status: :class:`ClientStatus` |
|||
The :class:`~.ClientStatus` model which holds information about the status of the user on various clients. |
|||
activities: Tuple[Union[:class:`BaseActivity`, :class:`Spotify`]] |
|||
The activities the user is currently doing. Due to a Discord API limitation, a user's Spotify activity may not appear |
|||
if they are listening to a song with a title longer than ``128`` characters. See :issue:`1738` for more information. |
|||
""" |
|||
|
|||
__slots__ = ('user_id', 'guild_id', 'guild', 'client_status', 'activities') |
|||
|
|||
def __init__(self, *, data: PartialPresenceUpdate, state: ConnectionState) -> None: |
|||
self.user_id: int = int(data['user']['id']) |
|||
self.client_status: ClientStatus = ClientStatus(status=data['status'], data=data['client_status']) |
|||
self.activities: Tuple[ActivityTypes, ...] = tuple(create_activity(d, state) for d in data['activities']) |
|||
self.guild_id: Optional[int] = _get_as_snowflake(data, 'guild_id') |
|||
self.guild: Optional[Guild] = state._get_guild(self.guild_id) |
|||
@ -0,0 +1,359 @@ |
|||
""" |
|||
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 AsyncIterator, Optional, TYPE_CHECKING |
|||
|
|||
from datetime import datetime |
|||
|
|||
from . import utils |
|||
from .enums import try_enum, SKUType, EntitlementType |
|||
from .flags import SKUFlags |
|||
from .object import Object |
|||
from .subscription import Subscription |
|||
|
|||
if TYPE_CHECKING: |
|||
from .abc import SnowflakeTime, Snowflake |
|||
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) |
|||
|
|||
async def fetch_subscription(self, subscription_id: int, /) -> Subscription: |
|||
"""|coro| |
|||
|
|||
Retrieves a :class:`.Subscription` with the specified ID. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
Parameters |
|||
----------- |
|||
subscription_id: :class:`int` |
|||
The subscription's ID to fetch from. |
|||
|
|||
Raises |
|||
------- |
|||
NotFound |
|||
An subscription with this ID does not exist. |
|||
HTTPException |
|||
Fetching the subscription failed. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`.Subscription` |
|||
The subscription you requested. |
|||
""" |
|||
data = await self._state.http.get_sku_subscription(self.id, subscription_id) |
|||
return Subscription(data=data, state=self._state) |
|||
|
|||
async def subscriptions( |
|||
self, |
|||
*, |
|||
limit: Optional[int] = 50, |
|||
before: Optional[SnowflakeTime] = None, |
|||
after: Optional[SnowflakeTime] = None, |
|||
user: Snowflake, |
|||
) -> AsyncIterator[Subscription]: |
|||
"""Retrieves an :term:`asynchronous iterator` of the :class:`.Subscription` that SKU has. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
Examples |
|||
--------- |
|||
|
|||
Usage :: |
|||
|
|||
async for subscription in sku.subscriptions(limit=100, user=user): |
|||
print(subscription.user_id, subscription.current_period_end) |
|||
|
|||
Flattening into a list :: |
|||
|
|||
subscriptions = [subscription async for subscription in sku.subscriptions(limit=100, user=user)] |
|||
# subscriptions is now a list of Subscription... |
|||
|
|||
All parameters are optional. |
|||
|
|||
Parameters |
|||
----------- |
|||
limit: Optional[:class:`int`] |
|||
The number of subscriptions to retrieve. If ``None``, it retrieves every subscription for this SKU. |
|||
Note, however, that this would make it a slow operation. Defaults to ``100``. |
|||
before: Optional[Union[:class:`~discord.abc.Snowflake`, :class:`datetime.datetime`]] |
|||
Retrieve subscriptions before this date or entitlement. |
|||
If a datetime is provided, it is recommended to use a UTC aware datetime. |
|||
If the datetime is naive, it is assumed to be local time. |
|||
after: Optional[Union[:class:`~discord.abc.Snowflake`, :class:`datetime.datetime`]] |
|||
Retrieve subscriptions after this date or entitlement. |
|||
If a datetime is provided, it is recommended to use a UTC aware datetime. |
|||
If the datetime is naive, it is assumed to be local time. |
|||
user: :class:`~discord.abc.Snowflake` |
|||
The user to filter by. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Fetching the subscriptions failed. |
|||
TypeError |
|||
Both ``after`` and ``before`` were provided, as Discord does not |
|||
support this type of pagination. |
|||
|
|||
Yields |
|||
-------- |
|||
:class:`.Subscription` |
|||
The subscription with the SKU. |
|||
""" |
|||
|
|||
if before is not None and after is not None: |
|||
raise TypeError('subscriptions pagination does not support both before and after') |
|||
|
|||
# This endpoint paginates in ascending order. |
|||
endpoint = self._state.http.list_sku_subscriptions |
|||
|
|||
async def _before_strategy(retrieve: int, before: Optional[Snowflake], limit: Optional[int]): |
|||
before_id = before.id if before else None |
|||
data = await endpoint(self.id, before=before_id, limit=retrieve, user_id=user.id) |
|||
|
|||
if data: |
|||
if limit is not None: |
|||
limit -= len(data) |
|||
|
|||
before = Object(id=int(data[0]['id'])) |
|||
|
|||
return data, before, limit |
|||
|
|||
async def _after_strategy(retrieve: int, after: Optional[Snowflake], limit: Optional[int]): |
|||
after_id = after.id if after else None |
|||
data = await endpoint( |
|||
self.id, |
|||
after=after_id, |
|||
limit=retrieve, |
|||
user_id=user.id, |
|||
) |
|||
|
|||
if data: |
|||
if limit is not None: |
|||
limit -= len(data) |
|||
|
|||
after = Object(id=int(data[-1]['id'])) |
|||
|
|||
return data, after, limit |
|||
|
|||
if isinstance(before, datetime): |
|||
before = Object(id=utils.time_snowflake(before, high=False)) |
|||
if isinstance(after, datetime): |
|||
after = Object(id=utils.time_snowflake(after, high=True)) |
|||
|
|||
if before: |
|||
strategy, state = _before_strategy, before |
|||
else: |
|||
strategy, state = _after_strategy, after |
|||
|
|||
while True: |
|||
retrieve = 100 if limit is None else min(limit, 100) |
|||
if retrieve < 1: |
|||
return |
|||
|
|||
data, state, limit = await strategy(retrieve, state, limit) |
|||
|
|||
# Terminate loop on next iteration; there's no data left after this |
|||
if len(data) < 100: |
|||
limit = 0 |
|||
|
|||
for e in data: |
|||
yield Subscription(data=e, state=self._state) |
|||
|
|||
|
|||
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 |
|||
consumed: :class:`bool` |
|||
For consumable items, whether the entitlement has been consumed. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'_state', |
|||
'id', |
|||
'sku_id', |
|||
'application_id', |
|||
'user_id', |
|||
'type', |
|||
'deleted', |
|||
'starts_at', |
|||
'ends_at', |
|||
'guild_id', |
|||
'consumed', |
|||
) |
|||
|
|||
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') |
|||
self.consumed: bool = data.get('consumed', False) |
|||
|
|||
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 consume(self) -> None: |
|||
"""|coro| |
|||
|
|||
Marks a one-time purchase entitlement as consumed. |
|||
|
|||
Raises |
|||
------- |
|||
NotFound |
|||
The entitlement could not be found. |
|||
HTTPException |
|||
Consuming the entitlement failed. |
|||
""" |
|||
|
|||
await self._state.http.consume_entitlement(self.application_id, self.id) |
|||
|
|||
async def delete(self) -> None: |
|||
"""|coro| |
|||
|
|||
Deletes the entitlement. |
|||
|
|||
Raises |
|||
------- |
|||
NotFound |
|||
The entitlement could not be found. |
|||
HTTPException |
|||
Deleting the entitlement failed. |
|||
""" |
|||
|
|||
await self._state.http.delete_entitlement(self.application_id, self.id) |
|||
@ -0,0 +1,325 @@ |
|||
""" |
|||
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 TYPE_CHECKING, Optional |
|||
|
|||
from . import utils |
|||
from .mixins import Hashable |
|||
from .partial_emoji import PartialEmoji, _EmojiTag |
|||
from .user import User |
|||
from .utils import MISSING |
|||
from .asset import Asset, AssetMixin |
|||
|
|||
if TYPE_CHECKING: |
|||
import datetime |
|||
from typing import Dict, Any |
|||
|
|||
from .types.soundboard import ( |
|||
BaseSoundboardSound as BaseSoundboardSoundPayload, |
|||
SoundboardDefaultSound as SoundboardDefaultSoundPayload, |
|||
SoundboardSound as SoundboardSoundPayload, |
|||
) |
|||
from .state import ConnectionState |
|||
from .guild import Guild |
|||
from .message import EmojiInputType |
|||
|
|||
__all__ = ('BaseSoundboardSound', 'SoundboardDefaultSound', 'SoundboardSound') |
|||
|
|||
|
|||
class BaseSoundboardSound(Hashable, AssetMixin): |
|||
"""Represents a generic Discord soundboard sound. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: x == y |
|||
|
|||
Checks if two sounds are equal. |
|||
|
|||
.. describe:: x != y |
|||
|
|||
Checks if two sounds are not equal. |
|||
|
|||
.. describe:: hash(x) |
|||
|
|||
Returns the sound's hash. |
|||
|
|||
Attributes |
|||
------------ |
|||
id: :class:`int` |
|||
The ID of the sound. |
|||
volume: :class:`float` |
|||
The volume of the sound as floating point percentage (e.g. ``1.0`` for 100%). |
|||
""" |
|||
|
|||
__slots__ = ('_state', 'id', 'volume') |
|||
|
|||
def __init__(self, *, state: ConnectionState, data: BaseSoundboardSoundPayload): |
|||
self._state: ConnectionState = state |
|||
self.id: int = int(data['sound_id']) |
|||
self._update(data) |
|||
|
|||
def __eq__(self, other: object) -> bool: |
|||
if isinstance(other, self.__class__): |
|||
return self.id == other.id |
|||
return NotImplemented |
|||
|
|||
def __ne__(self, other: object) -> bool: |
|||
return not self.__eq__(other) |
|||
|
|||
def _update(self, data: BaseSoundboardSoundPayload): |
|||
self.volume: float = data['volume'] |
|||
|
|||
@property |
|||
def url(self) -> str: |
|||
""":class:`str`: Returns the URL of the sound.""" |
|||
return f'{Asset.BASE}/soundboard-sounds/{self.id}' |
|||
|
|||
|
|||
class SoundboardDefaultSound(BaseSoundboardSound): |
|||
"""Represents a Discord soundboard default sound. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: x == y |
|||
|
|||
Checks if two sounds are equal. |
|||
|
|||
.. describe:: x != y |
|||
|
|||
Checks if two sounds are not equal. |
|||
|
|||
.. describe:: hash(x) |
|||
|
|||
Returns the sound's hash. |
|||
|
|||
Attributes |
|||
------------ |
|||
id: :class:`int` |
|||
The ID of the sound. |
|||
volume: :class:`float` |
|||
The volume of the sound as floating point percentage (e.g. ``1.0`` for 100%). |
|||
name: :class:`str` |
|||
The name of the sound. |
|||
emoji: :class:`PartialEmoji` |
|||
The emoji of the sound. |
|||
""" |
|||
|
|||
__slots__ = ('name', 'emoji') |
|||
|
|||
def __init__(self, *, state: ConnectionState, data: SoundboardDefaultSoundPayload): |
|||
self.name: str = data['name'] |
|||
self.emoji: PartialEmoji = PartialEmoji(name=data['emoji_name']) |
|||
super().__init__(state=state, data=data) |
|||
|
|||
def __repr__(self) -> str: |
|||
attrs = [ |
|||
('id', self.id), |
|||
('name', self.name), |
|||
('volume', self.volume), |
|||
('emoji', self.emoji), |
|||
] |
|||
inner = ' '.join('%s=%r' % t for t in attrs) |
|||
return f"<{self.__class__.__name__} {inner}>" |
|||
|
|||
|
|||
class SoundboardSound(BaseSoundboardSound): |
|||
"""Represents a Discord soundboard sound. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: x == y |
|||
|
|||
Checks if two sounds are equal. |
|||
|
|||
.. describe:: x != y |
|||
|
|||
Checks if two sounds are not equal. |
|||
|
|||
.. describe:: hash(x) |
|||
|
|||
Returns the sound's hash. |
|||
|
|||
Attributes |
|||
------------ |
|||
id: :class:`int` |
|||
The ID of the sound. |
|||
volume: :class:`float` |
|||
The volume of the sound as floating point percentage (e.g. ``1.0`` for 100%). |
|||
name: :class:`str` |
|||
The name of the sound. |
|||
emoji: Optional[:class:`PartialEmoji`] |
|||
The emoji of the sound. ``None`` if no emoji is set. |
|||
guild: :class:`Guild` |
|||
The guild in which the sound is uploaded. |
|||
available: :class:`bool` |
|||
Whether this sound is available for use. |
|||
""" |
|||
|
|||
__slots__ = ('_state', 'name', 'emoji', '_user', 'available', '_user_id', 'guild') |
|||
|
|||
def __init__(self, *, guild: Guild, state: ConnectionState, data: SoundboardSoundPayload): |
|||
super().__init__(state=state, data=data) |
|||
self.guild = guild |
|||
self._user_id = utils._get_as_snowflake(data, 'user_id') |
|||
self._user = data.get('user') |
|||
|
|||
self._update(data) |
|||
|
|||
def __repr__(self) -> str: |
|||
attrs = [ |
|||
('id', self.id), |
|||
('name', self.name), |
|||
('volume', self.volume), |
|||
('emoji', self.emoji), |
|||
('user', self.user), |
|||
] |
|||
inner = ' '.join('%s=%r' % t for t in attrs) |
|||
return f"<{self.__class__.__name__} {inner}>" |
|||
|
|||
def _update(self, data: SoundboardSoundPayload): |
|||
super()._update(data) |
|||
|
|||
self.name: str = data['name'] |
|||
self.emoji: Optional[PartialEmoji] = None |
|||
|
|||
emoji_id = utils._get_as_snowflake(data, 'emoji_id') |
|||
emoji_name = data['emoji_name'] |
|||
if emoji_id is not None or emoji_name is not None: |
|||
self.emoji = PartialEmoji(id=emoji_id, name=emoji_name) # type: ignore # emoji_name cannot be None here |
|||
|
|||
self.available: bool = data['available'] |
|||
|
|||
@property |
|||
def created_at(self) -> datetime.datetime: |
|||
""":class:`datetime.datetime`: Returns the snowflake's creation time in UTC.""" |
|||
return utils.snowflake_time(self.id) |
|||
|
|||
@property |
|||
def user(self) -> Optional[User]: |
|||
"""Optional[:class:`User`]: The user who uploaded the sound.""" |
|||
if self._user is None: |
|||
if self._user_id is None: |
|||
return None |
|||
return self._state.get_user(self._user_id) |
|||
return User(state=self._state, data=self._user) |
|||
|
|||
async def edit( |
|||
self, |
|||
*, |
|||
name: str = MISSING, |
|||
volume: Optional[float] = MISSING, |
|||
emoji: Optional[EmojiInputType] = MISSING, |
|||
reason: Optional[str] = None, |
|||
): |
|||
"""|coro| |
|||
|
|||
Edits the soundboard sound. |
|||
|
|||
You must have :attr:`~Permissions.manage_expressions` to edit the sound. |
|||
If the sound was created by the client, you must have either :attr:`~Permissions.manage_expressions` |
|||
or :attr:`~Permissions.create_expressions`. |
|||
|
|||
Parameters |
|||
---------- |
|||
name: :class:`str` |
|||
The new name of the sound. Must be between 2 and 32 characters. |
|||
volume: Optional[:class:`float`] |
|||
The new volume of the sound. Must be between 0 and 1. |
|||
emoji: Optional[Union[:class:`Emoji`, :class:`PartialEmoji`, :class:`str`]] |
|||
The new emoji of the sound. |
|||
reason: Optional[:class:`str`] |
|||
The reason for editing this sound. Shows up on the audit log. |
|||
|
|||
Raises |
|||
------- |
|||
Forbidden |
|||
You do not have permissions to edit the soundboard sound. |
|||
HTTPException |
|||
Editing the soundboard sound failed. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`SoundboardSound` |
|||
The newly updated soundboard sound. |
|||
""" |
|||
|
|||
payload: Dict[str, Any] = {} |
|||
|
|||
if name is not MISSING: |
|||
payload['name'] = name |
|||
|
|||
if volume is not MISSING: |
|||
payload['volume'] = volume |
|||
|
|||
if emoji is not MISSING: |
|||
if emoji is None: |
|||
payload['emoji_id'] = None |
|||
payload['emoji_name'] = None |
|||
else: |
|||
if isinstance(emoji, _EmojiTag): |
|||
partial_emoji = emoji._to_partial() |
|||
elif isinstance(emoji, str): |
|||
partial_emoji = PartialEmoji.from_str(emoji) |
|||
else: |
|||
partial_emoji = None |
|||
|
|||
if partial_emoji is not None: |
|||
if partial_emoji.id is None: |
|||
payload['emoji_name'] = partial_emoji.name |
|||
else: |
|||
payload['emoji_id'] = partial_emoji.id |
|||
|
|||
data = await self._state.http.edit_soundboard_sound(self.guild.id, self.id, reason=reason, **payload) |
|||
return SoundboardSound(guild=self.guild, state=self._state, data=data) |
|||
|
|||
async def delete(self, *, reason: Optional[str] = None) -> None: |
|||
"""|coro| |
|||
|
|||
Deletes the soundboard sound. |
|||
|
|||
You must have :attr:`~Permissions.manage_expressions` to delete the sound. |
|||
If the sound was created by the client, you must have either :attr:`~Permissions.manage_expressions` |
|||
or :attr:`~Permissions.create_expressions`. |
|||
|
|||
Parameters |
|||
----------- |
|||
reason: Optional[:class:`str`] |
|||
The reason for deleting this sound. Shows up on the audit log. |
|||
|
|||
Raises |
|||
------- |
|||
Forbidden |
|||
You do not have permissions to delete the soundboard sound. |
|||
HTTPException |
|||
Deleting the soundboard sound failed. |
|||
""" |
|||
await self._state.http.delete_soundboard_sound(self.guild.id, self.id, reason=reason) |
|||
@ -0,0 +1,107 @@ |
|||
""" |
|||
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 |
|||
|
|||
import datetime |
|||
from typing import List, Optional, TYPE_CHECKING |
|||
|
|||
from . import utils |
|||
from .mixins import Hashable |
|||
from .enums import try_enum, SubscriptionStatus |
|||
|
|||
if TYPE_CHECKING: |
|||
from .state import ConnectionState |
|||
from .types.subscription import Subscription as SubscriptionPayload |
|||
from .user import User |
|||
|
|||
__all__ = ('Subscription',) |
|||
|
|||
|
|||
class Subscription(Hashable): |
|||
"""Represents a Discord subscription. |
|||
|
|||
.. versionadded:: 2.5 |
|||
|
|||
Attributes |
|||
----------- |
|||
id: :class:`int` |
|||
The subscription's ID. |
|||
user_id: :class:`int` |
|||
The ID of the user that is subscribed. |
|||
sku_ids: List[:class:`int`] |
|||
The IDs of the SKUs that the user subscribed to. |
|||
entitlement_ids: List[:class:`int`] |
|||
The IDs of the entitlements granted for this subscription. |
|||
current_period_start: :class:`datetime.datetime` |
|||
When the current billing period started. |
|||
current_period_end: :class:`datetime.datetime` |
|||
When the current billing period ends. |
|||
status: :class:`SubscriptionStatus` |
|||
The status of the subscription. |
|||
canceled_at: Optional[:class:`datetime.datetime`] |
|||
When the subscription was canceled. |
|||
This is only available for subscriptions with a :attr:`status` of :attr:`SubscriptionStatus.inactive`. |
|||
renewal_sku_ids: List[:class:`int`] |
|||
The IDs of the SKUs that the user is going to be subscribed to when renewing. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'_state', |
|||
'id', |
|||
'user_id', |
|||
'sku_ids', |
|||
'entitlement_ids', |
|||
'current_period_start', |
|||
'current_period_end', |
|||
'status', |
|||
'canceled_at', |
|||
'renewal_sku_ids', |
|||
) |
|||
|
|||
def __init__(self, *, state: ConnectionState, data: SubscriptionPayload): |
|||
self._state = state |
|||
|
|||
self.id: int = int(data['id']) |
|||
self.user_id: int = int(data['user_id']) |
|||
self.sku_ids: List[int] = list(map(int, data['sku_ids'])) |
|||
self.entitlement_ids: List[int] = list(map(int, data['entitlement_ids'])) |
|||
self.current_period_start: datetime.datetime = utils.parse_time(data['current_period_start']) |
|||
self.current_period_end: datetime.datetime = utils.parse_time(data['current_period_end']) |
|||
self.status: SubscriptionStatus = try_enum(SubscriptionStatus, data['status']) |
|||
self.canceled_at: Optional[datetime.datetime] = utils.parse_time(data['canceled_at']) |
|||
self.renewal_sku_ids: List[int] = list(map(int, data['renewal_sku_ids'] or [])) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<Subscription id={self.id} user_id={self.user_id} status={self.status!r}>' |
|||
|
|||
@property |
|||
def created_at(self) -> datetime.datetime: |
|||
""":class:`datetime.datetime`: Returns the subscription's creation time in UTC.""" |
|||
return utils.snowflake_time(self.id) |
|||
|
|||
@property |
|||
def user(self) -> Optional[User]: |
|||
"""Optional[:class:`User`]: The user that is subscribed.""" |
|||
return self._state.get_user(self.user_id) |
|||
@ -0,0 +1,88 @@ |
|||
""" |
|||
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 List, TypedDict, Optional, Literal, TYPE_CHECKING |
|||
from typing_extensions import NotRequired |
|||
|
|||
from .snowflake import Snowflake |
|||
|
|||
if TYPE_CHECKING: |
|||
from .user import User |
|||
from .emoji import PartialEmoji |
|||
|
|||
|
|||
LayoutType = Literal[1] # 1 = Default |
|||
|
|||
|
|||
class PollMedia(TypedDict): |
|||
text: str |
|||
emoji: NotRequired[Optional[PartialEmoji]] |
|||
|
|||
|
|||
class PollAnswer(TypedDict): |
|||
poll_media: PollMedia |
|||
|
|||
|
|||
class PollAnswerWithID(PollAnswer): |
|||
answer_id: int |
|||
|
|||
|
|||
class PollAnswerCount(TypedDict): |
|||
id: Snowflake |
|||
count: int |
|||
me_voted: bool |
|||
|
|||
|
|||
class PollAnswerVoters(TypedDict): |
|||
users: List[User] |
|||
|
|||
|
|||
class PollResult(TypedDict): |
|||
is_finalized: bool |
|||
answer_counts: List[PollAnswerCount] |
|||
|
|||
|
|||
class PollCreate(TypedDict): |
|||
allow_multiselect: bool |
|||
answers: List[PollAnswer] |
|||
duration: float |
|||
layout_type: LayoutType |
|||
question: PollMedia |
|||
|
|||
|
|||
# We don't subclass Poll as it will |
|||
# still have the duration field, which |
|||
# is converted into expiry when poll is |
|||
# fetched from a message or returned |
|||
# by a `send` method in a Messageable |
|||
class Poll(TypedDict): |
|||
allow_multiselect: bool |
|||
answers: List[PollAnswerWithID] |
|||
expiry: str |
|||
layout_type: LayoutType |
|||
question: PollMedia |
|||
results: PollResult |
|||
@ -0,0 +1,53 @@ |
|||
""" |
|||
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: NotRequired[str] |
|||
consumed: NotRequired[bool] |
|||
|
|||
|
|||
EntitlementOwnerType = Literal[1, 2] |
|||
@ -0,0 +1,49 @@ |
|||
""" |
|||
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 typing import TypedDict, Optional, Union |
|||
from typing_extensions import NotRequired |
|||
|
|||
from .snowflake import Snowflake |
|||
from .user import User |
|||
|
|||
|
|||
class BaseSoundboardSound(TypedDict): |
|||
sound_id: Union[Snowflake, str] # basic string number when it's a default sound |
|||
volume: float |
|||
|
|||
|
|||
class SoundboardSound(BaseSoundboardSound): |
|||
name: str |
|||
emoji_name: Optional[str] |
|||
emoji_id: Optional[Snowflake] |
|||
user_id: NotRequired[Snowflake] |
|||
available: bool |
|||
guild_id: NotRequired[Snowflake] |
|||
user: NotRequired[User] |
|||
|
|||
|
|||
class SoundboardDefaultSound(BaseSoundboardSound): |
|||
name: str |
|||
emoji_name: str |
|||
@ -0,0 +1,43 @@ |
|||
""" |
|||
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 List, Literal, Optional, TypedDict |
|||
|
|||
from .snowflake import Snowflake |
|||
|
|||
SubscriptionStatus = Literal[0, 1, 2] |
|||
|
|||
|
|||
class Subscription(TypedDict): |
|||
id: Snowflake |
|||
user_id: Snowflake |
|||
sku_ids: List[Snowflake] |
|||
entitlement_ids: List[Snowflake] |
|||
current_period_start: str |
|||
current_period_end: str |
|||
status: SubscriptionStatus |
|||
canceled_at: Optional[str] |
|||
renewal_sku_ids: Optional[List[Snowflake]] |
|||
@ -0,0 +1,216 @@ |
|||
""" |
|||
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 |
|||
if row is not None: |
|||
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 |
|||
|
|||
async def callback(self, interaction: Interaction[ClientT]) -> Any: |
|||
return await self.item.callback(interaction) |
|||
|
|||
async def interaction_check(self, interaction: Interaction[ClientT], /) -> bool: |
|||
return await self.item.interaction_check(interaction) |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue