def process_search(merged_dict, search_result):
"""
Helper function. Returns different outputs depending on the search result.
:param merged_dict: Dictionary to obtain song links from
:param search_result: Result of the function search_song
:return: Appropriate discord.Embed object
"""
print("search result")
print(search_result)
print(type(search_result))
result = search_result.to_frame()
print("post conversion")
print(result)
print(type(result))
if len(result) == 0:
return utils.generate_embed(
status='Error',
msg="""No songs found. There could be an error with
your search or the bot.""")
elif len(result) == 1:
return embed_song(merged_dict, result)
elif len(result) > 1:
results = [row.Song for index, row in result.iterrows()]
return utils.generate_embed(status='Error',
msg="""Too many songs found. Please enter
a song from the list given.""" + "\r\n" +
"\r\n".join(results))
async def search_reminders(self, ctx, date: Optional[str] = None):
"""Searches for reminders on a specific day"""
if date:
try:
date = utils.split_date(date)
except UnboundLocalError:
await ctx.send(embed=utils.generate_embed(
"", "Date was not in the correct format."))
return 1
db_search = database.get_reminders(
ctx.message.guild.id,
**{
"year": date["year"],
"month": date["month"],
"day": date["day"]
},
)
else:
db_search = database.get_reminders(ctx.message.guild.id)
message = ""
for reminder in db_search:
message += f'\n{reminder["reminder_id"]}\t{reminder["human_readable_time"]}\t{reminder["reminder_text"]}\n'
if not message:
message = "No reminders found"
await ctx.send(
embed=utils.generate_embed("Search Results:", f"```{message}```"))
async def add_reminder_error(self, ctx, error):
"""Called when add_reminder() errors"""
print(error)
if isinstance(error, commands.errors.MissingRequiredArgument):
await ctx.send(
embed=utils.generate_embed(
"Error", f"`{error} Run {prefix}help add_reminder`"
)
)
elif isinstance(error, commands.errors.UserInputError):
await ctx.send(
embed=utils.generate_embed(
"Error", f"`{error} Run {prefix}help add_reminder`"
)
)
elif isinstance(error, commands.errors.CheckFailure):
await ctx.send(
embed=utils.generate_embed(
"Error", "`You do not have permissions for this command`"
)
)
else:
await ctx.send(
embed=utils.generate_embed(
"Error",
f"`An unexpected error has occured, run {prefix}help add_reminder`",
)
)
async def delete_reminders_error(self, ctx, error):
if isinstance(error, commands.errors.CheckFailure):
await ctx.send(embed=utils.generate_embed(
"Error", "`You do not have permissions for this command`"))
else:
await ctx.send(embed=utils.generate_embed(
"Error", f"{error} Try running {prefix}help delete_reminder"))
async def c2d(message, *, arg):
channel = message.channel
is_emote = re.search(utils.EMOTE_REGEX, arg)
is_ping = re.search(utils.PING_REGEX, arg)
if is_emote or is_ping:
await channel.send(embed=utils.generate_embed(
status='Error',
msg='Invalid input. Ping, emote, or channel name detected.'))
return
try:
input = int(arg)
if input in range(1, 16):
output = c2v.search_difficulty(merged_df, input)
for page in output:
await channel.send(", ".join(page))
else:
await channel.send(embed=utils.generate_embed(
status='Error',
msg='Invalid input. Not within correct difficulty range.'))
return
except:
await channel.send(embed=utils.generate_embed(
status='Error', msg='Invalid input. Not a number.'))
return
async def pat(self, ctx):
"""Pats the reminder bot, or a user"""
if len(ctx.message.mentions) >= 1:
pats = database.increment_pat(ctx.guild.id,
ctx.message.mentions[-1].id)
user = ctx.message.mentions[-1].name
else:
pats = database.increment_pat(ctx.guild.id, self.bot.user.id)
user = self.bot.user.name
if pats == 1:
await ctx.send(embed=utils.generate_embed(
"💜", f"{user} has received {pats} pat"))
else:
await ctx.send(embed=utils.generate_embed(
"💜", f"{user} has received {pats} pats"))
async def gen_radia(self, ctx, date):
"""Generates the World of Radia given a date
Enter a date with format Month-Day-Year or Month/Day/Year
ex. June 1st 2000 -> 06/01/2000 or 06-01-2000"""
date = utils.split_date(date)
if date is None:
ctx.send(embed=utils.generate_embed("Error",
"Please enter a valid date"))
center = Image.open("img/background.png")
ringsFiles = [
"img/rings/ring6.png",
"img/rings/ring5.png",
"img/rings/ring4.png",
"img/rings/ring3.png",
"img/rings/ring2.png",
"img/rings/ring1.png",
"img/rings/ring0.png",
]
ringSpeeds = [0.25, 1, -2, 1.5, 1, -2, 0] # num rotations per year
dayOfYear = 360 * date["year"] + 30 * (date["month"] -
1) + date["day"] - 1
for ring in ringsFiles:
temp = Image.open(ring)
temp = temp.rotate(angle=-ringSpeeds[ringsFiles.index(ring)] *
0.6 * dayOfYear) # 360 days per year
center.paste(temp, (0, 0), temp)
center.save("img/out.png")
await ctx.send(file=discord.File("img/out.png", filename="img/out.png")
)
async def c2s_error(ctx, error):
"""
Error handler in case user forgets to specify the difficulty level.
"""
if isinstance(error, commands.MissingRequiredArgument):
await ctx.send(embed=utils.generate_embed(
status='Error', msg="Please also specify a search key."))
async def delete_reminder(self, ctx, index: int):
"""Deletes a reminder at a specific index"""
search_result = database.get_reminders(ctx.message.guild.id,
**{"reminder_id": index})
if search_result != []:
delete_result = database.remove_reminder(search_result[0])
if delete_result:
await ctx.send(embed=utils.generate_embed(
"Deleted Reminder",
"The reminder was successfully removed"))
else:
await ctx.send(
embed=utils.generate_embed("Error", "Something went wrong")
)
else:
await ctx.send(embed=utils.generate_embed(
"Error", "Could not find a reminder at this index"))
async def add_reminder(
self,
ctx,
date: str,
user_time: str,
text: str,
repeating: Union[str, bool] = False,
):
"""Attempts to add a reminder"""
# Checks if the reminder should repeat, and if it is a valid interval
try:
_date = utils.split_date(date)
_time = utils.split_time(user_time)
except UnboundLocalError:
raise commands.UserInputError("Date or time was not in the correct format.")
if repeating and repeating not in conversion_dict:
raise commands.UserInputError()
# Tries to insert the reminder
result = database.insert_reminder(
ctx.guild.id,
ctx.channel.id,
_date["year"],
_date["month"],
_date["day"],
_time["hour"],
_time["minute"],
text,
repeating,
)
# Sends a status message, and restarts the reminders
if result:
await asyncio.create_task(self.setup_reminders())
await ctx.send(
embed=utils.generate_embed(
"Reminder Stored",
f"{date}\n{user_time}\n{text}\nrepeating: {repeating}",
)
)
# This means the insertion of the reminder failed
else:
await ctx.send(
embed=utils.generate_embed(
"Error",
"`This reminder already exists in the database or is not in the future`",
)
)
async def list_locations(self, ctx):
description = "\n"
for location in self.storage_dict:
description += location + "\n"
author = "Storage location list"
footer_text = f"Total of {len(self.storage_dict)} storage locations"
await ctx.send(
embed=utils.generate_embed(author, description, footer_text))
async def list_thumbers(self, ctx, user: Optional[str]) -> None:
"""Lists the number of thumbers for a user or the top 5 on the server"""
if user and len(ctx.message.mentions) >= 1:
user = database.DB[str(ctx.message.guild.id)].find_one(
{"_id": ctx.message.mentions[-1].id})
if user and "karma" in user.keys():
await ctx.send(embed=utils.generate_embed(
f"{user['name']} has {user['karma']} thumbers", ""))
else:
await ctx.send(embed=utils.generate_embed(
f"{ctx.message.mentions[-1].name} has no thumbers", ""))
else:
karma = (database.DB[str(ctx.message.guild.id)].find().sort(
"karma", DESCENDING).limit(5))
message = ""
for user in karma:
if "karma" in user.keys():
message += f'\n{user["karma"]} {user["name"]}'
await ctx.send(
embed=utils.generate_embed("# of Thumbers User", message))
async def info(self, ctx, name):
if name not in self.storage_dict:
await ctx.send(f"`Storage location {name} doesn't exist`")
return
author = name
description = f'Dimension: {self.storage_dict[name]["dimension"]}\n'
description += f'From: {self.storage_dict[name]["pos1"]}\n'
description += f'To: {self.storage_dict[name]["pos2"]}\n'
last_update = datetime.fromtimestamp(
self.cache[name]["last_update"]).isoformat(
" ", "seconds") if name in self.cache else "NaN"
description += f'Last update: {last_update}'
await ctx.send(embed=utils.generate_embed(author, description))
async def command(ctx, args, objectives, stat_list):
if not args:
raise commands.errors.MissingRequiredArgument
search_list = []
if args[0] == "stat":
search_list = stat_list
elif args[0] == "objective":
search_list = objectives
else:
await ctx.send("`Can only search for statistics or objectives`")
return
page = 1
if args[len(args) - 1].isdigit():
page = int(args[len(args) - 1])
key = args[1] if len(args) > 1 and not args[1].isdigit() else ""
search_result = []
temp = []
length = 0
for item in search_list:
if key in item:
temp.append(item)
length += len(item)
if length > 1500:
search_result.append(temp)
temp = []
length = 0
if temp:
search_result.append(temp)
if page > len(search_result):
await ctx.send("`None found`")
return
response = str(search_result[page - 1])[1:][:-1].replace("'", "")
footer_text = "Showing page " + \
str(page) + "/" + str(len(search_result))
await ctx.send(embed=utils.generate_embed(key if key else "\u200b",
response, footer_text))
async def c2s(message, *, arg):
"""
Searches ct2viewer for a song that matches closest to the user input.
Returns an embed containing the song information and links to its charts.
"""
channel = message.channel
is_emote = re.search(utils.EMOTE_REGEX, arg)
is_ping = re.search(utils.PING_REGEX, arg)
if is_emote or is_ping:
await channel.send(embed=utils.generate_embed(
status='Error',
msg='Invalid input. Ping, emote, or channel name detected.'))
return
result = c2v.search_song(merged_df, arg)
embed = c2v.process_search(merged_dict, result)
print(embed)
print(type(embed))
await channel.send(embed=embed)
async def search_reminders_error(self, ctx, error):
await ctx.send(embed=utils.generate_embed(
"Error",
f"Something went wrong, try running {prefix}help search_reminders",
))
async def add_operator(self, ctx, user):
"""Adds an operator to the database"""
database.insert_operator(ctx.message.guild.id, int(user[3:-1]))
await ctx.send(embed=utils.generate_embed(
"Success, Operator added",
f"Added user {user[3:-1]} as an operator"))
async def ping(self, ctx):
await ctx.send(embed=utils.generate_embed(
"Pong", f"{self.bot.latency * 1000:2.3f} ms"))
