from client import client
import discord
import random
client.basic_help(title="59",
desc="Returns a picture showing 59 signal reception")
fivenine = [
"https://cdn.discordapp.com/attachments/377206780700393473/409899331584524308/20180204_213324.jpg",
"https://cdn.discordapp.com/attachments/364489866119217153/412786093327384577/image.jpg",
"https://cdn.discordapp.com/attachments/364489866119217153/412784280809242624/image.jpg",
"https://cdn.discordapp.com/attachments/377206780700393473/414858156741754880/20180218_135538.jpg",
"https://cdn.discordapp.com/attachments/377206780700393473/416371229428285467/20180222_180823.jpg",
"https://cdn.discordapp.com/attachments/364489910759063552/440596315315896331/IMG_20180428_183441.jpg",
]
@client.command(trigger="59", aliases=["fivenine"])
async def command(command: str, message: discord.Message):
e = discord.Embed(title=discord.Embed.Empty,
description=discord.Embed.Empty,
colour=discord.Embed.Empty)
e = e.set_image(url=random.choice(fivenine))
await message.channel.send(embed=e)
return
from client import client
import discord
import modules.noofs
cmd_name = "oofs"
client.basic_help(title=cmd_name, desc="How many oofs have there been?")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name}",
"Arguments": "None",
"Description": "How many oofs have there been??",
# NO Aliases field, this will be added automatically!
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(
trigger=cmd_name,
aliases=[]) # aliases is a list of strs of other triggers for the command
async def command(message: discord.Message):
await message.channel.send(modules.noofs.oofs)
return
from client import client
import discord
cmd_name = "unmorse"
client.basic_help(title=cmd_name,
desc="reverses a Morse Code message back into text")
detailed_help = {
"Usage":
f"{client.default_prefix}{cmd_name}",
"Description":
"This command takes a given Morse Code string and reverts it back to text. Spaces denote separate letters and spaces with slashes denote separate words.",
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
morse_lookup = {
"A": ".-",
"B": "-...",
"C": "-.-.",
"D": "-..",
"E": ".",
"F": "..-.",
"G": "--.",
"H": "....",
"I": "..",
"J": ".---",
"K": "-.-",
"L": ".-..",
"M": "--",
"N": "-.",
from client import client
from modules import __common__
import discord
import asyncio
cmd_name = "debug"
client.basic_help(title=cmd_name, desc="Shows information about a specified object.")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name} <object>",
"Arguments": "`<object>` - a mention or ID to get information about",
"Description": "This command shows various debugging information about the user, the server used in, and the channel. The ID of a user, server, or channel can be passed in as well.",
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(trigger=cmd_name, aliases=["objinfo", "userinfo"])
async def command(command: str, message: discord.Message):
try:
try:
u = await client.get_user_info(__common__.stripMentionsToID(command[6:]))
except:
isUser = False
else:
isUser = True
s = client.get_guild(__common__.stripMentionsToID(command[6:]))
if s is None:
isServer = False
import os
import socket
import threading
import time
try:
import psutil
except ModuleNotFoundError:
has_psutil = False
else:
has_psutil = True
cmd_name = "stats"
client.basic_help(
title=cmd_name,
desc=f"shows various running statistics of {client.bot_name}")
detailed_help = {
"Usage":
f"{client.default_prefix}{cmd_name}",
"Description":
f"This command shows different available statistics of {client.bot_name}, including servers, uptime, and commands run.",
"Related":
f"`{client.default_prefix} info` - shows information about {client.bot_name}",
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.ready
async def readier():
from client import client
from modules import __common__
import discord
import sys
cmd_name = "about"
client.basic_help(title=cmd_name, desc=f"Returns information about {client.bot_name}")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name}",
"Description": "Shows information about the bot.",
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(trigger=cmd_name, aliases=['a']) # aliases is a list of strs of other triggers for the command
async def return_bot_info(command: str, message: discord.Message):
owner = client.get_user(288438228959363073)
python_version = f"Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
if sys.version_info[3] == "alpha":
python_version += f"a{sys.version_info.serial}"
if sys.version_info[3] == "beta":
python_version += f"b{sys.version_info.serial}"
if sys.version_info[3] == "candidate":
python_version += f"rc{sys.version_info.serial}"
embed = discord.Embed(title=f"{client.bot_name} info", description=discord.Embed.Empty, color=0x404040)
from client import client
from modules import __common__
import asyncio
import datetime
import discord
cmd_name = "info"
client.basic_help(
title=cmd_name,
desc="Shows information about a given server, channel, or user.")
detailed_help = {
"Usage":
f"{client.default_prefix}{cmd_name} <object>",
"Arguments":
"`<object>` - a mention or ID to get information about",
"Description":
"This command shows various debugging information about the user, the server used in, and the channel. The ID of a user, server, or channel can be passed in as well.",
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
def status_emoji(state: discord.Status) -> str:
if state is discord.Status.online:
return "<:status_online:534918510950744064>"
if state is discord.Status.idle: return "<:status_idle:534918510548090882>"
if state is discord.Status.dnd: return "<:status_dnd:534918509701103622>"
if state is discord.Status.offline:
return "<:status_offline:534918510652948501>"
from client import client
import discord
import time
cmd_name = "uptime"
client.basic_help(
title=cmd_name,
desc="Returns the current uptime of Awoobot, in seconds, hours, and days.")
@client.command(trigger=cmd_name, aliases=[])
async def uptime_cmd(command: str, message: discord.Message):
await message.channel.send(
f"**__Uptime:__**\n{time.perf_counter()-client.first_execution:.2f} seconds, or \n{(time.perf_counter()-client.first_execution)/3600:.3f} hours, or \n{(time.perf_counter()-client.first_execution)/86400:.4f} days"
)
return
from client import client
import discord
cmd_name = "phoneticize"
client.basic_help(title=cmd_name, desc="Turns into a phoneticize word.")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name}",
"Arguments": "letter",
"Description": "Turns into a phoneticize word.",
# NO Aliases field, this will be added automatically!
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(trigger=cmd_name,
aliases=["ph"]) # aliases is a list of strs of other triggers for the command
async def command(command: str, message: discord.Message):
phoneticize = command[3:]
await message.channel.send(phoneticize)
return
import datetime
import discord
import io
import json
import log
import random
import socket
import struct
SERVER_URL = "LittleDigPlanet.beastmc.com:25587" # Port is default 25565
COMMAND_TRIGGER = "mc" # "mc" default
# Following classes are forked/edited from Dinnerbone/mcstatus
client.basic_help("mc", "Shows information about the minecraft server")
class Connection:
def __init__(self):
self.sent = bytearray()
self.received = bytearray()
def read(self, length):
result = self.received[:length]
self.received = self.received[length:]
return result
def write(self, data):
if isinstance(data, Connection):
data = bytearray(data.flush())
from client import client
import discord
cmd_name = "ping"
client.basic_help(title=cmd_name, desc="shows the bot's latency to the Discord API endpoint")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name}",
"Arguments": "None",
"Description": "Returns the bot's latency to the Discord endpoint (implicitly telling you your connection is working).",
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(trigger=cmd_name)
async def ping(command: str, message: discord.Message):
await message.channel.send(f"Latency from bot to Discord endpoint (ms): `{client.latency*1000:.2f}`")
return
from client import client
import asyncio
import discord
import subprocess
client.basic_help(title="unit", desc="Converts units with the `units` Unix command.")
help_dict = {
"Usage": f"`{client.default_prefix}unit <src units> [dst units]`",
"Arguments": "`src units` - Source units to convert from. Supports any units the Unix `units` command supports (a *lot*!).\n`dst units` - (optional) Destination units to convert to.",
"Description": "This units transforms one unit into another unit. The command uses the underlying `units` Unix command, and supports over 3000 different units.\nIf destination units are not provided, the source units will be converted into standard units for length/width/height.",
"Example": f"`{client.default_prefix}units 1000km mi`\n`{client.default_prefix}units 0.0000026c`",
}
client.long_help(cmd="unit", mapping=help_dict)
@client.command(trigger="unit", aliases=["units", "c", "convert", "u"])
async def convert_units(command: str, message: discord.Message):
parts = command.split(" ")
if len(parts) == 1:
# no args
await message.channel.send(f"Need more arguments to run command. See command help for help.")
return
if len(parts) == 2:
proc = subprocess.Popen(["units", "-t", parts[1]], stdout=subprocess.PIPE)
if len(parts) == 3:
proc = subprocess.Popen(["units", "-t", parts[1], parts[2]], stdout=subprocess.PIPE)
if len(parts) == 4:
proc = subprocess.Popen(["units", "-t", f"'{parts[1]} {parts[2]}'", parts[3]], stdout=subprocess.PIPE)
if len(parts) == 5:
from client import client
import discord
@client.command(trigger="ping", aliases=["p"])
async def help_command(command: str, message: discord.Message):
await message.channel.send(
f"Latency to the connected Discord API endpoint: `{client.latency*1000:.0f} ms`"
)
return
client.basic_help("ping",
"Returns the bot's latency to its connected API endpoint.")
help_long_help = {
"Usage:":
f"`{client.default_prefix}ping`",
"Description":
"This command returns the bot's latency to the Discord API endpoint it is connected to."
}
client.long_help("ping", help_long_help)
await message.channel.send(embed=embed)
elif type(sub_help) == dict:
embed = discord.Embed(
title=f"Help for command `{command.lower()[5:]}`",
description=sub_help.get("_description", discord.Embed.Empty),
colour=0x06b206)
for title, text in sub_help.items():
embed = embed.add_field(name=title, value=text, inline=False)
if client.cmd_aliases.get(command.lower()[5:], []):
embed = embed.add_field(name="Aliases",
value="\n".join(
client.cmd_aliases.get(
command.lower()[5:], [])))
embed = embed.set_footer(text=datetime.datetime.utcnow().__str__())
await message.channel.send(embed=embed)
client.basic_help("help [command]",
"Get help with the bot or a certain command")
help_long_help = {
"Usage:":
f"`{client.default_prefix}help [command]`",
"Arguments":
"`command` - (Optional) Bot command to fetch detailed help with.",
"Description":
"This command fetches help information for a command or for all commands."
}
client.long_help("help", help_long_help)
from client import client
from datetime import datetime
import asyncio
import discord
import subprocess
import time
client.basic_help(title="time",
desc="Shows the current time, accounting for delays.")
client.long_help(
cmd="time",
mapping={
"Usage":
f"`{client.default_prefix}time",
"Description":
"This command shows the current UTC time as per the system clock, synchronized to a GPS receiver.\n"
"Typical accuracy of the clock is <500ns.\nDelays due to message sending in Discord are accounted "
"for with two test messages before recording and fudging the current time, and sending it back to you.\n"
"For further information on the clock synchronization on this machine, run the "
f"`{client.default_prefix}ntp` command.",
})
last_run = 0
@client.command(trigger="time")
async def show_simple_time(command: str, message: discord.Message):
global last_run
if (time.time() - last_run) < 15.0: # if cooldown,
from client import client
import discord
cmd_name = "x"
client.basic_help(title=cmd_name, desc="Pulls up a xkcd.")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name}",
"Arguments": "None",
"Description": "Pulls up a xkcd, all you need is a number!",
# NO Aliases field, this will be added automatically!
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(
trigger=cmd_name,
aliases=[]) # aliases is a list of strs of other triggers for the command
async def command(command: str, message: discord.Message):
num = command[2:]
await message.channel.send('http://xkcd.com/' + num)
return
import discord
import os
import socket
import time
try:
import psutil
except ModuleNotFoundError:
has_psutil = False
psutil = None
else:
has_psutil = True
psutil_update_thread = None
client.basic_help(title="stats", desc=f"Shows running statistics of {client.bot_name}")
detailed_help = {
"Usage": f"{client.default_prefix}stats",
"Description": f"This command shows different available statistics of {client.bot_name}, including servers, uptime, and commands run.",
"Related": f"`{client.default_prefix}info` - shows information about {client.bot_name}",
}
client.long_help(cmd="stats", mapping=detailed_help)
@client.command(trigger="stats", aliases=["statistics", "s", "status"])
async def statistics(command: str, message: discord.Message):
if "--uptime" in command:
up = time.perf_counter() - client.first_execution
await message.channel.send(f"Uptime:\n`{up:.3f}` seconds\n`{up/86400:.4f}` days")
return
from client import client
import datetime
import discord
import key
client.basic_help(
title="kzop",
desc="returns the time until Caleb/KZ0P's return from his two year leave")
@client.message
async def info_response(message: discord.Message):
if any([x in message.content for x in key.kzop_mentions]):
try:
await message.channel.send(
f"Hey there {message.author.mention}! You mentioned or pinged cSmith/KZ0P in your message, but he is on a two year long break. To send a message to him, please talk to @ntoskrnl#4435 instead."
)
except: # we literally don't care
pass
@client.command(trigger="kzop", aliases=["kz0p"])
async def timer(command: str, message: discord.Message):
await message.channel.send(
str(datetime.datetime(2020, 5, 25) - datetime.datetime.utcnow()))
return
from modules import __common__
from datetime import datetime
from client import client
import discord
import time
import key
import log
import os
client.basic_help(title="exit", desc="Cleans up and shuts down the bot.")
detailed_help = {
"Usage": f"{client.default_prefix}exit [pid]",
"Arguments": "`pid` - (Optional) Process ID identifying which bot to exit out of",
"Description": "This command completely exits out of the bot, and performs any registered cleanup procedures. A user ID check is performed against a builtin list of users allowed to run this command.",
# NO Aliases field, this will be added automatically!
}
client.long_help(cmd="exit", mapping=detailed_help)
@client.command(trigger="exit")
async def command(command: str, message: discord.Message):
if not __common__.check_permission(message.author):
await message.add_reaction("❌")
if message.author.id == key.shutdown_easter_egg_user:
await message.channel.send("*hehehe*\n\nCan't fool me! >:3")
return
else:
parts = command.split(" ")
try:
from client import client
import asyncio
import discord
import subprocess
client.basic_help(title="unit", desc="Converts between various units.")
help_dict = {
"Usage": f"`{client.default_prefix}unit <src units> [dst units]`",
"Arguments": "`src units` - Source units to convert from. Supports any units the Unix `units` command supports (a "
"*lot!*).\n`dst units` - (optional) Destination units to convert to.",
"Description": "This units transforms one unit into another unit. The command uses the underlying `units` Unix "
"command, and supports over 3000 different units.\nIf destination units are not provided, the "
"source units will be converted into standard SI units.",
"One argument usage": "`units 0.04128mi`\n`units 12d`\nWhen passing only one argument, the bot will convert the "
"given measurement into standard SI units.",
"Two argument usage": "`units 41.28mi km`\n`units 12um 0.02mm`\nWhen passing two arguments, the format is `units "
"<src> <dst>`. This will convert the given measurement into the destination unit, if "
"possible. If two numerical measurements are provided, this performs a ratio comparison "
"instead (see below). Note that providing one measurement but with a space is interpreted as "
"attempting to convert a dimensionless number into a measurement, and will throw a "
"conformability error.",
"Three argument usage": "`units 1.3 lightseconds m`\nWhen passing three arguments, the first two are interpreted "
"as the source measurement, which will be converted into the destination measurement given "
"by the third argument.",
"Four argument usage": "`units 0.128 us 0.000000319 sec`\nWhen passing four arguments, the first two and the last "
"two are interpreted to be the source and destination measurements. With numerical values "
"provided for both, this will perform a ratio comparison (see below).",
"Using temperature": "If it is desired to use temperatures, the temperature functions must be used: `tempC(1700)`, "
"`tempK(273.15)`, `tempF`, or `tempR`.",
"SI conversion": "If a single unit is passed without a destination unit or measurement to convert or compare to, "
from client import client
import discord
cmd_name = "morse"
client.basic_help(title=cmd_name, desc="converts a given string to morse code")
detailed_help = {
"Usage":
f"{client.default_prefix}{cmd_name} <string>",
"Arguments":
"`<string>` - the string to convert to morse code",
"Description":
"This command converts a given string into morse code. Works with letters, numbers, and some "
"punctuation.",
# NO Aliases field, this will be added automatically!
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
morse_lookup = {
"A": " .-",
"B": " -...",
"C": " -.-.",
"D": " -..",
"E": " .",
"F": " ..-.",
"G": " --.",
"H": " ....",
"I": " ..",
"J": " .---",
"K": " -.-",
from client import client
from datetime import datetime
import discord
import requests
cmd_name = "call"
client.basic_help(title=cmd_name,
desc="Looks up a callsign from the callook.info database.")
detailed_help = {
"Usage":
f"{client.default_prefix}{cmd_name} <callsign>",
"Arguments":
"`<callsign>` - the callsign to look up",
"Description":
"This command is a reimplementation of HamTheMan's `htm call` command. It retrieves information about a specified callsign and returns some info about it. This command exists in here because Ben doesn't know how to keep a bot online.",
# NO Aliases field, this will be added automatically!
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(
trigger=cmd_name,
aliases=[]) # aliases is a list of strs of other triggers for the command
async def command(command: str, message: discord.Message):
try:
requested_call = command.split(" ", 1)[1]
except TypeError:
await message.channel.send(
"Parameter `callsign` not given. See command help for help.")
import log
from client import client
from key import wa_key
import aiohttp
import discord
import time
import wolframalpha
http_client = aiohttp.ClientSession()
last_run_time = 0
blacklist_users = []
client.basic_help(
title=f"{client.default_prefix}wa",
desc="Performs a Wolfram|Alpha query and returns the results")
client.long_help(
cmd="wa",
mapping={
"Usage":
f"{client.default_prefix}wa",
"Arguments":
"Query to be evaluated",
"Description":
"The Wolfram|Alpha engine is a web-based computation engine that can perform a wide array of "
"mathematical, scientific, or engineering computations, statistical and information lookup, "
"conversion and calculation using units, and much, *much* more.",
"Note about results":
"Because Wolfram|Alpha can return results about (seemingly) anything under the sun, "
"it is difficult to automatically return intended, desired answers. For that reason, "
"if you encounter a query that does not show the answer or shows it improperly, "
from client import client
import requests
import discord
import time
cmd_name = "cond"
client.basic_help(title=cmd_name, desc="Shows current band conditions.")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name}",
"Arguments": "None",
"Description": "This is what the command does!",
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
last_cond_update = 0
cond_cache_time = 7200
@client.command(trigger=cmd_name)
async def command(command: str, message: discord.Message):
global cond_cache_time, last_cond_update
if command == "update":
last_cond_update = 1
if (time.time() - last_cond_update) >= cond_cache_time:
req = requests.get("http://www.hamqsl.com/solar101vhf.php")
with open("image.gif", "wb+") as tempfile:
for block in req.iter_content(16384):
tempfile.write(block)
last_cond_update = time.time()
from client import client
from datetime import datetime
from modules import __common__
from typing import Tuple
import asyncio
import discord
import markovify
cmd_name = "markov"
client.basic_help(title=cmd_name, desc="creates a message from a markov chain based on previous messages in a channel")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name} [mention] [--charlimit x] [--size y] [--attempts z]",
"Arguments": "`mention` - (optional) mention or ID of a channel or user to generate markov chain from (not provided = current channel)\n"
"`--charlimit` - (optional) specifies a custom maximum amount of permitted characters (default 1500 - lower values may require more --attempts)\n"
"`--size` - (optional) specifies the size of the markov chain. For text 2 or 3 is most common, for very large sources 4 may work. (default 3)\n"
"`--attempts` - (optional) specifies how many times the markov chain should attempt to generate valid output before giving up (default 50 - higher values have a better chance of succeeding for small sources)\n",
"Description": "This command reads input from a given source and feeds messages into a markov chain, which is then used to generate a random sentence that is similar to that of the input. Acceptable sources include the current channel (nothing given for `mention` argument), a specific user (that user's mention or preferably ID given for `mention` argument), or a specific channel (that channel's mention or ID given for `mention` argument).",
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
forbidden_channels = [
473570993072504832,
826099521032290334,
826868270740013116,
829321559217930240,
830263185088708660
]
from client import client
import discord
cmd_name = "command"
client.basic_help(title=cmd_name,
desc="This is what my command does, in a sentence.")
detailed_help = {
"Usage": f"{client.default_prefix}{cmd_name}",
"Arguments": "None",
"Description": "This is what the command does!",
# NO Aliases field, this will be added automatically!
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(
trigger=cmd_name,
aliases=[]) # aliases is a list of strs of other triggers for the command
async def command(command: str, message: discord.Message):
# Awesome stuff happens here!
return
from client import client
import discord
client.basic_help(title="cqdx", desc="SAY Q DX SAY Q DX SAY Q DXXXXX SAY Q DX SAY Q DX SAY Q DXxXxXxXxX CQDXCQDXCQDXCQDX")
@client.command(trigger="cqdx")
async def command(command: str, message: discord.Message):
# Awesome stuff happens here!
await message.channel.send("https://www.youtube.com/watch?v=5_bHuCwKmkI")
return
from key import shutdown_users, shutdown_easter_egg_user
from datetime import datetime
from client import client
import discord
import time
import log
import os
cmd_name = "exit"
client.basic_help(title=cmd_name, desc="Cleans up and shuts down the bot.")
detailed_help = {
"Usage":
f"{client.default_prefix}{cmd_name}",
"Arguments":
"None",
"Description":
"This command completely exits out of the bot, and performs any registered cleanup procedures. A user ID check is performed against a builtin list of users allowed to run this command.",
# NO Aliases field, this will be added automatically!
}
client.long_help(cmd=cmd_name, mapping=detailed_help)
@client.command(
trigger=cmd_name,
aliases=[]) # aliases is a list of strs of other triggers for the command
async def command(command: str, message: discord.Message):
if message.author.id not in shutdown_users:
try:
await message.add_reaction("❌")
"""Module to assist livepatching in new or updated modules."""
from client import client
from modules import __common__
import discord
import importlib
import modules
client.basic_help("livepatch",
"A module to load, reload, or unload modules on-the-fly")
detailed_help = {
"Usage":
f"`{client.default_prefix}livepatch <subcommands> []`",
"Description":
"This module is a kit of commands that can load and unload "
"modules on the fly while a bot is running, and show information about "
"currently loaded commands. Beware that this command can disable itself."
}
client.long_help("livepatch", detailed_help)
permissible_users = [ # list of IDs permitted to use the command
288438228959363073
]
# Correct for framework version 0.6
# As of 0.7 these remove the leading underscore
client_lists = [
# a list of all handlers the bot has
from exceptions import BaseFrameworkError
from typing import Union, Dict, List
import asyncio
import discord
import json
import key
import log
import os
import random
import socket
import time
import urllib
import youtube_dl
client.basic_help(title="music",
desc="Handles music functionality within the bot.")
detailed_help = {
"Usage":
f"{client.default_prefix}music <subcommand> [args]",
"Arguments":
"`subcommand` - subcommand to run\n`args` - (optional) arguments specific to the subcommand being run",
"Description":
"This command manages music related functionality within the bot. Music is available to several servers at once.",
"Subcommands":
f"`{client.default_prefix}music join` - Joins a voice channel\n"
f"`{client.default_prefix}music add <url>` - Adds the specified song to the queue\n"
f"`{client.default_prefix}music play` - Plays music in the queue\n"
f"`{client.default_prefix}music pause` - Toggles pause\n"
f"`{client.default_prefix}music playing` - Shows what is currently playing\n"
f"`{client.default_prefix}music skip` - Skips the currently playing song\n"
f"`{client.default_prefix}music queue` - Shows the current music queue\n"
