class Presence(Model):
__repr_keys__ = ['user']
user = Field(User)
game = Field(Activity)
guild_id = Field(Snowflake)
status = Field(str)
class ChannelMention(Model):
__repr_keys__ = ['id', 'name', 'type']
id = Field(Snowflake)
guild_id = Field(str)
type = Field(ChannelType)
name = Field(str)
class GuildMemberRemove(GatewayEvent):
guild_id = Field(Snowflake)
user = Field(User)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class PermissionOverwrite(Model):
__repr_keys__ = ['id', 'type']
id = Field(Snowflake)
type = Field(str)
deny = Field(Permission)
allow = Field(Permission)
class GuildRoleDelete(GatewayEvent):
guild_id = Field(Snowflake)
role = Field(Role)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class Emoji(Model):
__repr_keys__ = ['id', 'name']
id = Field(Snowflake)
name = Field(str, required=True)
roles = ListField(Role)
user = ListField(User)
require_colons = Field(bool, default=False)
managed = Field(bool, default=False)
animated = Field(bool, default=False)
class GuildBanAdd(GatewayEvent):
guild_id = Field(Snowflake)
user = Field(User)
@property
def ban(self):
return self.guild.bans.filter(lambda ban: ban.user.id == self.user.id)[0]
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class WebhooksUpdate(GatewayEvent):
guild_id = Field(Snowflake)
message_id = Field(Snowflake)
@property
def channel(self):
return self.cache.guilds.get(self.channel.id)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class MessageReactionRemoveAll(GatewayEvent):
channel_id = Field(Snowflake)
message_id = Field(Snowflake)
guild_id = Field(Snowflake)
@property
def channel(self):
return self.cache.guilds.get(self.channel_id)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class ChannelPinsUpdate(GatewayEvent):
guild_id = Field(Snowflake)
channel_id = Field(Snowflake)
last_pin_timestamp = Field(Timestamp)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
@property
def channel(self):
return self.cache.channels.get(self.channel_id)
class MessageDeleteBulk(GatewayEvent):
ids = ListField(Snowflake)
channel_id = Field(Snowflake)
guild_id = Field(Snowflake)
@property
def channel(self):
return self.cache.channels.get(self.channel_id)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class GuildMemberUpdate(GatewayEvent):
guild_id = Field(Snowflake)
user = Field(User)
roles = ListField(Snowflake)
nick = Field(str)
@property
def member(self):
return self.cache.guilds.find(id=self.guild_id).members.find(id=self.user.id)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class MessageReactionAdd(GatewayEvent):
user_id = Field(Snowflake)
channel_id = Field(Snowflake)
message_id = Field(Snowflake)
guild_id = Field(Snowflake)
emoji = Field(Emoji)
@property
def channel(self):
return self.cache.guilds.get(self.channel_id)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class GuildMembersChunk(GatewayEvent):
guild_id = Field(Snowflake)
members = ListField(GuildMember)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class GuildEmojisUpdate(GatewayEvent):
guild_id = Field(Snowflake)
emojis = ListField(Emoji)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class Sticker(Model):
id = Field(Snowflake, required=True)
pack_id = Field(Snowflake, required=True)
name = Field(str, required=True)
description = Field(str, required=True)
tags = Field(str)
asset = Field(str)
preview_asset = Field(str)
format_type = Field(StickerFormat)
class VoiceState(Model):
guild_id = Field(Snowflake)
channel_id = Field(Snowflake)
user_id = Field(Snowflake)
session_id = Field(str)
deaf = Field(bool)
mute = Field(bool)
self_deaf = Field(bool)
self_mute = Field(bool)
suppress = Field(bool)
def __eq__(self, other):
return self.user_id == other.user_id
class Emoji(Model):
__repr_keys__ = ['id', 'name']
id = Field(Snowflake, required=True)
name = Field(str, required=True)
roles = ListField(Role)
user = ListField(User)
require_colons = Field(bool, default=False)
managed = Field(bool, default=False)
animated = Field(bool, default=False)
# TODO: Implement Update ability
def rename(self):
raise NotImplementedError
def delete(self):
raise NotImplementedError
class InviteMetadata(Model):
inviter = Field(User)
uses = Field(int)
max_uses = Field(int)
max_age = Field(int)
temporary = Field(bool)
created_at = Field(Timestamp)
revoked = Field(bool)
class MessageUpdate(GatewayEvent):
message = Field(Message, json_key="d")
@property
def channel(self):
return self.cache.channels.get(self.message.channel_id)
@property
def guild(self):
if self.message.is_guild:
return self.cache.guilds.get(self.message.guild_id)
class GuildPreview(Model):
__repr_keys__ = ['id', 'name']
id = Field(Snowflake, required=True)
name = Field(str)
description = Field(str)
icon = Field(str)
splash = Field(str)
discovery_splash = Field(str)
emojis = ListField(Emoji)
features = ListField(str)
approximate_member_count = Field(int)
approximate_presence_count = Field(int)
class TypingStart(GatewayEvent):
guild_id = Field(Snowflake)
channel_id = Field(Snowflake)
user_id = Field(Snowflake)
unix_time = Field(int, json_key="timestamp")
@property
def timestamp(self):
return Timestamp.from_unix(self.unix_time)
@property
def user(self):
return self.cache.users.get(self.user_id)
@property
def channel(self):
return self.cache.guilds.get(self.channel_id)
@property
def guild(self):
return self.cache.guilds.get(self.guild_id)
class Attachment(Model):
__repr_keys__ = ['id', 'filename']
id = Field(Snowflake, required=True)
filename = Field(str, required=True)
size = Field(int, required=True)
url = Field(str, required=True)
proxy_url = Field(str, required=True)
height = Field(str)
width = Field(str)
class VoiceRegion(Model):
id = Field(str)
name = Field(str)
vip = Field(bool)
optimal = Field(bool)
deprecated = Field(bool)
custom = Field(bool)
class Activity(Model):
name = Field(str)
type = Field(ActivityType)
url = Field(str)
application_id = Field(int)
details = Field(str)
state = Field(str)
class Invite(Model):
code = Field(str)
guild = Field(Guild)
channel = Field(Channel)
target_user = Field(User)
target_user_type = Field(int)
approximate_presence_count = Field(int)
approximate_member_count = Field(int)
@property
def link(self):
return f"https://discord.gg/{self.code}"
class MessageCreate(GatewayEvent):
message = Field(Message, json_key="d")
@property
def channel(self):
return self.cache.channels.get(self.message.channel_id)
@property
def member(self):
if self.message.is_guild:
return self.guild.members.find(self.message.author.id)
@property
def guild(self):
if self.message.is_guild:
return self.cache.guilds.get(self.message.guild_id)
class Role(Model):
__repr_keys__ = ['id', 'name']
id = Field(Snowflake, required=True)
name = Field(str, required=True)
color = Field(int)
hoist = Field(bool)
position = Field(int)
permissions = Field(Permission)
managed = Field(bool)
mentionable = Field(bool)
# TODO: Implement update ability
def rename(self):
raise NotImplementedError
def delete(self):
raise NotImplementedError
class VoiceStateUpdate(GatewayEvent):
voice_state = Field(VoiceState, json_key="d")
@property
def connected(self):
return False if self.channel is None else True
@property
def user(self):
return self.cache.users.get(self.voice_state.user_id)
@property
def channel(self):
return self.cache.channels.get(self.voice_state.channel_id)
@property
def guild(self):
return self.cache.guilds.get(self.voice_state.guild_id)
class Message(Model):
__repr_keys__ = ['id', 'timestamp']
id = Field(Snowflake, required=True)
channel_id = Field(Snowflake, required=True)
guild_id = Field(Snowflake)
author = Field(User)
member = Field(GuildMember)
content = Field(str)
timestamp = Field(Timestamp)
edited_timestamp = Field(Timestamp)
tts = Field(bool, default=False)
mention_everyone = Field(bool, default=False)
mentions = ListField(User)
mention_roles = ListField(Role)
mention_channels = ListField(ChannelMention)
attachments = ListField(Attachment)
embeds = ListField(Embed)
reactions = ListField(Reaction)
nonce = Field(Snowflake)
pinned = Field(bool)
webhook_id = Field(Snowflake)
type = Field(MessageType)
activity = Field(MessageActivity)
application = Field(MessageApplication)
message_reference = Field(MessageReference)
flags = Field(int)
strickers = ListField(Sticker)
def add_reaction(self):
pass
def edit(self, message="", embed=None, mentions=None):
self.content = message
self.embed = embed
embed = embed if embed is not None else self.embed
mentions = mentions if mentions is not None else self.mentions
for user in mentions:
message = f"{user.mention} {message}"
message_data = {"content": message, "embed": embed}
self.api.edit_message(self.channel_id, self.id, message_data)
def reply(self, message):
self.channel.say(message, mentions=[self.author])
@property
def member(self):
# TODO error handling around if guild
return self.guild.members.find(id=self.author.id)
@property
def is_guild(self):
return self.guild_id is not None
@property
def is_dm(self):
return self.guild_id is None
@property
def channel(self):
return self.cache.channels[self.channel_id]
@property
def guild(self):
return self.cache.guilds[self.guild_id]
