You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
767 lines
20 KiB
767 lines
20 KiB
"""
|
|
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.
|
|
"""
|
|
|
|
import types
|
|
from collections import namedtuple
|
|
from typing import Any, ClassVar, Dict, List, Optional, TYPE_CHECKING, Type, TypeVar
|
|
|
|
__all__ = (
|
|
'Enum',
|
|
'ChannelType',
|
|
'MessageType',
|
|
'VoiceRegion',
|
|
'SpeakingState',
|
|
'VerificationLevel',
|
|
'ContentFilter',
|
|
'Status',
|
|
'DefaultAvatar',
|
|
'AuditLogAction',
|
|
'AuditLogActionCategory',
|
|
'UserFlags',
|
|
'ActivityType',
|
|
'NotificationLevel',
|
|
'TeamMembershipState',
|
|
'WebhookType',
|
|
'ExpireBehaviour',
|
|
'ExpireBehavior',
|
|
'StickerType',
|
|
'StickerFormatType',
|
|
'InviteTarget',
|
|
'VideoQualityMode',
|
|
'ComponentType',
|
|
'ButtonStyle',
|
|
'StagePrivacyLevel',
|
|
'InteractionType',
|
|
'NSFWLevel',
|
|
'RelationshipType',
|
|
'HypeSquadHouse',
|
|
'PremiumType',
|
|
'UserContentFilter',
|
|
'FriendFlags',
|
|
'Theme',
|
|
'StickerAnimationOptions',
|
|
'RelationshipAction',
|
|
'UnavailableGuildType',
|
|
'RequiredActionType',
|
|
'ReportType',
|
|
'BrowserEnum',
|
|
'CommandType',
|
|
'OptionType',
|
|
)
|
|
|
|
|
|
def _create_value_cls(name, comparable):
|
|
cls = namedtuple('_EnumValue_' + name, 'name value')
|
|
cls.__repr__ = lambda self: f'<{name}.{self.name}: {self.value!r}>'
|
|
cls.__str__ = lambda self: f'{name}.{self.name}'
|
|
if comparable:
|
|
cls.__le__ = lambda self, other: isinstance(other, self.__class__) and self.value <= other.value
|
|
cls.__ge__ = lambda self, other: isinstance(other, self.__class__) and self.value >= other.value
|
|
cls.__lt__ = lambda self, other: isinstance(other, self.__class__) and self.value < other.value
|
|
cls.__gt__ = lambda self, other: isinstance(other, self.__class__) and self.value > other.value
|
|
return cls
|
|
|
|
def _is_descriptor(obj):
|
|
return hasattr(obj, '__get__') or hasattr(obj, '__set__') or hasattr(obj, '__delete__')
|
|
|
|
|
|
class EnumMeta(type):
|
|
if TYPE_CHECKING:
|
|
__name__: ClassVar[str]
|
|
_enum_member_names_: ClassVar[List[str]]
|
|
_enum_member_map_: ClassVar[Dict[str, Any]]
|
|
_enum_value_map_: ClassVar[Dict[Any, Any]]
|
|
|
|
def __new__(cls, name, bases, attrs, *, comparable: bool = False):
|
|
value_mapping = {}
|
|
member_mapping = {}
|
|
member_names = []
|
|
|
|
value_cls = _create_value_cls(name, comparable)
|
|
for key, value in list(attrs.items()):
|
|
is_descriptor = _is_descriptor(value)
|
|
if key[0] == '_' and not is_descriptor:
|
|
continue
|
|
|
|
# Special case classmethod to just pass through
|
|
if isinstance(value, classmethod):
|
|
continue
|
|
|
|
if is_descriptor:
|
|
setattr(value_cls, key, value)
|
|
del attrs[key]
|
|
continue
|
|
|
|
try:
|
|
new_value = value_mapping[value]
|
|
except KeyError:
|
|
new_value = value_cls(name=key, value=value)
|
|
value_mapping[value] = new_value
|
|
member_names.append(key)
|
|
|
|
member_mapping[key] = new_value
|
|
attrs[key] = new_value
|
|
|
|
attrs['_enum_value_map_'] = value_mapping
|
|
attrs['_enum_member_map_'] = member_mapping
|
|
attrs['_enum_member_names_'] = member_names
|
|
attrs['_enum_value_cls_'] = value_cls
|
|
actual_cls = super().__new__(cls, name, bases, attrs)
|
|
value_cls._actual_enum_cls_ = actual_cls # type: ignore
|
|
return actual_cls
|
|
|
|
def __iter__(cls):
|
|
return (cls._enum_member_map_[name] for name in cls._enum_member_names_)
|
|
|
|
def __reversed__(cls):
|
|
return (cls._enum_member_map_[name] for name in reversed(cls._enum_member_names_))
|
|
|
|
def __len__(cls):
|
|
return len(cls._enum_member_names_)
|
|
|
|
def __repr__(cls):
|
|
return f'<enum {cls.__name__}>'
|
|
|
|
@property
|
|
def __members__(cls):
|
|
return types.MappingProxyType(cls._enum_member_map_)
|
|
|
|
def __call__(cls, value):
|
|
try:
|
|
return cls._enum_value_map_[value]
|
|
except (KeyError, TypeError):
|
|
raise ValueError(f"{value!r} is not a valid {cls.__name__}")
|
|
|
|
def __getitem__(cls, key):
|
|
return cls._enum_member_map_[key]
|
|
|
|
def __setattr__(cls, name, value):
|
|
raise TypeError('Enums are immutable.')
|
|
|
|
def __delattr__(cls, attr):
|
|
raise TypeError('Enums are immutable')
|
|
|
|
def __instancecheck__(self, instance):
|
|
# isinstance(x, Y)
|
|
# -> __instancecheck__(Y, x)
|
|
try:
|
|
return instance._actual_enum_cls_ is self
|
|
except AttributeError:
|
|
return False
|
|
|
|
|
|
if TYPE_CHECKING:
|
|
from enum import Enum
|
|
else:
|
|
|
|
class Enum(metaclass=EnumMeta):
|
|
@classmethod
|
|
def try_value(cls, value):
|
|
try:
|
|
return cls._enum_value_map_[value]
|
|
except (KeyError, TypeError):
|
|
return value
|
|
|
|
|
|
class ChannelType(Enum):
|
|
text = 0
|
|
private = 1
|
|
voice = 2
|
|
group = 3
|
|
category = 4
|
|
news = 5
|
|
store = 6
|
|
news_thread = 10
|
|
public_thread = 11
|
|
private_thread = 12
|
|
stage_voice = 13
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class MessageType(Enum):
|
|
default = 0
|
|
recipient_add = 1
|
|
recipient_remove = 2
|
|
call = 3
|
|
channel_name_change = 4
|
|
channel_icon_change = 5
|
|
channel_pinned_message = 6
|
|
pins_add = 6
|
|
member_join = 7
|
|
user_join = 7
|
|
new_member = 7
|
|
premium_guild_subscription = 8
|
|
premium_guild_tier_1 = 9
|
|
premium_guild_tier_2 = 10
|
|
premium_guild_tier_3 = 11
|
|
channel_follow_add = 12
|
|
guild_stream = 13
|
|
guild_discovery_disqualified = 14
|
|
guild_discovery_requalified = 15
|
|
guild_discovery_grace_period_initial_warning = 16
|
|
guild_discovery_grace_period_final_warning = 17
|
|
thread_created = 18
|
|
reply = 19
|
|
chat_input_command = 20
|
|
thread_starter_message = 21
|
|
guild_invite_reminder = 22
|
|
context_menu_command = 23
|
|
|
|
|
|
class VoiceRegion(Enum):
|
|
us_west = 'us-west'
|
|
us_east = 'us-east'
|
|
us_south = 'us-south'
|
|
us_central = 'us-central'
|
|
eu_west = 'eu-west'
|
|
eu_central = 'eu-central'
|
|
singapore = 'singapore'
|
|
london = 'london'
|
|
sydney = 'sydney'
|
|
amsterdam = 'amsterdam'
|
|
frankfurt = 'frankfurt'
|
|
brazil = 'brazil'
|
|
hongkong = 'hongkong'
|
|
russia = 'russia'
|
|
japan = 'japan'
|
|
southafrica = 'southafrica'
|
|
south_korea = 'south-korea'
|
|
india = 'india'
|
|
europe = 'europe'
|
|
dubai = 'dubai'
|
|
vip_us_east = 'vip-us-east'
|
|
vip_us_west = 'vip-us-west'
|
|
vip_amsterdam = 'vip-amsterdam'
|
|
|
|
def __str__(self):
|
|
return self.value
|
|
|
|
|
|
class SpeakingState(Enum):
|
|
none = 0
|
|
voice = 1
|
|
soundshare = 2
|
|
priority = 4
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
|
|
class VerificationLevel(Enum, comparable=True):
|
|
none = 0
|
|
low = 1
|
|
medium = 2
|
|
high = 3
|
|
highest = 4
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class ContentFilter(Enum, comparable=True):
|
|
disabled = 0
|
|
no_role = 1
|
|
all_members = 2
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class UserContentFilter(Enum):
|
|
always = 0
|
|
on_interaction = 1
|
|
never = 2
|
|
|
|
|
|
class StickerAnimationOptions(Enum):
|
|
disabled = 2
|
|
friends = 1
|
|
all_messages = 0
|
|
|
|
|
|
class FriendFlags(Enum):
|
|
noone = 0
|
|
mutual_guilds = 1
|
|
mutual_friends = 2
|
|
guild_and_friends = 3
|
|
everyone = 4
|
|
|
|
def to_dict(self):
|
|
if self.value == 0:
|
|
return {'all': False, 'mutual_friends': False, 'mutual_guilds': False}
|
|
if self.value == 1:
|
|
return {'all': False, 'mutual_friends': False, 'mutual_guilds': True}
|
|
if self.value == 2:
|
|
return {'all': False, 'mutual_friends': True, 'mutual_guilds': False}
|
|
if self.value == 3:
|
|
return {'all': False, 'mutual_friends': True, 'mutual_guilds': True}
|
|
if self.value == 4:
|
|
return {'all': True, 'mutual_friends': True, 'mutual_guilds': True}
|
|
|
|
@classmethod
|
|
def _from_dict(cls, data):
|
|
all = data.get('all')
|
|
mutual_guilds = data.get('mutual_guilds')
|
|
mutual_friends = data.get('mutual_friends')
|
|
|
|
if all:
|
|
return cls.everyone
|
|
elif mutual_guilds and mutual_friends:
|
|
return cls.guild_and_friends
|
|
elif mutual_guilds:
|
|
return cls.mutual_guilds
|
|
elif mutual_friends:
|
|
return cls.mutual_friends
|
|
else:
|
|
return cls.noone
|
|
|
|
|
|
class Theme(Enum):
|
|
light = 'light'
|
|
dark = 'dark'
|
|
|
|
|
|
class Status(Enum):
|
|
online = 'online'
|
|
offline = 'offline'
|
|
idle = 'idle'
|
|
dnd = 'dnd'
|
|
do_not_disturb = 'dnd'
|
|
invisible = 'invisible'
|
|
|
|
def __str__(self):
|
|
return self.value
|
|
|
|
|
|
class DefaultAvatar(Enum):
|
|
blurple = 0
|
|
grey = 1
|
|
gray = 1
|
|
green = 2
|
|
orange = 3
|
|
red = 4
|
|
pink = 5
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class RelationshipType(Enum, comparable=True):
|
|
friend = 1
|
|
blocked = 2
|
|
incoming_request = 3
|
|
outgoing_request = 4
|
|
|
|
|
|
class NotificationLevel(Enum, comparable=True):
|
|
all_messages = 0
|
|
all = 0
|
|
only_mentions = 1
|
|
nothing = 2
|
|
none = 2
|
|
server_default = 3
|
|
default = 3
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
|
|
class AuditLogActionCategory(Enum):
|
|
create = 1
|
|
delete = 2
|
|
update = 3
|
|
|
|
|
|
class AuditLogAction(Enum):
|
|
# fmt: off
|
|
guild_update = 1
|
|
channel_create = 10
|
|
channel_update = 11
|
|
channel_delete = 12
|
|
overwrite_create = 13
|
|
overwrite_update = 14
|
|
overwrite_delete = 15
|
|
kick = 20
|
|
member_prune = 21
|
|
ban = 22
|
|
unban = 23
|
|
member_update = 24
|
|
member_role_update = 25
|
|
member_move = 26
|
|
member_disconnect = 27
|
|
bot_add = 28
|
|
role_create = 30
|
|
role_update = 31
|
|
role_delete = 32
|
|
invite_create = 40
|
|
invite_update = 41
|
|
invite_delete = 42
|
|
webhook_create = 50
|
|
webhook_update = 51
|
|
webhook_delete = 52
|
|
emoji_create = 60
|
|
emoji_update = 61
|
|
emoji_delete = 62
|
|
message_delete = 72
|
|
message_bulk_delete = 73
|
|
message_pin = 74
|
|
message_unpin = 75
|
|
integration_create = 80
|
|
integration_update = 81
|
|
integration_delete = 82
|
|
stage_instance_create = 83
|
|
stage_instance_update = 84
|
|
stage_instance_delete = 85
|
|
sticker_create = 90
|
|
sticker_update = 91
|
|
sticker_delete = 92
|
|
thread_create = 110
|
|
thread_update = 111
|
|
thread_delete = 112
|
|
# fmt: on
|
|
|
|
@property
|
|
def category(self) -> Optional[AuditLogActionCategory]:
|
|
# fmt: off
|
|
lookup: Dict[AuditLogAction, Optional[AuditLogActionCategory]] = {
|
|
AuditLogAction.guild_update: AuditLogActionCategory.update,
|
|
AuditLogAction.channel_create: AuditLogActionCategory.create,
|
|
AuditLogAction.channel_update: AuditLogActionCategory.update,
|
|
AuditLogAction.channel_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.overwrite_create: AuditLogActionCategory.create,
|
|
AuditLogAction.overwrite_update: AuditLogActionCategory.update,
|
|
AuditLogAction.overwrite_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.kick: None,
|
|
AuditLogAction.member_prune: None,
|
|
AuditLogAction.ban: None,
|
|
AuditLogAction.unban: None,
|
|
AuditLogAction.member_update: AuditLogActionCategory.update,
|
|
AuditLogAction.member_role_update: AuditLogActionCategory.update,
|
|
AuditLogAction.member_move: None,
|
|
AuditLogAction.member_disconnect: None,
|
|
AuditLogAction.bot_add: None,
|
|
AuditLogAction.role_create: AuditLogActionCategory.create,
|
|
AuditLogAction.role_update: AuditLogActionCategory.update,
|
|
AuditLogAction.role_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.invite_create: AuditLogActionCategory.create,
|
|
AuditLogAction.invite_update: AuditLogActionCategory.update,
|
|
AuditLogAction.invite_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.webhook_create: AuditLogActionCategory.create,
|
|
AuditLogAction.webhook_update: AuditLogActionCategory.update,
|
|
AuditLogAction.webhook_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.emoji_create: AuditLogActionCategory.create,
|
|
AuditLogAction.emoji_update: AuditLogActionCategory.update,
|
|
AuditLogAction.emoji_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.message_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.message_bulk_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.message_pin: None,
|
|
AuditLogAction.message_unpin: None,
|
|
AuditLogAction.integration_create: AuditLogActionCategory.create,
|
|
AuditLogAction.integration_update: AuditLogActionCategory.update,
|
|
AuditLogAction.integration_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.stage_instance_create: AuditLogActionCategory.create,
|
|
AuditLogAction.stage_instance_update: AuditLogActionCategory.update,
|
|
AuditLogAction.stage_instance_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.sticker_create: AuditLogActionCategory.create,
|
|
AuditLogAction.sticker_update: AuditLogActionCategory.update,
|
|
AuditLogAction.sticker_delete: AuditLogActionCategory.delete,
|
|
AuditLogAction.thread_create: AuditLogActionCategory.create,
|
|
AuditLogAction.thread_update: AuditLogActionCategory.update,
|
|
AuditLogAction.thread_delete: AuditLogActionCategory.delete,
|
|
}
|
|
# fmt: on
|
|
return lookup[self]
|
|
|
|
@property
|
|
def target_type(self) -> Optional[str]:
|
|
v = self.value
|
|
if v == -1:
|
|
return 'all'
|
|
elif v < 10:
|
|
return 'guild'
|
|
elif v < 20:
|
|
return 'channel'
|
|
elif v < 30:
|
|
return 'user'
|
|
elif v < 40:
|
|
return 'role'
|
|
elif v < 50:
|
|
return 'invite'
|
|
elif v < 60:
|
|
return 'webhook'
|
|
elif v < 70:
|
|
return 'emoji'
|
|
elif v == 73:
|
|
return 'channel'
|
|
elif v < 80:
|
|
return 'message'
|
|
elif v < 83:
|
|
return 'integration'
|
|
elif v < 90:
|
|
return 'stage_instance'
|
|
elif v < 93:
|
|
return 'sticker'
|
|
elif v < 113:
|
|
return 'thread'
|
|
|
|
|
|
class UserFlags(Enum):
|
|
staff = 1
|
|
partner = 2
|
|
hypesquad = 4
|
|
bug_hunter = 8
|
|
bug_hunter_level_1 = 8
|
|
mfa_sms = 16
|
|
premium_promo_dismissed = 32
|
|
hypesquad_bravery = 64
|
|
hypesquad_brilliance = 128
|
|
hypesquad_balance = 256
|
|
early_supporter = 512
|
|
team_user = 1024
|
|
system = 4096
|
|
has_unread_urgent_messages = 8192
|
|
bug_hunter_level_2 = 16384
|
|
verified_bot = 65536
|
|
verified_bot_developer = 131072
|
|
discord_certified_moderator = 262144
|
|
bot_http_interactions = 524288
|
|
spammer = 1048576
|
|
|
|
|
|
class ActivityType(Enum):
|
|
unknown = -1
|
|
playing = 0
|
|
streaming = 1
|
|
listening = 2
|
|
watching = 3
|
|
custom = 4
|
|
competing = 5
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
|
|
class HypeSquadHouse(Enum):
|
|
bravery = 1
|
|
brilliance = 2
|
|
balance = 3
|
|
|
|
|
|
class PremiumType(Enum, comparable=True):
|
|
nitro_classic = 1
|
|
nitro = 2
|
|
|
|
|
|
class TeamMembershipState(Enum):
|
|
invited = 1
|
|
accepted = 2
|
|
|
|
|
|
class WebhookType(Enum):
|
|
incoming = 1
|
|
channel_follower = 2
|
|
application = 3
|
|
|
|
|
|
class ExpireBehaviour(Enum):
|
|
remove_role = 0
|
|
kick = 1
|
|
|
|
|
|
ExpireBehavior = ExpireBehaviour
|
|
|
|
|
|
class StickerType(Enum):
|
|
standard = 1
|
|
guild = 2
|
|
|
|
|
|
class StickerFormatType(Enum):
|
|
png = 1
|
|
apng = 2
|
|
lottie = 3
|
|
|
|
@property
|
|
def file_extension(self) -> str:
|
|
# fmt: off
|
|
lookup: Dict[StickerFormatType, str] = {
|
|
StickerFormatType.png: 'png',
|
|
StickerFormatType.apng: 'png',
|
|
StickerFormatType.lottie: 'json',
|
|
}
|
|
# fmt: on
|
|
return lookup[self]
|
|
|
|
|
|
class ReportType(Enum):
|
|
illegal_content = 1
|
|
harassment = 2
|
|
phishing = 3
|
|
self_harm = 4
|
|
nsfw_content = 5
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
|
|
class RelationshipAction(Enum, comparable=True):
|
|
send_friend_request = 'request'
|
|
unfriend = 'unfriend'
|
|
accept_request = 'accept'
|
|
deny_request = 'deny'
|
|
block = 'block'
|
|
unblock = 'unblock'
|
|
remove_pending_request = 'remove'
|
|
|
|
|
|
class UnavailableGuildType(Enum, comparable=True):
|
|
existing = 'ready'
|
|
joined = 'joined'
|
|
|
|
|
|
class RequiredActionType(Enum, comparable=True):
|
|
verify_phone = 'REQUIRE_VERIFIED_PHONE'
|
|
verify_email = 'REQUIRE_VERIFIED_EMAIL'
|
|
complete_captcha = 'REQUIRE_CAPTCHA'
|
|
accept_terms = 'AGREEMENTS'
|
|
|
|
|
|
class BrowserEnum(Enum):
|
|
google_chrome = 'chrome'
|
|
chrome = 'chrome'
|
|
chromium = 'chromium'
|
|
microsoft_edge = 'microsoft-edge'
|
|
edge = 'microsoft-edge'
|
|
opera = 'opera'
|
|
|
|
|
|
class InviteTarget(Enum):
|
|
unknown = 0
|
|
stream = 1
|
|
embedded_application = 2
|
|
|
|
|
|
class InteractionType(Enum, comparable=True):
|
|
ping = 1
|
|
application_command = 2
|
|
component = 3
|
|
|
|
|
|
class CommandType(Enum, comparable=True):
|
|
chat_input = 1
|
|
chat = 1
|
|
slash = 1
|
|
user = 2
|
|
message = 3
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
|
|
class OptionType(Enum, comparable=True):
|
|
sub_command = 1
|
|
sub_command_group = 2
|
|
string = 3
|
|
integer = 4
|
|
boolean = 5
|
|
user = 6
|
|
channel = 7
|
|
role = 8
|
|
mentionable = 9
|
|
number = 10
|
|
|
|
|
|
class VideoQualityMode(Enum):
|
|
auto = 1
|
|
full = 2
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
|
|
class ComponentType(Enum):
|
|
action_row = 1
|
|
button = 2
|
|
select = 3
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
|
|
class ButtonStyle(Enum):
|
|
primary = 1
|
|
secondary = 2
|
|
success = 3
|
|
danger = 4
|
|
link = 5
|
|
|
|
# Aliases
|
|
blurple = 1
|
|
grey = 2
|
|
gray = 2
|
|
green = 3
|
|
red = 4
|
|
url = 5
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
|
|
class StagePrivacyLevel(Enum):
|
|
public = 1
|
|
closed = 2
|
|
guild_only = 2
|
|
|
|
|
|
class NSFWLevel(Enum, comparable=True):
|
|
default = 0
|
|
explicit = 1
|
|
safe = 2
|
|
age_restricted = 3
|
|
|
|
|
|
T = TypeVar('T')
|
|
|
|
|
|
def create_unknown_value(cls: Type[T], val: Any) -> T:
|
|
value_cls = cls._enum_value_cls_ # type: ignore
|
|
name = f'unknown_{val}'
|
|
return value_cls(name=name, value=val)
|
|
|
|
|
|
def try_enum(cls: Type[T], val: Any) -> T:
|
|
"""A function that tries to turn the value into enum ``cls``.
|
|
|
|
If it fails it returns a proxy invalid value instead.
|
|
"""
|
|
|
|
try:
|
|
return cls._enum_value_map_[val] # type: ignore
|
|
except (KeyError, TypeError, AttributeError):
|
|
return create_unknown_value(cls, val)
|
|
|