async def base64(self, message, parameters): """Encodes or decodes text to or from base64.\n Parameters: conversionType: Whether to encode or decode text.\n text: The text to encode or decode.\n """ # Check for not enough parameters if len(parameters) < self._base64.getMinParameters(): embed = getErrorMessage(self._base64, Code.NOT_ENOUGH_PARAMETERS) # There were enough parameters else: # Conversion type is first parameter; Text is all parameters after conversionType = parameters[0] text = " ".join(parameters[1:]) # Conversion is Encode if conversionType in self._base64.getAcceptedParameter( "conversion", "encode").getAlternatives(): converted = base64.b64encode(text.encode()).decode() encoded = True embed = discord.Embed( title="`{}` {} Base64".format( text if len(text) < 180 else "[text is greater than 200 characters]", "encoded to" if encoded else "decoded from"), description=converted, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Conversion is Decode elif conversionType in self._base64.getAcceptedParameter( "conversion", "decode").getAlternatives(): converted = base64.b64decode(text.encode()).decode() encoded = False embed = discord.Embed( title="`{}` {} Base64".format( text if len(text) < 180 else "[text is greater than 200 characters]", "encoded to" if encoded else "decoded from"), description=converted, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Conversion is Invalid else: embed = getErrorMessage(self._base64, Code.INVALID_PARAMETER) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def morse(self, message, parameters): """Turns text into/from morse code """ # Check for not enough parameters if len(parameters) < self._morse.getMinParameters(): embed = getErrorMessage(self._morse, Code.NOT_ENOUGH_PARAMETERS) # There were the proper amount of parameters else: conversion = parameters[0] text = " ".join(parameters[1:]) # Check if the conversion is valid valid = True if conversion in self._morse.getAcceptedParameter( "conversion", "encode").getAlternatives(): conversion = "encode" elif conversion in self._morse.getAcceptedParameter( "conversion", "decode").getAlternatives(): conversion = "decode" # Conversion is invalid else: embed = getErrorMessage(self._morse, Code.INVALID_PARAMETER) valid = False if valid: response = await loop.run_in_executor( None, requests.get, Code.MORSE_API_CALL.format(conversion, text)) response = response.json() # Check if the API call was a success if response["success"]: value = response["value"] else: value = response["error"] embed = discord.Embed( title="{}".format("Text to Morse" if conversion == "encode" else "Morse To Text") if response["success"] else "Failed to convert", description="`{}`".format(value), colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def brainfuck(self, message, parameters): """Runs brainfuck code and returns the result.\n Parameters: code: The brainfuck code to run.\n parameters: The parameters to insert into the brainfuck code.\n """ # Check for not enough parameters if len(parameters) < self._brainfuck.getMinParameters(): embed = getErrorMessage(self._brainfuck, Code.NOT_ENOUGH_PARAMETERS) # Check for too many parameters elif len(parameters) > self._brainfuck.getMaxParameters(): embed = getErrorMessage(self._brainfuck, Code.TOO_MANY_PARAMETERS) # There were a proper amount of parameters else: code = parameters[0] if len(parameters) == 2: parameters = parameters[1] else: parameters = [] # Remove all invalid symbols validSymbols = "<>+-.,[]" newCode = "" for char in code: if char in validSymbols: newCode += char code = newCode try: async with async_timeout.timeout(5): description = await loop.run_in_executor( None, self.__brainfuck, code, parameters) except: description = "Timed out" # Create and return embed for result embed = discord.Embed(title="Result", description=description, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def kill(self, message, parameters): """Kills the bot and logs out. """ processId = OmegaPsi.PROCESS_ID # Check if parameters exceeds maximum parameters if len(parameters) > self._kill.getMaxParameters(): embed = getErrorMessage(self._kill, BotModerator.TOO_MANY_PARAMETERS) # Parameters do not exceed maximum parameters else: processId = OmegaPsi.PROCESS_ID if len( parameters) == 0 else parameters[0] embed = discord.Embed( title="Bot Killed", description="Omega Psi was killed (Process {})".format( OmegaPsi.PROCESS_ID), colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Only kill if processId is OmegaPsi.PROCESS_ID if str(processId) == str(OmegaPsi.PROCESS_ID): await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url)) await self.client.logout()
async def removeModerator(self, message, parameters): """Removes a bot moderator from the bot.\n Parameters: parameters: The Discord Users to remove as a bot moderator.\n """ # Check if message has no mentions if len(message.mentions) < self._removeModerator.getMinParameters(): embed = getErrorMessage(self._removeModerator, BotModerator.NOT_ENOUGH_PARAMETERS) # There was at least one mention else: # Iterate through each member result = "" for member in message.mentions: result += "{} {} a bot moderator.".format( member.mention, "was successfully removed as" if await OmegaPsi.removeModerator(member) else ("is not")) embed = discord.Embed(name="Removed Moderators", description=result, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def timchen(self, message, parameters): """Returns a random picture of Timchen with the caption. """ # Check for too many parameters if len(parameters) > self._timchen.getMaxParameters(): embed = getErrorMessage(self._timchen, Image.TOO_MANY_PARAMETERS) # There were the proper amount of parameters else: # Get a random image timchenData = await timchen.get_random() embed = discord.Embed( title="Timchen!", description=capitalizeSentences(timchenData.description), colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color).set_image(url=timchenData.url) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def cat(self, message, parameters): """Returns a random cat from the internet. """ # Check for too many parameters if len(parameters) > self._cat.getMaxParameters(): embed = getErrorMessage(self._cat, Image.TOO_MANY_PARAMETERS) # There were the proper amount of parameters else: result = await loop.run_in_executor( None, partial(requests.get, Image.CAT_API, headers={"x-api-key": os.environ["CAT_API_KEY"]})) result = result.json() embed = discord.Embed( title="Cat from the internet", description=" ", colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color).set_image(url=result[0]["url"]) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def dog(self, message, parameters): """Returns a random dog from the internet """ # Check for too many parameters if len(parameters) > self._dog.getMaxParameters(): embed = getErrorMessage(self._dog, Image.TOO_MANY_PARAMETERS) # There were the proper amount of parameters else: result = await loop.run_in_executor(None, requests.get, Image.DOG_API) result = result.json() embed = discord.Embed( title="Dog from the internet", description=" ", colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color).set_image(url=result["message"]) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def qrCode(self, message, parameters): """Turns data into a QR code. """ # Check for not enough parameters if len(parameters) < self._qrCode.getMinParameters(): embed = getErrorMessage(self._qrCode, Code.NOT_ENOUGH_PARAMETERS) # There were the proper amount of parameters else: data = " ".join(parameters) # The size should be a function of the data's length # Use this --> size = 10(length // 20) + 200 size = 10 * (len(data) // 20) + 200 embed = discord.Embed( title=" ", description=" ", colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color).set_image( url=Code.QR_API_CALL.format(size, data.replace(" ", "+"))) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def deactivate(self, message, parameters): """Deactivates a command globally in the bot.\n Parameters: command: The command to globally deactivate.\n reason: The reason the command is being globally deactivated.\n """ # Check for minimum amount of parameters if len(parameters) < self._deactivate.getMinParameters(): embed = getErrorMessage(self._deactivate, BotModerator.NOT_ENOUGH_PARAMETERS) # Parameters had the minimum amount of parameters else: # Command to be deactivated is first parameter; Reason is every parameter after command = parameters[0] reason = "No Reason" if len(parameters) > 1: reason = " ".join(parameters[1:]) # Open bot file bot = await OmegaPsi.openOmegaPsi() # Check if command is valid commandObject = None for category in self._categories: commandObject = self._categories[category].getCommand(command) if commandObject != None: break if commandObject == None: result = "`{}` is not a valid command.".format(command) else: bot["inactive_commands"][commandObject.getAlternatives() [0]] = reason result = "`{}` was globally deactivated.\nReason: {}".format( commandObject.getAlternatives()[0], reason) # Close bot file await OmegaPsi.closeOmegaPsi(bot) embed = discord.Embed(name="Deactivated", description=result, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def nasaImage(self, message, parameters): """Returns an image from NASA. """ keywords = " ".join(parameters) # Get data involving NASA images if keywords == "random": imageData = await loop.run_in_executor(None, requests.get, Image.NASA_RANDOM) else: imageData = await loop.run_in_executor( None, requests.get, Image.NASA_SEARCH.format(keywords.replace(" ", "+"))) imageData = imageData.json() # Check if there are no images if len(imageData["collection"]["items"]) == 0: embed = getErrorMessage(self._nasaImage, Image.NO_IMAGE) # There are images else: # Choose random item from collection item = choose(imageData["collection"]["items"]) # Get href from item imageLink = item["links"][0]["href"] # Make sure description is less than 2000 characters if len(item["data"][0] ["description"]) < Image.DESCRIPTION_THRESHOLD: description = item["data"][0]["description"] else: description = item["data"][0][ "description"][:Image.DESCRIPTION_THRESHOLD] + "[...]" embed = discord.Embed( title=item["data"][0]["title"], description=description, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color).set_image(url=imageLink) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def avatar(self, message, parameters): """Returns a random cute avatar that can be used as a placeholder. Parameters: parameters (list): The parameters that detect for too many parameters. """ # Check for too many parameters if len(parameters) > self._avatar.getMaxParameters(): embed = getErrorMessage(self._avatar, Image.TOO_MANY_PARAMETERS) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url)) # There were the proper amount of parameters else: # Get list of face features faceValues = await loop.run_in_executor(None, requests.get, Image.AVATAR_LIST) faceValues = faceValues.json()["face"] # Choose random eyes, nose, mouth, and color eyes = choose(faceValues["eyes"]) nose = choose(faceValues["nose"]) mouth = choose(faceValues["mouth"]) color = hex(randint(0, 16777215))[2:].rjust(6, "0") # Load image image = await loop.run_in_executor( None, loadImageFromUrl, Image.AVATAR_API.format(eyes, nose, mouth, color)) # Save image temporarily avatarFile = "{}_{}_{}_{}.png".format(eyes, nose, mouth, color) pygame.image.save(image, avatarFile) # Send file then delete image await sendMessage(self.client, message, filename=avatarFile) os.remove(avatarFile)
async def booty(self, message, parameters): """Sends a random picture of some booty. """ # Check for too many parameters if len(parameters) > self._booty.getMaxParameters(): return getErrorMessage(self._booty, NSFW.TOO_MANY_PARAMETERS) # There were the proper amount of parameters else: # Load image from URL, temporarily save it, send image while True: # Generate random number for an image; Add 0's to beginning until pad is reached (5) bootyNumber = str(random.randint(1, 5400)) bootyNumber = bootyNumber.rjust(5, "0") # Try loading the image try: loadImageFromUrl(NSFW.BOOTY_URL.format(bootyNumber)) break # Image load failed; Retry using new number. except: pass embed = discord.Embed( title="Booty Number {}".format(bootyNumber), description=" ", colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color).set_image( url=NSFW.BOOTY_URL.format(bootyNumber)) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def rank(self, message, parameters): """Returns an image displaying the rank of the member in this server.\n discordMember - The member to get the rank of.\n """ # Check for too many parameters if len(parameters) > self._rank.getMaxParameters(): result = getErrorMessage(self._rank, Rank.TOO_MANY_PARAMETERS) # There were the proper amount of parameters else: result = await createRankImage(message.author) # Check for an error if type(result) == discord.Embed: await sendMessage( self.client, message, embed = result.set_footer( text = "Requested by {}#{}".format( message.author.name, message.author.discriminator ), icon_url = message.author.avatar_url ) ) else: # Send rank image and remove await sendMessage( self.client, message, filename = result ) os.remove(result)
async def debug(self, message, parameters): """Debugs the bot. """ # Check if parameters exceeds maximum parameters if len(parameters) > self._debug.getMaxParameters(): embed = getErrorMessage(self._debug, BotModerator.TOO_MANY_PARAMETERS) # Parameters do not exceed maximum parameters else: embed = discord.Embed( title="Omega Psi Debugging", description="Process ID: {}".format(OmegaPsi.PROCESS_ID), colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def gif(self, message, parameters): """Returns a gif from giphy. """ keywords = " ".join(parameters) # Get data involving gifs from Giphy if keywords == "random": gifData = await loop.run_in_executor( None, requests.get, os.environ["GIPHY_RANDOM_API_URL"]) gifData = gifData.json() result = gifData["data"]["embed_url"] else: gifsData = await loop.run_in_executor( None, requests.get, os.environ["GIPHY_SEARCH_API_URL"].format( keywords.replace(" ", "+"))) gifsData = gifsData.json() # Return random embed url if len(gifsData) > 0: gifData = choose(gifsData["data"]) result = gifData["embed_url"] else: result = getErrorMessage(self._gif, Image.NO_GIFS_FOUND) if type(result) == discord.Embed: await sendMessage( self.client, message, embed=result.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url)) else: await sendMessage(self.client, message, message=result)
async def getServers(self, message, parameters): """Returns a list of servers the bot is in.\n """ # Check if parameters exceeds maximum parameters if len(parameters) > self._servers.getMaxParameters(): embed = getErrorMessage(self._servers, BotModerator.TOO_MANY_PARAMETERS) # Parameters do not exceed maximum parameters else: # Getting results through embed if len(parameters) == 0: # Add results to fields fields = [] fieldText = "" for server in self.client.guilds: text = "`{}` | Owner: {}\n".format(server.name, server.owner.mention) if len(fieldText) + len( text) >= OmegaPsi.MESSAGE_THRESHOLD: fields.append(fieldText) fieldText = "" fieldText += text # Add trailing field text if len(fieldText) > 0: fields.append(fieldText) # Create embed object embed = discord.Embed( title="Servers", description="A list of servers that Omega Psi is in.", colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Add fields to embed object count = 0 for field in fields: count += 1 embed.add_field( name="Servers {}".format("({} / {})".format( count, len(fields)) if len(fields) > 1 else ""), value=field, inline=False) # Getting results through markdown file else: # Setup markdown text markdown = "# Omega Psi Server Information\n" # Iterate through servers bot is in for guild in self.client.guilds: # Load file server = await Server.openServer(guild) # Add server information (owner, name) try: markdown += "## {} - {}\n".format( guild.name, guild.owner.name + "#" + guild.owner.discriminator) except: markdown += "## {} - No Owner\n".format(guild.name) # Iterate through members in server dictionary for member in server["members"]: member = server["members"][member] discordMember = guild.get_member(int(member["id"])) markdown += ( " * {} ({})\n" + " * Moderator? {}\n" + " * Experience: {}\n" + " * Level: {}\n" + " * Experience until next level: {}\n").format( discordMember.name + "#" + discordMember.discriminator, discordMember.nick, "Yes" if discordMember.guild_permissions.manage_guild else "No", member["experience"], member["level"], Server.getExpFromLevel(member["level"] + 1) - member["experience"]) # Save markdown temporarily mdFile = open(BotModerator.BOT_MARKDOWN, "w") mdFile.write(markdown) mdFile.close() mdFile = open(BotModerator.BOT_MARKDOWN, "r") # Send file to DMs; Then delete await message.author.send(file=discord.File(mdFile)) os.remove(BotModerator.BOT_MARKDOWN) embed = discord.Embed( title="File sent.", description= "The server information has been sent to your DM's", colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def imgur(self, message, parameters): """ """ attachments = message.attachments canScroll = False # Check for no attachments and no parameters if len(attachments) == 0 and len(parameters) == 0: embed = getErrorMessage(self._imgur, Image.NOT_ENOUGH_PARAMETERS) # There was at least one of either else: # Check if the first parameter is in the accepted for getting the album to the images # and getting a scroll embed to show the images try: if parameters[0] in self._imgur.getAcceptedParameter( "image", "me").getAlternatives(): me = True else: me = False except: me = False # Get user's imgur album ID album = await User.getImgurAlbum(message.author) albumHash = album["hash"] albumId = album["id"] # See if user does not have an album attached to them fields = [] fieldValue = "" if not albumId: response = await loop.run_in_executor( None, partial( requests.post, Image.IMGUR_ALBUM_API, data={ "title": "{}#{}".format(message.author.name, message.author.discriminator), "description": "An anonymous imgur album made for the above Discord User" }, headers={ "Authorization": "Client-ID {}".format(os.environ["IMGUR_API_KEY"]) })) response = response.json() # See if album creation failed if response["status"] != 200: error = response["data"]["error"] + "\n" # Add the error to the result field if len(fieldValue) + len( error) > OmegaPsi.MESSAGE_THRESHOLD: fields.append(fieldValue) fieldValue = "" fieldValue += error # Album creation did not fail else: success = "Anonymous Album Created at [this link]({}).\n".format( Image.IMGUR_ALBUM_URL.format(response["data"]["id"])) # Add the success message to the result field if len(fieldValue) + len( success) > OmegaPsi.MESSAGE_THRESHOLD: fields.append(fieldValue) fieldValue = "" fieldValue += success # Set the user's imgur album albumHash = response["data"]["deletehash"] albumId = response["data"]["id"] await User.setImgurAlbum(message.author, { "hash": albumHash, "id": albumId }) # Not getting their album and images; Adding one if not me: # Get url for each attachment for attachment in range(len(attachments)): attachments[attachment] = attachments[attachment].url attachments += parameters # Iterate through attachments for attachment in attachments: # Upload image response = await loop.run_in_executor( None, partial(requests.post, Image.IMGUR_IMAGE_API, data={ "image": attachment, "album": albumHash }, headers={ "Authorization": "Client-ID {}".format( os.environ["IMGUR_API_KEY"]) })) print(response.content) response = response.json() # See if image upload failed if response["status"] != 200: error = response["data"]["error"] + "\n" # Add the error to the result field if len(fieldValue) + len( error) > OmegaPsi.MESSAGE_THRESHOLD: fields.append(fieldValue) fieldValue = "" fieldValue += error # Image upload did not fail else: success = "Anonymous Image Uploaded and Added to your album. [Here]({}) is the direct link to the image.\n".format( Image.IMGUR_IMAGE_URL.format( response["data"]["id"])) # Add the success message to the result field if len(fieldValue) + len( success) > OmegaPsi.MESSAGE_THRESHOLD: fields.append(fieldValue) fieldValue = "" fieldValue += success # Add the trailing result field if len(fieldValue) > 0: fields.append(fieldValue) # Create embed embed = discord.Embed( title="Results {}".format("({} / {})".format( 1, len(fields)) if len(fields) > 1 else ""), description=fields[0], colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Add all the fields to the embed count = 1 for field in fields[1:]: count += 1 embed.add_field( name="Results {}".format("({} / {})".format( count, len(fields)) if len(fields) > 1 else ""), value=field, inline=False) # Getting the author's images else: # Get the list of images album = await loop.run_in_executor( None, partial( requests.get, Image.IMGUR_ALBUM_GET_API.format(albumId), headers={"Authorization": "Client-ID f473d8889fc2daf"})) album = album.json() # Create the first embed embed = discord.Embed( title="Image {}".format( "({} / {})".format(1, len(album["data"]["images"])) if len(album["data"]["images"]) > 1 else ""), description=album["data"]["description"], colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color, url=album["data"]["link"]).set_image( url=None if len(album["data"]["images"]) == 0 else album["data"]["images"][0]["link"]).set_author( name=album["data"]["title"], icon_url=message.author.avatar_url if album["data"]["cover"] == None else Image.IMGUR_IMAGE_URL.format( album["data"]["cover"])) # Create the scrolling embed self._scrollEmbeds[str(message.author.id)] = { "message": None, "images": album["data"]["images"], "value": 0, "min": 0, "max": len(album["data"]["images"]) - 1 } canScroll = len(album["data"]["images"]) > 0 msg = await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url)) if canScroll: for reaction in reactions: await msg.add_reaction(reaction) self._scrollEmbeds[str(message.author.id)]["message"] = msg
async def activate(self, message, parameters): """Activates commands globally in the bot. Parameters: parameters: The parameters to process. """ # Check if there are not enough parameters if len(parameters) < self._activate.getMinParameters(): embed = getErrorMessage(self._activate, BotModerator.NOT_ENOUGH_PARAMETERS) # Parameters had the minimum amount of parameters else: # Commands held in each parameter commands = parameters # Open bot file bot = await OmegaPsi.openOmegaPsi() # Iterate through commands if len(commands) > 0: result = "" acCommands = [] for command in commands: # Iterate through categories added = False for category in self._categories: # Check if command was part of category commandObject = self._categories[category].getCommand( command) if commandObject != None: acCommands.append(commandObject) added = True if not added: result += "`{}` is not a valid command.\n".format( command) # Activate commands for command in acCommands: if command.getAlternatives( )[0] in bot["inactive_commands"]: bot["inactive_commands"].pop( command.getAlternatives()[0]) result += "`{}` was activated globally.\n".format( command.getAlternatives()[0]) else: result += "`{}` is already globally active.\n".format( command.getAlternatives()[0]) else: result = "" for command in bot["inactive_commands"]: result += "`{}` was activated globally.\n".format(command) bot["inactive_commands"] = {} # Close bot file await OmegaPsi.closeOmegaPsi(bot) embed = discord.Embed(name="Activated", description=result, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def convert(self, message, parameters): """Converts a number from the start base to the end base.\n Parameters: startBase: The base to convert from.\n endBase: The base to convert to.\n number: The number to convert.\n """ # Check for not enough parameters if len(parameters) < self._convert.getMinParameters(): embed = getErrorMessage(self._convert, Code.NOT_ENOUGH_PARAMETERS) # Check for too many parameters elif len(parameters) > self._convert.getMaxParameters(): embed = getErrorMessage(self._convert, Code.TOO_MANY_PARAMETERS) # There were the proper amount of parameters else: startBase = "10" endBase = parameters[0] number = parameters[1] if len(parameters) == 3: startBase = parameters[0] endBase = parameters[1] number = parameters[2] # Only run if start base and end base are valid if startBase.isdigit() and endBase.isdigit(): startBase = int(startBase) endBase = int(endBase) if startBase >= 2 and startBase <= 64 and endBase >= 2 and endBase <= 64: # Try converting number from startBase to base-10 # Test to see if number is not zero start = number title = "Base-{} to Base-{}".format(startBase, endBase) description = "`{} --> {}`".format(start, number) # Check if number is not zero; Convert it if number not in ["0", 0]: number = convert(number, startBase, endBase) # Check if number is None; Invalid number for a base if number == None: embed = getErrorMessage(self._convert, Code.BASE_MISMATCH) # Number is not None; Valid base else: # Return number description = "`{} --> {}`".format(start, number) embed = discord.Embed( title=title, description=description, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Number is zero; Just send that else: embed = discord.Embed( title=title, description=description, colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Bases were not within range else: embed = getErrorMessage(self._convert, Code.BASE_OUT_OF_RANGE) # Bases were not numbers else: embed = getErrorMessage(self._convert, Code.INVALID_BASE) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def urban(self, message, parameters): """Returns the top 5 urban dictionary entries for the specified term.\n - term - The term to search on urban dictionary.\n - discordChannel - The Discord Channel the definition is being sent in.\n """ # Check for not enough parameters if len(parameters) < self._urban.getMinParameters(): embed = getErrorMessage(self._urban, NSFW.NOT_ENOUGH_PARAMETERS) # There were the proper amount of parameters else: term = " ".join(parameters) # Use requests to get the data in JSON try: urlCall = NSFW.URBAN_API_CALL.format(term.replace(" ", "+")) urbanData = await loop.run_in_executor(None, requests.get, urlCall) urbanData = urbanData.json() # Get first 5 values (or values if there are less than 5) if len(urbanData["list"]) < 5: definitions = urbanData["list"] else: definitions = urbanData["list"][:5] # Create discord embed embed = discord.Embed( title="{} Results Of `{}`".format( "Top 5" if len(definitions) > 5 else "", term), description=" ", colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color).set_thumbnail( url=NSFW.URBAN_ICON) # Add definitions defCount = 0 for definition in definitions: defCount += 1 # Get definition; Split up into multiple fields if necessary definitionFields = splitText(definition["definition"], OmegaPsi.MESSAGE_THRESHOLD) count = 0 for field in definitionFields: count += 1 embed.add_field(name="Definition {} {}".format( defCount, "({} / {})".format(count, len(definitionFields)) if len(definitionFields) > 1 else ""), value=field, inline=False) except: embed = getErrorMessage(self._urban, NSFW.NO_TERM) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def setStatus(self, message, parameters): """Sets the presence of the bot given the activity type and text.\n Parameters: activityType: The type of activity to set for the presence.\n text: The text to set.\n """ # Check if parameters is less than minimum parameters if len(parameters) < self._status.getMinParameters(): embed = getErrorMessage(self._status, BotModerator.NOT_ENOUGH_PARAMETERS) # Parameters has minumum parameters else: # Activity type is first parameter; Text is every parameter after activityType = parameters[0] text = " ".join(parameters[1:]) # Get the specific activity type activityText = activityType if activityType in self._status.getAcceptedParameter( "activity", "playing").getAlternatives(): activityType = discord.ActivityType.playing activityText = "Playing" elif activityType in self._status.getAcceptedParameter( "activity", "streaming").getAlternatives(): activityType = discord.ActivityType.streaming activityText = "Streaming" elif activityType in self._status.getAcceptedParameter( "activity", "listening").getAlternatives(): activityType = discord.ActivityType.listening activityText = "Listening" elif activityType in self._status.getAcceptedParameter( "activity", "watching").getAlternatives(): activityType = discord.ActivityType.watching activityText = "Watching" # Update the bot's activity setting await OmegaPsi.setActivityType(activityType) await OmegaPsi.setActivityName(text) # Change the presence of the bot await self.client.change_presence( status=discord.Status.online, activity=discord.Activity( name=text, type=activityType, url="https://www.twitch.tv/FellowHashbrown")) embed = discord.Embed( title="Presence Set", description="Activity: {}\nText: {}\n".format( activityText, text), colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))
async def levelUp(self, message, parameters): """Returns the amount of different interactions a Discord Member needs to level up. Parameters: discordMember (discord.Member): The Discord Member to get the interactions of. interactionType (str): The type of interaction to get. """ # Check for too many parameters if len(parameters) > self._levelUp.getMaxParameters(): embed = getErrorMessage(self._levelUp, Rank.TOO_MANY_PARAMETERS) # There were the proper amount of parameters else: interactionType = None if len(parameters) == 0 else parameters[0] # Get member info from server member = await Server.getMember(message.guild, message.author) # Get member's current and next experience currentExp = member["experience"] nextExp = Server.getExpFromLevel(member["level"] + 1) # Get each interaction type before checking the interaction type profanity = math.ceil( (nextExp - currentExp) / (Server.PROFANE_XP + Server.NORMAL_XP) ) reactions = math.ceil( (nextExp - currentExp) / Server.REACTION_XP ) normal = math.ceil( (nextExp - currentExp) / Server.NORMAL_XP ) # Check if interaction type is None; Get all stats if interactionType == None: embed = discord.Embed( title = "In order to level up, you need either", description = "{} Profane Messages\nor\n{} Reactions\nor\n{} Regular Messages".format( profanity, reactions, normal ), colour = self.getEmbedColor() if message.guild == None else message.author.top_role.color ) # Check if interaction type is valid elif interactionType in self._levelUp.getAcceptedParameter("interaction", "profanity").getAlternatives(): embed = discord.Embed( title = "In order to level up, you need", description = "{} Profane Messages".format(profanity), colour = self.getEmbedColor() if message.guild == None else message.author.top_role.color ) elif interactionType in self._levelUp.getAcceptedParameter("interaction", "reactions").getAlternatives(): embed = discord.Embed( title = "In order to level up, you need", description = "{} Reactions".format(reactions), colour = self.getEmbedColor() if message.guild == None else message.author.top_role.color ) elif interactionType in self._levelUp.getAcceptedParameter("interaction", "normal").getAlternatives(): embed = discord.Embed( title = "In order to level up, you need", description = "{} Regular Messages".format(normal), colour = self.getEmbedColor() if message.guild == None else message.author.top_role.color ) # Interaction type is invalid; error else: embed = getErrorMessage(self._levelUp, Rank.INVALID_INTERACTION) await sendMessage( self.client, message, embed = embed.set_footer( text = "Requested by {}#{}".format( message.author.name, message.author.discriminator ), icon_url = message.author.avatar_url ) )
async def todo(self, message, parameters): """Runs the todo command. Parameters: action (str): What action to perform for the todo command. item (str): The item to add/remove to/from the TODO list. """ # Check for no parameters; list the TODO list if len(parameters) == 0: todoList = await OmegaPsi.getToDoList() todoText = "" for item in range(len(todoList)): todoText += "`{}.) {}`\n".format(item + 1, todoList[item]) embed = discord.Embed( title="TODO List", description=todoText if len(todoText) > 0 else "Nothing Yet", colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Check for 2 or more parameters else: # Check if author is a bot moderator if await OmegaPsi.isAuthorModerator(message.author): action = parameters[0] # There is nothing to add if len(parameters) == 1: embed = getErrorMessage(self._todo, BotModerator.NOT_ENOUGH_PARAMETERS) # Check if action is valid elif action in self._todo.getAcceptedParameter( "action", "add").getAlternatives(): # Check if index is given if parameters[1].isdigit(): index = int(parameters[1]) item = " ".join(parameters[2:]) else: index = 0 item = " ".join(parameters[1:]) success = await OmegaPsi.addToDo(item, index) embed = discord.Embed( title="Added TODO Item" if success["success"] else "Failed to add TODO Item", description=success["reason"], colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) elif action in self._todo.getAcceptedParameter( "action", "remove").getAlternatives(): success = await OmegaPsi.removeToDo(" ".join( parameters[1:])) embed = discord.Embed( title="Removed TODO Item" if success["success"] else "Failed to remove TODO Item", description=success["reason"], colour=self.getEmbedColor() if message.guild == None else message.author.top_role.color) # Action is invalid else: embed = getErrorMessage(self._todo, BotModerator.INVALID_PARAMETER) # Author is not bot moderator else: embed = OmegaPsi.getNoAccessError() await sendMessage( self.client, message, embed=embed.set_footer(text="Requested by {}#{}".format( message.author.name, message.author.discriminator), icon_url=message.author.avatar_url))