async def _list(self, ctx):
""" Check your todo list """
todos = []
for num, todo, in enumerate(await self.bot.db.fetch(
'SELECT todo FROM todolist WHERE user_id = $1 ORDER BY time ASC',
ctx.author.id),
start=0):
if len(todo['todo']) > 195:
yourtodo = todo['todo'][:190] + '...'
elif len(todo['todo']) < 195:
yourtodo = todo['todo']
todos.append(f"`[{num + 1}]` {yourtodo}\n")
if len(todos) == 0:
return await ctx.send(f"{emotes.red_mark} You don't have any todos"
)
paginator = Pages(ctx,
title=f"Your todo list:",
entries=todos,
thumbnail=None,
per_page=10,
embed_color=self.color['embed_color'],
show_entry_count=True)
try:
await paginator.paginate()
except discord.HTTPException:
paginators = Pages(ctx,
title=f"Your todo list:",
entries=todos,
thumbnail=None,
per_page=5,
embed_color=self.color['embed_color'],
show_entry_count=True)
await paginators.paginate()
async def permissions(self, ctx, member: discord.Member = None):
""" See what permissions member has in the guild. """
member = member or ctx.author
sperms = dict(member.guild_permissions)
perm = []
for p in sperms.keys():
if sperms[p] == True and member.guild_permissions.administrator == False:
perm.append(f"{emotes.white_mark} {p}\n")
if sperms[p] == False and member.guild_permissions.administrator == False:
perm.append(f"{emotes.red_mark} {p}\n")
if member.guild_permissions.administrator == True:
perm = [f'{emotes.white_mark} Administrator']
paginator = Pages(ctx,
title=f"{member.name} guild permissions",
entries=perm,
thumbnail=None,
per_page = 20,
embed_color=ctx.bot.embed_color,
show_entry_count=False,
author=ctx.author)
await paginator.paginate()
async def remind_list(self, ctx):
""" Check your reminders list """
check_reminders = CM.get(self.bot, 'reminders', ctx.author.id)
if not check_reminders:
return await ctx.send(
_("{0} You have no reminders.").format(
self.bot.settings['emojis']['misc']['warn']))
reminders = []
for result in check_reminders:
when = btime.human_timedelta(check_reminders[result]['time'],
source=ctx.message.created_at)
content = check_reminders[result]['content']
reminders.append(
_("`[{0}]` Reminding in **{1}**\n{2}\n").format(
result, when,
content[:150] + '...' if len(content) > 150 else content))
paginator = Pages(
ctx,
entries=reminders,
thumbnail=None,
per_page=10,
embed_color=ctx.bot.settings['colors']['embed_color'],
embed_author=_("{0}'s Reminders").format(ctx.author),
show_entry_count=True)
await paginator.paginate()
async def queue(self, ctx):
"""Retrieve information on the next 5 songs from the queue."""
player = self.bot.wavelink.get_player(ctx.guild.id,
cls=Player,
context=ctx)
if not player.current or not player.queue._queue:
return await ctx.send(
_('There are no songs currently in the queue.'),
delete_after=20)
upcoming = []
total_duration = 0
for num, item in list(
enumerate(itertools.islice(player.queue._queue, 0,
player.queue.qsize()),
start=1)):
upcoming.append(
f"`[{num}]` {item} ({str(datetime.timedelta(milliseconds=int(item.length)))})\n"
)
total_duration += item.length
paginator = Pages(
ctx,
title=_("{0} Queue. Duration: {1}").format(
ctx.guild.name,
str(datetime.timedelta(milliseconds=int(total_duration)))),
entries=upcoming,
thumbnail=None,
per_page=10,
embed_color=self.bot.settings['colors']['embed_color'],
footertext=_("Total songs in the queue: {0}").format(
player.queue.qsize()),
author=ctx.author)
await paginator.paginate()
async def roles(self, ctx, *, role: discord.Role = None):
""" List of all the roles in the server
Providing a role mention will show all the members in that role. """
allroles = []
if not role:
for num, roles in enumerate(sorted(ctx.guild.roles, reverse=True), start=1):
if roles.is_default():
continue
allroles.append(f"`[{str(num).zfill(2)}]` {roles.mention} | {roles.id} | **[ Users : {len(roles.members)} ]**\n")
elif role:
for num, member in enumerate(role.members, start=1):
allroles.append(f"`[{str(num).zfill(2)}]` {member.mention} | {member.id} | **[ Total Roles : {len(member.roles)} ]**\n")
if len(allroles) == 0:
return await ctx.send(_("{0} Server has no roles").format(self.bot.settings['emojis']['misc']['warn']))
# data = BytesIO(allroles.encode('utf-8'))
paginator = Pages(ctx,
title=_("Roles in {0}").format(ctx.guild.name) if not role else _("Members in {0}").format(role.name),
entries=allroles,
thumbnail=None,
per_page=15,
embed_color=self.bot.settings['colors']['embed_color'],
show_entry_count=True,
author=ctx.author)
await paginator.paginate()
async def cases(self, ctx, member: converters.UserConverter):
"""View all mod cases for a member."""
query = 'SELECT * FROM mod_cases WHERE user_id = $1 ORDER BY issued DESC;'
records = await self.bot.pool.fetch(query, member.id)
if len(records) == 0:
return await ctx.send("None found.")
entries = []
for record in records:
id = record['id']
action = record['action']
issued = time.human_timedelta(datetime.datetime.utcnow() -
record['issued'],
largest_only=True)
duration = record['duration']
duration = time.human_timedelta(
duration) if duration is not None else None
reason = record['reason']
if duration is None:
entries.append(
f'#{id} • *{action.capitalize()}* • {reason} • {issued} ago'
)
else:
entries.append(
f'#{id} • *{action.capitalize()}* ({duration}) • {reason} • {issued} ago'
)
p = Pages(ctx, entries=entries)
p.embed.set_author(name=f'{member} Cases', icon_url=member.avatar_url)
p.embed.colour = discord.Colour.red()
await p.paginate()
async def todo_list(self, ctx):
""" Once you've added todos to your todo list you can use this command to check them. """
todos = await self.bot.db.fetch(
"SELECT DISTINCT todo, time, ROW_NUMBER () OVER (ORDER BY time) FROM todos WHERE user_id = $1 ORDER BY time",
ctx.author.id)
if not todos:
return await ctx.send(
_("{0} You don't have any items in your todo list.").format(
self.bot.settings['emojis']['misc']['warn']))
todol = []
for res in todos:
if len(res['todo']) > 195:
yourtodo = res['todo'][:190] + '...'
elif len(res['todo']) < 195:
yourtodo = res['todo']
todol.append(f"`[{res['row_number']}]` {yourtodo}\n")
paginator = Pages(
ctx,
entries=todol,
thumbnail=None,
per_page=10,
embed_color=ctx.bot.settings['colors']['embed_color'],
embed_author=_("{0}'s Todo List").format(ctx.author),
show_entry_count=True)
await paginator.paginate()
async def permissions(self, ctx, member: discord.Member = None):
""" See what permissions member has in the server. """
member = member or ctx.author
sperms = dict(member.guild_permissions)
del sperms['admin']
perm = []
for p in sperms.keys():
if sperms[p] is True and not member.guild_permissions.administrator:
perm.append(
f"{self.bot.settings['emojis']['misc']['enabled']} {p.replace('_', ' ').title()}\n"
)
if sperms[
p] is False and not member.guild_permissions.administrator:
perm.append(
f"{self.bot.settings['emojis']['misc']['disabled']} {p.replace('_', ' ').title()}\n"
)
if member.guild_permissions.administrator:
perm = [
f"{self.bot.settings['emojis']['misc']['enabled']} Administrator"
]
paginator = Pages(
ctx,
title=_("{0}'s Server Permissions").format(member.name),
entries=perm,
thumbnail=None,
per_page=20,
embed_color=ctx.bot.settings['colors']['embed_color'],
show_entry_count=False,
author=ctx.author)
await paginator.paginate()
async def seenon(self, ctx, *, user:discord.User=None):
if user is None:
user = ctx.author
elif not await self.bot.is_owner(ctx.author) \
and (user == self.bot.user or await self.bot.is_owner(user)):
return await ctx.send('no')
resp = await self.bot.rpc.seen_on(
ctx.message.id,
shards=True,
guild=ctx.guild.id if ctx.guild else None,
user=user.id
)
seen_on = list(resp)
try:
p = Pages(ctx, entries=seen_on, per_page=30,
extra_info='# at the end of each name refers to the shard.'
)
p.embed.title = 'Guilds Seen On'
if self.bot._connection.guild_subscriptions is False:
p.embed.description = "Member cache is disabled," \
"this will only show if they've been added to the cache."
p.embed.color = 0x738bd7
p.embed.set_author(name=user.display_name, icon_url=user.avatar_url or user.default_avatar_url)
await p.paginate()
except CannotPaginate:
joined = ', '.join(seen_on)
if len(joined) >= 2000:
return await ctx.send(
'\N{NO ENTRY} `Too many seen on guilds for non-embed response, please allow me to post embeds!`'
)
await ctx.send(f"**Guilds Seen On for __{user}__**\n`{joined}`")
async def temprole_list(self, ctx, member: discord.Member = None):
"""Lists temporary roles."""
if member is None:
query = 'SELECT * FROM temproles INNER JOIN timers ON temproles.timer_id = timers.id ORDER BY timers.expires;'
records = await self.bot.pool.fetch(query)
else:
query = 'SELECT * FROM temproles INNER JOIN timers ON temproles.timer_id = timers.id WHERE user_id = $1 ORDER BY timers.expires;'
records = await self.bot.pool.fetch(query, member.id)
if len(records) == 0:
return await ctx.send('No temporary roles to list.')
# embed = discord.Embed(title='Temprole List', colour=discord.Colour.green())
# embed.description = ''
entries = []
for record in records:
user = discord.utils.get(ctx.guild.members, id=record['user_id'])
role = discord.utils.get(ctx.guild.roles, id=record['role_id'])
expires = record['expires'].isoformat(timespec='minutes')
# embed.description = embed.description + f'**{user}** {role} **Expires:** {expires} UTC\n'
entries.append(f'**{user}** {role} **Expires:** {expires} UTC')
p = Pages(ctx, entries=entries)
p.embed.set_author(name='Temprole List')
p.embed.colour = discord.Colour.green()
await p.paginate()
async def roles(self, ctx):
""" List of roles in the server """
allroles = []
for num, role in enumerate(sorted(ctx.guild.roles, reverse=True),
start=1):
if role.is_default():
continue
allroles.append(
f"`[{str(num).zfill(2)}]` {role.mention} | {role.id} | **[ Users : {len(role.members)} ]**\n"
)
if len(allroles) == 0:
return await ctx.send(f"{emotes.red_mark} Server has no roles")
#data = BytesIO(allroles.encode('utf-8'))
paginator = Pages(ctx,
title=f"{ctx.guild.name} roles list",
entries=allroles,
thumbnail=None,
per_page=15,
embed_color=ctx.bot.embed_color,
show_entry_count=True,
author=ctx.author)
await paginator.paginate()
async def search(self, ctx, *, query: str):
"""Shows results for the queried keyword(s) in McGill courses"""
keyword = query.replace(" ", "+")
pagelimit = 5
pagenum = 0
courses = []
while (True and pagenum < pagelimit):
url = "http://www.mcgill.ca/study/2018-2019/courses/search\
?search_api_views_fulltext=%s&sort_by=field_subject_code&page=%d" % (
keyword, pagenum)
r = requests.get(url)
soup = BeautifulSoup(r.content, "html.parser")
found = soup.find_all("div", {"class": "views-row"})
if (len(found) < 1):
break
else:
courses = courses + found
pagenum += 1
if (len(courses) < 1):
await ctx.send("No course found for: %s." % query)
return
courseList = {'names': [], 'values': []}
for course in courses:
# split results into titles + information
title = course.find_all("h4")[0].get_text().split(" ")
courseList['names'].append(' '.join(title[:2]))
courseList['values'].append(' '.join(title[2:]))
p = Pages(ctx,
itemList=courseList,
title='Courses found for {}'.format(query),
option='EMBEDS',
editableContent=False)
await p.paginate()
async def remind_list(self, ctx):
sql = 'SELECT * FROM `reminders` WHERE user={0}'.format(ctx.author.id)
q = await self.cursor.execute(sql)
result = await q.fetchall()
if not result:
return await ctx.send(
"\N{NO ENTRY} You don't have any reminders set!")
try:
entries = [
f"**__{human_timedelta(datetime.fromtimestamp(x['time']))}__**" \
f"\n{x['message'] or ''}" \
for x in result
]
p = Pages(ctx, entries=entries, per_page=8, show_zero=False)
p.embed.title = 'Reminders'
p.embed.color = self.bot.funcs.get_color()()
p.embed.set_author(name=ctx.author.display_name,
icon_url=ctx.author.avatar_url_as())
await p.paginate()
except CannotPaginate:
reminders = []
count = 0
for reminder in result:
created_at = human_timedelta(
datetime.fromtimestamp(reminder['time']))
if reminder['message'] is not None:
reminders.append('**{0}.** __{2}__: `{1}`'.format(
count, reminder['message'], created_at))
else:
reminders.append('**{0}.** __{1}__'.format(
count, created_at))
count += 1
await self.truncate(
ctx.channel, '**Reminders**\n{0}'.format('\n'.join(reminders)))
async def locked(self, ctx, typ="Embed"):
"""[M] List all locked members"""
entries = [self.bot.get_user(uid) for uid in ctx.config['locked']]
if typ.lower() in ('embed', 'e'):
p = Pages(self.bot,
message=ctx.message,
entries=[e.mention for e in entries])
p.embed.set_author(name="Locked members")
await p.paginate()
elif typ.lower() in ('text', 'txt', 't'):
fmt = '```'
for e in entries:
fmt += e.name + "\n"
fmt += '```'
try:
await ctx.send(fmt)
except: # noqa
await ctx.send(
f"List too long, use `{ctx.prefix}locked embed` for a paginated version."
)
else:
await ctx.send("Invalid type! Can be either `text` or `embed`")
async def userlist(self, ctx):
""" Whole list of users that bot can see """
try:
await ctx.message.delete()
except:
pass
async with ctx.channel.typing():
await asyncio.sleep(2)
user_list = []
for user in self.bot.users:
user_list.append(user)
user_lists = [] # Let's list the users
for num, user in enumerate(user_list, start=0):
user_lists.append(
f'`[{num + 1}]` **{user.name}** ({user.id})\n**Created at:** {btime.human_timedelta(user.created_at)}\n**────────────────────────**\n'
)
paginator = Pages(ctx,
title=f"__Users:__ `[{len(user_lists)}]`",
entries=user_lists,
per_page=10,
embed_color=self.bot.embed_color,
show_entry_count=False,
author=ctx.author)
await paginator.paginate()
async def _list(self, ctx, page: int = 1):
"""List the guilds I am in."""
try:
await ctx.message.delete()
except:
pass
guild_list = []
for num, guild in enumerate(self.bot.guilds, start=0):
people = len([x for x in guild.members if not x.bot])
bots = len([x for x in guild.members if x.bot])
botfarm = int(100 / len(guild.members) * bots)
guild_list.append(
f"`[{num + 1}]` {guild} ({guild.id}) `[Ratio: {botfarm}%]`\n**Joined:** {humanize.naturaltime(guild.get_member(self.bot.user.id).joined_at)}\n"
)
paginator = Pages(ctx,
title=f"Guilds I'm In:",
thumbnail=None,
entries=guild_list,
per_page=10,
embed_color=self.bot.embed_color,
show_entry_count=False,
author=ctx.author)
await paginator.paginate()
async def duckduckgo(self, ctx, *, search: str):
"""Search duckduckgo.com"""
load = await self.f_api(ctx.command.name, text=search, json=True)
if isinstance(load, str):
return await ctx.send(load)
elif not load or not any(load.values()):
return await ctx.send("\N{WARNING SIGN} `Invalid Search.`")
urls = load['results'] if 'results' in load else None
card = load['cards'] if 'cards' in load else {}
ecard = Embed.from_dict(card)
ecard.color = 0x738bd7
try:
p = Pages(ctx,
embed=ecard,
google=bool(card),
per_page=3,
entries=[f"**{x['title']}**\n{x['link']}" for x in urls])
if card is None and not p.embed.title:
p.embed.title = 'DuckDuckGo Results'
p.embed.set_author(name=ctx.author.display_name,
icon_url=ctx.author.avatar_url
or ctx.author.default_avatar_url)
await p.paginate()
except CannotPaginate:
more = '\n'.join([f"<{x['link']}>" for x in urls[1:4]])
await ctx.send(
f"**{urls[0]['title']}**\n{urls[0]['link']}\n\n__More Results__\n{more}"
)
async def google(self, ctx, *, search: str):
"""Search the largest search engine on the internet"""
level = await self.google_safety(ctx.message, True)
urls, card = await self.google_scrap(search,
True if level != 'off' else False,
False)
if not urls and not card:
return await ctx.send("\N{WARNING SIGN} `Invalid Search.`")
try:
p = Pages(ctx,
embed=card,
color=0x738bd7,
google=bool(card),
entries=[f'**{x[0]}**\n{x[1]}' for x in urls],
per_page=3,
method=2)
if card is None:
p.embed.title = 'Google Search Results'
p.embed.set_author(name=ctx.author.display_name,
icon_url=ctx.author.avatar_url
or ctx.author.default_avatar_url)
await p.paginate()
except CannotPaginate:
more = '\n'.join([f'<{x[1]}>' for x in urls[1:4]])
await ctx.send(
f'**{urls[0][0]}**\n{urls[0][1]}\n\n__More Results__\n{more}')
async def queue(self, ctx):
"""Shows the current queue."""
vc = ctx.voice_client
if vc is None:
return await ctx.send('Not in a voice channel.')
if not vc.is_playing() and not vc.is_paused():
return await ctx.send('Not currently playing anything.')
queue = self.get_queue(ctx.guild).songs._queue
if len(queue) == 0:
return await ctx.invoke(self.playing)
songs = [
f'[{song.entry.title}]({song.entry.url})\nRequested by {song.requester}'
for song in queue
]
try:
p = Pages(ctx, entries=songs, per_page=10)
p.embed.colour = 0x738bd7
p.embed.title = f'Currently Playing {vc.source.entry.title} requested by {vc.source.requester}'
p.embed.url = vc.source.entry.url
await p.paginate()
except Exception as e:
await ctx.send(e)
async def send_cog_help(self, cog):
if cog.qualified_name in self.ignore_cogs:
return await self.send_error_message(await self.command_not_found(
cog.qualified_name.lower()))
if cog.qualified_name in self.owner_cogs and not await self.context.bot.is_owner(
self.context.author):
return await self.send_error_message(await self.command_not_found(
cog.qualified_name.lower()))
if cog.qualified_name in self.admin_cogs and not await self.context.bot.is_admin(
self.context.author):
return await self.send_error_message(await self.command_not_found(
cog.qualified_name.lower()))
if cog.qualified_name in self.booster_cogs and not await self.context.bot.is_booster(
self.context.author):
return await self.send_error_message(await self.command_not_found(
cog.qualified_name.lower()))
if await checks.cog_disabled(self.context, cog.qualified_name):
return await self.send_error_message(await self.command_not_found(
cog.qualified_name.lower()))
commands = []
if cog.aliases:
commands.append(
_("**Category aliases:** {0}\n").format(
'`' + '`, `'.join(cog.aliases) + '`'))
c = 0
for cmd in cog.get_commands():
if cmd.hidden and not await self.context.bot.is_admin(
self.context.author):
continue
if await checks.is_disabled(
self.context, cmd) and not await self.context.bot.is_admin(
self.context.author):
continue
if cmd.short_doc is None:
brief = _('No information.')
else:
brief = cmd.short_doc
if not cmd.hidden or not await checks.is_disabled(
self.context, cmd):
if not await self.context.bot.is_admin(self.context.author):
c += 1
else:
c += 1
commands.append(f"`{cmd.qualified_name}` - {brief}\n")
paginator = Pages(
self.context,
title=f"{cog.qualified_name.title()} ({c})",
thumbnail=cog.big_icon,
entries=commands,
per_page=12,
embed_color=self.context.bot.settings['colors']['embed_color'],
show_entry_count=False,
author=self.context.author)
await paginator.paginate()
async def stats(self, ctx):
data = await self.pool.hgetall('cmd_stats', encoding='utf-8')
data = {x: int(data[x]) for x in data}
entries = [f"`{x}` - {int(data[x]):,}"
for x in sorted(data, reverse=True, key=data.get)]
p = Pages(ctx, entries=entries, per_page=25, method=2)
p.embed.title = '\N{KEYBOARD} Top Commands (Since 07/14/2018):'
p.embed.color = 0x3498db
await p.paginate()
async def lyrics(self, ctx, *, title):
""" Get song lyrics """
def split_lyrics(lyr, page_size=2048, newline_max=None):
verses = lyr.split("\n\n")
joined_verses = []
while len(verses) > 0:
joined_verse = ""
verse_count = 0
newline_count = 0
while True:
v = verses[verse_count:]
if len(verses[verse_count:]) == 0:
break
verse_to_be_added = verses[verse_count:][0]
if len(verse_to_be_added) > page_size or (
newline_max is not None and verse_to_be_added.count("\n") > newline_max):
return None
if (len(joined_verse) + len(verse_to_be_added)) + len("\n\n") > page_size:
break
if newline_max is not None and newline_count > newline_max:
break
joined_verse = (joined_verse + "\n\n" + verse_to_be_added).strip()
newline_count = joined_verse.count("\n")
verse_count = verse_count + 1
verses = verses[verse_count:]
joined_verses.append(joined_verse)
return joined_verses
genius = lyricsgenius.Genius(config.GENIUSTOKEN, verbose=False)
song = await genius.search_song(title)
if song is None:
return await ctx.send("Couldn't find any song by that title.")
verse_array = split_lyrics(song.to_text(), newline_max=30)
if verse_array is None:
return await ctx.send("Verse size exceeds maximum. You can find the lyrics at {0}".format(song.url))
paginator = Pages(ctx,
title="{0} by {1}".format(song.title, song.artist),
entries=verse_array,
thumbnail=song.header_image_url,
per_page=1,
embed_color=discord.Color.dark_teal(),
show_entry_count=True)
await paginator.paginate()
async def quipqiup_beta2(self, ctx, *, query=None):
if not query:
await ctx.send(
'Example: `!qq cbg bfabdbebfab` or `!qq cbg bfabdbebfab c=s b=a`'
)
return
# set up query
clues = ''
poseq = [m.start() for m in re.finditer('=', query)]
if poseq:
clues = query[poseq[0] - 1:]
query = query[:poseq[0] - 2]
# data scrapper adapted from
# https://github.com/cmpunches/NSA-CryptoChallenge-Solver/blob/340ba7f65072bf00bdc2a4d0cc313d50e3ba6070/cryptochallenge-solver.py
client = requests.Session()
client.headers.update({
'Accept-Encoding': "gzip, deflate, br",
'Referer': "https://quipqiup.com/",
'Content-type': "application/x-www-form-urlencoded",
'Origin': "https://quipqiup.com/"
})
body = {"ciphertext": query, "clues": clues, "time": 5}
rawresult = client.post(
"https://6n9n93nlr5.execute-api.us-east-1.amazonaws.com/prod/dict",
json.dumps(body)).content
obj = json.loads(rawresult.decode())
print(obj)
# set up embed template
embed = discord.Embed(title='Quipqiup',
colour=discord.Colour.dark_orange())
if clues:
embed.set_footer(text='Query: ' + query + '\nKey: ' + clues)
elif not clues:
embed.set_footer(text='Query: ' + query)
# send result
if 'errorMessage' in obj:
final = 'Exited with error message: \n' + obj['errorMessage']
embed.description(final)
await ctx.send(embed=embed)
else:
solnsort = sorted(obj['solutions'],
key=lambda k: k['logp'],
reverse=True)
solns = []
weights = []
for n in range(0, len(solnsort)):
solns.append(solnsort[n]['plaintext'])
weights.append(solnsort[n]['logp'])
p = Pages(ctx, solutions=solns, weights=weights, embedTemp=embed)
await p.pageLoop()
async def partnerslist(self, ctx):
""" Displays a list of partners and information how to become a partner """
partners = await self.bot.db.fetch(
"SELECT * FROM partners ORDER BY time ASC")
partner = []
for res in partners:
if res['type'] == 0:
partnered = f"{self.bot.get_user(res['_id'])} ({res['_id']})"
ptype = f"Bot: [{self.bot.get_user(res['bot_id'])}](https://discord.com/users/{res['bot_id']})"
if partnered is None:
partnered = f"({res['_id']})"
elif res['type'] == 1:
guild = self.bot.get_guild(res['_id'])
if guild is not None:
try:
guildinv = await guild.invites()
for inv in guildinv[:1]:
partnered = f"[{guild}]({inv}) ({res['_id']}) | Owner: {guild.owner} ({guild.owner.id})"
except Exception:
partnered = f"{guild} ({res['_id']}) | Owner: {guild.owner} ({guild.owner.id})"
ptype = _('Server')
elif not guild and res['valid']:
partnered = f"[{res['name']}]({res['invite']})"
ptype = _('Server')
else:
partnered = f"({res['_id']})"
ptype = 'Invalid type, unpartner.'
partner.append(
_("**Partner:** {0}\n"
"**Partnered for:** {1}\n"
"**Partner type:** {2}\n"
"**Partnered message:**\n>>> {3}").format(
partnered,
btime.human_timedelta(res['time'],
source=datetime.utcnow(),
suffix=None), ptype,
res['message']))
msg = await self.bot.get_channel(
self.bot.settings['channels']['partners']
).fetch_message(741690217379135569)
partner.append(
_("Interested in partnering? Here's the official message:\n\n{0}"
" or [join the support server]({1})").format(
msg.content, self.bot.support))
paginator = Pages(
ctx,
title=_("Partnered people with Dredd"),
entries=partner,
thumbnail=None,
per_page=1,
embed_color=self.bot.settings['colors']['embed_color'],
show_entry_count=True)
await paginator.paginate()
async def send_cog_help(self, cog):
if cog.qualified_name in self.ignore_cogs:
return await self.send_error_message(
self.command_not_found(cog.qualified_name.lower()))
if cog.qualified_name in self.owner_cogs and not await self.context.bot.is_owner(
self.context.author):
return await self.send_error_message(
self.command_not_found(cog.qualified_name.lower()))
if cog.qualified_name in self.admin_cogs and not await self.context.bot.is_admin(
self.context.author):
return await self.send_error_message(
self.command_not_found(cog.qualified_name.lower()))
if cog.qualified_name in self.vip_cogs and not await self.context.bot.is_booster(
self.context.author):
return await self.send_error_message(
self.command_not_found(cog.qualified_name.lower()))
commands = []
c = 0
for cmd in cog.get_commands():
if cmd.hidden:
continue
if await self.context.bot.db.fetchval(
"SELECT * FROM guilddisabled WHERE guild_id = $1 AND command = $2",
self.context.guild.id, str(cmd)):
continue
if await self.context.bot.db.fetchval(
"SELECT * FROM cmds WHERE command = $1", str(cmd)):
continue
if cmd.short_doc is None:
brief = 'No info'
else:
brief = cmd.short_doc
if not cmd.hidden or not await self.context.bot.db.fetchval(
"SELECT * FROM guilddisabled WHERE guild_id = $1 AND command = $2",
self.context.guild.id,
str(cmd)) or not await self.context.bot.db.fetchval(
"SELECT * FROM cmds WHERE command = $1", str(cmd)):
c += 1
commands.append(f"`{cmd.qualified_name}` - {brief}\n")
paginator = Pages(self.context,
title=f"{cog.qualified_name.title()} ({c})",
thumbnail=cog.big_icon,
entries=commands,
per_page=12,
embed_color=self.color['embed_color'],
show_entry_count=False,
author=self.context.author)
await paginator.paginate()
async def tags(self, ctx):
g = mongo_setup.tags.find_one({'_id': ctx.guild.id}) # if theres tags for ctx.guild, then the dict should be formatted like: {'tag name': {'author': user id, 'value': 'tag value'}}
if not g:
return await ctx.send("This server has no tags yet.")
tag_info = []
for key, val in g.items():
if not isinstance(val, dict): # yea this is probably useless for juan so change this
continue
author = val['author']
tag_info.append(f'Name: {key}\nAuthor: {self.bot.get_user(author)}')
pages = Pages(ctx, entries=tag_info, specific_name=f'Tags for {ctx.guild.name}') # change this since the paginator for juan probably doesnt have specific_name, but it should
await pages.paginate()
async def ownerlist(ctx):
"""Shows a list of all servers using paginator"""
for guild in bot.guilds:
guilds = [
f"**{guild.name}** \nServer Owner: **{guild.owner.name}#{guild.owner.discriminator}**\nServer ID: **{guild.id}**\nTotal Members: **{guild.member_count}**"
for guild in bot.guilds
]
try:
p = Pages(ctx, entries=guilds, per_page=5)
p.embed.colour = passcolor
await p.paginate()
except Exception as e:
await ctx.send(e)
async def send_cog_help(self, cog):
commands = []
for command in await self.filter_commands(cog.get_commands()):
commands.append(f"`{command.qualified_name}` - **{command.short_doc}**\n")
paginator = Pages(self.context,
title=f"{cog.qualified_name} help",
entries=commands,
thumbnail=None,
per_page=10,
embed_color=discord.Color.dark_teal(),
show_entry_count=True)
await paginator.paginate()
async def queue(self, ctx):
"""Shows the currently queued songs"""
q = ctx.state.queue
if q.empty():
return await ctx.send(
"The queue is currently empty.\nYou can queue songs by typing `m!play <song name>`."
)
queue = [
f"{song.player.title}\n By: {song.ctx.author.name}"
for song in q._queue
]
p = Pages(self.bot, message=ctx.message, entries=queue)
p.embed.set_author(name="Music Queue")
await p.paginate()
async def wolframalpha(self, ctx, *, q:str):
try:
result = await self.wa.query(q, proxy=self.bot.funcs.proxy)
except:
return await ctx.send('\N{WARNING SIGN} Wolfram Alpha API Failed.')
if result is None or result['@success'] == 'false':
return await ctx.send('\N{WARNING SIGN} `No results found on` <https://wolframalpha.com>')
imgs = []
prev = False
try:
pods = list(result.pods)
except AttributeError:
return await ctx.send('\N{NO ENTRY} Standard computation time exceeded...')
load = {}
for pod in pods:
if 'subpod' not in pod:
continue
subs = pod['subpod']
if isinstance(subs, dict):
subs = (subs,)
for sub in subs:
txt = sub['plaintext']
if txt == prev:
continue
elif txt:
load[pod['@title']] = txt
if 'img' in sub:
imgs.append(sub['img']['@src'])
if txt != None:
prev = txt
imgs.reverse()
try:
p = Pages(ctx, entries=imgs, images=True, minimal=True)
e = p.embed
e.title = 'Wolfram|Alpha Result'
for x in load:
e.add_field(name=x, value=load[x])
e.set_thumbnail(url='https://cdn.discordapp.com/attachments/178313653177548800/287641775823126538/Pd8NO4lgMW1gsSrlv_zqoFq18mXrVz0AE-Nrxn5sijtp7AacJywTWoM_1kaJeorJKOhVw300.png')
e.set_author(name=ctx.author.display_name, icon_url=ctx.author.avatar_url or ctx.author.default_avatar_url)
e.color = discord.Colour(int("FF4C4C", 16))
await p.paginate()
except CannotPaginate:
msg = '\n'.join([f'**{x}**: `{load[x]}`' for x in load])
#usually cause bot doesnt have embed perms but add images anyways ;-;
msg += '\n' + '\n'.join(imgs[:3])
if len(msg) >= 2000:
await ctx.send('\N{WARNING SIGN} Results too long...')
else:
await ctx.send(msg)
