def _from_data(self, guild):
member_count = guild.get("member_count", None)
if member_count is not None:
self._member_count = member_count
self.name = guild.get("name")
self.region = try_enum(VoiceRegion, guild.get("region"))
self.verification_level = try_enum(VerificationLevel, guild.get("verification_level"))
self.default_notifications = try_enum(NotificationLevel, guild.get("default_message_notifications"))
self.explicit_content_filter = try_enum(ContentFilter, guild.get("explicit_content_filter", 0))
self.afk_timeout = guild.get("afk_timeout")
self.icon = guild.get("icon")
self.banner = guild.get("banner")
self.unavailable = guild.get("unavailable", False)
self.id = int(guild["id"])
self.mfa_level = guild.get("mfa_level")
self.features = guild.get("features", [])
self.splash = guild.get("splash")
self._system_channel_id = utils._get_as_snowflake(guild, "system_channel_id")
self.description = guild.get("description")
self.max_presences = guild.get("max_presences")
self.max_members = guild.get("max_members")
self.max_video_channel_users = guild.get("max_video_channel_users")
self.premium_tier = guild.get("premium_tier", 0)
self.premium_subscription_count = guild.get("premium_subscription_count") or 0
self._system_channel_flags = guild.get("system_channel_flags", 0)
self.preferred_locale = guild.get("preferred_locale")
self.discovery_splash = guild.get("discovery_splash")
self._rules_channel_id = utils._get_as_snowflake(guild, "rules_channel_id")
self._public_updates_channel_id = utils._get_as_snowflake(guild, "public_updates_channel_id")
self._large = None if member_count is None else self._member_count >= 250
self.owner_id = utils._get_as_snowflake(guild, "owner_id")
self._afk_channel_id = utils._get_as_snowflake(guild, "afk_channel_id")
def _update(self, guild, data):
self.guild = guild
self.name = data.get("name", "")
self.category_id = utils._get_as_snowflake(data, "parent_id")
self.topic = data.get("topic", "")
self.position = data.get("position", 0)
self.nsfw = data.get("nsfw", False)
self.slowmode_delay = data.get("rate_limit_per_user", 0)
self._type = data.get("type", self._type)
self.last_message_id = utils._get_as_snowflake(data, "last_message_id")
self._fill_overwrites(data)
async def parse_voice_state_update(self, data, old):
guild = await self._get_guild(utils._get_as_snowflake(
data, "guild_id"))
if guild:
member = await guild.get_member(int(data["user_id"]))
if member:
channel = await self.get_channel(
utils._get_as_snowflake(data, "channel_id"))
if channel:
before = None
after = VoiceState(data=data, channel=channel)
old_channel = await self.get_channel(old["channel_id"])
if old and old_channel:
before = VoiceState(data=data, channel=old_channel)
self.dispatch("voice_state_update", member, before, after)
def __init__(self, *, state, data):
self._state = state
self.id = int(data["id"])
self.type = try_enum(InteractionType, data["type"])
self.data = "data" in data and InteractionData(data["data"])
self.guild_id = _get_as_snowflake(data, "guild_id")
self.channel_id = _get_as_snowflake(data, "channel_id")
self.author = (
("member" in data
and Member(data=data["member"], guild=guild, state=state) if
(guild := state._get_guild(self.guild_id)) else User(
state=state, data=data["member"]["user"]))
or "user" in data and User(state=state, data=data["user"]))
self.token = data["token"]
self.version = data["version"]
async def get_reaction_emoji(self, data):
emoji_id = utils._get_as_snowflake(data, "id")
if not emoji_id:
return data["name"]
return await self.get_emoji(emoji_id)
async def parse_message_reaction_add(self, data, old):
emoji = PartialEmoji.with_state(
self,
id=utils._get_as_snowflake(data["emoji"], "id"),
animated=data["emoji"].get("animated", False),
name=data["emoji"]["name"],
)
raw = RawReactionActionEvent(data, emoji, "REACTION_ADD")
member = data.get("member")
if member:
guild = await self._get_guild(raw.guild_id)
if guild:
raw.member = Member(guild=guild, state=self, data=member)
self.dispatch("raw_reaction_add", raw)
message = await self._get_message(raw.message_id)
if message:
reaction = Reaction(message=message,
data=data,
emoji=await self._upgrade_partial_emoji(emoji))
user = raw.member or await self._get_reaction_user(
message.channel, raw.user_id)
if user:
self.dispatch("reaction_add", reaction, user)
def parse_member_update(self, data):
"""Replacement for hacky https://github.com/Rapptz/discord.py/blob/master/discord/state.py#L547"""
guild_id = utils._get_as_snowflake(data, "guild_id")
guild = self.bot._connection._get_guild(guild_id)
user_data = data["user"]
member_id = int(user_data["id"])
user = self.bot.get_user(member_id)
if guild is None and user is None:
return
elif guild is None and user is not None:
user.name = user_data["username"]
user.discriminator = user_data["discriminator"]
user.avatar = user_data["avatar"]
else:
member = guild.get_member(member_id)
if member is None:
if "username" not in user_data:
# sometimes we receive 'incomplete' member data post-removal.
# skip these useless cases.
return
# https://github.com/Rapptz/discord.py/blob/master/discord/member.py#L214
member = discord.Member(data=data,
guild=guild,
state=self.bot._connection)
guild._add_member(member)
member._user.name = user_data["username"]
member._user.discriminator = user_data["discriminator"]
member._user.avatar = user_data["avatar"]
def __init__(self, *, state, channel, data):
self._state = state
self._data = data
self.id = int(data["id"])
self.webhook_id = utils._get_as_snowflake(data, "webhook_id")
self.reactions = [
Reaction(message=self, data=d) for d in data.get("reactions", [])
]
self.attachments = [
Attachment(data=a, state=self._state) for a in data["attachments"]
]
self.embeds = [Embed.from_dict(a) for a in data["embeds"]]
self.application = data.get("application")
self.activity = data.get("activity")
self.channel = channel
self._edited_timestamp = utils.parse_time(data["edited_timestamp"])
self.type = try_enum(MessageType, data["type"])
self.pinned = data["pinned"]
self.flags = MessageFlags._from_value(data.get("flags", 0))
self.mention_everyone = data["mention_everyone"]
self.tts = data["tts"]
self.content = data["content"]
self.nonce = data.get("nonce")
ref = data.get("message_reference")
self.reference = MessageReference(state, **
ref) if ref is not None else None
for handler in ("call", "flags"):
try:
getattr(self, "_handle_%s" % handler)(data[handler])
except KeyError:
continue
def __init__(self, data, *, adapter, state=None):
self.id = int(data['id'])
self.type = try_enum(WebhookType, int(data['type']))
self.channel_id = utils._get_as_snowflake(data, 'channel_id')
self.guild_id = utils._get_as_snowflake(data, 'guild_id')
self.name = data.get('name')
self.avatar = data.get('avatar')
self.token = data.get('token')
self._state = state or _PartialWebhookState(adapter, self, parent=state)
self._adapter = adapter
self._adapter._prepare(self)
user = data.get('user')
if user is None:
self.user = None
elif state is None:
self.user = BaseUser(state=None, data=user)
else:
self.user = User(state=state, data=user)
async def parse_channel_create(self, data, old):
factory, ch_type = _channel_factory(data["type"])
if ch_type is ChannelType.private:
channel = DMChannel(me=self.user, data=data, state=self)
self.dispatch("private_channel_create", channel)
else:
guild = await self._get_guild(
utils._get_as_snowflake(data, "guild_id"))
if guild:
channel = factory(guild=guild, state=self, data=data)
self.dispatch("guild_channel_create", channel)
async def parse_channel_delete(self, data, old):
if old and old["guild_id"]:
guild = await self._get_guild(
utils._get_as_snowflake(data, "guild_id"))
if guild:
factory, _ = _channel_factory(old["type"])
channel = factory(guild=guild, state=self, data=old)
self.dispatch("guild_channel_delete", channel)
elif old:
channel = DMChannel(me=self.user, state=self, data=old)
self.dispatch("private_channel_delete", channel)
async def parse_message_reaction_remove_emoji(self, data, old):
emoji = PartialEmoji.with_state(
self,
id=utils._get_as_snowflake(data["emoji"], "id"),
name=data["emoji"]["name"],
)
raw = RawReactionClearEmojiEvent(data, emoji)
self.dispatch("raw_reaction_clear_emoji", raw)
message = await self._get_message(raw.message_id)
if message:
reaction = Reaction(message=message,
data=data,
emoji=await self._upgrade_partial_emoji(emoji))
self.dispatch("reaction_clear_emoji", reaction)
def __init__(self, *, state, channel, data):
self._state = state
self._data = data
self.id = int(data["id"])
self.webhook_id = utils._get_as_snowflake(data, "webhook_id")
self.reactions = [
Reaction(message=self, data=x, emoji="x")
for x in data.get("reactions", [])
]
self.attachments = [
Attachment(data=x, state=self._state) for x in data["attachments"]
]
self.embeds = [Embed.from_dict(x) for x in data["embeds"]]
self.application = data.get("application")
self.activity = data.get("activity")
self.channel = channel
self._edited_timestamp = utils.parse_time(data["edited_timestamp"])
self.type = try_enum(MessageType, data["type"])
self.pinned = data["pinned"]
self.flags = MessageFlags._from_value(data.get("flags", 0))
self.mention_everyone = data["mention_everyone"]
self.tts = data["tts"]
self.content = data["content"]
self.nonce = data.get("nonce")
ref = data.get("message_reference")
self.reference = MessageReference.with_state(
state, ref) if ref is not None else None
try:
self._author = self._state.store_user(self._data["author"])
except KeyError:
self._author = None
try:
author = self._author
try:
author._update_from_message(self._data["member"])
except AttributeError:
author = Member._from_message(message=self,
data=self._data["member"])
self._member = author
except KeyError:
self._member = None
for handler in ("call", "flags"):
try:
getattr(self, f"_handle_{handler}")(data[handler])
except KeyError:
continue
async def parse_presence_update(self, data, old):
guild = await self._get_guild(utils._get_as_snowflake(
data, "guild_id"))
if not guild:
return
old_member = None
member = await guild.get_member(int(data["user"]["id"]))
if member and old:
old_member = Member._copy(member)
user_update = old_member._presence_update(data=old,
user=old["user"])
if user_update:
self.dispatch("user_update", user_update[1], user_update[0])
self.dispatch("member_update", old_member, member)
async def parse_typing_start(self, data, old):
channel = await self._get_guild_channel(int(data["channel_id"]))
if channel:
member = None
if isinstance(channel, DMChannel):
member = channel.recipient
elif isinstance(channel, TextChannel):
guild = await self._get_guild(int(data["guild_id"]))
if guild:
member = await guild.get_member(
utils._get_as_snowflake(data, "user_id"))
if member:
self.dispatch(
"typing", channel, member,
datetime.datetime.utcfromtimestamp(data.get("timestamp")))
async def parse_channel_update(self, data, old):
channel_type = try_enum(ChannelType, data.get("type"))
if old and channel_type is ChannelType.private:
channel = DMChannel(me=self.user, state=self, data=data)
old_channel = DMChannel(me=self.user, state=self, data=old)
self.dispatch("private_channel_update", old_channel, channel)
elif old:
guild = await self._get_guild(
utils._get_as_snowflake(data, "guild_id"))
if guild:
factory, _ = _channel_factory(data["type"])
channel = factory(guild=guild, state=self, data=data)
old_factory, _ = _channel_factory(old["type"])
old_channel = old_factory(guild=guild, state=self, data=old)
self.dispatch("guild_channel_update", old_channel, channel)
async def parse_message_reaction_remove(self, data, old):
emoji = PartialEmoji.with_state(
self,
id=utils._get_as_snowflake(data["emoji"], "id"),
name=data["emoji"]["name"],
)
raw = RawReactionActionEvent(data, emoji, "REACTION_REMOVE")
self.dispatch("raw_reaction_remove", raw)
message = await self._get_message(raw.message_id)
if message:
reaction = Reaction(message=message,
data=data,
emoji=await self._upgrade_partial_emoji(emoji))
user = await self._get_reaction_user(message.channel, raw.user_id)
if user:
self.dispatch("reaction_remove", reaction, user)
