async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*args):
for a in args:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "tf"):
if not self.tf.success:
await client.send_message(
message.channel,
"This command is currently unavailable. Apologies.")
return
item_name = message.content[len(prefix + "tf "):]
item = self.tf.get_item_by_name(str(item_name))
if not item:
await client.send_message(
message.channel,
"An item with that name *does not exist*.".format(
item_name))
self.stats.add(WRONG_ARG)
return
ls = []
for qu in item.get_all_qualities():
down = qu.get(list(qu.keys())[0])
dt = "__**{}**__: `{} {}`".format(
get_quality_name(list(qu.keys())[0]),
down.get("price").get("value"),
"ref" if down.get("price").get("currency") == "metal" else
down.get("price").get("currency"))
ls.append(dt)
det = """**{}** *(on bp.tf)*\n\n{}""".format(
item.name, "\n".join(ls))
await client.send_message(message.channel, det)
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
assert isinstance(self.stats, NanoStats)
prefix = kwargs.get("prefix")
client = self.client
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# Loop over simple commands
for trigger, response in simple_commands.items():
if message.content.startswith(trigger.replace("_", prefix)):
await client.send_message(message.channel, response)
self.stats.add(MESSAGE)
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
# Other commands
if startswith(prefix + "kappa"):
await client.send_file(message.channel,
"data/images/kappasmall.png")
self.stats.add(IMAGE_SENT)
elif startswith(prefix + "cat"):
await client.send_file(message.channel, "data/images/cattypo.gif")
self.stats.add(IMAGE_SENT)
elif startswith(prefix + "randomgif"):
random_gif = self.gif.screensaver().media_url
await client.send_message(message.channel, str(random_gif))
self.stats.add(IMAGE_SENT)
elif startswith(prefix + "rip"):
if len(message.mentions) == 1:
ripperoni = message.mentions[0].mention
elif len(message.mentions) == 0:
ripperoni = message.content[len(prefix + "rip "):]
else:
ripperoni = ""
ripperoni = self.nano.get_plugin("commons").get(
"instance").at_everyone_filter(ripperoni, message.author,
message.server)
prays = self.stats.get_amount(PRAYER)
await client.send_message(
message.channel,
"Rest in pepperoni{}{}.\n`{}` *prayers said so far*...".format(
", " if ripperoni else "", ripperoni, prays))
self.stats.add(PRAYER)
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
prefix = kwargs.get("prefix")
client = self.client
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "wiki", prefix + "define"):
if startswith(prefix + "wiki"):
search = str(message.content)[len(prefix + "wiki "):]
elif startswith(prefix + "define"):
search = str(message.content)[len(prefix + "define "):]
else:
return
if not search or search == " ": # If empty args
await client.send_message(
message.channel,
"Please include a word you want to define.")
return
try:
answer = wikipedia.summary(search,
sentences=parser.get(
"wiki", "sentences"),
auto_suggest=True)
await client.send_message(
message.channel, "**{} :** \n".format(search) + answer)
except wikipedia.exceptions.PageError:
await client.send_message(message.channel,
"No definitions found.")
except wikipedia.exceptions.DisambiguationError:
await client.send_message(
message.channel,
"Got multiple definitions of {}, please be more specific (somehow)."
.format(search))
elif startswith(prefix + "urban"):
search = str(message.content)[len(prefix + "urban "):]
define = requests.get(
"http://www.urbandictionary.com/define.php?term={}".format(
search))
answer = BeautifulSoup(define.content,
"html.parser").find("div",
attrs={
"class": "meaning"
}).text
# Check if there are no definitions
if str(answer).startswith("\nThere aren't any"):
await client.send_message(message.channel,
"No definition found")
else:
await client.send_message(
message.channel,
"**" + message.content[7:] + "** *:*" + answer)
async def on_message(self, message, **kwargs):
# Things
assert isinstance(message, Message)
client = self.client
# Prefixes
prefix = kwargs.get("prefix")
# Custom commands registered for the server
server_commands = self.handler.get_custom_commands(
message.channel.server)
# Checks for server specific commands
for command in server_commands:
# UPDATE 2.1.4: not .startswith anymore!
if str(message.content) == command:
# Maybe same replacement logic in the future update?
# /todo implement advanced replacement logic
await client.send_message(message.channel,
server_commands.get(command))
self.stats.add(MESSAGE)
return
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
# A shortcut
def startswith(*msg):
for b in msg:
if message.content.startswith(b):
return True
return False
# COMMANDS
# !hello
if startswith(prefix + "hello"):
if len(message.mentions) >= 1:
await client.send_message(message.channel,
"Hi " + message.mentions[0].mention)
elif len(message.mentions) == 0:
await client.send_message(message.channel,
"Hi " + message.author.mention)
# !uptime
elif startswith(prefix + "uptime"):
d = datetime(
1, 1, 1) + timedelta(seconds=time.time() - self.nano.boot_time)
uptime = "I have been tirelessly answering people for\n" \
"**{} days, {} hours, {} minutes and {} seconds!**".format(d.day - 1, d.hour, d.minute, d.second)
await client.send_message(message.channel, uptime)
# !nano, nano.info
elif startswith((prefix + "nano", "nano.info")):
await client.send_message(
message.channel,
nano_info.replace("<version>", self.nano.version))
# !github
elif startswith(prefix + "github"):
await client.send_message(message.channel, nano_github)
# !roll
elif startswith(prefix + "roll"):
if startswith(prefix + "roll"):
num = message.content[len(prefix + "roll "):]
else:
num = message.content[len(prefix + "rng "):]
if not str(num).isnumeric():
await client.send_message(message.channel, "Not a number.")
return
rn = randint(0, int(num))
result = "**{}**. {}".format(rn,
"**GG**" if rn == int(num) else "")
await client.send_message(
message.channel,
"{}, you rolled {}".format(message.author.mention, result))
# !dice
elif startswith(prefix + "dice"):
rn = randint(1, 6)
await client.send_message(
message.channel,
"{}, the dice shows... **{}**".format(message.author.mention,
rn))
# !ping
elif startswith(prefix + "ping"):
base_time = datetime.now() - message.timestamp
base_taken = int(divmod(base_time.total_seconds(), 60)[1] * 100)
a = await client.send_message(message.channel, PING_MSG)
self.pings[a.id] = [
time.monotonic(), message.channel.id, base_taken
]
await client.add_reaction(a, "\U0001F44D")
self.stats.add(PING)
# !decide
elif startswith(prefix + "decide"):
cut = str(message.content)[len(prefix + "decide "):]
if len(cut.split("|")) == 1:
await client.send_message(
message.channel,
"Guess what? It's " + str(cut) + ". **ba dum tss.**")
else:
split = cut.split("|")
rn = randint(0, len(split) - 1)
await client.send_message(
message.channel,
"**drum roll**... I have decided: {}".format(split[rn]))
# !8ball
elif startswith(prefix + "8ball"):
answer = eight_ball[randint(0, len(eight_ball) - 1)]
await client.send_message(
message.channel, "The magic 8ball says: *{}*.".format(answer))
# !quote
elif startswith(prefix + "quote"):
chosen = str(quotes[randint(0, len(quotes) - 1)])
# Find the part where the author is mentioned
place = chosen.rfind("–")
await client.send_message(
message.channel, "{}\n- __{}__".format(chosen[:place],
chosen[place + 1:]))
# !invite
elif startswith(prefix + "invite", "nano.invite"):
application = await client.application_info()
# Most of the permissions that Nano uses
perms = "1543765079"
url = "<https://discordapp.com/oauth2/" \
"authorize?client_id={}&scope=bot&permissions={}>".format(application.id, perms)
await client.send_message(message.channel,
invite.replace("<link>", url))
# !avatar
elif startswith(prefix + "avatar"):
# Selects the proper user
if len(message.mentions) == 0:
name = str(str(message.content)[len(prefix + "avatar "):])
member = utils.find(lambda m: m.name == name,
message.channel.server.members)
else:
member = message.mentions[0]
if not member:
member = message.author
url = member.avatar_url
if url:
await client.send_message(
message.channel,
"**{}**'s avatar: {}".format(member.name, url))
else:
await client.send_message(
message.channel,
"**{}** does not have an avatar. {}".format(
member.name, StandardEmoji.EXPRESSIONLESS))
# !say
elif startswith(prefix + "say"):
if not self.handler.is_mod(message.author, message.server):
await client.send_message(message.channel,
StandardEmoji.WARNING + not_mod)
return "return"
content = str(message.content[len(prefix + "say "):]).strip(" ")
if len(message.channel_mentions) != 0:
channel = message.channel_mentions[0]
content = content.replace(channel.mention, "").strip(" ")
else:
channel = message.channel
content = self.at_everyone_filter(content, message.author,
message.server)
await client.send_message(channel, content)
await self.log_say_command(message, content, prefix)
# !selfrole [role name]
elif startswith(prefix + "selfrole"):
role = str(message.content[len(prefix + "selfrole"):]).strip(" ")
s_role = self.handler.get_selfrole(message.server.id)
if is_disabled(s_role):
await client.send_message(
message.channel, StandardEmoji.WARNING +
" This feature is not enabled on this server.")
elif (role != s_role) and len(message.role_mentions) == 0:
await client.send_message(
message.channel, StandardEmoji.CROSS + " Wrong role name.")
else:
if len(message.role_mentions) != 0:
role = message.role_mentions[0]
else:
role = utils.find(lambda r: r.name == s_role,
message.server.roles)
if not role:
return
# If user already has the role, remove it
if role in message.author.roles:
await client.remove_roles(message.author, role)
await client.send_message(
message.channel, StandardEmoji.PERFECT +
" Removed **{}** from your list of roles.".format(
s_role))
else:
await client.add_roles(message.author, role)
await client.send_message(message.channel,
StandardEmoji.PERFECT)
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
assert isinstance(self.handler, ServerHandler)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*args):
for a in args:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "vote start"):
if not self.handler.can_use_restricted_commands(message.author, message.channel.server):
await client.send_message(message.content, "You are not permitted to use this command.")
self.stats.add(WRONG_PERMS)
return
if self.vote.in_progress(message.channel.server):
await client.send_message(message.channel, "A vote is already in progress.")
return
vote_content = message.content[len(prefix + "vote start "):]
self.vote.start_vote(message.author.name, message.channel.server, vote_content)
ch = []
n = 1
for this in self.vote.get_content(message.channel.server):
ch.append("{}. {}".format(n, this))
n += 1
ch = "\n".join(ch).strip("\n")
await client.send_message(message.channel, "**{}**\n"
"```{}```".format(self.vote.get_vote_header(message.channel.server), ch))
elif startswith(prefix + "vote end"):
if not self.handler.can_use_restricted_commands(message.author, message.channel.server):
await client.send_message(message.channel, "You are not permitted to use this command.")
self.stats.add(WRONG_PERMS)
return
if not self.vote.in_progress(message.channel.server):
await client.send_message(message.channel, "There is no vote in progress.")
return
votes = self.vote.get_votes(message.channel.server)
header = self.vote.get_vote_header(message.channel.server)
content = self.vote.get_content(message.channel.server)
# Actually end the voting
self.vote.end_voting(message.channel.server)
# Put results together
cn = ["{} - `{} votes`".format(a, votes[a]) for a in content]
combined = "Vote ended:\n__{}__\n\n{}".format(header, "\n".join(cn))
await client.send_message(message.channel, combined)
elif startswith(prefix + "vote"):
# Get the choice, but tell the author if he/she didnt supply a number
try:
choice = int(message.content[len(prefix + "vote "):])
except ValueError:
m = await client.send_message(message.channel, "Vote argument must be a number.")
await asyncio.sleep(1.5)
await client.delete_message(m)
return
if (not choice) or (not self.vote.in_progress(message.channel.server)):
return
res = self.vote.plus_one(choice, message.author.id, message.channel.server)
if res == -1:
msg = await client.send_message(message.channel, "Cheater :smile:")
await asyncio.sleep(1)
await client.delete_message(msg)
elif res:
msg = await client.send_message(message.channel, ":ok_hand:")
await asyncio.sleep(1.5)
await client.delete_message(msg)
self.stats.add(VOTE)
async def on_message(self, message, *_, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
# A shortcut
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# !help and @Nanos
if message.content.strip(" ") == (prefix + "help"):
await client.send_message(message.channel,
help_nano.replace(">", prefix))
self.stats.add(HELP)
# @Nano help
elif self.client.user in message.mentions:
un_mentioned = str(message.content[21:])
if un_mentioned == "" or un_mentioned == " ":
await client.send_message(message.channel,
help_nano.replace(">", prefix))
self.stats.add(HELP)
# !cmds or !commands
elif startswith(prefix + "cmds", prefix + "commands"):
await client.send_message(
message.channel,
"Commands and their explanations can be found here: "
"http://nanobot.pw/commands.html")
self.stats.add(HELP)
# !help simple
elif startswith(prefix + "help simple"):
await client.send_message(message.channel,
help_simple.replace("_", prefix))
self.stats.add(HELP)
# !help [command]
elif startswith(prefix + "help"):
search = str(message.content)[len(prefix + "help "):]
self.stats.add(HELP)
def get_command_info(cmd):
# Normal commands
cmd1 = self.commands.get(
str(cmd.replace(prefix, "_").strip(" ")))
if cmd1 is not None:
cmd_name = cmd.replace(prefix, "")
description = cmd1.get("desc")
use = cmd1.get("use")
if use:
use = cmd1.get("use").replace(
"[command]", prefix + cmd_name
if not cmd_name.startswith("nano.") else cmd_name)
alias = cmd1.get("alias")
if alias:
alias = cmd1.get("alias").replace("_", prefix)
emb = Embed(colour=Colour.blue())
emb.add_field(name="Description", value=description)
if use:
emb.add_field(name="Use", value=use, inline=False)
if alias:
emb.add_field(name="Aliases",
value=alias,
inline=False)
self.stats.add(HELP)
return "**{}**".format(cmd_name), emb
if not cmd1:
self.stats.add(WRONG_ARG)
return None, None
# Allows for !help ping AND !help !ping
if search.startswith(prefix) or search.startswith("nano."):
name, embed = get_command_info(search)
if name:
await client.send_message(message.channel,
name,
embed=embed)
else:
await client.send_message(
message.channel, "Command could not be found.\n"
"**(Use: `>help [command]`)**".replace(">", prefix))
else:
name, embed = get_command_info(prefix + search)
if name:
await client.send_message(message.channel,
name,
embed=embed)
else:
await client.send_message(
message.channel, "Command could not be found.\n"
"**(Use: `>help [command]`)**".replace(">", prefix))
# !notifydev
elif startswith(prefix + "report", prefix + "suggest"):
if startswith(prefix + "report"):
report = message.content[len(prefix + "report "):]
typ = "Report"
elif startswith(prefix + "suggest"):
report = message.content[len(prefix + "suggest "):]
typ = "Suggestion"
else:
return
# Disallow empty reports
if not report.strip(" "):
await client.send_message(
message.channel, "You cannot submit an empty report.")
return
# Cooldown implementation
if not self.last_times.get(message.author.id):
self.last_times[message.author.id] = time.time()
else:
# 300 seconds --> 5 minute cooldown
if (time.time() - self.last_times[message.author.id]) < 300:
await client.send_message(
message.channel,
"You are being rate limited. Try again in 5 minutes.")
return
else:
self.last_times[message.author.id] = time.time()
# Find Nano Lounge (or whatever is in settings.ini under Dev)
dev_server = utils.get(client.servers, id=self.nano.dev_server)
# Timestamp
ts = datetime.now().strftime("%d.%m.%Y %H:%M:%S")
# 'Compiled' report
comp = "{} from {} ({}):\n```{}```\n**__Timestamp__**: `{}`\n**__Server__**: `{}` ({} members)\n" \
"**__Server Owner__**: {}".format(typ, message.author.name, message.author.id, report, ts,
message.channel.server.name, message.channel.server.member_count,
"Yes" if message.author.id == message.channel.server.owner.id
else message.channel.server.owner.id)
# Saves the submission
await save_submission(
comp.replace(
message.author.mention,
"{} ({})\n".format(message.author.name,
message.author.id)))
await client.send_message(dev_server.owner, comp)
await client.send_message(
message.channel, "**Thank you** for your *{}*.".format(
"submission" if typ == "Report" else "suggestion"))
# !bug
elif startswith(prefix + "bug"):
await client.send_message(message.channel,
nano_bug.replace("_", prefix))
async def on_message(self, message, **kwargs):
# Things
assert isinstance(message, Message)
client = self.client
# Prefixes
prefix = kwargs.get("prefix")
# Custom commands registered for the server
server_commands = self.handler.get_custom_commands(
message.channel.server)
# Checks for server specific commands
for command in server_commands:
if str(message.content).startswith(command):
# Maybe same replacement logic in the future update?
# /todo implement advanced replacement logic
await client.send_message(message.channel,
server_commands.get(command))
self.stats.add(MESSAGE)
return
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
# A shortcut
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# COMMANDS
# !hello
if startswith(prefix + "hello"):
if len(message.mentions) >= 1:
await client.send_message(message.channel,
"Hi " + message.mentions[0].mention)
elif len(message.mentions) == 0:
await client.send_message(message.channel,
"Hi " + message.author.mention)
# !uptime
elif startswith(prefix + "uptime"):
d = datetime(
1, 1, 1) + timedelta(seconds=time.time() - self.nano.boot_time)
uptime = "I have been tirelessly answering people for\n" \
"**{} days, {} hours, {} minutes and {} seconds!**".format(d.day - 1, d.hour, d.minute, d.second)
await client.send_message(message.channel, uptime)
# !nano, nano.info
elif startswith((prefix + "nano", "nano.info")):
await client.send_message(
message.channel,
nano_info.replace("<version>", self.nano.version))
# !github
elif startswith(prefix + "github"):
await client.send_message(message.channel, nano_github)
# !roll
elif startswith((prefix + "roll", prefix + "rng")):
if startswith(prefix + "roll"):
num = message.content[len(prefix + "roll "):]
else:
num = message.content[len(prefix + "rng "):]
if not str(num).isnumeric():
await client.send_message(message.channel, "Not a number.")
return
rn = randint(0, int(num))
result = "**{}**. {}".format(rn,
"**GG**" if rn == int(num) else "")
await client.send_message(
message.channel,
"{}, you rolled {}".format(message.author.mention, result))
# !dice
elif startswith(prefix + "dice"):
rn = randint(1, 6)
await client.send_message(
message.channel,
"{}, the dice shows... **{}**".format(message.author.mention,
rn))
# !ping
elif startswith(prefix + "ping"):
await client.send_message(message.channel, "**Pong!**")
self.stats.add(PING)
# !decide
elif startswith(prefix + "decide"):
cut = str(message.content)[len(prefix + "decide "):]
if len(cut.split("|")) == 1:
await client.send_message(
message.channel,
"Guess what? It's " + str(cut) + ". **ba dum tss.**")
else:
split = cut.split("|")
rn = randint(0, len(split) - 1)
await client.send_message(
message.channel,
"**drum roll**... I have decided: {}".format(split[rn]))
# !8ball
elif startswith(prefix + "8ball"):
answer = eight_ball[randint(0, len(eight_ball) - 1)]
await client.send_message(
message.channel, "The magic 8ball says: *{}*.".format(answer))
# !quote
elif startswith(prefix + "quote"):
chosen = str(quotes[randint(0, len(quotes) - 1)])
# Find the part where the author is mentioned
place = chosen.rfind("–")
await client.send_message(
message.channel, "{}\n__{}__".format(chosen[:place],
chosen[place:]))
# !invite
elif startswith(prefix + "invite", "nano.invite"):
application = await client.application_info()
# Most of the permissions that Nano uses
perms = str("0x510917638")
url = "https://discordapp.com/oauth2/" \
"authorize?client_id={}&scope=bot&permissions={}".format(application.id, perms)
await client.send_message(message.channel,
invite.replace("<link>", url))
# !avatar
elif startswith(prefix + "avatar"):
# Selects the proper user
if len(message.mentions) == 0:
name = str(str(message.content)[len(prefix + "avatar "):])
member = utils.find(lambda m: m.name == name,
message.channel.server.members)
else:
member = message.mentions[0]
if not member:
member = message.author
url = member.avatar_url
if url:
await client.send_message(
message.channel,
"**{}**'s avatar: {}".format(member.name, url))
else:
await client.send_message(
message.channel,
"**{}** does not have an avatar. :expressionless:".format(
member.name))
# !say
elif startswith(prefix + "say"):
content = message.content[len(prefix + "say "):]
content = self.at_everyone_filter(content, message.author,
message.server)
await client.send_message(message.channel, content)
async def on_message(self, message, **kwargs):
if not is_valid_command(message.content, valid_commands, prefix=kwargs.get("prefix")):
return
else:
self.stats.add(MESSAGE)
assert isinstance(message, Message)
client = self.client
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# Global owner filter
assert isinstance(self.handler, (RedisServerHandler, LegacyServerHandler))
if not self.handler.is_bot_owner(message.author.id):
await client.send_message(message.channel, StandardEmoji.WARNING + "You are not permitted to use this feature. (must be bot owner)")
return
# nano.dev.get_servers
if startswith("nano.dev.get_servers"):
# fixme message is still too long
servers = ["{} ({} u) - `{}`".format(srv.name, srv.member_count, srv.id) for srv in client.servers]
final = ["\n".join(a) for a in [servers[i:i+1000] for i in range(0, len(servers), 1000)]]
for chunk in final:
await client.send_message(message.channel, chunk)
# nano.dev.server_info [id]
elif startswith("nano.dev.server_info"):
s_id = message.content[len("nano.dev.server_info "):]
srv = utils.find(lambda s: s.id == s_id, client.servers)
if not srv:
await client.send_message(message.channel, "Error. " + StandardEmoji.CROSS)
return
nano_data = self.handler.get_server_data(srv)
to_send = "{}\n```css\nMember count: {}\nChannels: {}\nOwner: {}```\n" \
"*Settings*: ```{}```".format(srv.name, srv.member_count, ",".join([ch.name for ch in srv.channels]), srv.owner.name, nano_data)
await client.send_message(message.channel, to_send)
# nano.dev.test_error
elif startswith("nano.dev.test_exception"):
int("abcdef")
# nano.dev.embed_test
elif startswith("nano.dev.embed_test"):
emb = Embed(title="Stats", colour=Colour.darker_grey())
emb.add_field(name="Messages Sent", value="sample messages")
await client.send_message(message.channel, "Stats", embed=emb)
# nano.dev.backup
elif startswith("nano.dev.backup"):
self.backup.manual_backup()
await client.send_message(message.channel, "Backup completed " + StandardEmoji.PERFECT)
# nano.dev.leave_server
elif startswith("nano.dev.leave_server"):
sid = int(message.content[len("nano.dev.leave_server "):])
srv = utils.find(lambda a: a.id == sid, client.servers)
await client.leave_server(srv)
await client.send_message(message.channel, "Left {}".format(srv.name))
# nano.dev.tf.reload
elif startswith("nano.dev.tf.clean"):
self.nano.get_plugin("tf2").get("instance").tf.request()
await client.send_message(message.channel, "Re-downloaded data...")
# nano.dev.plugin.reload
elif startswith("nano.dev.plugin.reload"):
name = str(message.content)[len("nano.dev.plugin.reload "):]
v_old = self.nano.get_plugin(name).get("plugin").NanoPlugin.version
s = await self.nano.reload_plugin(name)
v_new = self.nano.get_plugin(name).get("plugin").NanoPlugin.version
if s:
await client.send_message(message.channel, "Successfully reloaded **{}**\n"
"From version *{}* to *{}*.".format(name, v_old, v_new))
else:
await client.send_message(message.channel, "Something went wrong, check the logs.")
# nano.dev.servers.clean
elif startswith("nano.dev.servers.clean"):
self.handler.delete_server_by_list([s.id for s in self.client.servers])
elif startswith("nano.dev.server.leave"):
s_id = int(str(message.content)[len("nano.dev.server.leave "):])
serv = Object(id=s_id)
if not serv:
await client.send_messsage(message.channel, "Could not leave server: does not exist")
else:
await client.leave_server(serv)
await client.send_message(message.channel, StandardEmoji.PERFECT + " Left {}".format(serv.id))
# nano.reload
elif startswith("nano.reload"):
self.handler.reload()
await client.send_message(message.channel, "Refreshed server data {} {}".format(StandardEmoji.MUSCLE, StandardEmoji.SMILE))
# nano.restart
elif startswith("nano.restart"):
m = await client.send_message(message.channel, "Restarting...")
await client.send_message(message.channel, "**DED**")
await client.delete_message(m)
await client.logout()
self.mode = "restart"
return "shutdown"
# nano.kill
elif startswith("nano.kill"):
await client.send_message(message.channel, "**DED**")
await client.logout()
self.mode = "exit"
return "shutdown"
# nano.playing
elif startswith("nano.playing"):
status = message.content[len("nano.playing "):]
await client.change_presence(game=Game(name=str(status)))
await client.send_message(message.channel, "Status changed " + StandardEmoji.THUMBS_UP)
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "steam"):
if startswith(prefix + "steam friends "):
uid = str(message.content)[len(prefix + "steam friends "):]
# Friend search
await client.send_typing(message.channel)
try:
username, friends = self.steam.get_friends(uid)
except ValueError:
await client.send_message(message.channel, NOT_WHOLE_URL)
return
except (steamapi.errors.APIFailure,
steamapi.errors.APIException):
await client.send_message(
message.channel,
"Something went wrong. User could have a private profile. "
+ StandardEmoji.CRY)
reraise()
return
if not username:
await client.send_message(message.channel,
"User **does not exist**.")
self.stats.add(WRONG_ARG)
return
if not friends:
await client.send_message(
message.channel,
"Could not fetch friends (probably because the user has a private profile."
)
self.stats.add(WRONG_ARG)
return
friends = ["`" + friend + "`" for friend in friends]
await client.send_message(
message.channel, "*User:* **{}**\n\n*Friends:* {}".format(
username, ", ".join(friends)))
elif startswith(prefix + "steam games"):
uid = str(message.content)[len(prefix + "steam games "):]
# Game search
await client.send_typing(message.channel)
try:
username, games = self.steam.get_owned_games(uid)
except ValueError:
await client.send_message(message.channel, NOT_WHOLE_URL)
return
except (steamapi.errors.APIFailure,
steamapi.errors.APIException):
await client.send_message(
message.channel,
"Something went wrong. User could have a private profile. "
+ StandardEmoji.CRY)
reraise()
return
if not username:
await client.send_message(message.channel,
"User **does not exist**.")
self.stats.add(WRONG_ARG)
return
if not games:
await client.send_message(
message.channel,
"Could not fetch games (probably because the user has a private profile."
)
self.stats.add(WRONG_ARG)
return
games = ["`{}`".format(game) for game in games]
try:
await client.send_message(
message.channel,
"*User:* **{}**:\n\n*Owned games:* {}".format(
username, ", ".join(games)))
except HTTPException:
await client.send_message(
message.channel,
"This message can not fit onto Discord: **user has too many games to display (lol)**"
)
elif startswith(prefix + "steam user "):
uid = str(message.content)[len(prefix + "steam user "):]
# Basic search
await client.send_typing(message.channel)
try:
steam_user = self.steam.get_user(uid)
except ValueError:
await client.send_message(message.channel, NOT_WHOLE_URL)
return
except (steamapi.errors.APIFailure,
steamapi.errors.APIException):
await client.send_message(
message.channel,
"Something went wrong. User could have a private profile. "
+ StandardEmoji.CRY)
reraise()
return
if not steam_user:
await client.send_message(message.channel,
"User **does not exist**.")
self.stats.add(WRONG_ARG)
return
try:
info = "User: **{}**\n```css\nStatus: {}\nLevel: {}\nGames: {} owned (including free games)\nFriends: {}```\n" \
"Direct link: http://steamcommunity.com/id/{}/".format(steam_user.name, "Online" if steam_user.state else "Offline",
steam_user.level, len(steam_user.games), len(steam_user.friends), uid)
except AttributeError:
await client.send_message(
message.channel,
"Could not display user info. This can happen when the user has a private profile. "
+ StandardEmoji.FROWN)
return
if len(info) > 2000:
await client.send_message(
message.channel,
"This message can not fit onto Discord: **user has too many friends to display (lol)**"
)
else:
await client.send_message(message.channel, info)
elif startswith(prefix + "steam") or startswith(prefix +
"steam help"):
await client.send_message(
message.channel,
"**Steam commands:**\n`_steam user community_url`, `_steam friends community_url`, `_steam games community_url`"
.replace("_", prefix))
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
prefix = kwargs.get("prefix")
client = self.client
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "wiki", prefix + "define"):
if startswith(prefix + "wiki"):
search = str(message.content)[len(prefix + "wiki "):]
elif startswith(prefix + "define"):
search = str(message.content)[len(prefix + "define "):]
else:
return
if not search or search == " ": # If empty args
await client.send_message(
message.channel,
"Please include a word you want to define.")
return
try:
answer = wikipedia.summary(search,
sentences=parser.get(
"wiki", "sentences"),
auto_suggest=True)
await client.send_message(
message.channel, "**{} :** \n".format(search) + answer)
except wikipedia.exceptions.PageError:
await client.send_message(message.channel,
"No definitions found.")
except wikipedia.exceptions.DisambiguationError:
await client.send_message(
message.channel,
"Got multiple definitions of {}, please be more specific (somehow)."
.format(search))
except wikipedia.exceptions.WikipediaException as e:
if str(e).startswith(QUERY_TOO_LONG):
await client.send_message(
message.channel,
"Search query is too long: 300 is the maximum length (you searched with {})"
.format(len(search)))
elif startswith(prefix + "urban"):
search = str(message.content)[len(prefix + "urban "):]
async with aiohttp.ClientSession() as session:
async with session.get(
"http://www.urbandictionary.com/define.php?term={}".
format(search)) as resp:
define = await resp.text()
try:
answer = BeautifulSoup(define,
"html.parser").find("div",
attrs={
"class":
"meaning"
}).text
except AttributeError:
await client.send_message(message.channel,
"No definition found")
return
# Check if there are no definitions
if str(answer).startswith("\nThere aren't any"):
await client.send_message(message.channel,
"No definition found")
else:
if (len(answer) + len(search)) > 1900:
await client.send_message(
message.channel,
StandardEmoji.WARNING + "Definition is too long!")
return
content = "**{}** *:* {}".format(search, answer)
await client.send_message(message.channel, content)
async def on_message(self, message, **kwargs):
client = self.client
prefix = kwargs.get("prefix")
assert isinstance(message, Message)
assert isinstance(client, Client)
if not is_valid_command(message.content, valid_commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# !remind me in [time]:[reminder]
if startswith(prefix + "remind me in"):
args = str(message.content)[len(prefix + "remind me in "):].strip().split(":")
if len(args) != 2:
await client.send_message(message.channel, "Incorrect command use. See `_help remind me in` for usage".replace("_", prefix))
self.stats.add(WRONG_ARG)
return
content = str(args[1]).strip(" ")
if not args[0].isnumeric():
if "[" in args[0]:
# When people actually do !remind here in [1h 32min]: omg why
await client.send_message(message.channel, "Do not use **[** and **]** ! Try again without them.")
return
ttr = convert_to_seconds(args[0])
else:
ttr = int(args[0])
resp = self.reminder.set_reminder(message.author, message.author, content, ttr, reminder_type=REMINDER_PERSONAL)
if resp == -1:
await client.send_message(message.channel, EXCEEDED_REMINDER_LIMIT)
elif resp is False:
await client.send_message(message.channel, "Not a valid time range (5 seconds to 2 days")
else:
await client.send_message(message.channel, "Reminder set :)")
# !remind here in [time]:[reminder]
elif startswith(prefix + "remind here in"):
args = str(message.content)[len(prefix + "remind here in "):].strip().split(":")
if len(args) != 2:
await client.send_message(message.channel, "Incorrect command use. See `_help remind here in` for usage".replace("_", prefix))
self.stats.add(WRONG_ARG)
return
content = str(args[1]).strip(" ")
if not args[0].isnumeric():
try:
ttr = convert_to_seconds(args[0])
except ValueError:
await client.send_message(message.channel, "Please do not use partial minutes/hours/days etc.. (such as 1.7 days - use `1d 16h 48min` instead {}".format(StandardEmoji.WINK))
return
else:
ttr = int(args[0])
resp = self.reminder.set_reminder(message.channel, message.author, content, ttr, reminder_type=REMINDER_CHANNEL)
if resp == -1:
await client.send_message(message.channel, EXCEEDED_REMINDER_LIMIT)
elif resp is False:
await client.send_message(message.channel, "Not a valid time range (5 seconds to 2 days")
else:
await client.send_message(message.channel, "Reminder set :)")
# !remind list
elif startswith(prefix + "remind list", prefix + "reminder list"):
reminders = self.reminder.get_reminders(message.author.id)
if not reminders:
await client.send_message(message.channel, "You don't have any reminders.")
return
rem = []
for reminder in reminders.values():
# Gets the remaining time
ttl = reminder.get("time_target") - time.time()
cont = self.nano.get_plugin("commons").get("instance").at_everyone_filter(reminder.get("raw"), message.author, message.server)
if (ttl != abs(ttl)) or ttl == 0:
when = "**soon™**"
else:
when = "in **{}**".format(resolve_time(ttl))
rem.append("➤ {} ({})".format(cont, when))
await client.send_message(message.channel, "Your reminders:\n" + "\n".join(rem))
# !remind remove
elif startswith(prefix + "remind remove"):
r_name = message.content[len(prefix + "remind remove"):].strip()
if r_name == "all":
self.reminder.remove_all_reminders(message.author)
await client.send_message(message.channel, "All reminders have been deleted. " + StandardEmoji.PERFECT)
else:
r_resp = self.reminder.remove_reminder(message.author.id, r_name)
if not r_resp:
await client.send_message(message.channel, "No reminder with such content.")
else:
await client.send_message(message.channel, "Reminder removed.")
# !remind help
elif startswith(prefix + "remind", prefix + "remind help"):
await client.send_message(message.channel, remind_help.replace("_", prefix))
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*args):
for a in args:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "osu"):
username = message.content[len(prefix + "osu "):]
t_start = time.time()
user = self.osu.get_user(username)
if not user:
await client.send_message(message.channel,
"User does not exist.")
return
# About inverting: this inverts the number before and after the splitting
def prepare(this):
if not type(this) in (float, int):
return None
return invert_str(",".join(
split_every(str(invert_num(this)), 3)))
global_rank = prepare(user.world_rank)
country_rank = prepare(user.country_rank)
total_score = prepare(user.total_score)
ranked_score = prepare(user.ranked_score)
try:
acc = str(round(float(user.accuracy), 2)) + " %"
except TypeError:
await client.send_message(message.channel,
":warning: Something went wrong...")
return
pp_amount = str(int(float(user.pp)))
osu_level = int(float(user.level))
avatar_url = "http://a.ppy.sh/{}".format(user.id)
# Color is determined by the level range
if osu_level < 10:
color = Colour.darker_grey()
elif osu_level < 25:
color = Colour.light_grey()
elif osu_level < 40:
color = Colour.dark_teal()
elif osu_level < 50:
color = Colour.teal()
elif osu_level < 75:
color = Colour.dark_purple()
elif osu_level < 100:
color = Colour.purple()
# Only the masters get the gold ;)
else:
color = Colour.gold()
desc = "**Level**: {}\n**Rank**: \n\t" \
"**Global**: #{}\n\t" \
"**Country** (**{}**): #{}\n" \
"Total PP: **{}**".format(osu_level, global_rank, user.country, country_rank, pp_amount)
embed = Embed(url=user.profile_url, description=desc, colour=color)
embed.set_author(name=user.name)
embed.set_thumbnail(url=avatar_url)
embed.add_field(name="Total score", value=total_score)
embed.add_field(name="Ranked score", value=ranked_score)
embed.add_field(name="Average accuracy", value=acc)
delta = int((time.time() - t_start) * 1000)
embed.set_footer(text="Search took {} ms".format(delta))
try:
await client.send_message(message.channel, embed=embed)
except errors.HTTPException:
await client.send_message(
message.channel,
"Something went wrong " + StandardEmoji.THINKING)
async def on_message(self, message, **kwargs):
assert isinstance(message, discord.Message)
prefix = kwargs.get("prefix")
client = self.client
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# !status
if startswith(prefix + "status"):
server_count = 0
members = 0
channels = 0
# Iterate though servers and add up things
for server in client.servers:
server_count += 1
members += int(server.member_count)
channels += len(server.channels)
embed = discord.Embed(name="Stats",
colour=discord.Colour.dark_blue())
embed.add_field(name="Servers",
value="{} servers".format(server_count),
inline=True)
embed.add_field(name="Users",
value="{} members".format(members),
inline=True)
embed.add_field(name="Channels",
value="{} channels".format(channels),
inline=True)
await client.send_message(message.channel,
"**Stats**",
embed=embed)
# !debug
elif startswith(prefix + "debug", prefix + "stats more"):
# Some more debug data
if ((self.lt - time.time()) <
360) and not self.handler.is_bot_owner(message.author.id):
return
else:
self.lt = time.time()
# CPU
cpu = psutil.cpu_percent(interval=0.5)
# RAM
def check_ram():
nano_process = psutil.Process(os.getpid())
return round(nano_process.memory_info()[0] / float(2**20),
1) # Converts to MB
mem_before = check_ram()
# Attempt garbage collection
gc.collect()
mem_after = check_ram()
garbage = round(mem_after - mem_before, 2)
# OTHER
d = datetime(
1, 1, 1) + timedelta(seconds=time.time() - self.nano.boot_time)
uptime = "{} days, {}:{}:{}".format(d.day - 1, d.hour, d.minute,
d.second)
nano_version = self.nano.version
discord_version = discord.__version__
reminders = self.nano.get_plugin("reminder").get(
"instance").reminder.get_reminder_amount()
polls = self.nano.get_plugin("voting").get(
"instance").vote.get_vote_amount()
embed = discord.Embed(colour=discord.Colour.green())
embed.add_field(name="Nano version", value=nano_version)
embed.add_field(name="discord.py", value=discord_version)
embed.add_field(name="RAM usage",
value="{} MB (garbage collected {} MB)".format(
mem_after, garbage))
embed.add_field(name="CPU usage", value="{} %".format(cpu))
embed.add_field(name="Ongoing reminders", value=str(reminders))
embed.add_field(name="Ongoing votes", value=str(polls))
# Balances some stats
if isinstance(self.handler, RedisServerHandler):
redis_mem = self.handler.db_info("memory").get(
"used_memory_human")
embed.add_field(name="Redis memory",
value=redis_mem,
inline=False)
redis_size = self.handler.db_size()
embed.add_field(name="Redis keys", value=redis_size)
else:
embed.add_field(name="Uptime", value=uptime)
await client.send_message(message.channel,
"**Debug data:**",
embed=embed)
# !stats
elif startswith(prefix + "stats"):
file = self.stats.get_data()
messages = file.get("msgcount")
wrong_args = file.get("wrongargcount")
sleeps = file.get("timesslept")
wrong_permissions = file.get("wrongpermscount")
helps = file.get("peoplehelped")
votes = file.get("votesgot")
pings = file.get("timespinged")
imgs = file.get("imagessent")
embed = discord.Embed(colour=discord.Colour.gold())
embed.add_field(name="Messages sent", value=messages)
embed.add_field(name="Wrong arguments got", value=wrong_args)
embed.add_field(name="Command abuses tried",
value=wrong_permissions)
embed.add_field(name="People Helped", value=helps)
embed.add_field(name="Images sent", value=imgs)
embed.add_field(name="Votes got", value=votes)
embed.add_field(name="Times slept", value=sleeps)
embed.add_field(name="Times Pong!-ed", value=pings)
# Left out "images uploaded" because there was no use
await client.send_message(message.channel,
"**Stats**",
embed=embed)
# !prefix
elif startswith(prefix + "prefix"):
await client.send_message(message.channel, "You guessed it!")
# nano.prefix
elif startswith("nano.prefix"):
await client.send_message(
message.channel,
"The prefix on this server is **{}**".format(prefix))
# !members
elif startswith(prefix + "members"):
ls = [member.name for member in message.channel.server.members]
members = "*__Members__*:\n\n{}".format(", ".join(
["`{}`".format(mem)
for mem in ls])) + "\nTotal: **{}** members".format(len(ls))
if len(members) > 2000:
# Only send the number if the message is too long.
await client.send_message(
message.channel,
"This guild has a total number of **{}** members".format(
len(ls)))
else:
await client.send_message(message.channel, members)
# !server
elif startswith(prefix + "server"):
user_count = message.server.member_count
users_online = len([
user.id for user in message.server.members
if user.status == user.status.online
])
v_level = message.server.verification_level
if v_level == v_level.none:
v_level = "None"
elif v_level == v_level.low:
v_level = "Low"
elif v_level == v_level.medium:
v_level = "Medium"
else:
v_level = "High (╯°□°）╯︵ ┻━┻"
channels = len(message.server.channels)
text_chan = len([
chan.id for chan in message.server.channels
if chan.type == chan.type.text
])
voice_chan = len([
chan.id for chan in message.server.channels
if chan.type == chan.type.voice
])
# Teal Blue
embed = discord.Embed(colour=discord.Colour(0x3F51B5),
description="ID: *{}*".format(
message.server.id))
if message.server.icon:
embed.set_author(name=message.server.name,
icon_url=message.server.icon_url)
embed.set_thumbnail(url=message.server.icon_url)
else:
embed.set_author(name=message.server.name)
embed.set_footer(
text="Server created at {}".format(message.server.created_at))
embed.add_field(name="Members [{} total]".format(user_count),
value="{} online".format(users_online))
embed.add_field(name="Channels [{} total]".format(channels),
value="{} voice | {} text".format(
voice_chan, text_chan))
embed.add_field(name="Verification level", value=v_level)
embed.add_field(
name="Roles",
value="{} custom".format(len(message.server.roles) - 1))
embed.add_field(name="Server Owner",
value="{}#{} ID:{}".format(
message.server.owner.name,
message.server.owner.discriminator,
message.server.owner.id))
await client.send_message(message.channel,
"**Server info:**",
embed=embed)
async def on_message(self, message, *_, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
# A shortcut
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# !help and @Nano
if message.content.strip(" ") == (prefix + "help"):
await client.send_message(message.channel, help_nano)
self.stats.add(HELP)
# @Nano help
elif self.client.user in message.mentions:
un_mentioned = str(message.content[21:])
if un_mentioned == "" or un_mentioned == " ":
await client.send_message(message.channel, help_nano)
self.stats.add(HELP)
# !cmds or !commands
elif startswith(prefix + "cmds", prefix + "commands"):
await client.send_message(
message.channel,
"A 'complete' list of commands is available here: https://github.com/DefaltSimon/Nano/wiki/Commands"
)
self.stats.add(HELP)
# !help simple
elif startswith(prefix + "help simple"):
await client.send_message(message.channel, help_simple)
self.stats.add(HELP)
# !help [command]
elif startswith(prefix + "help"):
search = str(message.content)[len(prefix + "help "):]
self.stats.add(HELP)
def get_command_info(cmd):
# Normal commands
cmd1 = cmd_help_normal.get(
str(cmd.replace(prefix, "_").strip(" ")))
if cmd1 is not None:
cmd_name = search.replace(prefix, "")
description = cmd1.get("desc")
use = cmd1.get("use")
alias = cmd1.get("alias")
preset = "Command: **{}**\n```css\n" \
"Description: {}{}{}```".format(cmd_name, description, "\n" + use if use else "", "\n" + alias if alias else "")
self.stats.add(HELP)
return preset
# Admin commands
cmd2 = cmd_help_admin.get(
str(cmd.replace(prefix, "_").strip(" ")))
if cmd2 is not None:
cmd_name = search.replace(prefix, "")
description = cmd2.get("desc")
use = cmd2.get("use")
alias = cmd2.get("alias")
preset = "Command: **{}** (admin only)\n```css\n" \
"Description: {}{}{}```".format(cmd_name, description, "\n" + use if use else "", "\n" + alias if alias else "")
self.stats.add(HELP)
return preset
# Owner commands
cmd3 = cmd_help_owner.get(
str(cmd.replace(prefix, "_").strip(" ")))
if cmd3 is not None:
cmd_name = search.replace(prefix, "")
description = cmd3.get("desc")
use = cmd3.get("use")
alias = cmd3.get("alias")
preset = "Command: **{}** (owner only)\n```css\n" \
"Description: {}{}{}```".format(cmd_name, description, "\n" + use if use else "", "\n" + alias if alias else "")
self.stats.add(HELP)
return preset
if not cmd1 or not cmd2 or not cmd3:
self.stats.add(WRONG_ARG)
return None
# Allows for !help ping AND !help !ping
if search.startswith(prefix):
res = get_command_info(search)
if res:
await client.send_message(message.channel, res)
else:
await client.send_message(
message.channel, "Command could not be found.\n"
"**(Use: `>help command`)**".replace(">", prefix))
else:
res = get_command_info(prefix + search)
if res:
await client.send_message(message.channel, res)
else:
await client.send_message(
message.channel, "Command could not be found.\n"
"**(Use: `>help command`)**".replace(">", prefix))
# !notifydev
elif startswith(prefix + "notifydev", prefix + "suggest"):
if startswith(prefix + "notifydev"):
report = message.content[len(prefix + "notifydev "):]
typ = "Report"
elif startswith(prefix + "suggest"):
report = message.content[len(prefix + "suggest "):]
typ = "Suggestion"
else:
return
dev_server = utils.get(client.servers, id=self.nano.dev_server)
# Timestamp
ts = datetime.now().strftime("%d.%m.%Y %H:%M:%S")
# 'Compiled' report
comp = "{} from {} ({}):\n```{}```\n**__Timestamp__**: `{}`\n**__Server__**: `{}` ({} members)\n" \
"**__Server Owner__**: {}".format(typ, message.author.name, message.author.id, report, ts,
message.channel.server.name, message.channel.server.member_count,
"Yes" if message.author.id == message.channel.server.owner.id
else message.channel.server.owner.id)
# Saves the submission to disk
save_submission(
comp.replace(
message.author.mention,
"{} ({})\n".format(message.author.name,
message.author.id)))
await client.send_message(dev_server.owner, comp)
await client.send_message(
message.channel, "**Thank you** for your *{}*.".format(
"submission" if typ == "Report" else "suggestion"))
# !bug
elif startswith(prefix + "bug"):
await client.send_message(message.channel,
nano_bug.replace("_", prefix))
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*args):
for a in args:
if message.content.startswith(a):
return True
return False
# !cat gif/jpg/png
if startswith(prefix + "cat"):
args = str(message.content[len(prefix + "cat"):]).strip(" ")
# GIF is the default type!
type_ = "gif"
if len(args) != 0:
if args == "jpg":
type_ = "jpg"
elif args == "png":
type_ = "png"
pic = await self.cat.random_cat(type_)
if not pic:
await client.send_message(
message.channel, "Could not get a random cat picture... " +
StandardEmoji.CRY)
else:
await client.send_message(message.channel, pic)
self.stats.add(IMAGE_SENT)
# !xkcd random/number/latest
elif startswith(prefix + "xkcd"):
args = str(message.content[len(prefix + "xkcd"):]).strip(" ")
# Decides mode
fetch = "random"
if len(args) != 0:
if is_number(args):
# Check if number is valid
if int(args) > self.xkcd.last_num:
await client.send_message(
message.channel,
"Such XKCD number does not exist.")
return
else:
fetch = "number"
elif args == "random":
# Already random mode
pass
else:
fetch = "latest"
if fetch == "random":
xkcd = await self.xkcd.get_random_xkcd()
elif fetch == "number":
xkcd = await self.xkcd.get_xkcd_by_number(args)
else:
xkcd = await self.xkcd.get_latest_xkcd()
if not xkcd:
await client.send_message(
message.channel,
"Could not fetch xkcd " + StandardEmoji.CRY +
". Error has been logged for inspection.")
log_to_file("XKCD: string {}, fetch: {}, got None".format(
args, fetch))
else:
await client.send_message(
message.channel,
"**XKCD number {}:**\n{}".format(xkcd.num, xkcd.img))
# !joke (yo mama/chuck norris)
elif startswith(prefix + "joke"):
arg = str(message.content[len(prefix + "joke"):]).strip(" ")
if arg.lower() == "yo mama":
joke = await self.joke.get_joke(0)
elif arg.lower() == "chuck norris":
joke = await self.joke.get_joke(1)
else:
# Already random
joke = await self.joke.get_joke()
if not joke:
await client.send_message(
message.channel,
"Could not get a proper joke... " + StandardEmoji.CRY)
return
await client.send_message(message.channel, str(joke))
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
assert isinstance(self.handler, ServerHandler)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*args):
for a in args:
if message.content.startswith(a):
return True
return False
# !vote start
if startswith(prefix + "vote start"):
if not self.handler.can_use_restricted_commands(message.author, message.channel.server):
await client.send_message(message.channel, "You are not permitted to use this command.")
self.stats.add(WRONG_PERMS)
return
if self.vote.in_progress(message.channel.server):
await client.send_message(message.channel, IN_PROGRESS)
return
vote_content = message.content[len(prefix + "vote start "):]
base = str(vote_content).split("\"")
if len(base) != 3:
await client.send_message(message.channel, "Incorrect usage. Check {}help vote start for info.".format(prefix))
self.stats.add(WRONG_ARG)
return
title = str(base[1])
vote_items = str(base[2]).split("|")
vote_items = [a.strip(" ") for a in list(vote_items)]
if len(vote_items) > VOTE_ITEM_LIMIT:
await client.send_message(message.channel, StandardEmoji.WARNING + " Too many vote options "
"(max is **{}**, you put *{}*)".format(VOTE_ITEM_LIMIT, len(vote_items)))
return
if (len(title) + sum([len(a) for a in vote_items])) > VOTE_ITEM_MAX_LENGTH:
await client.send_message(message.channel, StandardEmoji.WARNING + " The whole thing is too long! (max is {}, you have {}".format(VOTE_ITEM_MAX_LENGTH, sum([len(a) for a in vote_items])))
self.vote.start_vote(message.author.name, message.server.id, title, vote_items)
ch = "\n".join(["{}. {}".format(en + 1, ch) for en, ch in
enumerate(self.vote.get_choices(message.server.id))]).strip("\n")
await client.send_message(message.channel, "Vote started:\n**{}**\n"
"```js\n{}```".format(self.vote.get_vote_title(message.server.id), ch))
# !vote end
elif startswith(prefix + "vote end"):
if not self.handler.can_use_restricted_commands(message.author, message.server):
await client.send_message(message.channel, "You are not permitted to use this command.")
self.stats.add(WRONG_PERMS)
return
if not self.vote.in_progress(message.server):
await client.send_message(message.channel, NO_VOTE)
return
votes = self.vote.get_votes(message.server.id)
title = self.vote.get_vote_title(message.server.id)
embed = Embed(title=title, colour=Colour(0x303F9F),
description="(In total, {} people voted)".format(sum(votes.values())))
embed.set_footer(text="Voting ended")
for name, val in votes.items():
embed.add_field(name=name, value="{} votes".format(val))
try:
await client.send_message(message.channel, "Vote ended:", embed=embed)
except errors.HTTPException as e:
await client.send_message(message.channel, "Something went wrong when trying to end voting. It has been logged and will be inspected.")
log_to_file("VOTING ({}): {}".format(e, embed.to_dict()))
return
# Actually end the voting
self.vote.end_voting(message.server)
# !vote status
elif startswith(prefix + "vote status"):
if not self.vote.in_progress(message.server):
await client.send_message(message.channel, NO_VOTE)
return
header = self.vote.get_vote_title(message.server.id)
votes = sum(self.vote.get_votes(message.server.id).values())
if votes == 0:
vote_disp = "no-one has voted yet"
elif votes == 1:
vote_disp = "only one person has voted"
else:
vote_disp = "{} people have voted".format(votes)
await client.send_message(message.channel, "**Vote:** \"{}\"\n```So far, {}.```".format(header, vote_disp))
# !vote
elif startswith(prefix + "vote"):
# Ignore if there is no vote going on instead of getting an exception
if not self.vote.in_progress(message.server):
print("not in progress")
return
# Get the choice, but tell the author if he/she didn't supply a number
try:
choice = int(message.content[len(prefix + "vote "):]) - 1
except ValueError:
m = await client.send_message(message.channel, "Vote argument must be a number.")
await asyncio.sleep(1.5)
await client.delete_message(m)
return
if choice < 0:
return
res = self.vote.plus_one(choice, message.author.id, message.channel.server)
if res == -1:
msg = await client.send_message(message.channel, "Cheater " + StandardEmoji.SMILE)
await asyncio.sleep(1)
await client.delete_message(msg)
elif res:
await client.add_reaction(message, OK_EMOJI)
else:
msg = await client.send_message(message.channel, "Something went wrong... " + StandardEmoji.FROWN2)
await asyncio.sleep(1)
await client.delete_message(msg)
self.stats.add(VOTE)
async def on_message(self, message, **kwargs):
assert isinstance(message, discord.Message)
assert isinstance(self.stats, NanoStats)
prefix = kwargs.get("prefix")
client = self.client
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# !status
if startswith(prefix + "status"):
server_count = 0
members = 0
channels = 0
# Iterate though servers and add up things
for server in client.servers:
server_count += 1
members += int(server.member_count)
channels += len(server.channels)
stats = "**Stats**\n\nServers: `{}`\nUsers: `{}`\nChannels: `{}`".format(
server_count, members, channels)
await client.send_message(message.channel, stats)
# !debug
elif startswith(prefix + "debug", prefix + "stats more"):
# Some more debug data
# RAM
def check_ram():
nano_process = psutil.Process(os.getpid())
return round(nano_process.memory_info()[0] / float(2**20),
1) # Converts to MB
mem_before = check_ram()
# Attempt garbage collection
gc.collect()
mem_after = check_ram()
garbage = round(mem_after - mem_before, 2)
# CPU
cpu = psutil.cpu_percent(interval=0.5)
# OTHER
d = datetime(
1, 1, 1) + timedelta(seconds=time.time() - self.nano.boot_time)
uptime = "{} days, {}:{}:{}".format(d.day - 1, d.hour, d.minute,
d.second)
nano_version = self.nano.version
discord_version = discord.__version__
reminders = len(
self.nano.get_plugin("reminder").get(
"instance").reminder.reminders)
polls = len(
self.nano.get_plugin("voting").get("instance").vote.progress)
debug_data = """```
Nano: {}
discord.py: {}
RAM usage: {} MB (garbage collected {} MB)
Cpu usage: {} %
Uptime: {}
Current reminders: {}
Current votes: {}```""".format(nano_version, discord_version,
mem_after, garbage, cpu, uptime,
reminders, polls)
await client.send_message(message.channel, debug_data)
# !stats
elif startswith(prefix + "stats"):
file = self.stats.get_data()
messages = file.get("msgcount")
wrong_args = file.get("wrongargcount")
sleeps = file.get("timesslept")
wrong_permissions = file.get("wrongpermscount")
helps = file.get("peoplehelped")
images = file.get("imagessent")
votes = file.get("votesgot")
pings = file.get("timespinged")
to_send = "**Stats**\n```python\n{} messages sent\n{} people yelled at because of wrong args\n" \
"{} people denied because of wrong permissions\n{} people helped\n{} votes got\n{} times slept\n" \
"{} images uploaded\n{} times Pong!-ed```".format(messages, wrong_args, wrong_permissions,
helps, votes, sleeps, images, pings)
await client.send_message(message.channel, to_send)
# !prefix
elif startswith(prefix + "prefix"):
await client.send_message(message.channel, "You guessed it!")
# nano.prefix
elif startswith("nano.prefix"):
await client.send_message(
message.channel,
"The prefix on this server is **{}**".format(prefix))
# !members
elif startswith(prefix + "members"):
ls = [member.name for member in message.channel.server.members]
members = "*__Members__*:\n\n{}".format(", ".join(
["`{}`".format(mem)
for mem in ls])) + "\nTotal: **{}** members".format(len(ls))
if len(members) > 2000:
# Only send the number if the message is too long.
await client.send_message(
message.channel,
"This guild has a total number of **{}** members".format(
len(ls)))
else:
await client.send_message(message.channel, members)
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "steam"):
if startswith(prefix + "steam friends "):
uid = str(message.content)[len(prefix + "steam friends "):]
# Friend search
await client.send_typing(message.channel)
username, friends = self.steam.get_friends(uid)
friends = ["`" + friend + "`" for friend in friends]
if not username:
await client.send_message(message.channel,
"User **does not exist**.")
# stat.pluswrongarg()
return
await client.send_message(
message.channel, "*User:* **{}**\n\n*Friends:* {}".format(
username, ", ".join(friends)))
elif startswith(prefix + "steam games"):
uid = str(message.content)[len(prefix + "steam games "):]
# Game search
await client.send_typing(message.channel)
username, games = self.steam.get_owned_games(uid)
if not username:
await client.send_message(message.channel,
"User **does not exist**.")
# stat.pluswrongarg()
return
games = ["`{}`".format(game) for game in games]
try:
await client.send_message(
message.channel,
"*User:* **{}**:\n\n*Owned games:* {}".format(
username, ", ".join(games)))
except HTTPException:
await client.send_message(
message.channel,
"This message can not fit onto Discord: **user has too many games to display (lol)**"
)
elif startswith(prefix + "steam user "):
uid = str(message.content)[len(prefix + "steam user "):]
# Basic search
await client.send_typing(message.channel)
steam_user = self.steam.get_user(uid)
if not steam_user:
await client.send_message(message.channel,
"User **does not exist**.")
# stat.pluswrongarg()
return
info = "User: **{}**\n```css\nStatus: {}\nLevel: {}\nGames: {} owned (including free games)\nFriends: {}```\n" \
"Direct link: http://steamcommunity.com/id/{}/".format(steam_user.name, "Online" if steam_user.state else "Offline",
steam_user.level, len(steam_user.games), len(steam_user.friends), uid)
try:
await client.send_message(message.channel, info)
except HTTPException:
await client.send_message(
message.channel,
"This message can not fit onto Discord: **user has too many friends to display (lol)**"
)
elif startswith(prefix + "steam") or startswith(prefix +
"steam help"):
await client.send_message(
message.channel,
"**Steam commands:**\n`_steam user community_url`, `_steam friends community_url`, `_steam games community_url`"
.replace("_", prefix))
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
prefix = kwargs.get("prefix")
client = self.client
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# Loop over simple commands
for trigger, response in simple_commands.items():
if message.content.startswith(trigger.replace("_", prefix)):
await client.send_message(message.channel, response)
self.stats.add(MESSAGE)
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
# Other commands
if startswith(prefix + "kappa"):
await client.send_file(message.channel,
"data/images/kappasmall.png")
self.stats.add(IMAGE_SENT)
elif startswith(prefix + "randomgif"):
# Check if giphy is enabled
if not self.giphy_enabled:
return
random_gif = self.gif.screensaver().media_url
await client.send_message(message.channel, str(random_gif))
self.stats.add(IMAGE_SENT)
elif startswith(prefix + "meme", prefix + "caption"):
# Check if imgflip is enabled
if not self.imgflip_enabled:
return
if startswith(prefix + "meme"):
query = message.content[len(prefix + "meme "):]
elif startswith(prefix + "caption"):
query = message.content[len(prefix + "caption "):]
else:
# u wot pycharm
return
middle = [str(a).strip(" ") for a in str(query).split("|")]
if len(middle) != 3:
await client.send_message(
message.channel,
"Incorrect usage. See _help caption/_help meme for info".
replace("_", prefix))
return
name = middle[0]
top = middle[1]
bottom = middle[2]
meme = await self.generator.caption_meme(name, top, bottom)
if not meme:
await client.send_message(message.channel,
"Meme is non-existent. rip")
else:
await client.send_message(message.channel, meme)
elif startswith(prefix + "rip"):
if len(message.mentions) == 1:
ripperoni = message.mentions[0].mention
elif len(message.mentions) == 0:
ripperoni = message.content[len(prefix + "rip "):]
else:
ripperoni = ""
ripperoni = self.nano.get_plugin("commons").get(
"instance").at_everyone_filter(ripperoni, message.author,
message.server)
prays = self.stats.get_amount(PRAYER)
await client.send_message(
message.channel,
"Rest in pepperoni{}{}.\n`{}` *prayers said so far*...".format(
", " if ripperoni else "", ripperoni, prays))
self.stats.add(PRAYER)
async def on_message(self, message, **kwargs):
prefix = kwargs.get("prefix")
client = self.client
handler = self.handler
assert isinstance(message, Message)
assert isinstance(handler, ServerHandler)
assert isinstance(client, Client)
# Check if this is a valid command
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if not handler.can_use_restricted_commands(message.author,
message.channel.server):
await client.send_message(
message.channel, WARNING +
" You do not have the correct permissions to use this command (must be a server admin)."
)
return
# !welcomemsg
if startswith(prefix + "welcomemsg"):
change = message.content[len(prefix + "welcomemsg "):]
handler.update_var(message.channel.server.id, "welcomemsg", change)
await client.send_message(
message.channel, "Welcome message has been updated :smile:")
# !banmsg
elif startswith(prefix + "banmsg"):
change = message.content[len(prefix + "banmsg "):]
handler.update_var(message.channel.server.id, "banmsg", change)
await client.send_message(message.channel,
"Ban message has been updated :smile:")
# !kickmsg
elif startswith(prefix + "kickmsg"):
change = message.content[len(prefix + "kickmsg "):]
handler.update_var(message.channel.server.id, "kickmsg", change)
await client.send_message(message.channel,
"Kick message has been updated :smile:")
# !leavemsg
elif startswith(prefix + "leavemsg"):
change = message.content[len(prefix + "leavemsg "):]
handler.update_var(message.channel.server.id, "leavemsg", change)
await client.send_message(
message.channel, "Leave message has been updated :smile:")
# !nuke
elif startswith(prefix + "nuke"):
amount = str(message.content)[len(prefix + "nuke "):]
try:
amount = int(amount) + 1 # Includes the sender's message
except ValueError:
await client.send_message(message.channel, "Must be a number.")
return
await client.delete_message(message)
await client.send_message(
message.channel,
"Purging last {} messages... :boom:".format(amount - 1))
await client.purge_from(message.channel, limit=amount)
# Show success
m = await client.send_message(
message.channel,
"Purged {} messages {}".format(CHECK_MARK, amount - 1))
# Wait 1.5 sec and delete the message
await asyncio.sleep(1.5)
await client.delete_message(m)
# !kick
elif startswith(prefix + "kick"):
if len(message.mentions) >= 1:
user = message.mentions[0]
else:
user_name = str(str(message.content)[len(prefix + "kick "):])
user = utils.find(lambda u: u.name == str(user_name),
message.channel.server.members)
if not user:
return
await client.kick(user)
await client.send_message(
message.channel,
handler.get_var(message.channel.server.id,
"kickmsg").replace(":user", user.name))
# !ban
elif startswith(prefix + "ban"):
if len(message.mentions) >= 1:
user = message.mentions[0]
else:
user_name = str(str(message.content)[len(prefix + "ban "):])
user = utils.find(lambda u: u.name == str(user_name),
message.channel.server.members)
if not user:
return
await client.send_message(
message.channel, "Are you sure you want to ban " + user.name +
"? Confirm by replying 'CONFIRM'.")
followup = await client.wait_for_message(author=message.author,
channel=message.channel,
timeout=15,
content="CONFIRM")
if followup is None:
await client.send_message(
message.channel,
"Confirmation not received, NOT banning :upside_down:")
else:
await client.ban(user, delete_message_days=0)
await client.send_message(
message.channel,
handler.get_var(message.channel.server.id,
"banmsg").replace(":user", user.name))
# !unban
# but wait, you cant really mention the person so this is practically useless lmao
#elif startswith(prefix + "unban"):
# if len(message.mentions) >= 1:
# user = message.mentions[0]
#
# else:
# user_name = str(str(message.content)[len(prefix + "kick "):])
#
# user = utils.find(lambda u: u.name == str(user_name), message.channel.server.members)
#
# if not user:
# return
#
# await client.unban(user)
# await client.send_message(message.channel, "{} has been unbanned.".format(user.name))
# !softban
elif startswith(prefix + "softban"):
if len(message.mentions) == 0:
await client.send_message(
message.channel,
"Please mention the member you want to softban.")
return
user = message.mentions[0]
tim = message.content[len(prefix + "softban "):].replace(
"<@{}>".format(user.id), "").strip()
await client.ban(user)
self.timer.set_softban(message.channel.server, user, tim)
await client.send_message(
message.channel, "{} has been softbanned.".format(user.name))
# !mute list
elif startswith(prefix + "mute list"):
mutes = handler.mute_list(message.server)
if mutes:
final = "Muted members: \n" + ", ".join(
["`{}`".format(u) for u in mutes])
else:
final = "No members are muted."
await client.send_message(message.channel, final)
# !mute
elif startswith(prefix + "mute"):
if len(message.mentions) == 0:
await client.send_message(
message.channel,
"Please mention the member you want to mute.")
return
user = message.mentions[0]
handler.mute(user)
await client.send_message(
message.channel,
"**{}** can now not speak here. :zipper_mouth:".format(
user.name))
# !unmute
elif startswith(prefix + "unmute"):
if len(message.mentions) == 0:
await client.send_message(
message.channel,
"Please mention the member you want to unmute.")
return
user = message.mentions[0]
handler.unmute(user)
await client.send_message(
message.channel,
"**{}** can now speak here again :rofl:".format(user.name))
# !user
elif startswith(prefix + "user"):
# Selects the proper user
if len(message.mentions) == 0:
name = message.content[len(prefix + "user "):]
member = utils.find(lambda u: u.name == name,
message.channel.server.members)
else:
member = message.mentions[0]
# If the member does not exist
if not member:
await client.send_message(message.channel,
"Member does not exist.")
return
# Gets info
name = member.name
mid = member.id
avatar = str(member.avatar_url)
is_bot = ":robot:" if member.bot else ""
role = member.top_role
account_created = member.created_at
status = "Online" if member.status.online or member.status.idle else "Offline"
# Filter @everyone out
if role == "@everyone":
role = "None"
# 'Compiles' info
final = "User: **{}** #{} {}\n➤ Status: {}\n➤ Id: `{}`\n➤ Avatar: {}\n\n➤ Top role_: **{}**\n" \
"➤ Created at: `{}`".format(name, member.discriminator, is_bot, status, mid,
avatar, role, account_created)
await client.send_message(message.channel, final)
# !role
elif startswith(prefix + "role"):
# This selects the proper user
if len(message.mentions) == 0:
await client.send_message(message.channel,
"Please mention someone.")
return
elif len(message.mentions) >= 2:
await client.send_message(
message.channel,
"Please mention only one person at a time.")
return
else:
user = message.mentions[0]
# Checks if the user is permitted to change this role (can only change roles lower in the hierarchy)
def is_lower(user_role, selected_role):
return user_role.position >= selected_role.position
# Combines both
def can_change_role(member_a, selected_role):
return is_lower(member_a.top_role, selected_role)
# Branching
if startswith(prefix + "role " + "add "):
a_role = str(
message.content[len(prefix +
"role add "):]).split("<")[0].strip()
role = utils.find(lambda r: r.name == a_role,
message.channel.server.roles)
if not can_change_role(message.author, role):
await client.send_message(message.channel, error_hierarchy)
return
await client.add_roles(user, role)
await client.send_message(message.channel,
"Done " + CHECK_MARK)
elif startswith(prefix + "role " + "remove "):
a_role = str(message.content[len(prefix +
"role remove "):]).split(
"<")[0].strip()
role = utils.find(lambda r: r.name == a_role,
message.channel.server.roles)
if not can_change_role(message.author, role):
await client.send_message(message.channel, error_hierarchy)
return
await client.remove_roles(user, role)
await client.send_message(message.channel,
"Done " + CHECK_MARK)
elif startswith(prefix + "role " + "replaceall "):
a_role = str(message.content[len(prefix +
"role replaceall "):]).split(
"<")[0].strip()
role = utils.find(lambda r: r.name == a_role,
message.channel.server.roles)
if not can_change_role(message.author, role):
await client.send_message(message.channel, error_hierarchy)
return
await client.replace_roles(user, role)
await client.send_message(message.channel,
"Done " + CHECK_MARK)
# !cmd add
elif startswith(prefix + "cmd add"):
try:
cut = str(message.content)[len(prefix +
"cmd add "):].split("|")
if len(cut) != 2:
await client.send_message(
message.channel,
"Incorrect parameters.\n`_cmd add trigger|response`".
replace("_", prefix))
return
handler.update_command(message.server, cut[0], cut[1])
await client.send_message(message.channel,
"Command '{}' added.".format(cut[0]))
except (KeyError or IndexError):
await client.send_message(
message.channel,
":no_entry_sign: Wrong args, separate command and response with |"
)
# !cmd remove
elif startswith(prefix + "cmd remove"):
cut = str(message.content)[len(prefix + "cmd remove "):]
handler.remove_command(message.server, cut)
await client.send_message(message.channel, "Ok " + CHECK_MARK)
# !cmd list
elif startswith(prefix + "cmd list"):
custom_cmds = handler.get_custom_commands(message.server)
if not custom_cmds:
await client.send_message(
message.channel, "No custom commands on this server. "
"Add one with `_cmd add trigger|response`!".replace(
"_", prefix))
return
final = "\n".join([
"{} : {}".format(name, content)
for name, content in custom_cmds.items()
])
await client.send_message(
message.channel, "*Custom commands:*\n```" + final + "```")
# nano.settings
elif startswith("nano.settings"):
try:
cut = str(message.content)[len("nano.settings "):].rsplit(
" ", 1)
except IndexError:
return
try:
value = handler.update_moderation_settings(
message.channel.server, cut[0], get_decision(cut[1]))
except IndexError:
# stat.pluswrongarg()
return
if get_decision(cut[0],
("word filter", "filter words", "wordfilter")):
await client.send_message(
message.channel, "Word filter {}".format(
CHECK_MARK if value else CROSS_MARK))
elif get_decision(cut[0],
("spam filter", "spamfilter", "filter spam")):
await client.send_message(
message.channel, "Spam filter {}".format(
CHECK_MARK if value else CROSS_MARK))
elif get_decision(
cut[0], ("filterinvite", "filterinvites", "invite removal",
"invite filter", "invitefilter")):
await client.send_message(
message.channel, "Invite filter {}".format(
CHECK_MARK if value else CROSS_MARK))
# nano.displaysettings
elif startswith("nano.displaysettings"):
settings = handler.get_server_data(message.server.id)
blacklisted_c = ",".join(settings.get("blacklisted"))
if not blacklisted_c:
blacklisted_c = "None"
spam_filter = "On" if settings.get("filterspam") else "Off"
word_filter = "On" if settings.get("filterwords") else "Off"
invite_filter = "On" if settings.get("filterinvite") else "Off"
log_channel = settings.get("logchannel") if settings.get(
"logchannel") else "None"
msg_join = settings.get("welcomemsg")
msg_leave = settings.get("leavemsg")
msg_ban = settings.get("banmsg")
msg_kick = settings.get("kickmsg")
final = """**Settings for current server:**```css
Blacklisted channels: {}
Spam filter: {}
Word filter: {}
Invite removal: {}
Log channel: {}
Prefix: {}```
Messages:
➤ Join: `{}`
➤ Leave: `{}`
➤ Ban: `{}`
➤ Kick: `{}`""".format(blacklisted_c, spam_filter,
word_filter, invite_filter, log_channel,
settings.get("prefix"), msg_join, msg_leave, msg_ban,
msg_kick)
await client.send_message(message.channel, final)
# nano.admins add
elif startswith("nano.admins add"):
if len(message.mentions) == 0:
await client.send_message(
message.channel,
"Please mention the person you want to add.")
return
elif len(message.mentions) == 1:
member = message.mentions[0]
else:
await client.send_message(message.channel, "One at a time :)")
return
handler.add_admin(message.server, member)
await client.send_message(
message.channel, "Added **{}** to admins.".format(member.name))
# nano.admins remove
elif startswith("nano.admins remove"):
if len(message.mentions) == 0:
await client.send_message(
message.channel,
"Please mention the person you want to add.")
return
elif len(message.mentions) == 1:
member = message.mentions[0]
else:
await client.send_message(message.channel, "One at a time :)")
return
handler.remove_admin(message.server, member)
await client.send_message(
message.channel,
"Removed **{}** from admins".format(member.name))
# nano.admins list
elif startswith("nano.admins list"):
admins = handler.get_admins(message.server)
if len(admins) == 0:
await client.send_message(
message.channel,
"There are no Nano admins on this server.")
else:
final = ""
for usr in admins:
user = utils.find(lambda u: u.id == usr,
message.channel.server.members)
final += "{}, ".format(user.name)
# Remove last comma and space
final = final.strip(", ")
if len(admins) == 1:
await client.send_message(
message.channel,
"**" + final + "** is the only admin here.")
else:
await client.send_message(message.channel,
"**Admins:** " + final)
# nano.reset
elif startswith("nano.serverreset"):
await client.send_message(
message.channel, WARNING +
" Are you sure you want to reset all Nano-related sever settings to default? Confirm by replying 'CONFIRM'."
)
followup = await client.wait_for_message(author=message.author,
channel=message.channel,
timeout=15,
content="CONFIRM")
if followup is None:
await client.send_message(
message.channel,
"Confirmation not received, NOT resetting :upside_down:")
handler.server_setup(message.server)
await client.send_message(message.channel,
"Reset. :white_check_mark: ")
# !setup, nano.setup
elif startswith(prefix + "setup", "nano.setup"):
auth = message.author
async def timeout(msg):
await client.send_message(
msg.channel,
"You ran out of time :upside_down: (FYI: the timeout is 35 seconds)"
)
msg_intro = "**SERVER SETUP**\nYou have started the server setup. It consists of a few steps, " \
"where you will be prompted to answer.\n**Let's get started, shall we?**"
await client.send_message(message.channel, msg_intro)
await asyncio.sleep(2)
# FIRST MESSAGE
msg_one = "Do you want to reset all bot-related settings for this server?\n" \
"(this includes spam and swearing protection, admin list, blacklisted channels, \n" \
"log channel, prefix, welcome, ban and kick message). **yes / no**"
await client.send_message(message.channel, msg_one)
# First check
def check_yes1(msg):
# yes or no
if str(msg.content).lower().strip(" ") == "yes":
handler.server_setup(message.channel.server)
return True
ch1 = await client.wait_for_message(timeout=35,
author=auth,
check=check_yes1)
if ch1 is None:
timeout(message)
return
# SECOND MESSAGE
msg_two = "What prefix would you like to use for all commands?\n" \
"Type that prefix.\n(prefix example: **!** 'translates to' `!help`, `!ping`, ...)"
await client.send_message(message.channel, msg_two)
# Second check, does not need yes/no filter
ch2 = await client.wait_for_message(timeout=35, author=auth)
if ch2 is None:
timeout(message)
return
if ch2.content:
handler.change_prefix(message.channel.server,
str(ch2.content).strip(" "))
# THIRD MESSAGE
msg_three = "What would you like me to say when a person joins your server?\n" \
"Reply with that message or with None if you want to disable welcome messages. \n" \
"(:user translates to a mention of the joined user; for example -> :user, welcome to this server!)"
await client.send_message(message.channel, msg_three)
ch3 = await client.wait_for_message(timeout=35, author=auth)
if ch3 is None:
timeout(message)
return
if ch3.content.strip(" ").lower() == "none":
handler.update_var(message.server.id, "welcomemsg", None)
else:
handler.update_var(message.server.id, "welcomemsg",
str(ch3.content))
# FOURTH MESSAGE
msg_four = """Would you like me to filter spam? **yes / no**"""
await client.send_message(message.channel, msg_four)
# Fourth check
def check_yes3(msg):
# yes or no
if str(msg.content).lower().strip(" ") == "yes":
handler.update_moderation_settings(message.channel.server,
"filterspam", True)
else:
handler.update_moderation_settings(message.channel.server,
"filterspam", False)
return True
ch3 = await client.wait_for_message(timeout=35,
author=auth,
check=check_yes3)
if ch3 is None:
timeout(message)
return
# FIFTH MESSAGE
msg_five = """Would you like me to filter swearing? **yes / no**"""
await client.send_message(message.channel, msg_five)
# Fifth check check
def check_yes4(msg):
# yes or no
if str(msg.content).lower().strip(" ") == "yes":
handler.update_moderation_settings(message.channel.server,
"filterwords", True)
else:
handler.update_moderation_settings(message.channel.server,
"filterwords", False)
return True
ch4 = await client.wait_for_message(timeout=35,
author=auth,
check=check_yes4)
if ch4 is None:
timeout(message)
return
msg_final = """**This concludes the basic server setup.**
But there are a few more settings to set up if you need'em:
➤ channel blacklisting - `nano.blacklist add/remove channel_name`
➤ kick message - `_kickmsg message`
➤ ban message - `_banmsg message`
The prefix can simply be changed again with `nano.changeprefix prefix`.
Admin commands can only be used by people with a role named "Nano Admin". If you do not want to assign roles, use `nano.admins add @mention`.
You and all admins can also add/remove/list custom commands with `_cmd add/remove/list command|response`.
For a list of all commands, use `_cmds`.""".replace("_", str(ch2.content))
await client.send_message(message.channel, msg_final)
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "imdb"):
# The process can take some time so we show that something is happening
await client.send_typing(message.channel)
if startswith(prefix + "imdb plot") or startswith(prefix + "imdb story"):
if startswith(prefix + "imdb plot"):
search = str(message.content[len(prefix + "imdb plot "):])
else:
search = str(message.content[len(prefix + "imdb story "):])
data = self.imdb.get_page_by_name(search)
if not data:
await client.send_message(message.channel, "No results.")
return
if data.type == PERSON:
return
else:
await client.send_message(message.channel,
"**{}**'s story\n```{}```".format(data.name, data.storyline))
elif startswith(prefix + "imdb search"):
search = str(message.content[len(prefix + "imdb search "):])
data = self.imdb.get_page_by_name(search)
if not data:
await client.send_message(message.channel, "No results.")
return
if data.type == MOVIE:
st = """**{}** ({})\n\nLength: `{}`\nGenres: {}\nRating: **{}/10**\n\nDirector: *{}*\nSummary:
```{}```""".format(data.name, data.year, data.length, str("`" + "`, `".join(data.genres) + "`"),
data.rating, data.director, data.summary)
elif data.type == SERIES:
st = """**{}** series\n\nGenres: {}\nRating: **{}/10**\n\nDirector: *{}*\nSummary:
```{}```""".format(data.name, str("`" + "`, `".join(data.genres) + "`"), data.rating,
data.director, data.summary)
elif data.type == PERSON:
st = """**{}**\n\nKnown for: {}\nIMDB Rank: **{}**\n\nShort bio:
```{}```""".format(data.name, str("`" + "`, `".join(data.known_for) + "`"), data.rank, data.short_bio)
else:
return
# Send the details
await client.send_message(message.channel, st)
elif startswith(prefix + "imdb trailer"):
search = str(message.content[len(prefix + "imdb trailer "):])
data = self.imdb.get_page_by_name(search)
if not data:
await client.send_message(message.channel, "No results.")
return
if data.type == PERSON:
return
await client.send_message(message.channel,
"**{}**'s trailer on IMDB: {}".format(data.name, data.trailer))
elif startswith(prefix + "imdb rating"):
search = str(message.content[len(prefix + "imdb rating "):])
data = self.imdb.get_page_by_name(search)
if not data:
await client.send_message(message.channel, "No results.")
return
if not data.type == MOVIE:
await client.send_message(message.channel, "Only movies have Metascores.")
return
await client.send_message(message.channel,
"**{}**'s ratings on IMDB\nUser ratings: __{} out of 10__\n"
"Metascore: __{}__".format(data.name, data.rating, data.metascore))
else:
await client.send_message(message.channel,
"**IMDB help**\n\n`_imdb search [name or title]`, `_imdb plot [title]`, "
"`_imdb trailer [title]`, `_imdb rating [title]`".replace("_", prefix))
async def on_message(self, message, **kwargs):
prefix = kwargs.get("prefix")
client = self.client
mc = self.mc
assert isinstance(client, Client)
assert isinstance(message, Message)
if not is_valid_command(message.content, valid_commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "mc", prefix + "minecraft"):
if startswith(prefix + "mc help", prefix + "minecraft help"):
# Help message
await client.send_message(message.channel,
"**Minecraft**\n```css\n"
"_mc name/id:meta - search for items and display their details```".replace("_", prefix))
return
elif startswith(prefix + "mc "):
da = message.content[len(prefix + "mc "):]
elif startswith(prefix + "minecraft "):
da = message.content[len(prefix + "minecraft "):]
else:
return
# Determines if arg is id or name
if len(str(da).split(":")) > 1:
typ = ITEM_ID_PAIR
else:
try:
int(da)
typ = ITEM_ID
except ValueError:
typ = ITEM_NAME
# Requests item data from minecraft plugin
if typ == ITEM_ID_PAIR or typ == ITEM_ID:
data = mc.id_to_data(da)
else:
# Check for groupings
if mc.get_group_by_name(da):
data = mc.get_group_by_name(da)
else:
data = mc.name_to_data(str(da))
if not data:
await client.send_message(message.channel, "**No item with that name/id**")
self.stats.add(WRONG_ARG)
return
if not isinstance(data, list):
details = "**{}**```css\nId: {}:{}```".format(data.get("name"), data.get("type"), data.get("meta"))
# Details are uploaded simultaneously with the picture
try:
with open("plugins/mc/{}-{}.png".format(data.get("type"), data.get("meta") or 0), "rb") as pic:
await client.send_file(message.channel, pic, content=details)
self.stats.add(IMAGE_SENT)
except FileNotFoundError:
await client.send_message(message.channel, details)
self.stats.add(IMAGE_SENT)
else:
combined = []
for item in data:
details = "**{}**```css\nId: {}:{}```".format(item.get("name"), item.get("type"), item.get("meta"))
combined.append(details)
await client.send_message(message.channel, "".join(combined))
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith((prefix + "imdb"), (prefix + "tmdb")):
# The process can take some time so we show that something is happening
await client.send_typing(message.channel)
if startswith((prefix + "imdb plot"), (prefix + "tmdb plot")):
search = str(message.content[len(prefix + "imdb plot "):])
try:
data = await self.tmdb.search_multi(search)
except tmdbie.TMDbException:
await client.send_message(
message.channel, "Something went wrong... Try again?")
raise
if not data:
await client.send_message(message.channel, "No results.")
return
if data.media_type not in ["tv", "movie"]:
await client.send_message(
message.channel,
"You can't get the plot of a person " +
StandardEmoji.SMILE)
return
try:
info = "**{}**'s story\n```{}```".format(
data.title, data.overview)
await client.send_message(message.channel, info)
except AttributeError:
await client.send_message(
message.channel,
"This title seems to have a missing plot description.")
elif startswith((prefix + "imdb search"),
(prefix + "tmdb search")):
search = str(message.content[len(prefix + "imdb search "):])
try:
data = await self.tmdb.search_multi(search)
except tmdbie.TMDbException:
await client.send_message(
message.channel, "Something went wrong... Try again?")
raise
if not data:
await client.send_message(message.channel, "No results.")
return
if data.media_type in ["tv", "movie"]:
info = []
# Step-by-step adding - some data might be missing
try:
media_type = "series" if data.media_type == "tv" else ""
info.append("**{}** {}\n".format(
data.title, media_type))
except AttributeError:
pass
try:
genres = "`{}`".format("`, `".join(data.genres))
info.append("Genres: {}".format(genres))
except AttributeError:
pass
try:
info.append("Average rating: **{}/10**".format(
data.vote_average))
except AttributeError:
pass
if data.media_type == "tv":
try:
info.append("Seasons: **{}**".format(
len(data.seasons)))
except AttributeError:
pass
try:
info.append("\nSummary:\n```{}```\n".format(
data.overview))
except AttributeError:
pass
try:
if data.poster:
info.append("Poster: {}".format(data.poster))
except AttributeError:
pass
# Compile together info that is available
media_info = "\n".join(info)
else:
await client.send_message(
"Person search is not yet supported.")
return
# Send the details
try:
await client.send_message(message.channel, media_info)
except errors.HTTPException:
await client.send_message(
message.channel,
"Something went wrong, please report it to the dev, preferably with a screenshot. Thanks!"
)
elif startswith((prefix + "imdb trailer"),
(prefix + "tmdb trailer")):
search = str(message.content[len(prefix + "imdb trailer "):])
try:
data = await self.tmdb.search_multi(search)
except tmdbie.TMDbException:
await client.send_message(
message.channel, "Something went wrong... Try again?")
raise
if not data:
await client.send_message(message.channel, "No results.")
return
try:
await client.send_message(
message.channel,
"**{}**'s trailers on IMDB:\n\n{}".format(
data.title, data.trailer))
except AttributeError:
await client.send_message(
message.channel,
"This title appears to have no trailer on IMDb. ")
elif startswith((prefix + "imdb rating"),
(prefix + "tmdb rating")):
search = str(message.content[len(prefix + "imdb rating "):])
try:
data = await self.tmdb.search_multi(search)
except tmdbie.TMDbException:
await client.send_message(
message.channel, "Something went wrong... Try again?")
raise
if not data:
await client.send_message(message.channel, "No results.")
return
try:
content = "**{}**'s ratings\n\nUser ratings on TMDb: __**{}** out of 10__".format(
data.title, data.vote_average)
await client.send_message(message.channel, content)
except AttributeError:
await client.send_message(
message.channel,
"It appears that this title does not have any ratings. Weird."
)
else:
await client.send_message(
message.channel,
"**TMDb/IMDb help**\n\n`_imdb search [name or title]`, `_imdb plot [title]`, "
"`_imdb trailer [title]`, `_imdb rating [title]`".replace(
"_", prefix))
async def on_message(self, message, **kwargs):
client = self.client
prefix = kwargs.get("prefix")
assert isinstance(message, Message)
assert isinstance(client, Client)
if not is_valid_command(message.content, valid_commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# !remind me in [time]:[reminder]
if startswith(prefix + "remind me in"):
args = str(message.content)[len(prefix + "remind me in "):].strip().split(":")
if not args[0].isnumeric():
ttr = convert_to_seconds(args[0])
else:
ttr = int(args[0])
resp = self.reminder.set_reminder(message.author, message.author, args[1], ttr)
if resp == -1:
await client.send_message(message.channel,
"You have exceeded the maximum amount of reminders (**1** at once).")
elif resp is False:
await client.send_message(message.channel, "Not a valid time range (5 seconds to 2 days")
else:
await client.send_message(message.channel, "Reminder set :)")
# !remind here in [time]:[reminder]
elif startswith(prefix + "remind here in"):
args = str(message.content)[len(prefix + "remind here in "):].strip().split(":")
if not args[0].isnumeric():
ttr = convert_to_seconds(args[0])
else:
ttr = int(args[0])
resp = self.reminder.set_reminder(message.channel, message.author, args[1].strip(), ttr)
if resp == -1:
await client.send_message(message.channel,
"You have exceeded the maximum amount of reminders (**1** at once).")
elif resp is False:
await client.send_message(message.channel, "Not a valid time range (5 seconds to 2 days")
else:
await client.send_message(message.channel, "Reminder set :)")
# !remind list
elif startswith(prefix + "remind list", prefix + "reminder list"):
reminders = self.reminder.get_reminders(message.author)
if not reminders:
await client.send_message(message.channel, "You have not set any reminders.")
return
rem = []
for reminder in reminders:
# Gets the remaining time
ttl = reminder.get("time_target") - time.time()
cont = self.nano.get_plugin("commons").get("instance").at_everyone_filter(reminder.get("raw"), message.author, message.server)
rem.append("➤ {} (in **{}**)".format(cont, resolve_time(ttl)))
await client.send_message(message.channel, "Your reminders:\n" + "\n".join(rem))
# !remind remove
elif startswith(prefix + "remind remove"):
r_name = message.content[len(prefix + "remind remove"):].strip()
if r_name == "all":
self.reminder.remove_all_reminders(message.author)
else:
r_resp = self.reminder.remove_reminder(message.author, r_name)
if not r_resp:
await client.send_message(message.channel, "No reminder with such content.")
else:
await client.send_message(message.channel, "Reminder removed.")
# !remind help
elif startswith(prefix + "remind", prefix + "remind help"):
await client.send_message(message.channel, remind_help.replace("_", prefix))
async def on_message(self, message, **kwargs):
if not is_valid_command(
message.content, valid_commands, prefix=kwargs.get("prefix")):
return
else:
self.stats.add(MESSAGE)
assert isinstance(message, Message)
client = self.client
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# Global owner filter
assert isinstance(self.handler, ServerHandler)
if not self.handler.is_bot_owner(message.author.id):
await client.send_message(
message.channel,
"You are not permitted to use this feature. (must be bot owner)"
)
return
# nano.dev.get_servers
if startswith("nano.dev.get_servers"):
# /fixme message is still too long
servers = [
"{} ({} u) - `{}`".format(srv.name, srv.member_count, srv.id)
for srv in client.servers
]
final = [
"\n".join(a) for a in
[servers[i:i + 1500] for i in range(0, len(servers), 1500)]
]
for chunk in final:
await client.send_message(message.channel, chunk)
# nano.dev.server_info [id]
elif startswith("nano.dev.server_info"):
id = message.content[len("nano.dev.server_info "):]
srv = utils.find(lambda s: s.id == id, client.servers)
if not srv:
await client.send_message(message.channel, "Error. :x:")
return
nano_data = self.handler.get_server_data(srv.id)
to_send = "{}\n```css\nMember count: {}\nChannels: {}\nOwner: {}```\n" \
"*Settings*: ```{}```".format(srv.name, srv.member_count, ",".join([ch.name for ch in srv.channels]), srv.owner.name, nano_data)
await client.send_message(message.channel, to_send)
# nano.dev.test_error
elif startswith("nano.dev.test_error"):
int("abcdef")
# nano.dev.backup
elif startswith("nano.dev.backup"):
self.backup.manual_backup()
await client.send_message(message.channel,
"Backup completed :ok_hand:")
# nano.reload
elif startswith("nano.reload"):
self.handler.reload()
await client.send_message(message.channel,
"Refreshed :muscle: :smile:")
# nano.restart
elif startswith("nano.restart"):
m = await client.send_message(message.channel, "Restarting...")
await client.send_message(message.channel, "**DED**")
await client.delete_message(m)
await client.logout()
self.mode = "restart"
return "shutdown"
# nano.kill
elif startswith("nano.kill"):
await client.send_message(message.channel, "**DED**")
await client.logout()
self.mode = "exit"
return "shutdown"
# nano.playing
elif startswith("nano.playing"):
status = message.content[len("nano.playing "):]
await client.change_presence(game=Game(name=str(status)))
await client.send_message(message.channel, "Status changed :+1:")