def __init__(self, *, data, guild, state):
self._state = state
self._user = state.store_user(data["user"])
self.guild = guild
self.joined_at = utils.parse_time(data.get("joined_at"))
self.premium_since = utils.parse_time(data.get("premium_since"))
self._update_roles(data)
self.nick = data.get("nick", None)
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 from_dict(cls, data):
"""Converts a :class:`dict` to a :class:`Embed` provided it is in the
format that Discord expects it to be in.
You can find out about this format in the `official Discord documentation`__.
.. _DiscordDocs: https://discord.com/developers/docs/resources/channel#embed-object
__ DiscordDocs_
Parameters
-----------
data: :class:`dict`
The dictionary to convert into an embed.
"""
# we are bypassing __init__ here since it doesn't apply here
self = cls.__new__(cls)
# fill in the basic fields
self.title = data.get('title', EmptyEmbed)
self.type = data.get('type', EmptyEmbed)
self.description = data.get('description', EmptyEmbed)
self.url = data.get('url', EmptyEmbed)
if self.title is not EmptyEmbed:
self.title = str(self.title)
if self.description is not EmptyEmbed:
self.description = str(self.description)
if self.url is not EmptyEmbed:
self.url = str(self.url)
# try to fill in the more rich fields
try:
self._colour = Colour(value=data['color'])
except KeyError:
pass
try:
self._timestamp = utils.parse_time(data['timestamp'])
except KeyError:
pass
for attr in ('thumbnail', 'video', 'provider', 'author', 'fields',
'image', 'footer'):
try:
value = data[attr]
except KeyError:
continue
else:
setattr(self, '_' + attr, value)
return self
async def parse_channel_pins_update(self, data, old):
channel = await self.get_channel(int(data["channel_id"]))
last_pin = utils.parse_time(
data["last_pin_timestamp"]) if data["last_pin_timestamp"] else None
try:
channel.guild
except AttributeError:
self.dispatch("private_channel_pins_update", channel, last_pin)
else:
self.dispatch("guild_channel_pins_update", channel, last_pin)
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 started(self):
return parse_time(
str(await self._connection._get("gateway_started").split(".")[0]))
def last_ack(self):
return parse_time(self._data["last_ack"].split(".")[0])
def _handle_edited_timestamp(self: message.Message, value: str) -> None:
"""Helper function that takes care of parsing the edited timestamp."""
self._edited_timestamp = utils.parse_time(value)
