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 __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):
self.load_type: LoadType = try_enum(LoadType, data.pop('loadType'))
playlist_info_raw = data.pop('playlistInfo')
self.playlist_info: typing.Optional[PlaylistInfo] = \
PlaylistInfo(**playlist_info_raw) if playlist_info_raw != {} else None
self.tracks: typing.List[Track] = [
Track(**t) for t in data.pop('tracks')
]
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_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 change_status(self, ctx, action, name):
"""Modifies the parameters of the Discord Game to display."""
# print(action)
# print(name)
if len(name) > 0:
mention = self.nyx.user.mention
if ctx.guild is not None:
mention = ctx.guild.get_member(self.nyx.user.id).mention
name = name.replace(mention, "@{}".format(self.nyx.user.name))
if self.game is None:
self.game = Activity(name=name, type=action)
else:
self.game.name = name
self.game.type = try_enum(ActivityType, action)
await self.update_status(ctx)
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"]
def _channel_factory(channel_type):
value = try_enum(ChannelType, channel_type)
if value is ChannelType.text:
return TextChannel, value
elif value is ChannelType.voice:
return VoiceChannel, value
elif value is ChannelType.private:
return DMChannel, value
elif value is ChannelType.category:
return CategoryChannel, value
elif value is ChannelType.group:
return GroupChannel, value
elif value is ChannelType.news:
return TextChannel, value
elif value is ChannelType.store:
return StoreChannel, value
else:
return None, value
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)
def __init__(self, bot, interaction: Interaction):
self.interaction = interaction
self.bot = bot
self.channel = interaction.channel
self.channel_id = interaction.channel_id
self.guild = interaction.guild
self.guild_id = interaction.guild_id
self.author = interaction.user
self.permissions = interaction.permissions
self._data = interaction.data
self.message = None
self.command_type = try_enum(ApplicationCommandType,
self._data['type'])
self.app_command = ApplicationCommand(state=self.bot._connection,
data=self._data)
self.command_name = self.app_command.name
self.command = bot.all_commands[self.command_name]
self.cog = self.command.cog
for option in self.app_command.options:
if option.type.value in (1, 2):
self.command_name += ' ' + option.name
async def from_incomplete(cls, *, state, data):
try:
guild = await state._get_guild(int(data["guild"]["id"]))
if guild is None:
guild = PartialInviteGuild(state, data["guild"],
int(data["guild"]["id"]))
except KeyError:
guild = None
channel = PartialInviteChannel(
id=int(data["channel"]["id"]),
name=data["channel"]["name"],
type=try_enum(ChannelType, data["channel"]["type"]),
)
if guild is not None and not isinstance(guild, PartialInviteGuild):
channel = await guild.get_channel(int(data["channel"]["id"])
) or channel
data["guild"] = guild
data["channel"] = channel
return cls(state=state, data=data)
async def status(self):
return try_enum(Status, await self._client_status())
def __init__(self, http, data):
self._http = http
self.type = try_enum(RelationshipType, data['type'])
self.user = User(**data['user'])