matthew/enhanced-discord.py
1
0
Fork 0
Code Issues 4 Pull Requests 21 Projects Releases Wiki Activity

Fix code style issues with Black

Browse Source
This commit is contained in:
Lint Action
2021-09-05 21:34:20 +00:00
parent a23dae8604
commit 7513c2138f
108 changed files with 5369 additions and 4858 deletions
Download Patch File Download Diff File Expand all files Collapse all files

447
discord/guild.py
View File

@@ -79,9 +79,7 @@ from .file import File
from .welcome_screen import WelcomeScreen, WelcomeChannel
__all__ = (
'Guild',
)
__all__ = ("Guild",)
MISSING = utils.MISSING
@@ -240,45 +238,45 @@ class Guild(Hashable):
"""
__slots__ = (
'afk_timeout',
'afk_channel',
'name',
'id',
'unavailable',
'region',
'owner_id',
'mfa_level',
'emojis',
'stickers',
'features',
'verification_level',
'explicit_content_filter',
'default_notifications',
'description',
'max_presences',
'max_members',
'max_video_channel_users',
'premium_tier',
'premium_subscription_count',
'preferred_locale',
'nsfw_level',
'_members',
'_channels',
'_icon',
'_banner',
'_state',
'_roles',
'_member_count',
'_large',
'_splash',
'_voice_states',
'_system_channel_id',
'_system_channel_flags',
'_discovery_splash',
'_rules_channel_id',
'_public_updates_channel_id',
'_stage_instances',
'_threads',
"afk_timeout",
"afk_channel",
"name",
"id",
"unavailable",
"region",
"owner_id",
"mfa_level",
"emojis",
"stickers",
"features",
"verification_level",
"explicit_content_filter",
"default_notifications",
"description",
"max_presences",
"max_members",
"max_video_channel_users",
"premium_tier",
"premium_subscription_count",
"preferred_locale",
"nsfw_level",
"_members",
"_channels",
"_icon",
"_banner",
"_state",
"_roles",
"_member_count",
"_large",
"_splash",
"_voice_states",
"_system_channel_id",
"_system_channel_flags",
"_discovery_splash",
"_rules_channel_id",
"_public_updates_channel_id",
"_stage_instances",
"_threads",
)
_PREMIUM_GUILD_LIMITS: ClassVar[Dict[Optional[int], _GuildLimit]] = {
@@ -338,21 +336,23 @@ class Guild(Hashable):
return to_remove
def __str__(self) -> str:
return self.name or ''
return self.name or ""
def __repr__(self) -> str:
attrs = (
('id', self.id),
('name', self.name),
('shard_id', self.shard_id),
('chunked', self.chunked),
('member_count', getattr(self, '_member_count', None)),
("id", self.id),
("name", self.name),
("shard_id", self.shard_id),
("chunked", self.chunked),
("member_count", getattr(self, "_member_count", None)),
)
inner = ' '.join('%s=%r' % t for t in attrs)
return f'<Guild {inner}>'
inner = " ".join("%s=%r" % t for t in attrs)
return f"<Guild {inner}>"
def _update_voice_state(self, data: GuildVoiceState, channel_id: int) -> Tuple[Optional[Member], VoiceState, VoiceState]:
user_id = int(data['user_id'])
def _update_voice_state(
self, data: GuildVoiceState, channel_id: int
) -> Tuple[Optional[Member], VoiceState, VoiceState]:
user_id = int(data["user_id"])
channel = self.get_channel(channel_id)
try:
# check if we should remove the voice state from cache
@@ -372,7 +372,7 @@ class Guild(Hashable):
member = self.get_member(user_id)
if member is None:
try:
member = Member(data=data['member'], state=self._state, guild=self)
member = Member(data=data["member"], state=self._state, guild=self)
except KeyError:
member = None
@@ -404,57 +404,57 @@ class Guild(Hashable):
def _from_data(self, guild: GuildPayload) -> None:
# according to Stan, this is always available even if the guild is unavailable
# I don't have this guarantee when someone updates the guild.
member_count = guild.get('member_count', None)
member_count = guild.get("member_count", None)
if member_count is not None:
self._member_count: int = member_count
self.name: str = guild.get('name')
self.region: VoiceRegion = try_enum(VoiceRegion, guild.get('region'))
self.verification_level: VerificationLevel = try_enum(VerificationLevel, guild.get('verification_level'))
self.name: str = guild.get("name")
self.region: VoiceRegion = try_enum(VoiceRegion, guild.get("region"))
self.verification_level: VerificationLevel = try_enum(VerificationLevel, guild.get("verification_level"))
self.default_notifications: NotificationLevel = try_enum(
NotificationLevel, guild.get('default_message_notifications')
NotificationLevel, guild.get("default_message_notifications")
)
self.explicit_content_filter: ContentFilter = try_enum(ContentFilter, guild.get('explicit_content_filter', 0))
self.afk_timeout: int = guild.get('afk_timeout')
self._icon: Optional[str] = guild.get('icon')
self._banner: Optional[str] = guild.get('banner')
self.unavailable: bool = guild.get('unavailable', False)
self.id: int = int(guild['id'])
self.explicit_content_filter: ContentFilter = try_enum(ContentFilter, guild.get("explicit_content_filter", 0))
self.afk_timeout: int = guild.get("afk_timeout")
self._icon: Optional[str] = guild.get("icon")
self._banner: Optional[str] = guild.get("banner")
self.unavailable: bool = guild.get("unavailable", False)
self.id: int = int(guild["id"])
self._roles: Dict[int, Role] = {}
state = self._state # speed up attribute access
for r in guild.get('roles', []):
for r in guild.get("roles", []):
role = Role(guild=self, data=r, state=state)
self._roles[role.id] = role
self.mfa_level: MFALevel = guild.get('mfa_level')
self.emojis: Tuple[Emoji, ...] = tuple(map(lambda d: state.store_emoji(self, d), guild.get('emojis', [])))
self.mfa_level: MFALevel = guild.get("mfa_level")
self.emojis: Tuple[Emoji, ...] = tuple(map(lambda d: state.store_emoji(self, d), guild.get("emojis", [])))
self.stickers: Tuple[GuildSticker, ...] = tuple(
map(lambda d: state.store_sticker(self, d), guild.get('stickers', []))
map(lambda d: state.store_sticker(self, d), guild.get("stickers", []))
)
self.features: List[GuildFeature] = guild.get('features', [])
self._splash: Optional[str] = guild.get('splash')
self._system_channel_id: Optional[int] = utils._get_as_snowflake(guild, 'system_channel_id')
self.description: Optional[str] = guild.get('description')
self.max_presences: Optional[int] = guild.get('max_presences')
self.max_members: Optional[int] = guild.get('max_members')
self.max_video_channel_users: Optional[int] = guild.get('max_video_channel_users')
self.premium_tier: int = guild.get('premium_tier', 0)
self.premium_subscription_count: int = guild.get('premium_subscription_count') or 0
self._system_channel_flags: int = guild.get('system_channel_flags', 0)
self.preferred_locale: Optional[str] = guild.get('preferred_locale')
self._discovery_splash: Optional[str] = guild.get('discovery_splash')
self._rules_channel_id: Optional[int] = utils._get_as_snowflake(guild, 'rules_channel_id')
self._public_updates_channel_id: Optional[int] = utils._get_as_snowflake(guild, 'public_updates_channel_id')
self.nsfw_level: NSFWLevel = try_enum(NSFWLevel, guild.get('nsfw_level', 0))
self.features: List[GuildFeature] = guild.get("features", [])
self._splash: Optional[str] = guild.get("splash")
self._system_channel_id: Optional[int] = utils._get_as_snowflake(guild, "system_channel_id")
self.description: Optional[str] = guild.get("description")
self.max_presences: Optional[int] = guild.get("max_presences")
self.max_members: Optional[int] = guild.get("max_members")
self.max_video_channel_users: Optional[int] = guild.get("max_video_channel_users")
self.premium_tier: int = guild.get("premium_tier", 0)
self.premium_subscription_count: int = guild.get("premium_subscription_count") or 0
self._system_channel_flags: int = guild.get("system_channel_flags", 0)
self.preferred_locale: Optional[str] = guild.get("preferred_locale")
self._discovery_splash: Optional[str] = guild.get("discovery_splash")
self._rules_channel_id: Optional[int] = utils._get_as_snowflake(guild, "rules_channel_id")
self._public_updates_channel_id: Optional[int] = utils._get_as_snowflake(guild, "public_updates_channel_id")
self.nsfw_level: NSFWLevel = try_enum(NSFWLevel, guild.get("nsfw_level", 0))
self._stage_instances: Dict[int, StageInstance] = {}
for s in guild.get('stage_instances', []):
for s in guild.get("stage_instances", []):
stage_instance = StageInstance(guild=self, data=s, state=state)
self._stage_instances[stage_instance.id] = stage_instance
cache_joined = self._state.member_cache_flags.joined
self_id = self._state.self_id
for mdata in guild.get('members', []):
for mdata in guild.get("members", []):
member = Member(data=mdata, guild=self, state=state)
if cache_joined or member.id == self_id:
self._add_member(member)
@@ -462,35 +462,35 @@ class Guild(Hashable):
self._sync(guild)
self._large: Optional[bool] = None if member_count is None else self._member_count >= 250
self.owner_id: Optional[int] = utils._get_as_snowflake(guild, 'owner_id')
self.afk_channel: Optional[VocalGuildChannel] = self.get_channel(utils._get_as_snowflake(guild, 'afk_channel_id')) # type: ignore
self.owner_id: Optional[int] = utils._get_as_snowflake(guild, "owner_id")
self.afk_channel: Optional[VocalGuildChannel] = self.get_channel(utils._get_as_snowflake(guild, "afk_channel_id")) # type: ignore
for obj in guild.get('voice_states', []):
self._update_voice_state(obj, int(obj['channel_id']))
for obj in guild.get("voice_states", []):
self._update_voice_state(obj, int(obj["channel_id"]))
# TODO: refactor/remove?
def _sync(self, data: GuildPayload) -> None:
try:
self._large = data['large']
self._large = data["large"]
except KeyError:
pass
empty_tuple = tuple()
for presence in data.get('presences', []):
user_id = int(presence['user']['id'])
for presence in data.get("presences", []):
user_id = int(presence["user"]["id"])
member = self.get_member(user_id)
if member is not None:
member._presence_update(presence, empty_tuple) # type: ignore
if 'channels' in data:
channels = data['channels']
if "channels" in data:
channels = data["channels"]
for c in channels:
factory, ch_type = _guild_channel_factory(c['type'])
factory, ch_type = _guild_channel_factory(c["type"])
if factory:
self._add_channel(factory(guild=self, data=c, state=self._state)) # type: ignore
if 'threads' in data:
threads = data['threads']
if "threads" in data:
threads = data["threads"]
for thread in threads:
self._add_thread(Thread(guild=self, state=self._state, data=thread))
@@ -713,7 +713,7 @@ class Guild(Hashable):
@property
def emoji_limit(self) -> int:
""":class:`int`: The maximum number of emoji slots this guild has."""
more_emoji = 200 if 'MORE_EMOJI' in self.features else 50
more_emoji = 200 if "MORE_EMOJI" in self.features else 50
return max(more_emoji, self._PREMIUM_GUILD_LIMITS[self.premium_tier].emoji)
@property
@@ -722,13 +722,13 @@ class Guild(Hashable):
.. versionadded:: 2.0
"""
more_stickers = 60 if 'MORE_STICKERS' in self.features else 0
more_stickers = 60 if "MORE_STICKERS" in self.features else 0
return max(more_stickers, self._PREMIUM_GUILD_LIMITS[self.premium_tier].stickers)
@property
def bitrate_limit(self) -> float:
""":class:`float`: The maximum bitrate for voice channels this guild can have."""
vip_guild = self._PREMIUM_GUILD_LIMITS[1].bitrate if 'VIP_REGIONS' in self.features else 96e3
vip_guild = self._PREMIUM_GUILD_LIMITS[1].bitrate if "VIP_REGIONS" in self.features else 96e3
return max(vip_guild, self._PREMIUM_GUILD_LIMITS[self.premium_tier].bitrate)
@property
@@ -744,15 +744,15 @@ class Guild(Hashable):
@property
def humans(self) -> List[Member]:
"""List[:class:`Member`]: A list of human members that belong to this guild.
.. versionadded:: 2.0 """
.. versionadded:: 2.0"""
return [member for member in self.members if not member.bot]
@property
def bots(self) -> List[Member]:
"""List[:class:`Member`]: A list of bots that belong to this guild.
.. versionadded:: 2.0 """
.. versionadded:: 2.0"""
return [member for member in self.members if member.bot]
def get_member(self, user_id: int, /) -> Optional[Member]:
@@ -872,21 +872,21 @@ class Guild(Hashable):
"""Optional[:class:`Asset`]: Returns the guild's banner asset, if available."""
if self._banner is None:
return None
return Asset._from_guild_image(self._state, self.id, self._banner, path='banners')
return Asset._from_guild_image(self._state, self.id, self._banner, path="banners")
@property
def splash(self) -> Optional[Asset]:
"""Optional[:class:`Asset`]: Returns the guild's invite splash asset, if available."""
if self._splash is None:
return None
return Asset._from_guild_image(self._state, self.id, self._splash, path='splashes')
return Asset._from_guild_image(self._state, self.id, self._splash, path="splashes")
@property
def discovery_splash(self) -> Optional[Asset]:
"""Optional[:class:`Asset`]: Returns the guild's discovery splash asset, if available."""
if self._discovery_splash is None:
return None
return Asset._from_guild_image(self._state, self.id, self._discovery_splash, path='discovery-splashes')
return Asset._from_guild_image(self._state, self.id, self._discovery_splash, path="discovery-splashes")
@property
def member_count(self) -> int:
@@ -910,7 +910,7 @@ class Guild(Hashable):
If this value returns ``False``, then you should request for
offline members.
"""
count = getattr(self, '_member_count', None)
count = getattr(self, "_member_count", None)
if count is None:
return False
return count == len(self._members)
@@ -957,7 +957,7 @@ class Guild(Hashable):
result = None
members = self.members
if len(name) > 5 and name[-5] == '#':
if len(name) > 5 and name[-5] == "#":
# The 5 length is checking to see if #0000 is in the string,
# as a#0000 has a length of 6, the minimum for a potential
# discriminator lookup.
@@ -985,20 +985,20 @@ class Guild(Hashable):
if overwrites is MISSING:
overwrites = {}
elif not isinstance(overwrites, dict):
raise InvalidArgument('overwrites parameter expects a dict.')
raise InvalidArgument("overwrites parameter expects a dict.")
perms = []
for target, perm in overwrites.items():
if not isinstance(perm, PermissionOverwrite):
raise InvalidArgument(f'Expected PermissionOverwrite received {perm.__class__.__name__}')
raise InvalidArgument(f"Expected PermissionOverwrite received {perm.__class__.__name__}")
allow, deny = perm.pair()
payload = {'allow': allow.value, 'deny': deny.value, 'id': target.id}
payload = {"allow": allow.value, "deny": deny.value, "id": target.id}
if isinstance(target, Role):
payload['type'] = abc._Overwrites.ROLE
payload["type"] = abc._Overwrites.ROLE
else:
payload['type'] = abc._Overwrites.MEMBER
payload["type"] = abc._Overwrites.MEMBER
perms.append(payload)
@@ -1099,16 +1099,16 @@ class Guild(Hashable):
options = {}
if position is not MISSING:
options['position'] = position
options["position"] = position
if topic is not MISSING:
options['topic'] = topic
options["topic"] = topic
if slowmode_delay is not MISSING:
options['rate_limit_per_user'] = slowmode_delay
options["rate_limit_per_user"] = slowmode_delay
if nsfw is not MISSING:
options['nsfw'] = nsfw
options["nsfw"] = nsfw
data = await self._create_channel(
name, overwrites=overwrites, channel_type=ChannelType.text, category=category, reason=reason, **options
@@ -1183,19 +1183,19 @@ class Guild(Hashable):
"""
options = {}
if position is not MISSING:
options['position'] = position
options["position"] = position
if bitrate is not MISSING:
options['bitrate'] = bitrate
options["bitrate"] = bitrate
if user_limit is not MISSING:
options['user_limit'] = user_limit
options["user_limit"] = user_limit
if rtc_region is not MISSING:
options['rtc_region'] = None if rtc_region is None else str(rtc_region)
options["rtc_region"] = None if rtc_region is None else str(rtc_region)
if video_quality_mode is not MISSING:
options['video_quality_mode'] = video_quality_mode.value
options["video_quality_mode"] = video_quality_mode.value
data = await self._create_channel(
name, overwrites=overwrites, channel_type=ChannelType.voice, category=category, reason=reason, **options
@@ -1258,13 +1258,18 @@ class Guild(Hashable):
"""
options: Dict[str, Any] = {
'topic': topic,
"topic": topic,
}
if position is not MISSING:
options['position'] = position
options["position"] = position
data = await self._create_channel(
name, overwrites=overwrites, channel_type=ChannelType.stage_voice, category=category, reason=reason, **options
name,
overwrites=overwrites,
channel_type=ChannelType.stage_voice,
category=category,
reason=reason,
**options,
)
channel = StageChannel(state=self._state, guild=self, data=data)
@@ -1305,7 +1310,7 @@ class Guild(Hashable):
"""
options: Dict[str, Any] = {}
if position is not MISSING:
options['position'] = position
options["position"] = position
data = await self._create_channel(
name, overwrites=overwrites, channel_type=ChannelType.category, reason=reason, **options
@@ -1480,108 +1485,108 @@ class Guild(Hashable):
fields: Dict[str, Any] = {}
if name is not MISSING:
fields['name'] = name
fields["name"] = name
if description is not MISSING:
fields['description'] = description
fields["description"] = description
if preferred_locale is not MISSING:
fields['preferred_locale'] = preferred_locale
fields["preferred_locale"] = preferred_locale
if afk_timeout is not MISSING:
fields['afk_timeout'] = afk_timeout
fields["afk_timeout"] = afk_timeout
if icon is not MISSING:
if icon is None:
fields['icon'] = icon
fields["icon"] = icon
else:
fields['icon'] = utils._bytes_to_base64_data(icon)
fields["icon"] = utils._bytes_to_base64_data(icon)
if banner is not MISSING:
if banner is None:
fields['banner'] = banner
fields["banner"] = banner
else:
fields['banner'] = utils._bytes_to_base64_data(banner)
fields["banner"] = utils._bytes_to_base64_data(banner)
if splash is not MISSING:
if splash is None:
fields['splash'] = splash
fields["splash"] = splash
else:
fields['splash'] = utils._bytes_to_base64_data(splash)
fields["splash"] = utils._bytes_to_base64_data(splash)
if discovery_splash is not MISSING:
if discovery_splash is None:
fields['discovery_splash'] = discovery_splash
fields["discovery_splash"] = discovery_splash
else:
fields['discovery_splash'] = utils._bytes_to_base64_data(discovery_splash)
fields["discovery_splash"] = utils._bytes_to_base64_data(discovery_splash)
if default_notifications is not MISSING:
if not isinstance(default_notifications, NotificationLevel):
raise InvalidArgument('default_notifications field must be of type NotificationLevel')
fields['default_message_notifications'] = default_notifications.value
raise InvalidArgument("default_notifications field must be of type NotificationLevel")
fields["default_message_notifications"] = default_notifications.value
if afk_channel is not MISSING:
if afk_channel is None:
fields['afk_channel_id'] = afk_channel
fields["afk_channel_id"] = afk_channel
else:
fields['afk_channel_id'] = afk_channel.id
fields["afk_channel_id"] = afk_channel.id
if system_channel is not MISSING:
if system_channel is None:
fields['system_channel_id'] = system_channel
fields["system_channel_id"] = system_channel
else:
fields['system_channel_id'] = system_channel.id
fields["system_channel_id"] = system_channel.id
if rules_channel is not MISSING:
if rules_channel is None:
fields['rules_channel_id'] = rules_channel
fields["rules_channel_id"] = rules_channel
else:
fields['rules_channel_id'] = rules_channel.id
fields["rules_channel_id"] = rules_channel.id
if public_updates_channel is not MISSING:
if public_updates_channel is None:
fields['public_updates_channel_id'] = public_updates_channel
fields["public_updates_channel_id"] = public_updates_channel
else:
fields['public_updates_channel_id'] = public_updates_channel.id
fields["public_updates_channel_id"] = public_updates_channel.id
if owner is not MISSING:
if self.owner_id != self._state.self_id:
raise InvalidArgument('To transfer ownership you must be the owner of the guild.')
raise InvalidArgument("To transfer ownership you must be the owner of the guild.")
fields['owner_id'] = owner.id
fields["owner_id"] = owner.id
if region is not MISSING:
fields['region'] = str(region)
fields["region"] = str(region)
if verification_level is not MISSING:
if not isinstance(verification_level, VerificationLevel):
raise InvalidArgument('verification_level field must be of type VerificationLevel')
raise InvalidArgument("verification_level field must be of type VerificationLevel")
fields['verification_level'] = verification_level.value
fields["verification_level"] = verification_level.value
if explicit_content_filter is not MISSING:
if not isinstance(explicit_content_filter, ContentFilter):
raise InvalidArgument('explicit_content_filter field must be of type ContentFilter')
raise InvalidArgument("explicit_content_filter field must be of type ContentFilter")
fields['explicit_content_filter'] = explicit_content_filter.value
fields["explicit_content_filter"] = explicit_content_filter.value
if system_channel_flags is not MISSING:
if not isinstance(system_channel_flags, SystemChannelFlags):
raise InvalidArgument('system_channel_flags field must be of type SystemChannelFlags')
raise InvalidArgument("system_channel_flags field must be of type SystemChannelFlags")
fields['system_channel_flags'] = system_channel_flags.value
fields["system_channel_flags"] = system_channel_flags.value
if community is not MISSING:
features = []
if community:
if 'rules_channel_id' in fields and 'public_updates_channel_id' in fields:
features.append('COMMUNITY')
if "rules_channel_id" in fields and "public_updates_channel_id" in fields:
features.append("COMMUNITY")
else:
raise InvalidArgument(
'community field requires both rules_channel and public_updates_channel fields to be provided'
"community field requires both rules_channel and public_updates_channel fields to be provided"
)
fields['features'] = features
fields["features"] = features
data = await http.edit_guild(self.id, reason=reason, **fields)
return Guild(data=data, state=self._state)
@@ -1612,9 +1617,9 @@ class Guild(Hashable):
data = await self._state.http.get_all_guild_channels(self.id)
def convert(d):
factory, ch_type = _guild_channel_factory(d['type'])
factory, ch_type = _guild_channel_factory(d["type"])
if factory is None:
raise InvalidData('Unknown channel type {type} for channel ID {id}.'.format_map(d))
raise InvalidData("Unknown channel type {type} for channel ID {id}.".format_map(d))
channel = factory(guild=self, state=self._state, data=d)
return channel
@@ -1641,10 +1646,10 @@ class Guild(Hashable):
The active threads
"""
data = await self._state.http.get_active_threads(self.id)
threads = [Thread(guild=self, state=self._state, data=d) for d in data.get('threads', [])]
threads = [Thread(guild=self, state=self._state, data=d) for d in data.get("threads", [])]
thread_lookup: Dict[int, Thread] = {thread.id: thread for thread in threads}
for member in data.get('members', []):
thread = thread_lookup.get(int(member['id']))
for member in data.get("members", []):
thread = thread_lookup.get(int(member["id"]))
if thread is not None:
thread._add_member(ThreadMember(parent=thread, data=member))
@@ -1700,7 +1705,7 @@ class Guild(Hashable):
"""
if not self._state._intents.members:
raise ClientException('Intents.members must be enabled to use this.')
raise ClientException("Intents.members must be enabled to use this.")
return MemberIterator(self, limit=limit, after=after)
@@ -1791,7 +1796,7 @@ class Guild(Hashable):
The :class:`BanEntry` object for the specified user.
"""
data: BanPayload = await self._state.http.get_ban(user.id, self.id)
return BanEntry(user=User(state=self._state, data=data['user']), reason=data['reason'])
return BanEntry(user=User(state=self._state, data=data["user"]), reason=data["reason"])
async def fetch_channel(self, channel_id: int, /) -> Union[GuildChannel, Thread]:
"""|coro|
@@ -1824,16 +1829,16 @@ class Guild(Hashable):
"""
data = await self._state.http.get_channel(channel_id)
factory, ch_type = _threaded_guild_channel_factory(data['type'])
factory, ch_type = _threaded_guild_channel_factory(data["type"])
if factory is None:
raise InvalidData('Unknown channel type {type} for channel ID {id}.'.format_map(data))
raise InvalidData("Unknown channel type {type} for channel ID {id}.".format_map(data))
if ch_type in (ChannelType.group, ChannelType.private):
raise InvalidData('Channel ID resolved to a private channel')
raise InvalidData("Channel ID resolved to a private channel")
guild_id = int(data['guild_id'])
guild_id = int(data["guild_id"])
if self.id != guild_id:
raise InvalidData('Guild ID resolved to a different guild')
raise InvalidData("Guild ID resolved to a different guild")
channel: GuildChannel = factory(guild=self, state=self._state, data=data) # type: ignore
return channel
@@ -1860,7 +1865,7 @@ class Guild(Hashable):
"""
data: List[BanPayload] = await self._state.http.get_bans(self.id)
return [BanEntry(user=User(state=self._state, data=e['user']), reason=e['reason']) for e in data]
return [BanEntry(user=User(state=self._state, data=e["user"]), reason=e["reason"]) for e in data]
async def prune_members(
self,
@@ -1920,7 +1925,7 @@ class Guild(Hashable):
"""
if not isinstance(days, int):
raise InvalidArgument(f'Expected int for ``days``, received {days.__class__.__name__} instead.')
raise InvalidArgument(f"Expected int for ``days``, received {days.__class__.__name__} instead.")
if roles:
role_ids = [str(role.id) for role in roles]
@@ -1930,7 +1935,7 @@ class Guild(Hashable):
data = await self._state.http.prune_members(
self.id, days, compute_prune_count=compute_prune_count, roles=role_ids, reason=reason
)
return data['pruned']
return data["pruned"]
async def templates(self) -> List[Template]:
"""|coro|
@@ -2012,7 +2017,7 @@ class Guild(Hashable):
"""
if not isinstance(days, int):
raise InvalidArgument(f'Expected int for ``days``, received {days.__class__.__name__} instead.')
raise InvalidArgument(f"Expected int for ``days``, received {days.__class__.__name__} instead.")
if roles:
role_ids = [str(role.id) for role in roles]
@@ -2020,7 +2025,7 @@ class Guild(Hashable):
role_ids = []
data = await self._state.http.estimate_pruned_members(self.id, days, role_ids)
return data['pruned']
return data["pruned"]
async def invites(self) -> List[Invite]:
"""|coro|
@@ -2046,7 +2051,7 @@ class Guild(Hashable):
data = await self._state.http.invites_from(self.id)
result = []
for invite in data:
channel = self.get_channel(int(invite['channel']['id']))
channel = self.get_channel(int(invite["channel"]["id"]))
result.append(Invite(state=self._state, data=invite, guild=self, channel=channel))
return result
@@ -2070,10 +2075,10 @@ class Guild(Hashable):
"""
from .template import Template
payload = {'name': name}
payload = {"name": name}
if description:
payload['description'] = description
payload["description"] = description
data = await self._state.http.create_template(self.id, payload)
@@ -2130,9 +2135,9 @@ class Guild(Hashable):
data = await self._state.http.get_all_integrations(self.id)
def convert(d):
factory, _ = _integration_factory(d['type'])
factory, _ = _integration_factory(d["type"])
if factory is None:
raise InvalidData('Unknown integration type {type!r} for integration ID {id}'.format_map(d))
raise InvalidData("Unknown integration type {type!r} for integration ID {id}".format_map(d))
return factory(guild=self, data=d)
return [convert(d) for d in data]
@@ -2237,20 +2242,20 @@ class Guild(Hashable):
The created sticker.
"""
payload = {
'name': name,
"name": name,
}
if description:
payload['description'] = description
payload["description"] = description
try:
emoji = unicodedata.name(emoji)
except TypeError:
pass
else:
emoji = emoji.replace(' ', '_')
emoji = emoji.replace(" ", "_")
payload['tags'] = emoji
payload["tags"] = emoji
data = await self._state.http.create_guild_sticker(self.id, payload, file, reason)
return self._state.store_sticker(self, data)
@@ -2517,24 +2522,24 @@ class Guild(Hashable):
"""
fields: Dict[str, Any] = {}
if permissions is not MISSING:
fields['permissions'] = str(permissions.value)
fields["permissions"] = str(permissions.value)
else:
fields['permissions'] = '0'
fields["permissions"] = "0"
actual_colour = colour or color or Colour.default()
if isinstance(actual_colour, int):
fields['color'] = actual_colour
fields["color"] = actual_colour
else:
fields['color'] = actual_colour.value
fields["color"] = actual_colour.value
if hoist is not MISSING:
fields['hoist'] = hoist
fields["hoist"] = hoist
if mentionable is not MISSING:
fields['mentionable'] = mentionable
fields["mentionable"] = mentionable
if name is not MISSING:
fields['name'] = name
fields["name"] = name
data = await self._state.http.create_role(self.id, reason=reason, **fields)
role = Role(guild=self, data=data, state=self._state)
@@ -2587,12 +2592,12 @@ class Guild(Hashable):
A list of all the roles in the guild.
"""
if not isinstance(positions, dict):
raise InvalidArgument('positions parameter expects a dict.')
raise InvalidArgument("positions parameter expects a dict.")
role_positions: List[Dict[str, Any]] = []
for role, position in positions.items():
payload = {'id': role.id, 'position': position}
payload = {"id": role.id, "position": position}
role_positions.append(payload)
@@ -2665,16 +2670,16 @@ class Guild(Hashable):
The edited welcome screen.
"""
try:
welcome_channels = kwargs['welcome_channels']
welcome_channels = kwargs["welcome_channels"]
except KeyError:
pass
else:
welcome_channels_serialised = []
for wc in welcome_channels:
if not isinstance(wc, WelcomeChannel):
raise InvalidArgument('welcome_channels parameter must be a list of WelcomeChannel')
raise InvalidArgument("welcome_channels parameter must be a list of WelcomeChannel")
welcome_channels_serialised.append(wc.to_dict())
kwargs['welcome_channels'] = welcome_channels_serialised
kwargs["welcome_channels"] = welcome_channels_serialised
if kwargs:
data = await self._state.http.edit_welcome_screen(self.id, kwargs)
@@ -2793,19 +2798,19 @@ class Guild(Hashable):
# we start with { code: abc }
payload = await self._state.http.get_vanity_code(self.id)
if not payload['code']:
if not payload["code"]:
return None
# get the vanity URL channel since default channels aren't
# reliable or a thing anymore
data = await self._state.http.get_invite(payload['code'])
data = await self._state.http.get_invite(payload["code"])
channel = self.get_channel(int(data['channel']['id']))
payload['revoked'] = False
payload['temporary'] = False
payload['max_uses'] = 0
payload['max_age'] = 0
payload['uses'] = payload.get('uses', 0)
channel = self.get_channel(int(data["channel"]["id"]))
payload["revoked"] = False
payload["temporary"] = False
payload["max_uses"] = 0
payload["max_age"] = 0
payload["uses"] = payload.get("uses", 0)
return Invite(state=self._state, data=payload, guild=self, channel=channel)
# TODO: use MISSING when async iterators get refactored
@@ -2882,7 +2887,13 @@ class Guild(Hashable):
action = action.value
return AuditLogIterator(
self, before=before, after=after, limit=limit, oldest_first=oldest_first, user_id=user_id, action_type=action
self,
before=before,
after=after,
limit=limit,
oldest_first=oldest_first,
user_id=user_id,
action_type=action,
)
async def widget(self) -> Widget:
@@ -2936,9 +2947,9 @@ class Guild(Hashable):
"""
payload = {}
if channel is not MISSING:
payload['channel_id'] = None if channel is None else channel.id
payload["channel_id"] = None if channel is None else channel.id
if enabled is not MISSING:
payload['enabled'] = enabled
payload["enabled"] = enabled
await self._state.http.edit_widget(self.id, payload=payload)
@@ -2964,7 +2975,7 @@ class Guild(Hashable):
"""
if not self._state._intents.members:
raise ClientException('Intents.members must be enabled to use this.')
raise ClientException("Intents.members must be enabled to use this.")
if not self._state.is_guild_evicted(self):
return await self._state.chunk_guild(self, cache=cache)
@@ -3025,20 +3036,20 @@ class Guild(Hashable):
"""
if presences and not self._state._intents.presences:
raise ClientException('Intents.presences must be enabled to use this.')
raise ClientException("Intents.presences must be enabled to use this.")
if query is None:
if query == '':
raise ValueError('Cannot pass empty query string.')
if query == "":
raise ValueError("Cannot pass empty query string.")
if user_ids is None:
raise ValueError('Must pass either query or user_ids')
raise ValueError("Must pass either query or user_ids")
if user_ids is not None and query is not None:
raise ValueError('Cannot pass both query and user_ids')
raise ValueError("Cannot pass both query and user_ids")
if user_ids is not None and not user_ids:
raise ValueError('user_ids must contain at least 1 value')
raise ValueError("user_ids must contain at least 1 value")
limit = min(100, limit or 5)
return await self._state.query_members(