Python discord 模块,TextChannel() 实例源码
我们从Python开源项目中,提取了以下50个代码示例,用于说明如何使用discord.TextChannel()。
def nostalgia(self, ctx, date: date = None, *, channel: discord.TextChannel = None):
"""Pins an old message from a specific date.
If a date is not given,then pins first message from the channel.
If a channel is not given,then pins from the channel the
command was ran on.
The format of the date must be either YYYY-MM-DD or YYYY/MM/DD.
"""
if channel is None:
channel = ctx.channel
if date is None:
date = channel.created_at
async for m in ctx.history(after=date, limit=1):
try:
await m.pin()
except:
await ctx.send('\N{THUMBS DOWN SIGN} Could not pin message.')
def dad_jokes(message, match):
name = ' '.join(match.group(5).replace('@everyone', '@\N{ZERO WIDTH SPACE}everyone').replace('@here', '@\N{ZERO WIDTH SPACE}here').split()[0:4])
if name.startswith((',', '.', '!')):
name = name[1:].lstrip()
for mem in message.mentions:
name = name.replace(mem.mention, [sub for sub in [mem.display_name, mem.name, '<\\@%s>' % mem.id] if '<@' not in sub][0])
for role in message.role_mentions:
name = name.replace(role.mention, role.name if '<@' not in role.name else '<\\@&%s>' % role.id)
response = await message.channel.send('Hello **%s**,I\'m %s!' % (name, message.guild.me.display_name if isinstance(message.channel, discord.TextChannel) else message.channel.me.display_name))
try:
await bot.wait_for('message_delete', check=lambda m: m == message, timeout=60)
except asyncio.TimeoutError:
pass
else:
await response.delete()
### LONGCAT
def afk_send(ctx, message_key, *args, **kwargs):
global afk_targets
if afk_targets is None:
afk_targets = {channel.id: channel for channel in ctx.bot.get_all_channels() if isinstance(channel, discord.TextChannel)}
afk_targets.update({mem.id: mem for mem in ctx.bot.get_all_members() if mem.bot})
for info in ctx.bot.config['afk_messages']:
if message_key in info:
trigger = await afk_targets[info['dest']].send(info[message_key].format(*args, **kwargs))
try:
response = await ctx.bot.wait_for('message', check=lambda m: m.channel == trigger.channel, timeout=10)
await response.ack()
except asyncio.TimeoutError:
pass
await ctx.message.delete()
def create_reminder(self, due, note):
cid = ctx.channel.id if isinstance(ctx.channel, discord.TextChannel) else ctx.author.id
await self.bot.pgpool.execute(
"""
INSERT INTO reminders
(author_id,channel_id,note,due)
VALUES ($1,$2,$3,$4)
""",
ctx.author.id, cid, note, due
)
logger.debug('Creating reminder -- due=%s note=%s cid=%d aid=%d', ctx.author.id)
# we just created a reminder,we definitely have one Now!
self.queue.has_item.set()
# check if it's earlier
if self.queue.current_item and self.queue.current_item['due'] > due:
logger.debug('Got a reminder that is due earlier than the current one,rebooting task!')
self.queue.reboot()
def watch(self, channel: discord.TextChannel, subreddit: str):
"""
Sets up a channel for me to forward hot posts to,from a subreddit of your choosing.
Only Dogbot Moderators may use this command.
"""
# check that there isn't too many Feeds
async with self.bot.pgpool.acquire() as conn:
count = (await conn.fetchrow('SELECT COUNT(*) FROM reddit_Feeds WHERE guild_id = $1', ctx.guild.id))['count']
logger.debug('Guild %s (%d) has %d Feeds', ctx.guild.name, ctx.guild.id, count)
if count >= 2:
# they have 2 Feeds,which is the max
return await ctx.send(
f'You have too many Feeds! You can only have two at a time. Use `{ctx.prefix}reddit Feeds` '
'check the Feeds in this server.'
)
await conn.execute('INSERT INTO reddit_Feeds VALUES ($1,$3)', channel.id, subreddit)
await ctx.ok()
def is_publicly_visible(bot: Dogbot, channel: discord.TextChannel) -> bool:
"""
Returns whether a text channel should be considered as "publicly visible".
If the guild has been configured to log all message events,this will always return True.
Args:
bot: The bot instance.
channel: The channel to check for.
Returns:
Whether the text channel is considered "publicly visible".
"""
# guild is configured to log all message events
if await bot.config_is_set(channel.guild, 'log_all_message_events'):
return True
# find the @everyone overwrite for the channel
everyone_overwrite = discord.utils.find(lambda t: t[0].name == '@everyone', channel.overwrites)
return everyone_overwrite is None or everyone_overwrite[1].read_messages is not False
def _display_plonked(self, entries, plonk):
# things = channels,members
colour, action = _plonk_embed_mappings[plonk]
embed = (discord.Embed(colour=colour)
.set_author(name=f'{action.title()} successful!', icon_url=PLONK_ICON)
)
for thing in map(list, partition(lambda e: isinstance(e, discord.TextChannel), entries)):
if not thing:
continue
name = f'{_get_class_name(thing[0])}{"s" * (len(thing) != 1)} {action}ed'
value = truncate(','.join(map(str, thing)), 1024, '...')
embed.add_field(name=name, value=value, inline=False)
await ctx.send(embed=embed)
def modattach(self, memberlog: discord.TextChannel, modlog: discord.TextChannel):
"""Attach channels to the moderation system"""
modconfig = await self.modcfg_get(ctx.guild)
if modconfig is not None:
raise self.SayException('Mod config already exists.')
modconfig = {
'guild_id': ctx.guild.id,
'member_log_id': memberlog.id,
'mod_log_id': modlog.id,
'last_action_id': 0,
}
log.info('[modlog:attach] Creating a modcfg @ g=%s[gid=%d]',
ctx.guild.name, ctx.guild.id)
res = await self.modcfg_coll.insert_one(modconfig)
await ctx.success(res.ackNowledged)
def starattach(self, starboard_chan: discord.TextChannel):
"""Attach an existing channel as a starboard.
With this command you can create your starboard
without needing José to automatically create the starboard for you
"""
config = await self.get_starconfig(ctx.guild.id)
if config:
return await ctx.send('You already have a starboard config setup.')
config = empty_starconfig(ctx.guild)
config['starboard_id'] = starboard_chan.id
res = await self.starconfig_coll.insert_one(config)
if not res.ackNowledged:
raise self.SayException('Failed to create starboard config (no ack)')
return
await ctx.send('Done!')
await ctx.ok()
def mentionspam_ignore(self, *channels: discord.TextChannel):
"""Specifies what channels ignore mentionspam auto-bans.
If a channel is given then that channel will no longer be protected
by auto-banning from mention spammers.
To use this command you must have the Ban Members permission.
"""
query = """UPDATE guild_mod_config
SET safe_mention_channel_ids =
ARRAY(SELECT disTINCT * FROM unnest(COALESCE(safe_mention_channel_ids,'{}') || $2::bigint[]))
WHERE id = $1;
"""
if len(channels) == 0:
return await ctx.send('Missing channels to ignore.')
channel_ids = [c.id for c in channels]
await ctx.db.execute(query, channel_ids)
self.get_guild_settings.invalidate(self, ctx.guild.id)
await ctx.send(f'Mentions are Now ignored on {",".join(c.mention for c in channels)}.')
def mentionspam_unignore(self, *channels: discord.TextChannel):
"""Specifies what channels to take off the ignore list.
To use this command you must have the Ban Members permission.
"""
if len(channels) == 0:
return await ctx.send('Missing channels to protect.')
query = """UPDATE guild_mod_config
SET safe_mention_channel_ids =
ARRAY(SELECT element FROM unnest(safe_mention_channel_ids) AS element
WHERE NOT(element = ANY($2::bigint[])))
WHERE id = $1;
"""
await ctx.db.execute(query, [c.id for c in channels])
self.get_guild_settings.invalidate(self, ctx.guild.id)
await ctx.send('Updated mentionspam ignore list.')
def reaction_action(self, fmt, emoji, message_id, channel_id, user_id):
if str(emoji) != '\N{WHITE MEDIUM STAR}':
return
channel = self.bot.get_channel(channel_id)
if not isinstance(channel, discord.TextChannel):
return
method = getattr(self, f'{fmt}_message')
user = self.bot.get_user(user_id)
if user is None or user.bot:
return
async with self.bot.pool.acquire() as con:
config = self.bot.get_cog('Config')
if config:
plonked = await config.is_plonked(channel.guild.id, user_id, channel_id=channel_id, connection=con)
if plonked:
return
try:
await method(channel, connection=con)
except StarError:
pass
def on_raw_message_delete(self, channel_id):
if message_id in self._about_to_be_deleted:
# we triggered this deletion ourselves and
# we don't need to drop it from the database
self._about_to_be_deleted.discard(message_id)
return
channel = self.bot.get_channel(channel_id)
if channel is None or not isinstance(channel, discord.TextChannel):
return
starboard = await self.get_starboard(channel.guild.id)
if starboard.channel is None or starboard.channel.id != channel_id:
return
# at this point a message got deleted in the starboard
# so just delete it from the database
async with self.bot.pool.acquire() as con:
query = "DELETE FROM starboard_entries WHERE bot_message_id=$1;"
await con.execute(query, message_id)
def on_raw_bulk_message_delete(self, message_ids, channel_id):
if message_ids <= self._about_to_be_deleted:
# see comment above
self._about_to_be_deleted.difference_update(message_ids)
return
channel = self.bot.get_channel(channel_id)
if channel is None or not isinstance(channel, discord.TextChannel):
return
starboard = await self.get_starboard(channel.guild.id)
if starboard.channel is None or starboard.channel.id != channel_id:
return
async with self.bot.pool.acquire() as con:
query = "DELETE FROM starboard_entries WHERE bot_message_id=ANY($1::bigint[]);"
await con.execute(query, list(message_ids))
def on_raw_reaction_clear(self, channel_id):
channel = self.bot.get_channel(channel_id)
if channel is None or not isinstance(channel, discord.TextChannel):
return
async with self.bot.pool.acquire() as con:
starboard = await self.get_starboard(channel.guild.id, connection=con)
if starboard.channel is None:
return
query = "DELETE FROM starboard_entries WHERE message_id=$1 RETURNING bot_message_id;"
bot_message_id = await con.fetchrow(query, message_id)
if bot_message_id is None:
return
bot_message_id = bot_message_id[0]
msg = await self.get_message(starboard.channel, bot_message_id)
if msg is not None:
await msg.delete()
def nostalgia(self, date: date, channel: discord.TextChannel = None):
"""Pins an old message from a specific date.
If a channel is not given,then pins from the channel the
command was ran on.
The format of the date must be either YYYY-MM-DD or YYYY/MM/DD.
"""
channel = channel or ctx.channel
message = await channel.history(after=date, limit=1).flatten()
if len(message) == 0:
return await ctx.send('Could not find message.')
message = message[0]
try:
await message.pin()
except discord.HTTPException:
await ctx.send('Could not pin message.')
else:
await ctx.send('Pinned message.')
def on_guild_channel_update(self, before, after):
self._log_ignored(f"Channel was updated in guild {after.guild.id}")
if not await self._accept_channel(after):
return
if before.name != after.name:
changed = f' (Now {after.name})'
else:
changed = ''
if isinstance(after, discord.TextChannel):
self.logger.info(f"Channel #{before.name}{changed} was changed in {after.guild.name}")
with self.sql.transaction() as trans:
self.sql.update_channel(trans, after)
# pylint: disable=not-callable
hook = self.hooks['on_guild_channel_update']
if hook:
self.logger.debug(f"Found hook {hook!r},calling it")
await hook(before, after)
elif isinstance(after, discord.VoiceChannel):
self.logger.info("Voice channel {before.name}{changed} was changed in {after.guild.name}")
with self.sql.transaction() as trans:
self.sql.update_voice_channel(trans, discord.CategoryChannel):
self.logger.info(f"Channel category {before.name}{changed} was changed in {after.guild.name}")
with self.sql.transaction() as trans:
self.sql.update_channel_category(trans, after)
def lol(ctx):
if ctx.message.guild.id == 213468583252983809:
msg = await ctx.send("Searching channels... (this may take a while)")
l = 0
for c in ctx.message.guild.channels:
if isinstance(c, discord.TextChannel):
if c.permissions_for(ctx.message.guild.me).read_messages:
async for m in c.history():
if m.author.id == 132584525296435200 and "lol" in m.content.lower():
l = l+1
await msg.edit(content="lars' total lol counter so far is: `{}`".format(l))
# force update
def link(self, text: discord.TextChannel, voice: discord.VoiceChannel):
"""Links an existing text channel to a voice channel."""
with ctx.session:
link = ctx.session.get(TextVoiceLink, text_id=text.id, voice_id=voice.id).one_or_none()
if link is not None:
return await ctx.send('BAKA! Those channels are already linked!')
role = await self._create_role(ctx.guild, text, voice, 'Voice link requested by {}'.format(ctx.author))
link = ctx.session.add(TextVoiceLink(role_id=role.id, voice_id=voice.id))
await ctx.send(content='Linked {} to "{}"'.format(text.mention, voice.name))
def unlink(self, voice: discord.VoiceChannel):
"""Unlinks a voice channel and deletes the corresponding role."""
with ctx.session:
link = ctx.session.get(TextVoiceLink, voice_id=voice.id).one_or_none()
if link is None:
return await ctx.send('BAKA! Those channels are not linked!')
role_id, text_id, voice_id = link.role_id, link.text_id, link.voice_id
ctx.session.delete(link)
role = discord.utils.get(ctx.guild.roles, id=role_id)
if role is None:
await ctx.send(content='Unlinked {} from "{}" and deleted the "{}" role.'.format(text.mention, voice.name, role.name))
else:
await self._delete_role(ctx.guild, role, 'Voice unlink requested by {}'.format(ctx.author))
await ctx.send(content='Unlinked {} from "{}" and deleted the "{}" role.'.format(text.mention, role.name))
def on_command_error(self, err):
if isinstance(err, errors.PermissionDenied):
await ctx.send('BAKA! You do not have my permission!')
elif isinstance(err, errors.MissingPermissions):
await ctx.send('BAKA! I require these permissions: %s' % ','.join(err.args))
elif isinstance(err, commands.noprivateMessage):
await ctx.send('BAKA! This command does not work in private messages!')
elif isinstance(err, commands.BadArgument):
str_err = str(err)
if not str_err.endswith(('.', '!')):
str_err += '.'
await ctx.send('BAKA! %s' % str_err)
elif isinstance(err, commands.MissingrequiredArgument):
await ctx.send('BAKA! Missing required argument: `%s`' % err.args[0].partition(' ')[0])
elif isinstance(err, commands.TooManyArguments):
await ctx.send('BAKA! Too many arguments!')
elif isinstance(err, commands.CommandNotFound):
pass
else:
await ctx.send('```\n%s\n```' % ''.join(traceback.format_exception_only(type(err), err)).strip())
if isinstance(ctx.channel, discord.TextChannel):
log.error('Error in command <{0}> ({1.name!r}({1.id}) {2}({2.id}) {3}({3.id}) {4!r})'.format(ctx.command, ctx.guild, ctx.channel, ctx.author, ctx.message.content))
else:
log.error('Error in command <{0}> (DM {1}({1.id}) {2!r})'.format(ctx.command, ctx.channel.recipient, ctx.message.content))
log.error(''.join(traceback.format_exception(type(err), err, err.__traceback__)))
def channelinfo(self, channel: discord.TextChannel=None):
"""display information about a text channel.
Defaults to the current channel.
* channel - Optional argument. A specific channel to get information about."""
# If channel is None,then it is set to ctx.channel.
channel = channel or ctx.channel
embed = discord.Embed(title=f"{channel.name}")
try:
embed.description = channel.topic
except AttributeError:
pass
embed.add_field(name="Channel ID", value=channel.id)
try:
embed.add_field(name="Guild", value=channel.guild.name)
except AttributeError:
pass
embed.add_field(name="Members", value=len(channel.members))
embed.add_field(name="Created at", value=channel.created_at.ctime())
if channel.is_nsfw():
embed.set_footer(text="NSFW content is allowed for this channel.")
await ctx.send(embed=embed)
def c4_enable(self, chan: discord.TextChannel=None):
"""Enable Connect Four on a channel
Run without an argument to enable on the current channel
Pass a channel as an argument to enable on that channel"""
if not chan:
chan = ctx.channel
if self.db.sadd(f"{self.app_name}:c4:allowed_channels", chan.id):
await self.message(ctx, msg="Connect Four successfully enabled on channel.")
else:
await self.message(ctx, msg="Connect Four already enabled on channel.", level=1)
def c4_disable(self, chan: discord.TextChannel=None):
"""disable Connect Four on a channel
Run without an argument to disabled on the current channel
Pass a channel as an argument to disable on that channel"""
if not chan:
chan = ctx.channel
if self.db.srem(f"{self.app_name}:c4:allowed_channels", msg="Connect Four successfully disabled on channel.")
else:
await self.message(ctx, msg="Connect Four already disabled on channel.", level=1)
def on_message(message):
default_prefix = get_default_prefix()
if not isinstance(message.channel, discord.TextChannel):
bot.command_prefix = [default_prefix]
else:
guild_prefix = db.hget(f'{config}:prefix', message.guild.id)
if guild_prefix:
bot.command_prefix = [guild_prefix, default_prefix]
else:
bot.command_prefix = [default_prefix]
await bot.process_commands(message)
def check_nsfw(self):
if isinstance(self.message.channel, discord.TextChannel):
if self.cmd.nsfw:
if self.message.channel.is_nsfw():
self.nsfw_denied = False
else:
self.nsfw_denied = True
else:
self.nsfw_denied = False
else:
self.nsfw_denied = False
def count_channels(channels):
text = 0
voice = 0
categories = 0
for channel in channels:
if isinstance(channel, discord.TextChannel):
text += 1
elif isinstance(channel, discord.VoiceChannel):
voice += 1
elif isinstance(channel, discord.CategoryChannel):
categories += 1
return text, categories
def hardunmute(cmd, message, args):
if message.author.permissions_in(message.channel).manage_channels:
if message.mentions:
target = message.mentions[0]
if len(args) > 1:
reason = ' '.join(args[1:])
else:
reason = 'Not stated.'
hierarchy_me = hierarchy_permit(message.guild.me, target)
if hierarchy_me:
hierarchy_auth = hierarchy_permit(message.author, target)
if hierarchy_auth:
ongoing = discord.Embed(color=0x696969, title='? Editing permissions...')
ongoing_msg = await message.channel.send(embed=ongoing)
for channel in message.guild.channels:
if isinstance(channel, discord.TextChannel) or isinstance(channel, discord.CategoryChannel):
try:
await channel.set_permissions(target, overwrite=None, reason=reason)
except discord.Forbidden:
pass
log_embed = generate_log_embed(message, target, args)
await log_event(cmd.db, message.guild, log_embed)
title = f'? {target.display_name} has been hard-unmuted.'
response = discord.Embed(color=0x77B255, title=title)
await ongoing_msg.delete()
else:
response = discord.Embed(color=0xBE1931, title='? That user is euqal or above you.')
else:
response = discord.Embed(color=0xBE1931, title='? I can\'t mute a user equal or above me.')
else:
response = discord.Embed(color=0xBE1931, title='? No user targetted.')
else:
response = discord.Embed(title='? Access Denied. Manage Channels needed.', color=0xBE1931)
await message.channel.send(embed=response)
def quote(cmd, args):
if args:
lookup = args[0]
try:
lookup = int(lookup)
except ValueError:
lookup = None
if lookup:
msg = None
for channel in message.guild.channels:
if isinstance(channel, discord.TextChannel):
try:
msg = await channel.get_message(lookup)
break
except discord.Forbidden:
msg = None
except discord.NotFound:
msg = None
if msg:
if msg.content:
location = f'{msg.guild.name} | #{msg.channel.name}'
response = discord.Embed(color=msg.author.color, timestamp=msg.created_at)
response.set_author(name=f'{msg.author.display_name}', icon_url=user_avatar(msg.author))
response.description = msg.content
response.set_footer(text=location)
else:
response = discord.Embed(color=0xBE1931, title='? That message has no text content.')
else:
response = discord.Embed(color=0xBE1931, title='? Message not found.')
else:
response = discord.Embed(color=0xBE1931, title='? Invalid ID given.')
else:
response = discord.Embed(color=0xBE1931, title='? No ID given.')
await message.channel.send(embed=response)
def _get_recent_image(channel: discord.TextChannel) -> typing.Optional[discord.Message]:
async for msg in channel.history(limit=100):
# Scan any attached images.
for attachment in msg.attachments:
if attachment.height:
return attachment.proxy_url
# Scan any embeds in the message.
for embed in msg.embeds:
if embed.image is discord.Embed.Empty:
continue
return embed.image.proxy_url
def on_raw_bulk_message_delete(self, channel_id: int):
# add to list of bulk deletes so we don't process message delete events for these messages
self.bulk_deletes.add(message_ids=message_ids)
# resolve the channel that the message was deleted in
channel = self.bot.get_channel(channel_id)
# don't handle non-existent channels or dms
if not channel or not isinstance(channel, discord.TextChannel):
return
# log
await self.log(channel.guild, f'\U0001f6ae {len(message_ids)} message(s) deleted in {channel.mention}')
def on_message_delete(self, msg: discord.Message):
# don't handle message deletion elsewhere
if not isinstance(msg.channel, discord.TextChannel):
return
# do not process bulk message deletes,or message censors (the censor cog does that already)
# Todo: do this but cleanly,maybe paste website?
if await self.bulk_deletes.check_batch(msg.id) or await self.censored_messages.check(message_id=msg.id):
return
# if this channel isn't publicly visible or deletes shouldn't be tracked,bail
if (not await is_publicly_visible(self.bot, msg.channel) or
await self.bot.config_is_set(msg.guild, 'modlog_notrack_deletes')):
return
# if the author was a bot and we aren't configured to allow bots,return
if msg.author.bot and not await self.bot.config_is_set(msg.guild, 'modlog_filter_allow_bot'):
return
# format attachment list
attachments = 'no attachments' if not msg.attachments else f'{len(msg.attachments)} attachment(s): ' + \
','.join(f'{a.filename},{filesize(a.size)}' for a in msg.attachments)
content = utils.prevent_codeblock_breakout(utils.truncate(msg.content, 1500))
fmt = (f'\U0001f6ae Message by {describe(msg.author)} deleted in {msg.channel.mention}: ```\n{content}\n``` '
f'({attachments},{len(msg.embeds)} embed(s)')
await self.log(msg.guild, fmt)
def is_public(self, channel: discord.TextChannel=None):
"""
Checks if a channel is public.
This command is in the Modlog cog because the modlog does not process message edit and
delete events for private channels.
If you have turned 'log_all_message_events' on,this will always say public.
"""
channel = channel if channel else ctx.channel
public = f'{channel.mention} {{}} public to @\u200beveryone.'
await ctx.send(public.format('is' if await is_publicly_visible(self.bot, channel) else '**is not**'))
def guildinfo(self, ctx):
"""Get loads of info about this guild.
Usage: guildinfo"""
s = ctx.guild
ach = s.channels
chlist = [len(ach), 0, 0]
for i in ach:
if isinstance(i, discord.TextChannel):
chlist[1] += 1
else:
chlist[2] += 1
iurl = s.icon_url
s_reg = str(s.region)
r_embed = discord.Embed(color=random.randint(0, 255**3-1))
if iurl:
thing = {'url': iurl}
else:
thing = {}
r_embed.set_author(name=s.name, **thing, icon_url=(iurl if iurl else ctx.me.avatar_url))
r_embed.set_footer(text=ctx.me.display_name, icon_url=ctx.me.avatar_url)
if iurl:
r_embed.set_image(url=iurl)
r_embed.add_field(name='ID', value=s.id)
r_embed.add_field(name='Members', value=len(s.members))
r_embed.add_field(name='Channels', value=ch_fmt.format(*[str(i) for i in chlist]))
r_embed.add_field(name='Roles', value=len(s.roles))
r_embed.add_field(name='Custom Emojis', value=len(s.emojis))
r_embed.add_field(name='Region (Location)', value=str(s.region).replace('-', ' ').title().replace('Eu ', 'EU ').replace('Us ', 'US ').replace('Vip', 'VIP '))
r_embed.add_field(name='Owner', value=str(s.owner))
r_embed.add_field(name='Default Channel', value=f'<#{s.default_channel.id}>\n(#{s.default_channel.name})' if s.default_channel is not None else 'None (deleted)')
r_embed.add_field(name='Admins Need 2FA', value=('Yes' if s.mfa_level else 'No'))
r_embed.add_field(name='Verification Level', value=v_level_map[str(s.verification_level)])
await ctx.send(embed=r_embed)
def info(self, ctx):
"""Get bot info.
Usage: info"""
ach = self.bot.get_all_channels()
chlist = [0, 0]
for i in ach:
chlist[0] += 1
if isinstance(i, discord.TextChannel):
chlist[1] += 1
else:
chlist[2] += 1
up = self.bot.format_uptime()
ram = self.bot.get_ram()
got_conversion = ram[0]
emb = discord.Embed(color=random.randint(0, 255**3-1))
emb.set_author(name=ctx.me.display_name, url='https://khronodragon.com/', icon_url=ctx.me.avatar_url)
emb.set_footer(text='Made in Python 3.6+ with discord.py %s' % self.bot.lib_version, icon_url='https://upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Python-logo-notext.svg/400px-Python-logo-notext.svg.png')
emb.add_field(name='Guilds', value=len(self.bot.guilds))
emb.add_field(name='Author', value='Dragon5232#1841')
emb.add_field(name='Uptime', value=up)
emb.add_field(name='Local Time', value=time.strftime(absfmt, time.localtime()))
emb.add_field(name='Cogs Loaded', value=len(self.bot.cogs))
emb.add_field(name='Command Calls', value=sum(self.bot.command_calls.values()))
emb.add_field(name='Memory Used', value=(str(round(ram[1], 1)) + ' MB (%s MiB)' % str(round(ram[2], 1))) if got_conversion else 'Couldn\'t fetch')
emb.add_field(name='Members Seen', value=sum(g.member_count for g in self.bot.guilds))
emb.add_field(name='Channels', value=ch_fmt.format(*[str(i) for i in chlist]))
emb.add_field(name='Custom Emojis', value=len(self.bot.emojis))
emb.add_field(name='Commands', value=str(len(self.bot.all_commands)))
emb.add_field(name='ID', value=ctx.me.id)
if self.bot.user.id == 239775420470394897:
emb.add_field(name='Invite Link', value='https://tiny.cc/goldbot')
await ctx.send(home_broadcast, embed=emb)
def _add_command(self, username: str = None, channel: discord.TextChannel = None):
"""add command"""
username = await self.validate_username(username)
channel = await validate_notification_channel(ctx, channel)
async with ctx.typing():
subscriber = Subscriber(channel or ctx.author)
await self._subscribe_to_streamer(subscriber, username)
await ctx.send(f'{subscriber} subscribed to {username} successfully!')
def _del_command(self, channel: discord.TextChannel = None):
"""del command"""
username = await self.validate_username(username)
channel = await validate_notification_channel(ctx, channel)
async with ctx.typing():
subscriber = Subscriber(channel or ctx.author)
await self._del_subscription(subscriber, username)
await ctx.send(f'{subscriber} unsubscribed to {username} successfully!')
def _list_command(self, channel: discord.TextChannel = None):
"""list command"""
channel = await validate_notification_channel(ctx, channel)
subscriber = Subscriber(channel or ctx.author)
async with ctx.typing():
streamers = await self.bot.database.get_subscriptions_from_subscriber(subscriber.id, self.service_name)
embed = self._make_list_embed(streamers, subscriber)
await ctx.send(embed=embed)
def on_guild_channel_delete(self, channel: discord.TextChannel):
log.info('Guild channel deleted')
await self._remove_channels_from_database([channel])
def __init__(self, ctx):
permissions_in = ctx.author.permissions_in
_channel_parsers = {
discord.TextChannel: functools.partial(_parse_channel, prefix='#', predicate=lambda c: permissions_in(c).read_messages),
discord.VoiceChannel: functools.partial(_parse_channel, prefix='', predicate=lambda c: permissions_in(c).connect),
}
entries = [
(category, [_channel_parsers[c.__class__](c) for c in entries])
for category, channels in ctx.guild.by_category()
for entries in sliced(channels, 10)
]
super().__init__(ctx, lines_per_page=1)
def info_channel(self, channel: union(discord.TextChannel, discord.VoiceChannel)=None):
"""Shows info about a voice or text channel."""
if channel is None:
channel = ctx.channel
embed_type = 'text_channel_embed' if isinstance(channel, discord.TextChannel) else 'voice_channel_embed'
channel_embed = getattr(self, embed_type)(channel)
channel_embed.colour = self.bot.colour
await ctx.send(embed=channel_embed)
def stats(self, ctx):
"""Shows some general statistics about the bot.
Do not confuse this with `{prefix}about` which is just the
general info. This is just numbers.
"""
bot = self.bot
command_map = itertools.starmap('{1} {0}'.format, bot.command_counter.most_common())
command_stats = '\n'.join(command_map) or 'No stats yet.'
extension_stats = '\n'.join(f'{len(set(getattr(bot,attr).values()))} {attr}'
for attr in ('cogs', 'extensions'))
with self.process.oneshot():
memory_usage_in_mb = self.process.memory_full_info().uss / 1024**2
cpu_usage = self.process.cpu_percent() / psutil.cpu_count()
uptime_seconds = bot.uptime.total_seconds()
average_messages = bot.message_counter / uptime_seconds
message_field = f'{bot.message_counter} messages\n({average_messages :.2f} messages/sec)'
text, voice = partition(lambda c: isinstance(c, bot.get_all_channels())
presence = (f"{bot.guild_count} Servers\n{ilen(text)} Text Channels\n"
f"{ilen(voice)} Voice Channels\n{bot.user_count} Users")
chiaki_embed = (discord.Embed(description=bot.appinfo.description, colour=self.bot.colour)
.set_author(name=str(ctx.bot.user), icon_url=bot.user.avatar_url)
.add_field(name='Modules', value=extension_stats)
.add_field(name='cpu Usage', value=f'{cpu_usage}%\n{memory_usage_in_mb :.2f}MB')
.add_field(name='Messages', value=message_field)
.add_field(name='Presence', value=presence)
.add_field(name='Commands', value=command_stats)
.add_field(name='Uptime', value=self.bot.str_uptime.replace(', '\n'))
)
await ctx.send(embed=chiaki_embed)
def convert(self, argument):
bot = ctx.bot
match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument)
result = None
guild = ctx.guild
if match is not None:
return await super().convert(ctx, argument)
else:
if self.case_sensitive:
def check(c):
return isinstance(c, discord.TextChannel) and c.name == argument
else:
# not a mention
lowered = argument.lower()
def check(c):
return isinstance(c, discord.TextChannel) and c.name.lower() == lowered
if guild:
result = list(filter(check, guild.text_channels))
transform = str
else:
result = list(filter(check, bot.get_all_channels()))
transform = '{0} (Server: {0.guild})'
return await ctx.disambiguate(result, transform)
def send_message(self, msg):
"""Sends a message to a particular channel"""
owner = (await self.bot.application_info()).owner
await channel.send(f"Message from {owner}:\n{msg}")
await ctx.send(f"Successfully sent message in {channel}: {msg}")
def on_message(self, message):
#if message.channel.is_private:
if not isinstance(message.channel, discord.TextChannel):
return
if message.author.bot:
return
await self.process_commands(message)
def invite(self, guild=None):
"""
Creates an invite to a specified server
"""
guild_names = list("{} - ID: {}".format(g.name, g.id) for g in self.bot.guilds)
if guild is None:
guild = await reaction_menu.start_reaction_menu(self.bot, guild_names, count=1,
timeout=60, per_page=10, header=header,
return_from=self.bot.guilds, allow_none=True)
guild = guild[0]
else:
guild = discord.utils.find(lambda s: s.name == guild or str(s.id) == guild, self.bot.guilds)
if guild is None:
await ctx.send("`Unable to locate guild`")
return
for channel in guild.channels:
if isinstance(channel, discord.TextChannel):
try:
invite = await channel.create_invite()
await ctx.send("`Created an invite to guild,I will DM it to you`")
dm_channel = ctx.author.dm_channel
if dm_channel is None:
dm_channel = await ctx.author.create_dm()
await dm_channel.send(invite.url)
break
except discord.HTTPException:
await ctx.send("`Failed to create invite for guild!`")
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。