async def crabmeme(self, ctx, *, text: str):
'''Limited to owner only (for now, it may return) due to this command using like 90% CPU'''
if not await self.bot.is_team_owner(ctx.author):
return
if not '|' in text:
raise commands.ArgumentParsingError(
'Text should be separated by |')
if not text:
raise commands.MissingRequiredArgument(
'You need to provide text for the meme')
filename = str(ctx.author.id) + '.mp4'
t = text.upper().replace('| ', '|').split('|')
if len(t) != 2:
raise commands.ArgumentParsingError(
'Text should have 2 sections, separated by |')
if (not t[0] and not t[0].strip()) or (not t[1] and not t[1].strip()):
raise commands.ArgumentParsingError('Cannot use an empty string')
msg = await ctx.send('🦀 Generating Crab Rave 🦀')
await self.loop.run_in_executor(None,
func=functools.partial(
self.gencrabrave, t, filename))
meme = discord.File(filename, 'crab.mp4')
await msg.delete()
await ctx.send(file=meme)
os.remove(filename)
async def wep_exp(self, ctx):
self.calls += 1
args = ctx.message.content.split()
if len(args) == 8:
try:
rarity = int(args[1])
curr_level = int(args[2])
goal_level = int(args[3])
curr_exp = int(args[4])
mystic_count = int(args[5])
fine_count = int(args[6])
normal_count = int(args[7])
except ValueError:
raise commands.ArgumentParsingError(message="Please enter integer values only.")
if not rarity in [5, 4, 3, 2, 1]:
raise commands.ArgumentParsingError(message="Please enter a valid weapon rarity value.")
if curr_level > goal_level:
raise commands.ArgumentParsingError(message="Please enter current level and goal level where current level is less than goal level.")
if mystic_count < 0 or fine_count < 0 or normal_count < 0:
raise commands.ArgumentParsingError(message="Please enter number of enhancement ores greater or equal to 0.")
embed_msg = default_embed_template(ctx, self._client.user.name)
embed_msg = self.calculate(embed_msg, rarity, curr_level, goal_level, curr_exp, mystic_count, fine_count, normal_count)
await ctx.send(embed=embed_msg)
else:
await ctx.send(f"`Usage: {self._client.command_prefix}wep_exp <rarity> <curr_level> <goal_level> <curr_exp> <mystic_count> <fine_count> <normal_count>`\n`{self._client.command_prefix}help` for more details.")
async def user_role(self, ctx, *, cmd: shlex.split = ''):
"""Give a role."""
args = ctx.parser.parse_known_args(cmd)[0]
try:
user = await commands.MemberConverter().convert(
ctx, str(args.user))
except Exception as err:
raise commands.ArgumentParsingError(
f'Invalid member ({args.user}): {err}')
try:
role = await commands.RoleConverter().convert(ctx, str(args.role))
except Exception as err:
raise commands.ArgumentParsingError(
f'Invalid role ({args.role}): {err}')
if role.id not in self.enabled_roles:
raise commands.ArgumentParsingError(
f'Invalid role {role} ({args.role})')
reason = f'[{ctx.author}] “{args.reason}”'
logentry = discord.Embed(timestamp=ctx.message.created_at,
colour=discord.Colour.green())
logentry.set_author(name=ctx.author, icon_url=ctx.author.avatar_url)
roles_to_add = []
roles_to_remove = []
roles_action = 'added'
for user_role in user.roles:
if user_role.id == role.id:
roles_action = 'removed'
roles_to_remove.append(role)
logentry.colour = discord.Colour.orange()
if role.id in self.proficiency_roles:
roles_to_add.append(self.nolevel_role)
break
else:
roles_to_add.append(role)
if role.id in self.proficiency_roles:
for user_role in user.roles:
if user_role.id in self.proficiency_roles:
roles_to_remove.append(user_role)
if self.nolevel_role in user.roles:
roles_to_remove.append(self.nolevel_role)
logentry.description = f'{ctx.author.mention} {roles_action} role ({user}, {role}) “{args.reason}”'
if roles_to_add:
await user.add_roles(*roles_to_add, reason=reason)
if roles_to_remove:
await user.remove_roles(*roles_to_remove, reason=reason)
return await self.logger_webhook.send(embed=logentry)
async def convert(self, ctx, arg):
arg = arg.upper()
if arg.startswith("R"):
return "red", int(arg[1:])
elif arg.startswith("B"):
return "black", int(arg[1:])
raise commands.ArgumentParsingError("unexisting area")
async def help(ctx):
args = ctx.message.content.split()
helptxt = HelpText()
embedded_message = default_embed_template(ctx, f"{client.user.name}")
if len(args) == 1:
cmd_msg = ""
for cmd in client.commands:
if not cmd.hidden:
cmd_msg += f"\n{helptxt.usage[cmd.name]}\n"
cmd_msg += f"{helptxt.description[cmd.name]} Use `{client.command_prefix}help {cmd.name}` for more details.\n"
embedded_message.add_field(name="Commands", value=cmd_msg)
await ctx.send(embed=embedded_message)
elif len(args) == 2:
found = False
for cmd in client.commands:
if cmd.name == args[1]:
found = True
break
if found:
cmd_msg = f"{helptxt.description[cmd.name]}\n\n"
cmd_msg += f"Usage: {helptxt.usage[cmd.name]}\n\n"
cmd_msg += f"{helptxt.details[cmd.name]}\n"
embedded_message.add_field(
name=f"{client.command_prefix}{cmd.name} command details",
value=cmd_msg)
await ctx.send(embed=embedded_message)
else:
raise commands.ArgumentParsingError(
message=
f"Command '{args[1]}' does not exist. Cannot provide help.")
else:
await ctx.send(f"Usage: {client.command_prefix}help")
def getLang(self, lang: str) -> str:
if lang in self.langs.values():
return lang
if lang in self.langs:
return self.langs[lang]
raise commands.ArgumentParsingError('Invalid language.')
async def convert(self, ctx, arg):
cat = discord.utils.get(ctx.guild.categories, name="poker")
chan = discord.utils.get(cat.text_channels, name=arg)
lobby = PokerLobby.instances.get(chan, None)
if lobby is None:
raise commands.ArgumentParsingError(
"this poker lobby does not exists")
return lobby
async def wolframalpha(self, ctx, *, query):
res = await REST(f"http://api.wolframalpha.com/v1/simple?appid={getAPIKey('wolframalpha')}&layout=labelbar&ip=None&background=2F3136&foreground=white&i={escapeURL(query)}", returns=('raw', 'status'))
data = BytesIO(res[0])
if res[1] == 501:
raise commands.ArgumentParsingError(data.read().decode('utf-8'))
elif res[1] != 200:
raise commands.CommandError(data.read().decode('utf-8'))
answer = discord.File(data, filename='wolfram.png')
await ctx.send(files=[answer])
async def softban(self, ctx, user: StaffCheck = None, messages: int = 7, *, reason = "No Reason Provided."):
"""PFXsoftban <user> <amount of days: 1-7> [<reason>]"""
await ctx.message.delete()
await ctx.trigger_typing()
if user == False:
return
if not user:
return await ctx.send("You must specify a user")
if messages > 7:
raise commands.ArgumentParsingError('I can only delete up to 7 days of messages')
elif messages < 0:
raise commands.ArgumentParsingError('That\'s not a valid number of days. It should be 1-7')
try:
await ctx.guild.ban(user, reason=f"Softbanned by {ctx.author} for {reason}", delete_message_days=messages)
logchannels = self.bot.get_cog("Settings").logchannels
logid = logchannels[ctx.guild.id] if ctx.guild.id in logchannels else None
if logid:
logch = ctx.guild.get_channel(logid['modlogs'])
if logch:
embed = discord.Embed(color=discord.Color.red(), timestamp=datetime.datetime.utcnow())
embed.set_author(name=f'Softban | {user}', icon_url=str(user.avatar_url_as(static_format='png', size=2048)))
embed.add_field(name='User', value=f'{user}({user.id})', inline=False)
embed.add_field(name='Moderator', value=ctx.author.mention, inline=False)
embed.add_field(name='Reason', value=reason, inline=False)
embed.set_footer(text=f'User ID: {user.id} | Mod ID: {ctx.author.id}')
try:
await logch.send(embed=embed)
except Exception:
pass
await ctx.guild.unban(user, reason="Temporarily Banned")
await ctx.send(f"<a:fireSuccess:603214443442077708> **{discord.utils.escape_mentions(discord.utils.escape_markdown(str(user)))}** has been soft-banned.")
await self.bot.loop.run_in_executor(None, func=functools.partial(self.bot.datadog.increment, 'moderation.softbans'))
con = await self.bot.db.acquire()
async with con.transaction():
query = 'INSERT INTO modlogs (\"gid\", \"uid\", \"reason\", \"date\", \"type\", \"caseid\") VALUES ($1, $2, $3, $4, $5, $6);'
await self.bot.db.execute(query, ctx.guild.id, user.id, reason or "No Reason Provided.", datetime.datetime.utcnow().strftime('%d/%m/%Y @ %I:%M:%S %p'), 'softban', datetime.datetime.utcnow().timestamp() + user.id)
await self.bot.db.release(con)
await self.loadmodlogs()
except discord.Forbidden:
await ctx.send("<a:fireFailed:603214400748257302> Soft-ban failed. Are you trying to soft-ban someone higher than the bot?")
def parse_csl(self, str_list: str):
"""
Parses a comma separated list of values in a string, into a list
"""
the_list = str_list.strip(' ,').split(',')
parsed_list = [item.strip() for item in the_list]
if "" in parsed_list:
raise commands.ArgumentParsingError(
"Provided list contains an empty item")
return parsed_list
async def char_exp(self, ctx):
self.calls += 1
args = ctx.message.content.split()
if len(args) == 7:
try:
curr_level = int(args[1])
goal_level = int(args[2])
curr_exp = int(args[3])
herowit_count = int(args[4])
advexp_count = int(args[5])
wandadv_count = int(args[6])
except ValueError:
raise commands.ArgumentParsingError(
message="Please enter integer values only.")
if curr_level > goal_level:
raise commands.ArgumentParsingError(
message=
"Please enter current level and goal level where current level is less than goal level."
)
if herowit_count < 0 or advexp_count < 0 or wandadv_count < 0:
raise commands.ArgumentParsingError(
message=
"Please enter number of materials equal to or greater than 0."
)
embed_msg = default_embed_template(ctx, self._client.user.name)
embed_msg = self.calculate(embed_msg, curr_level, goal_level,
curr_exp, herowit_count, advexp_count,
wandadv_count)
await ctx.send(embed=embed_msg)
else:
await ctx.send(
f"Usage: `{self._client.command_prefix}char_exp <curr_level> <goal_level> <curr_exp> <herowit_count> <advexp_count> <wandadv_count>`\nCheck out `{self._client.command_prefix}help` for more details."
)
async def get_leaderboard(self, ctx, *args):
try:
parsed_args = ServerArgParsers.LEADERBOARD_ARG_PARSER.parse_known_args(args)[0]
except ArgumentParserError as e:
raise commands.ArgumentParsingError(message=e.args[0])
if parsed_args.mobile:
headers = ["N", "S", "CS", "LS"]
else:
headers = ["Name", "Score", "Current Streak", "Longest Streak"]
emoji = find(lambda em: str(em) == parsed_args.emoji, ctx.guild.emojis)
try:
if emoji.name not in Config.get_config_property("server", "leaderboard", "emojiMap").keys():
raise commands.BadArgument("There is no leaderboard associated with the emoji.")
relative_path = "{0}/leaderboards/{1}/{2}.json".format(Config.get_config_property("saveDir"),
str(ctx.guild.id), emoji.name)
with open(str(get_project_dir() / relative_path)) as f:
leaderboard_json = json.load(f)
entries = sorted(leaderboard_json, key=lambda e: (leaderboard_json[e]["score"],
leaderboard_json[e]["current_streak"], leaderboard_json[e]["longest_streak"]),
reverse=True)
except AttributeError as e:
LOGGER.error("ServerCog::leaderboard - Called with default emoji.")
raise commands.BadArgument("Leaderboards don't exist for default emojis.")
except FileNotFoundError as e:
LOGGER.error("ServerCog::leaderboard - No leaderboard data found for called emoji")
raise commands.BadArgument("No leaderboard data found for called emoji.")
try:
entries = entries[0:int(parsed_args.top)]
except TypeError:
pass
except IndexError:
LOGGER.warning("Specified a value that was larger than the amount of users with scores")
pass
except ValueError:
LOGGER.error("ServerCog::leaderboard - " + parsed_args.top + " is not an int")
raise commands.BadArgument("Bad argument for top parameter. Expected integer.")
table = [[find(lambda u: str(u.id) == e, ctx.guild.members).name, leaderboard_json[e]["score"],
leaderboard_json[e]["current_streak"], leaderboard_json[e]["longest_streak"]] for e in entries]
await ctx.channel.send("{0}*** Leaderboard ***{0}\n```{1}```".format(str(emoji), tabulate(table,
headers=headers)))
async def hypixel(self, ctx, arg1: str = None, arg2: str = None):
if arg1 is None:
return await ctx.send("I need an IGN or `watchdog`",
delete_after=5)
arg1 = arg1.lower().replace('-', '')
if arg2:
arg2 = arg2.lower()
if arg1.lower() == "watchdog":
route = Route('GET', '/watchdogstats')
watchdog = await self.bot.http.hypixel.request(route)
color = ctx.author.color
embed = discord.Embed(title="Watchdog Stats",
colour=color,
timestamp=datetime.datetime.now(
datetime.timezone.utc))
embed.set_thumbnail(
url="https://hypixel.net/attachments/cerbtrimmed-png.245674/")
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
embed.add_field(name="Watchdog Bans in the last minute",
value=watchdog['watchdog_lastMinute'],
inline=False)
embed.add_field(name="Staff bans in the last day",
value=format(watchdog['staff_rollingDaily'], ',d'),
inline=False)
embed.add_field(name="Watchdog bans in the last day",
value=format(watchdog['watchdog_rollingDaily'],
',d'),
inline=False)
embed.add_field(name="Staff Total Bans",
value=format(watchdog['staff_total'], ',d'),
inline=False)
embed.add_field(name="Watchdog Total Bans",
value=format(watchdog['watchdog_total'], ',d'),
inline=False)
return await ctx.send(embed=embed)
elif arg1.lower() == 'skyblock':
if not arg2 or arg2 == 'news':
route = Route('GET', '/skyblock/news')
sbnews = await self.bot.http.hypixel.request(route)
paginator = WrappedPaginator(prefix='',
suffix='',
max_size=250)
for entry in sbnews['items']:
paginator.add_line(
f'[{entry["title"]}]({entry["link"]})\n{entry["text"]}\n'
)
embed = discord.Embed(color=ctx.author.color,
timestamp=datetime.datetime.now(
datetime.timezone.utc))
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
return await interface.send_to(ctx)
if arg2 is None:
channel = ctx.message.channel
color = ctx.author.color
async with channel.typing():
try:
player = hypixel.Player(arg1)
except hypixel.PlayerNotFoundException:
raise commands.ArgumentParsingError(
'Couldn\'t find that player...')
except AttributeError:
raise commands.ArgumentParsingError(
'Couldn\'t find that player...')
p = player.JSON
tributes = p.get('tourney', {}).get('total_tributes',
0) # TOURNAMENT TRIBUTES
level = str(player.getLevel()).split('.')[0]
lastlogin = p.get('lastLogin', 0)
lastlogout = p.get('lastLogout', 1)
if lastlogin > lastlogout:
status = "Online!"
else:
status = "Offline!"
tag = None
route = Route('GET', f'/guild/player/{player.UUID}')
guild = await self.bot.http.sk1er.request(route)
if guild.get('success', False):
guild = guild['guild']
tag = guild['tag'] if 'tag' in guild else None
if tag:
tagcolor = guild[
'tagColor'] if 'tagColor' in guild else 'GRAY'
if tagcolor == 'GRAY' or tagcolor == 'GREY':
tag = f'§7[{tag}]'
elif tagcolor == 'GOLD':
tag = f'§6[{tag}]'
elif tagcolor == 'DARK_GREEN':
tag = f'§2[{tag}]'
elif tagcolor == 'YELLOW':
tag = f'§e[{tag}]'
elif tagcolor == 'DARK_AQUA':
tag = f'§3[{tag}]'
if not tag:
tag = f'§7[{tag}]'
route = Route('GET', f'/player/{player.UUID}')
apiplayer = await self.bot.http.sk1er.request(route)
if apiplayer['success']:
try:
nametag = apiplayer['player']['playerdisplay'].replace(
'§0YOUTUBE', '§fYOUTUBE'
) if 'playerdisplay' in apiplayer else apiplayer[
'player']['display'].replace(
'§0YOUTUBE', '§fYOUTUBE')
except Exception:
displayname = p['displayname']
nametag = f'§f{displayname}'
if tag:
nametag = f'{nametag} {tag}'
if nametag:
parsedtxt = mcfont.parse(nametag)
width = mcfont.get_width(parsedtxt)
img = Image.new('RGBA', (width + 25, 42))
mcfont.render((5, 0), parsedtxt, img)
buf = BytesIO()
img.save(buf, format='PNG')
buf.seek(0)
customtag = discord.File(buf,
'imaginereadingthefilename.png')
if arg2 is None:
msg = await ctx.send(
f"Retrieving {discord.utils.escape_mentions(discord.utils.escape_markdown(p['displayname']))}'s info..."
)
uuid = player.UUID
embed = discord.Embed(
title=
f"{discord.utils.escape_markdown(p['displayname'])}'s Info",
colour=color,
timestamp=datetime.datetime.now(datetime.timezone.utc))
if nametag:
embed.set_image(
url=f'attachment://imaginereadingthefilename.png')
embed.set_thumbnail(
url=f"https://crafatar.com/avatars/{uuid}?overlay=true"
)
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
embed.add_field(name="Online Status",
value=status,
inline=True)
language = p.get('userLanguage', 'Not Set')
embed.add_field(name="Language",
value=language,
inline=True)
channel = p.get('channel', 'ALL')
embed.add_field(name="Chat Channel",
value=channel,
inline=True)
embed.add_field(name="Level", value=level, inline=True)
embed.add_field(name="Karma",
value=format(p.get('karma', 0), ',d'),
inline=True)
if 'twitter' not in ctx.config.get('mod.linkfilter'):
twitter = p.get('socialMedia',
{}).get('TWITTER', 'Not Set')
else:
twitter = 'Hidden'
if 'youtube' not in ctx.config.get('mod.linkfilter'):
yt = p.get('socialMedia',
{}).get('links',
{}).get('YOUTUBE', 'Not Set')
else:
yt = 'Hidden'
insta = p.get('socialMedia',
{}).get('INSTAGRAM', 'Not Set')
if 'twitch' not in ctx.config.get('mod.linkfilter'):
twitch = p.get('socialMedia',
{}).get('TWITCH', 'Not Set')
else:
twitch = 'Hidden'
beam = p.get('socialMedia', {}).get('BEAM', 'Not Set')
if 'discord' not in ctx.config.get('mod.linkfilter'):
dscrd = p.get('socialMedia',
{}).get('links',
{}).get('DISCORD', 'Not Set')
else:
dscrd = 'Hidden'
embed.add_field(
name="Social Media",
value=
f"Twitter: {twitter}\nYouTube: {yt}\nInstagram: {insta}\nTwitch: {twitch}\nBeam: {beam}\nDiscord: {dscrd}",
inline=False)
if tributes != 0:
embed.add_field(name="Tournament Tributes",
value=tributes,
inline=False)
if customtag:
await msg.delete()
await ctx.send(embed=embed, file=customtag)
else:
await msg.edit(content=None, embed=embed)
elif arg2 == 'friends':
uuid = await self.name_to_uuid(arg1)
if not uuid:
return await ctx.error(f'Couldn\'t find that player')
route = Route('GET', f'/friends/{uuid}')
friends = await self.bot.http.sk1er.request(route)
paginator = WrappedPaginator(
prefix=f'''-----------------------------------------------------
Friends ({len(friends)}) >>''',
suffix='-----------------------------------------------------',
max_size=512)
for uuid in friends:
friend = friends[uuid]
try:
name = re.sub(remcolor, '', friend['display'], 0,
re.IGNORECASE)
time = str(
datetime.datetime.fromtimestamp(
friend['time'] / 1000,
datetime.timezone.utc)).split('.')[0]
except TypeError:
raise commands.ArgumentParsingError(
'Couldn\'t find that persons friends. Check the name and try again'
)
return
paginator.add_line(
discord.utils.escape_markdown(f'{name} added on {time}'))
embed = discord.Embed(color=ctx.author.color,
timestamp=datetime.datetime.now(
datetime.timezone.utc))
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await interface.send_to(ctx)
elif arg2 == 'guild':
uuid = await self.name_to_uuid(arg1)
if not uuid:
return await ctx.error(f'Couldn\'t find that player')
route = Route('GET', f'/guild/player/{uuid}')
guild = await self.bot.http.sk1er.request(route)
if guild['success'] != True:
raise commands.ArgumentParsingError(
'Couldn\'t find a guild. Maybe they aren\'t in one...')
guild = guild['guild']
embed = discord.Embed(colour=ctx.author.color,
timestamp=datetime.datetime.now(
datetime.timezone.utc))
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
gtagcolor = guild.get('tagColor',
'GRAY').lower().replace('_',
' ').capitalize()
gtag = guild.get('tag', '')
if gtag:
gtag = f'[{gtag}] ({gtagcolor})'
desc = guild.get('description', 'No Description Set.')
embed.add_field(
name=f"{arg1}'s guild",
value=
f"{guild['name']} {gtag}\n{desc}\n\nLevel: {guild['level_calc']}"
)
embed.add_field(name="Joinable?",
value=guild.get('joinable', 'False'),
inline=False)
embed.add_field(name="Publicly Listed?",
value=guild.get('publiclyListed', 'False'),
inline=False)
embed.add_field(name="Legacy Rank",
value=format(guild.get('legacyRanking', -1), ',d'),
inline=False)
games = []
for game in guild.get('preferredGames', ['this is a placeholder']):
games.append(picklegames.get(game, 'Preferred Games not set.'))
embed.add_field(name="Preferred Games",
value=', '.join(games)
if games else 'Preferred Games not set.',
inline=False)
ranks = []
for rank in guild.get('ranks', {
'name': 'No custom ranks',
'tag': ''
}):
name = rank['name']
if not rank.get('tag', ''):
tag = ''
else:
tag = rank['tag']
tag = f'[{tag}]'
ranks.append(f'{name} {tag}')
embed.add_field(
name="Ranks",
value='\n'.join(ranks) if ranks else 'No custom ranks',
inline=False)
await ctx.send(embed=embed)
gname = guild['name']
paginatorembed = discord.Embed(
title=f'{gname}\'s Members ({len(guild["members"])})',
color=ctx.author.color,
timestamp=datetime.datetime.now(datetime.timezone.utc))
ranktags = {}
for rank in ranks:
ranktags[rank.split(' ')[0]] = rank.split(' ')[1]
paginator = WrappedPaginator(prefix='', suffix='', max_size=380)
for member in guild['members']:
name = re.sub(
remcolor, '',
member.get('displayname',
member.get('name', 'Unknown Player')), 0,
re.IGNORECASE)
joined = str(
datetime.datetime.fromtimestamp(
member['joined'] / 1000,
datetime.timezone.utc)).split('.')[0]
try:
ranktag = ranktags[member['rank']]
except KeyError:
ranktag = ''
if ranktag != '':
paginator.add_line(f'{name} {ranktag} joined on {joined}')
else:
paginator.add_line(f'{name} joined on {joined}')
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=paginatorembed)
await interface.send_to(ctx)
async def reactrole(self,
ctx,
role: Role = None,
message: int = None,
emote: typing.Union[int, str] = None):
'''PFXautorole [<role name/id/mention> <message id> <emote>]\nUse command without arguments to disable'''
query = 'SELECT * FROM settings WHERE gid = $1;'
guildsettings = await self.bot.db.fetch(query, ctx.guild.id)
if guildsettings == []:
# await self.bot.db.execute(f'INSERT INTO settings (\"gid\") VALUES ({ctx.guild.id});')
# await self.bot.conn.commit()
con = await self.bot.db.acquire()
async with con.transaction():
query = 'INSERT INTO settings (\"gid\") VALUES ($1);'
await self.bot.db.execute(query, ctx.guild.id)
await self.bot.db.release(con)
if not role:
# await self.bot.db.execute(f'UPDATE settings SET (\"reactroleid\", \"reactrolemid\", \"reactroleeid\") = (0, 0, 0) WHERE gid = {ctx.guild.id}')
# await self.bot.conn.commit()
con = await self.bot.db.acquire()
async with con.transaction():
query = 'UPDATE settings SET (\"reactroleid\", \"reactrolemid\", \"reactroleeid\") = (0, 0, 0) WHERE gid = $1;'
await self.bot.db.execute(query, ctx.guild.id)
await self.bot.db.release(con)
try:
self.reactroles[ctx.guild.id] = None
except KeyError:
pass
return await ctx.send(
f'<a:fireSuccess:603214443442077708> Successfully disabled reaction role in {discord.utils.escape_mentions(ctx.guild.name)}'
)
else:
try:
msg = await ctx.channel.fetch_message(message)
except:
for channel in ctx.guild.text_channels:
perms = ctx.guild.me.permissions_in(channel)
try:
msg = await channel.fetch_message(message)
except:
continue
if not msg:
raise commands.ArgumentParsingError('Missing Message ID')
if not emote:
raise commands.ArgumentParsingError('Missing Emote')
roleid = role.id
messageid = msg.id
try:
emote = int(emote)
except Exception:
emote = str(emote)
if type(emote) == int:
emoteid = discord.utils.get(self.bot.emojis, id=emote)
if emoteid == None:
raise commands.ArgumentParsingError(
'Can\'t find emote from ID.')
else:
emote = emoteid
emoteid = emoteid.id
elif type(emote) == str:
emoteid = emote
# await self.bot.db.execute(f'UPDATE settings SET (\"reactroleid\", \"reactrolemid\", \"reactroleeid\") = ({roleid}, {messageid}, \"{emoteid}\") WHERE gid = {ctx.guild.id}')
# await self.bot.conn.commit()
con = await self.bot.db.acquire()
async with con.transaction():
query = 'UPDATE settings SET (\"reactroleid\", \"reactrolemid\", \"reactroleeid\") = ($2, $3, $4) WHERE gid = $1;'
await self.bot.db.execute(query, ctx.guild.id, roleid,
messageid, emoteid)
await self.bot.db.release(con)
await msg.add_reaction(emote)
self.reactroles[ctx.guild.id] = {
"role": roleid,
"message": messageid,
"emote": emoteid
}
return await ctx.send(
f'<a:fireSuccess:603214443442077708> Successfully enabled reaction role in {discord.utils.escape_mentions(ctx.guild.name)}!'
)
def calculate(self, embed_msg, rarity, curr_level, goal_level, curr_exp, mystic_count, fine_count, normal_count):
with open(f"./wep_exp_per_level/wep_exp_per_level_{rarity}.json", "r") as f:
next_level_exp = json.load(f)
f.close()
if not str(curr_level) in next_level_exp:
raise commands.ArgumentParsingError(message="Please enter a valid weapon level.")
if not str(goal_level) in next_level_exp:
raise commands.ArgumentParsingError(message="Please enter a valid goal level.")
if curr_exp > int(next_level_exp[str(curr_level)]):
raise commands.ArgumentParsingError(message="Invalid current weapon experience points value.")
msg = self.format_char_stats(rarity, curr_level, curr_exp, next_level_exp[str(curr_level)], mystic_count, fine_count, normal_count)
embed_msg.add_field(name="**Before**", value=msg, inline=True)
start_mystic_count = mystic_count
start_fine_count = fine_count
start_normal_count = normal_count
total_fine_refunded = 0
total_normal_refunded = 0
while mystic_count + fine_count + normal_count > 0 and curr_level < goal_level:
prev_mystic_count = mystic_count
prev_fine_count = fine_count
prev_normal_count = normal_count
curr_upper_level_cap = 0
for level_cap in ASCENSION_MILESTONES:
if level_cap > curr_level:
curr_upper_level_cap = level_cap
else:
break
level_upto = curr_upper_level_cap
if goal_level < curr_upper_level_cap:
level_upto = goal_level
# Add exp
new_level, new_exp, mystic_count, fine_count, normal_count, fine_ore_refunded, normal_ore_refunded, wasted_exp = self.add_exp(next_level_exp, curr_level, level_upto, curr_exp, mystic_count, fine_count, normal_count)
total_fine_refunded += fine_ore_refunded
total_normal_refunded += normal_ore_refunded
embed_msg.add_field(name=f"**Leveling: {curr_level} -> {level_upto}**", value=f"Reached level {new_level:,}/{curr_upper_level_cap:,}\nCurrent exp: {new_exp:,}/{next_level_exp[str(new_level)]:,}", inline=True)
embed_msg.add_field(name=f"**Used**", value=f"{prev_mystic_count - mystic_count}x Mystic\n{prev_fine_count - fine_count +fine_ore_refunded}x Fine\n{prev_normal_count - normal_count + normal_ore_refunded}x Enhancement", inline=True)
embed_msg.add_field(name=f"**Refunded**", value=f"{fine_ore_refunded}x Fine\n{normal_ore_refunded}x Enhancement", inline=True)
curr_level = new_level
curr_exp = new_exp
msg = self.format_char_stats(rarity, curr_level, curr_exp, next_level_exp[str(curr_level)], mystic_count, fine_count, normal_count)
embed_msg.insert_field_at(index=1, name="**After**", value=msg, inline=True)
if curr_level >= goal_level:
msg = f"You have enough enhancement ores to reach level {goal_level}.\n\n"
else:
msg = f"You do not have enough enhancement ores to reach level {goal_level}.\n\n"
msg += f"__Total used__\n{start_mystic_count - mystic_count}x Mystic\n{start_fine_count - fine_count + total_fine_refunded}x Fine\n{start_normal_count - normal_count + total_normal_refunded}x Enhancement\n\n"
msg += f"__Total refunded__\n{total_fine_refunded}x Fine\n{total_normal_refunded}x Enhancement\n"
embed_msg.insert_field_at(index=2, name="**Summary**", value=msg, inline=False)
return embed_msg
def _print_message(self, message, file=None):
if message:
raise commands.ArgumentParsingError(message)
async def help(self, ctx, item: str = None):
cogs = []
cmds = {}
allcmds = False
cmdhelp = False
usedprefix = ctx.prefix
if usedprefix == f'{ctx.guild.me.mention} ':
usedprefix = '@Fire '
if item:
if item == 'all':
allcmds = True
cmdhelp = False
else:
cmd = self.bot.get_command(item)
if not cmd:
raise commands.ArgumentParsingError(
f'No command called {item}')
cmdhelp = True
else:
cmdhelp = False
if not cmdhelp:
for cog in self.bot.cogs.values():
skip = False
if not allcmds:
if cog.qualified_name.lower() == 'jishaku':
skip = True
if cog.qualified_name.lower() == 'help':
skip = True
if cog.qualified_name.lower() == 'premium commands':
premiumGuilds = cog.premiumGuilds
if not ctx.guild.id in premiumGuilds:
skip = True
if cog.qualified_name.lower() == 'discordbotsorgapi':
skip = True
if cog.qualified_name.lower() == 'fire api':
skip = True
if not skip:
cogs.append(f'**{cog.qualified_name.upper()}**')
cmds[f'**{cog.qualified_name.upper()}**'] = []
for cmd in cog.get_commands():
if cmd.hidden:
if allcmds:
cmds[
f'**{cog.qualified_name.upper()}**'].append(
cmd.name)
else:
pass
else:
cmds[f'**{cog.qualified_name.upper()}**'].append(
cmd.name)
cmds[f'**{cog.qualified_name.upper()}**'] = ' - '.join(
cmds[f'**{cog.qualified_name.upper()}**'])
elif cmd:
name = cmd.name
desc = cmd.description
usage = cmd.help.replace('PFX', ctx.prefix)
embed = discord.Embed(colour=ctx.author.color)
embed.set_author(
name=f"Help has arrived for {name}!",
icon_url=
"https://cdn.discordapp.com/avatars/444871677176709141/1b7beb893e2bf1d2a759d869e7f287dd.webp?size=1024"
)
embed.add_field(name="Description", value=desc, inline=False)
embed.add_field(name="Usage", value=usage, inline=False)
embed.set_footer(text="<> = Required | [<>] = Optional")
await ctx.send(embed=embed)
return
text = []
for cog in cogs:
text.append(f'{cog}\n{cmds[cog]}\n')
embed = discord.Embed(colour=ctx.author.color,
description='\n'.join(text))
embed.set_author(
name="Help has arrived!",
icon_url=
"https://cdn.discordapp.com/avatars/444871677176709141/1b7beb893e2bf1d2a759d869e7f287dd.webp?size=1024"
)
embed.set_footer(
text=f"Do {usedprefix}help <command> for more information")
await ctx.send(embed=embed)
def calculate(self, embed_msg, curr_level, goal_level, curr_exp,
herowit_count, advexp_count, wandadv_count):
with open("./char_exp_per_level/char_exp_per_level.json", "r") as f:
next_level_exp = json.load(f)
f.close()
if not str(curr_level) in next_level_exp:
raise commands.ArgumentParsingError(
message="Please enter a valid character level.")
if not str(goal_level) in next_level_exp:
raise commands.ArgumentParsingError(
message="Please enter a valid character level.")
if curr_exp > int(next_level_exp[str(curr_level)]):
raise commands.ArgumentParsingError(
message="Invalid current character experience points value.")
msg = self.format_char_stats(curr_level, curr_exp,
next_level_exp[str(curr_level)],
herowit_count, advexp_count,
wandadv_count)
embed_msg.add_field(name="**Before**", value=msg, inline=True)
start_herowit_count = herowit_count
start_advexp_count = advexp_count
start_wandadv_count = wandadv_count
while herowit_count + advexp_count + wandadv_count > 0 and curr_level < goal_level:
prev_herowit_count = herowit_count
prev_advexp_count = advexp_count
prev_wandadv_count = wandadv_count
curr_upper_level_cap = 0
for level_cap in ASCENSION_MILESTONES:
if level_cap > curr_level:
curr_upper_level_cap = level_cap
else:
break
level_upto = curr_upper_level_cap
if goal_level < curr_upper_level_cap:
level_upto = goal_level
# Add exp
new_level, new_exp, herowit_count, advexp_count, wandadv_count, wasted_exp = self.add_exp(
next_level_exp, curr_level, level_upto, curr_exp,
herowit_count, advexp_count, wandadv_count)
embed_msg.add_field(
name=f"**Leveling: {curr_level} -> {level_upto}**",
value=
f"Reached level {new_level:,}/{curr_upper_level_cap:,}\nCurrent exp: {new_exp:,}/{next_level_exp[str(new_level)]:,}\n",
inline=True)
embed_msg.add_field(
name=f"**Used**",
value=
f"{prev_herowit_count - herowit_count}x Hero's Wit\n{prev_advexp_count - advexp_count}x Adventurer's Experience\n{prev_wandadv_count - wandadv_count}x Wanderer's Advice",
inline=True)
embed_msg.add_field(name=f"**More Details**",
value=f"Exp wasted: {wasted_exp}\n")
curr_level = new_level
curr_exp = new_exp
msg = self.format_char_stats(curr_level, curr_exp,
next_level_exp[str(curr_level)],
herowit_count, advexp_count,
wandadv_count)
embed_msg.insert_field_at(index=1,
name="**After**",
value=msg,
inline=True)
if curr_level >= goal_level:
msg = f"You have enough materials to reach level {goal_level}.\n\n"
else:
msg = f"You do not have enough materials to reach level {goal_level}.\n\n"
msg += f"__Total used__\n{start_herowit_count - herowit_count}x Hero's Wit\n{start_advexp_count - advexp_count}x Adventurer's Experience\n{start_wandadv_count - wandadv_count}x Wanderer's Advice\n\n"
embed_msg.insert_field_at(index=2,
name="**Summary**",
value=msg,
inline=False)
return embed_msg
async def hypixel(self, ctx, arg1: str = None, arg2: str = None):
if arg1 is None:
msg = await ctx.send("I need an IGN, `key` or `watchdog`",
delete_after=5)
return
arg1 = arg1.lower()
if arg2:
arg2 = arg2.lower()
if arg1.lower() == "watchdog":
async with aiohttp.ClientSession() as session:
async with session.get(
f'https://api.hypixel.net/watchdogstats?key={hypixelkey}'
) as resp:
watchdog = await resp.json()
color = ctx.author.color
embed = discord.Embed(title="Watchdog Stats",
colour=color,
timestamp=datetime.datetime.utcnow())
embed.set_thumbnail(
url="https://hypixel.net/attachments/cerbtrimmed-png.245674/")
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
embed.add_field(name="Watchdog Bans in the last minute",
value=watchdog['watchdog_lastMinute'],
inline=False)
embed.add_field(name="Staff bans in the last day",
value=format(watchdog['staff_rollingDaily'], ',d'),
inline=False)
embed.add_field(name="Watchdog bans in the last day",
value=format(watchdog['watchdog_rollingDaily'],
',d'),
inline=False)
embed.add_field(name="Staff Total Bans",
value=format(watchdog['staff_total'], ',d'),
inline=False)
embed.add_field(name="Watchdog Total Bans",
value=format(watchdog['watchdog_total'], ',d'),
inline=False)
await ctx.send(embed=embed)
return
if arg1.lower() == "key":
lastmin = "0"
async with aiohttp.ClientSession() as session:
async with session.get(
f'https://api.hypixel.net/key?key={hypixelkey}'
) as resp:
key = await resp.json()
lastmin = key.get('record', {}).get('queriesInPastMin', 0)
color = ctx.author.color
embed = discord.Embed(title="My API Key Stats",
colour=color,
timestamp=datetime.datetime.utcnow())
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
embed.add_field(
name="Owner",
value="GamingGeeek (4686e7b58815485d8bc4a45445abb984)",
inline=False)
embed.add_field(name="Total Requests",
value=format(key['record']['totalQueries'], ',d'),
inline=False)
embed.add_field(name="Requests in the past minute",
value=lastmin,
inline=False)
await ctx.send(embed=embed)
return
if arg1.lower() == 'leaderboard':
if arg2 is None:
return
#Make available leaderboards embed
elif arg2.lower() == 'level':
msg = await ctx.send(f"Generating Network Level leaderboard..."
)
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://sk1er.club/leaderboards/newdata/LEVEL'
) as resp:
content = await resp.read()
lbjson = table2json(content, [
'Position', 'Change', 'Name', 'Level', 'Karma', 'Kills',
'Wins'
])
paginator = WrappedPaginator(
prefix='```vbs\n-------------------------------------',
suffix='-------------------------------------\n```',
max_size=420)
for player in lbjson:
try:
pos = player['Position']
name = player['Name']
level = player['Level']
paginator.add_line(f'[{pos}] {name} - {level}')
except Exception as e:
pass
embed = discord.Embed(title='Network Level Leaderboard',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await msg.delete()
return await interface.send_to(ctx)
elif arg2.lower() == 'karma':
msg = await ctx.send(f"Generating Karma leaderboard...")
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://sk1er.club/leaderboards/newdata/KARMA'
) as resp:
content = await resp.read()
lbjson = table2json(content, [
'Position', 'Change', 'Name', 'Karma', 'Level', 'Kills',
'Wins'
])
paginator = WrappedPaginator(
prefix='```vbs\n-------------------------------------',
suffix='-------------------------------------\n```',
max_size=420)
for player in lbjson:
try:
pos = player['Position']
name = player['Name']
karma = player['Karma']
paginator.add_line(f'[{pos}] {name} - {karma}')
except Exception as e:
pass
embed = discord.Embed(title='Karma Leaderboard',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await msg.delete()
return await interface.send_to(ctx)
elif arg2.lower() == 'coins':
msg = await ctx.send(f"Generating Coins leaderboard...")
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://sk1er.club/leaderboards/newdata/COINS'
) as resp:
content = await resp.read()
lbjson = table2json(content, [
'Position', 'Change', 'Name', 'Coins', 'Karma', 'Kills',
'Wins'
])
paginator = WrappedPaginator(
prefix='```vbs\n-------------------------------------',
suffix='-------------------------------------\n```',
max_size=420)
for player in lbjson:
try:
pos = player['Position']
name = player['Name']
coins = player['Coins']
paginator.add_line(f'[{pos}] {name} - {coins}')
except Exception as e:
pass
embed = discord.Embed(title='Coins Leaderboard',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await msg.delete()
return await interface.send_to(ctx)
elif arg2.lower() == 'kills':
msg = await ctx.send(f"Generating Total Kills leaderboard...")
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://sk1er.club/leaderboards/newdata/TOTAL_KILLS'
) as resp:
content = await resp.read()
lbjson = table2json(content, [
'Position', 'Change', 'Name', 'Kills', 'Level', 'Wins',
'Quests'
])
paginator = WrappedPaginator(
prefix='```vbs\n-------------------------------------',
suffix='-------------------------------------\n```',
max_size=420)
for player in lbjson:
try:
pos = player['Position']
name = player['Name']
kills = player['Kills']
paginator.add_line(f'[{pos}] {name} - {kills}')
except Exception as e:
pass
embed = discord.Embed(title='Total Kills Leaderboard',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await msg.delete()
return await interface.send_to(ctx)
elif arg2.lower() == 'wins':
msg = await ctx.send(f"Generating Total Wins leaderboard...")
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://sk1er.club/leaderboards/newdata/TOTAL_WINS'
) as resp:
content = await resp.read()
lbjson = table2json(content, [
'Position', 'Change', 'Name', 'Wins', 'Level', 'Kills',
'Quests'
])
paginator = WrappedPaginator(
prefix='```vbs\n-------------------------------------',
suffix='-------------------------------------\n```',
max_size=420)
for player in lbjson:
try:
pos = player['Position']
name = player['Name']
wins = player['Wins']
paginator.add_line(f'[{pos}] {name} - {wins}')
except Exception as e:
pass
embed = discord.Embed(title='Total Wins Leaderboard',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await msg.delete()
return await interface.send_to(ctx)
elif arg2.lower() == 'glevel':
msg = await ctx.send(f"Generating Guild Level leaderboard...")
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://sk1er.club/leaderboards/newdata/GUILD_LEVEL'
) as resp:
content = await resp.read()
lbjson = table2json(content, [
'Position', 'Change', 'Name', 'Level', 'Wins', 'Exp',
'Legacy', 'Created'
])
paginator = WrappedPaginator(
prefix='```vbs\n-------------------------------------',
suffix='-------------------------------------\n```',
max_size=420)
for player in lbjson:
try:
pos = player['Position']
name = player['Name']
level = player['Level']
paginator.add_line(f'[{pos}] {name} - {level}')
except Exception as e:
pass
embed = discord.Embed(title='Guild Level Leaderboard',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await msg.delete()
return await interface.send_to(ctx)
elif arg2.lower() == 'gexperience':
msg = await ctx.send(
f"Generating Guild Experience leaderboard...")
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://sk1er.club/leaderboards/newdata/GUILD_LEVEL'
) as resp:
content = await resp.read()
lbjson = table2json(content, [
'Position', 'Change', 'Name', 'Level', 'Wins', 'Exp',
'Legacy', 'Created'
])
paginator = WrappedPaginator(
prefix='```vbs\n-------------------------------------',
suffix='-------------------------------------\n```',
max_size=420)
for player in lbjson:
try:
pos = player['Position']
name = player['Name']
exp = player['Exp']
paginator.add_line(f'[{pos}] {name} - {exp}')
except Exception as e:
pass
embed = discord.Embed(title='Guild Experience Leaderboard',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await msg.delete()
return await interface.send_to(ctx)
elif arg2.lower() == 'gwins':
msg = await ctx.send(f"Generating Guild Wins leaderboard...")
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://sk1er.club/leaderboards/newdata/GUILD_WINS'
) as resp:
content = await resp.read()
lbjson = table2json(content, [
'Position', 'Change', 'Name', 'Wins', 'Level', 'Exp',
'Legacy', 'Created'
])
paginator = WrappedPaginator(
prefix='```vbs\n-------------------------------------',
suffix='-------------------------------------\n```',
max_size=420)
for player in lbjson:
try:
pos = player['Position']
name = player['Name']
wins = player['Wins']
paginator.add_line(f'[{pos}] {name} - {wins}')
except Exception as e:
pass
embed = discord.Embed(title='Guild Wins Leaderboard',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await msg.delete()
return await interface.send_to(ctx)
else:
return await ctx.send('Unknown leaderboard.')
elif arg1 == 'skyblock':
if not arg2 or arg2 == 'news':
async with aiohttp.ClientSession() as session:
async with session.get(
f'https://api.hypixel.net/skyblock/news?key={hypixelkey}'
) as resp:
sbnews = await resp.json()
paginator = WrappedPaginator(prefix='',
suffix='',
max_size=250)
for entry in sbnews['items']:
paginator.add_line(
f'[{entry["title"]}]({entry["link"]})\n{entry["text"]}\n'
)
embed = discord.Embed(color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
return await interface.send_to(ctx)
if arg2 is None:
cleaned = discord.utils.escape_mentions(
discord.utils.escape_markdown(arg1))
msg = await ctx.send(
f"Requesting info about {cleaned} from the Hypixel API!")
channel = ctx.message.channel
color = ctx.author.color
async with channel.typing():
try:
player = hypixel.Player(arg1)
except hypixel.PlayerNotFoundException:
raise commands.ArgumentParsingError(
'Couldn\'t find that player...')
except AttributeError:
raise commands.ArgumentParsingError(
'Couldn\'t find that player...')
p = player.JSON
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
tributes = p.get('tourney', {}).get('total_tributes',
0) # TOURNAMENT TRIBUTES
level = str(player.getLevel()).split('.')[0]
lastlogin = p.get('lastLogin', 0)
lastlogout = p.get('lastLogout', 1)
if lastlogin > lastlogout:
status = "Online!"
else:
status = "Offline!"
tag = None
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://api.sk1er.club/guild/player/{player.UUID}'
) as resp:
guild = await resp.json()
if guild['success']:
guild = guild['guild']
tag = guild['tag'] if 'tag' in guild else None
if tag:
tagcolor = guild[
'tagColor'] if 'tagColor' in guild else 'GRAY'
if tagcolor == 'GRAY' or tagcolor == 'GREY':
tag = f'§7[{tag}]'
elif tagcolor == 'GOLD':
tag = f'§6[{tag}]'
elif tagcolor == 'DARK_GREEN':
tag = f'§2[{tag}]'
elif tagcolor == 'YELLOW':
tag = f'§e[{tag}]'
elif tagcolor == 'DARK_AQUA':
tag = f'§3[{tag}]'
if not tag:
tag = f'§7[{tag}]'
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://api.sk1er.club/player/{arg1}') as resp:
apiplayer = await resp.json()
if apiplayer['success']:
try:
nametag = apiplayer['player']['playerdisplay'].replace(
'§0YOUTUBE', '§fYOUTUBE'
) if 'playerdisplay' in apiplayer else apiplayer[
'player']['display'].replace(
'§0YOUTUBE', '§fYOUTUBE')
except Exception:
displayname = p['displayname']
nametag = f'§f{displayname}'
if tag:
nametag = f'{nametag} {tag}'
if nametag:
parsedtxt = mcfont.parse(nametag)
width = mcfont.get_width(parsedtxt)
img = Image.new('RGBA', (width + 25, 42))
mcfont.render((5, 0), parsedtxt, img)
buf = BytesIO()
img.save(buf, format='PNG')
buf.seek(0)
customtag = discord.File(buf,
'imaginereadingthefilename.png')
if arg2 is None:
msg = await ctx.send(
f"Retrieving {discord.utils.escape_mentions(discord.utils.escape_markdown(p['displayname']))}'s info..."
)
uuid = player.UUID
embed = discord.Embed(
title=
f"{discord.utils.escape_markdown(p['displayname'])}'s Info",
colour=color,
timestamp=datetime.datetime.utcnow())
if nametag:
embed.set_image(
url=f'attachment://imaginereadingthefilename.png')
embed.set_thumbnail(
url=f"https://crafatar.com/avatars/{uuid}?overlay=true"
)
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
embed.add_field(name="Online Status",
value=status,
inline=True)
language = p.get('userLanguage', 'Not Set')
embed.add_field(name="Language",
value=language,
inline=True)
channel = p.get('channel', 'ALL')
embed.add_field(name="Chat Channel",
value=channel,
inline=True)
embed.add_field(name="Level", value=level, inline=True)
embed.add_field(name="Karma",
value=format(p.get('karma', 0), ',d'),
inline=True)
if 'twitter' not in self.bot.configs[ctx.guild.id].get(
'mod.linkfilter'):
twitter = p.get('socialMedia',
{}).get('TWITTER', 'Not Set')
else:
twitter = 'Hidden'
if 'youtube' not in self.bot.configs[ctx.guild.id].get(
'mod.linkfilter'):
yt = p.get('socialMedia',
{}).get('links',
{}).get('YOUTUBE', 'Not Set')
else:
yt = 'Hidden'
insta = p.get('socialMedia',
{}).get('INSTAGRAM', 'Not Set')
if 'twitch' not in self.bot.configs[ctx.guild.id].get(
'mod.linkfilter'):
twitch = p.get('socialMedia',
{}).get('TWITCH', 'Not Set')
else:
twitch = 'Hidden'
beam = p.get('socialMedia', {}).get('BEAM', 'Not Set')
if 'discord' not in self.bot.configs[ctx.guild.id].get(
'mod.linkfilter'):
dscrd = p.get('socialMedia',
{}).get('links',
{}).get('DISCORD', 'Not Set')
else:
dscrd = 'Hidden'
embed.add_field(
name="Social Media",
value=
f"Twitter: {twitter}\nYouTube: {yt}\nInstagram: {insta}\nTwitch: {twitch}\nBeam: {beam}\nDiscord: {dscrd}",
inline=False)
if tributes != 0:
embed.add_field(name="Tournament Tributes",
value=tributes,
inline=False)
if customtag:
await msg.delete()
await ctx.send(embed=embed, file=customtag)
else:
await msg.edit(content=None, embed=embed)
elif arg2 == 'friends':
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://api.sk1er.club/friends/{arg1}') as resp:
friends = await resp.json()
paginator = WrappedPaginator(
prefix=
f'-----------------------------------------------------\n Friends ({len(friends)}) >>',
suffix='-----------------------------------------------------',
max_size=512)
for uuid in friends:
friend = friends[uuid]
try:
name = re.sub(remcolor, '', friend['display'], 0,
re.IGNORECASE)
time = str(
datetime.datetime.utcfromtimestamp(friend['time'] /
1000)).split('.')[0]
except TypeError:
raise commands.ArgumentParsingError(
'Couldn\'t find that persons friends. Check the name and try again'
)
return
paginator.add_line(
discord.utils.escape_markdown(f'{name} added on {time}'))
embed = discord.Embed(color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await interface.send_to(ctx)
elif arg2 == 'guild':
uuid = await self.nameToUUID(arg1)
headers = {
'USER-AGENT':
'Fire (Python 3.7.2 / aiohttp 3.3.2) | Fire Discord Bot',
'CONTENT-TYPE': 'application/json'
}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(
f'https://api.sk1er.club/guild/player/{uuid}') as resp:
guild = await resp.json()
if guild['success'] != True:
raise commands.ArgumentParsingError(
'Couldn\'t find a guild. Maybe they aren\'t in one...')
guild = guild['guild']
embed = discord.Embed(colour=ctx.author.color,
timestamp=datetime.datetime.utcnow())
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
gtagcolor = guild.get('tagColor',
'GRAY').lower().replace('_',
' ').capitalize()
gtag = guild.get('tag', '')
if gtag:
gtag = f'[{gtag}] ({gtagcolor})'
desc = guild.get('description', 'No Description Set.')
embed.add_field(
name=f"{arg1}'s guild",
value=
f"{guild['name']} {gtag}\n{desc}\n\nLevel: {guild['level_calc']}"
)
embed.add_field(name="Joinable?",
value=guild.get('joinable', 'False'),
inline=False)
embed.add_field(name="Publicly Listed?",
value=guild.get('publiclyListed', 'False'),
inline=False)
embed.add_field(name="Legacy Rank",
value=format(guild.get('legacyRanking', -1), ',d'),
inline=False)
games = []
for game in guild.get('preferredGames', ['this is a placeholder']):
games.append(picklegames.get(game, 'Preferred Games not set.'))
embed.add_field(name="Preferred Games",
value=', '.join(games)
if games else 'Preferred Games not set.',
inline=False)
ranks = []
for rank in guild.get('ranks', {
'name': 'No custom ranks',
'tag': ''
}):
name = rank['name']
if not rank.get('tag', ''):
tag = ''
else:
tag = rank['tag']
tag = f'[{tag}]'
ranks.append(f'{name} {tag}')
embed.add_field(
name="Ranks",
value='\n'.join(ranks) if ranks else 'No custom ranks',
inline=False)
await ctx.send(embed=embed)
gname = guild['name']
paginatorembed = discord.Embed(
title=f'{gname}\'s Members ({len(guild["members"])})',
color=ctx.author.color,
timestamp=datetime.datetime.utcnow())
ranktags = {}
for rank in ranks:
ranktags[rank.split(' ')[0]] = rank.split(' ')[1]
paginator = WrappedPaginator(prefix='', suffix='', max_size=380)
for member in guild['members']:
name = re.sub(
remcolor, '',
member.get('displayname',
member.get('name', 'Unknown Player')), 0,
re.IGNORECASE)
joined = str(
datetime.datetime.utcfromtimestamp(member['joined'] /
1000)).split('.')[0]
try:
ranktag = ranktags[member['rank']]
except KeyError:
ranktag = ''
if ranktag != '':
paginator.add_line(f'{name} {ranktag} joined on {joined}')
else:
paginator.add_line(f'{name} joined on {joined}')
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=paginatorembed)
await interface.send_to(ctx)
async def convert(cls, ctx, argument):
if not argument.upper() in Region.VALID_REGIONS:
raise commands.ArgumentParsingError(
f"Invalid region; expected {'/'.join(Region.VALID_REGIONS)}")
return cls(argument)
async def slencounter(self, ctx, *args):
try:
parsed_args = SquadlockeArgParsers.SLENCOUNTER_ARG_PARSER.parse_known_args(
args)[0]
except ArgumentParserError as e:
raise commands.ArgumentParsingError(message=e.args[0])
re = RouteEncounter(parsed_args.route)
if parsed_args.get_info:
encounter_info = re.get_info()
i = 0
for section in encounter_info:
for weather in encounter_info[section]:
message = "```"
if len(encounter_info) > 1:
message += "Section: " + section + " (id: " + str(
i) + ")\n"
if len(encounter_info[section]) > 1:
message += "Weather: " + weather + " (id: " + str(
WEATHER_DICT[weather]) + ")\n"
message += "\n" + encounter_info[section][weather] + "```"
await ctx.channel.send(message)
i = i + 1
return
if not parsed_args.all:
re.add_area_filter([2, 3, 6, 7], -1)
if parsed_args.fishing:
re.add_area_filter([2], False)
if parsed_args.weather is not None:
re.add_weather_filter(parsed_args.weather.split(","), 0)
if parsed_args.section is not None:
re.add_section_filter(parsed_args.section.split(","), 0)
if parsed_args.area is not None:
re.add_area_filter(parsed_args.area.split(","), 0)
enc = re.get_encounter()
try:
v1, v2 = enc.get()
except AttributeError:
LOGGER.warning(
"SquadlockeCog::slencounter - No encounters for specified arguments: "
+ str(parsed_args))
raise commands.UserInputError(
message=
"There are no encounters available on this route with the specified "
"filters.")
generic_embed_descr = "Encounter rate: " + str(v1.get("rate")) + "%\n Normalized encounter rate: " + \
str(v1.get("n_rate")) + "%\n Area: " + ENCOUNTER_AREA_DICT.inverse[v1.get("area")][0] \
+ "\n Section: " + v1.get("section")
if v1.get("weather") != "None":
generic_embed_descr += "\n Weather: " + v1.get("weather")
embed_color = discord.Color.purple()
v2embed = None
if v2 is not None:
v2_embed_descr = "Exclusive to Pokémon Shield!\n" + generic_embed_descr
generic_embed_descr = "Exclusive to Pokémon Sword!\n" + generic_embed_descr
v2embed = build_embed(title=v2.get("name"),
thumbnail="https://serebii.net" +
v2.get("sprite"),
description=v2_embed_descr,
color=discord.Color.red())
embed_color = discord.Color.blue()
v1embed = build_embed(title=v1.get("name"),
thumbnail="https://serebii.net" +
v1.get("sprite"),
description=generic_embed_descr,
color=embed_color)
pub_embed = build_embed(title=ctx.message.author.name +
" encountered something!",
thumbnail=RESOURCES["questionMark"],
description=ctx.message.author.name +
" encountered a Pokemon.\n The details of the "
"encounter are hidden to\neveryone else.\nNo "
"peeking!",
color=discord.Color.dark_grey())
if not parsed_args.public:
output_channel = ctx.message.author
await ctx.channel.send(embed=pub_embed)
else:
output_channel = ctx.channel
await output_channel.send(embed=v1embed)
if v2embed is not None:
await ctx.message.author.send(embed=v2embed)
def valid_category(self, category_name):
if category_name in ("add", "remove", "delete", "list", "all", "info"):
raise commands.ArgumentParsingError(
"Provided category name is banned")
else:
return True
async def OCRSPACE(self, ctx, *, args=None):
"""ocr.space engine V1. Results not what you expected? Try ocr2 command.
args = [link] [language]
or args = [language] if image as attachment
or args = [link] if language is english
args can also be empty if language is english (default) and image in attachment
Use ocrlangs command to see supported languages.
"""
if args:
args = args.split(' ')
else:
args = []
if '-v2' in args:
engine = 2
del args[-1]
lang = 'eng'
if not args and len(ctx.message.attachments) == 0:
raise commands.MissingRequiredArgument(args)
elif not args:
link = ctx.message.attachments[0].url
elif isURL(args[0]):
link = args[0]
else:
raise commands.ArgumentParsingError()
else:
engine = 1
if not args and len(ctx.message.attachments) == 0:
raise commands.MissingRequiredArgument(args)
elif not args:
link = ctx.message.attachments[0].url
lang = 'eng'
elif isURL(args[0]) and len(args) == 1:
link = args[0]
lang = 'eng'
elif len(args) == 1 and len(ctx.message.attachments) != 0:
link = ctx.message.attachments[0].url
lang = self.getLang(args[0])
elif len(args) == 2 and isURL(args[0]):
link = args[0]
lang = self.getLang(args[1])
elif len(args) == 2 and isURL(args[1]):
lang = self.getLang(args[0])
link = args[1]
else:
raise commands.ArgumentParsingError()
data = await REST('https://api.ocr.space/parse/image',
method='POST',
headers={'apikey': getAPIKey('ocrspace')},
data={
'url': link,
'language': lang,
'OCREngine': engine
})
if data['OCRExitCode'] != 1:
await ctx.send(f"`{data['ErrorMessage']}`")
else:
await ctx.send(f"```{data['ParsedResults'][0]['ParsedText']} ```")
async def convert(cls, ctx, argument):
if not argument.upper() in Race.VALID_RACES:
raise commands.ArgumentParsingError(
f"Invalid race; expected {'/'.join(Race.VALID_RACES)}")
return cls(argument)
async def extract(self,
query,
command: bool = False,
payload: discord.RawReactionActionEvent = None,
ctx: "MyContext" = None,
guild=None,
channel: discord.TextChannel = None,
message: discord.Message = None):
if ctx is None and message is not None:
ctx = await self.bot.get_context(message)
if guild is None and not ctx.guild_id:
raise commands.ArgumentParsingError()
if channel is None and not ctx.channel_id:
raise commands.ArgumentParsingError()
if message is None and not command:
raise commands.ArgumentParsingError()
# TODO: check the max file size of the server and change the quality of the video to match
reg = re.findall(PATTERN, query)
if len(reg) != 1:
return await ctx.send(
embed=embed(title="That is not a reddit post url",
color=MessageColors.ERROR))
data = await self.reddit.submission(url=reg[0])
link, linkdata, video = None, None, None
# try:
if data.media is not None and "reddit_video" in data.media:
link = data.media["reddit_video"]["hls_url"]
content_length = 0
async with self.lock:
async with self.bot.session.get(
link,
headers={
'User-Agent':
'Friday Discord bot v1.0.0 (by /u/Motostar19)'
}) as r:
if r.status == 200:
content_length = r.content_length
loop = asyncio.get_event_loop()
linkdata = await loop.run_in_executor(
None, lambda: ytdl.extract_info(link, content_length))
ext = "webm" # linkdata['ext']
video = True
# linkdata = await ytdl.extract_info(link, download=True)
if 'entries' in linkdata:
# take first item from a playlist
linkdata = linkdata['entries'][0]
# link = linkdata["url"]
# pprint.pprint(linkdata)
# print(f'{linkdata["extractor"]}-{linkdata["id"]}-{linkdata["title"]}.{linkdata["ext"]}')
# link = data["media"]["reddit_video"]["fallback_url"]
else:
link = data.url
# except:
# raise
# TODO: Does not get url for videos atm
channel = message.channel if payload is not None else ctx.channel
nsfw = channel.nsfw if channel is not None and not isinstance(
channel, discord.Thread
) else channel.parent.nsfw if channel is not None and isinstance(
channel, discord.Thread) else False
if (nsfw is True and data.over_18 is True) or (
nsfw is False
and data.over_18 is False) or (nsfw is True
and data.over_18 is False):
spoiler = False
else:
spoiler = True
if video is True:
thispath = os.getcwd()
if "\\" in thispath:
seperator = "\\\\"
else:
seperator = "/"
mp4file = f'{thispath}{seperator}{linkdata["extractor"]}-{linkdata["id"]}-{linkdata["title"]}.{ext}'
try:
# name = f'{linkdata["extractor"]}-{linkdata["id"]}-{linkdata["title"]}.{linkdata["ext"]}'
name = data.title.split()
return await ctx.send(file=discord.File(
fp=mp4file,
filename=f'friday-bot.com_{"_".join(name)}.{ext}',
spoiler=spoiler))
except discord.HTTPException:
return await ctx.send(embed=embed(
title="This file is too powerful to be uploaded",
description="You will have to open reddit to view this",
color=MessageColors.ERROR))
finally:
try:
os.remove(mp4file)
except PermissionError:
pass
else:
if spoiler is True:
return await ctx.send(content="||" + link + "||")
else:
return await ctx.send(content=link)
