def back(m, message):
global back_messages
args = m.group(1).strip().split()
if len(args) < 2:
return f"<{message.nick}> Usage: @back <lang> <message> [n]"
nick = args[0]
dst = args[1]
if dst not in LANGS:
return f"<{message.nick}> {dst} is not a valid language code!"
n = 1
if len(args) > 2:
if args[2].isdigit():
n = int(args[2])
else:
return f"<{message.nick}> The third argument must be a number"
if n > MAX_BACK_TRANSLATIONS:
return f"<{message.nick}> You should use a number less than {MAX_BACK_TRANSLATIONS}"
if message.channel not in back_messages:
return f"<{message.nick}> No messages found for this channel"
if nick not in back_messages[message.channel]:
return f"<{message.nick}> No messages found for {nick} on this channel"
cached = back_messages[message.channel][nick]
if len(cached) < n:
return f"<{message.nick}> There are only {len(cached)} messages for {nick} on this channel"
text = cached[-n]
translated_msg = trans(text, dst, "auto") or text
return Message(
message=f" <{message.sender_nick} ({dst.upper()})> {translated_msg}",
channel=message.channel,
)
def translate(m, message, dst, src="auto", autodetect=True):
translated_msg = trans(m, dst, src, autodetect)
if translated_msg:
return Message(
message=f" <{message.sender_nick} ({dst.upper()})> {translated_msg}",
channel=message.channel,
)
def reset_babel(m, message):
global babel_prefs
babel_prefs[message.nick] = {}
return Message(
message=f"<{message.nick}> Reset babel preferences",
channel=message.nick,
is_private=True,
)
def babel_warning(m, message, babel_nick, dst, src="en"):
translated_msg = trans(m, dst, src)
if translated_msg:
return Message(
message=f"<{babel_nick}> {translated_msg}",
channel=babel_nick,
is_private=True,
)
async def on_dcc_send(bot: IrcBot, **m):
nick = m["nick"]
if not await is_identified(bot, nick):
await bot.dcc_reject(DccServer.SEND, nick, m["filename"])
await bot.send_message(
"You cannot use this bot before you register your nick", nick
)
return
notify_each_b = progress_curve(m["size"])
config = Config.get(nick)
async def progress_handler(p, message):
if not config.display_progress:
return
percentile = int(p * 100)
if percentile % notify_each_b == 0:
await bot.send_message(message % percentile, m["nick"])
folder = Folder(nick)
if folder.size() + int(m["size"]) > int(Config.get(nick).quota) * 1048576:
await bot.send_message(
Message(
m["nick"],
message="Your quota has exceeded! Type 'info' to check, 'list' to see your files and 'delete [filename]' to free some space",
is_private=True,
)
)
return
path = folder.download_path(m["filename"])
await bot.dcc_get(
str(path),
m,
progress_callback=lambda _, p: progress_handler(
p, f"UPLOAD {Path(m['filename']).name} %s%%"
),
)
await bot.send_message(
Message(
m["nick"], message=f"{m['filename']} has been received!", is_private=True
)
)
def include(m, message):
nick = message.sender_nick
for user in users.data:
if nick == user[table_columns[0]]:
return MSGS.already_registered_error
temp_users.push(
message, {
table_columns[0]: message.sender_nick,
table_columns[-1]: str(datetime.datetime.now())[:-7]
})
if USE_NICK:
return ReplyIntent(
Message(channel=message.sender_nick,
sender_nick=message.sender_nick,
message=MSGS.include_age), getAge)
else:
return ReplyIntent(
Message(channel=message.sender_nick,
sender_nick=message.sender_nick,
message=MSGS.include_name), getName)
def babel_message(m, message, babel_nick, dst, src="auto"):
if type(m) != str:
m = m.group(1)
translated_msg = trans(m, dst, src)
if not translated_msg:
translated_msg = m
return Message(
message=f" \x02({colorize(message.channel)}) <{colorize(message.nick)}>\x02 {translated_msg}",
channel=babel_nick,
is_private=True,
)
async def send(bot: IrcBot, args, message): # If a handler is async, its first argument will be the bot itself
args = utils.m2list(args)
if len(args) < 3:
return "Check help send"
if not args[1].isdigit():
return "Delay argument should be integer and in seconds"
utils.log("waiting")
await bot.sleep(int(args[1])) #Wait for the delay
# Sends the message. The channel can be also a username for private messages
utils.log("sending")
await bot.send_message(Message(channel=args[0], message=" ".join(args[2:])))
def show(m, message):
search_nick = m.group(1)
return_value = ""
if search_nick == "me":
search_nick = message.sender_nick
for user in users.data:
if search_nick == user[table_columns[0]]:
return_value = ", ".join(
[f"{u}: {user[u]}" for u in user if not "id" in u])
break
return_value = MSGS.nick_not_registerd_error if not return_value else return_value
return Message(channel=message.sender_nick,
sender_nick=message.sender_nick,
message=return_value) if PRIVATEONLY_SHOW else return_value
def onEnter(nick, channel):
if nick == NICK: # Ignore myself ;)
return
if botState.has_any_game(nick, channel):
games = botState.get_games(nick, channel)
msg = []
for game in games:
if game.nicks[game.player] == nick:
msg.append(
f"<{nick}> you have a game with {game.nicks[not game.player]} and it is your turn"
)
botState.select_game(nick, game.other(nick), channel)
else:
msg.append(
f"<{nick}> you have a game with {game.nicks[game.player]}")
game = botState.get_selected_game(nick, channel)
msg.append(f"Game with {game.other(nick)}")
msg += game.utf8_board(nick)
return Message(channel, message=msg)
def babel(m, message):
global babel_users, babel_prefs
dst = m.group(1).strip()
nick = message.sender_nick
channel = message.channel
if channel not in babel_users:
babel_users[channel] = {}
if dst == "off":
if nick in babel_users[channel]:
del babel_users[channel][nick]
del babel_prefs[nick]
return f"<{message.nick}> Babel mode disabled"
else:
return f"<{message.nick}> You do not have babel mode enabled"
if dst not in LANGS:
return f"<{message.nick}> {dst} is not a valid language code!"
babel_users[channel][nick] = {"channel": channel, "dst": dst, "counter": 0}
babel_prefs[nick] = {}
return Message(
message=f"<{message.nick}> Babel mode enabled. You will now receive translations in {dst} as private messages for this channel: {channel}",
channel=message.nick,
is_private=True,
)
def find(m, message):
log(str(users.data))
query = m.group(1)
args = m.group(1).split(" ")
msg = "Searching for: "
age_min = None
age_max = None
sex = None
orientation = None
r = re.match(r"^\D*([0-9]+)-([0-9]+).*$", query)
if r:
msg += "age in range: "
if r.group(1) and r.group(2):
age_min = r.group(1)
age_max = r.group(2)
msg += f"from {age_min} to {age_max}; "
else:
msg += "Age range in wrong format (Correct eg. 20-35); "
for sex_ in VALIDATE.sex:
if sex_ in args:
msg += "Biological sex: " + sex_ + "; "
sex = sex_
break
for orientation_ in VALIDATE.orientation:
if orientation_ in args:
msg += "Orientation: " + orientation_ + "; "
orientation = orientation_
break
words = []
for word in args:
if not "-" in word and len(word) > 1:
words.append(word)
if words:
msg += " words: " + ", ".join(words)
results = []
for user in users.data:
mask = [False, False, False, False]
i = 0
if not age_min is None and not age_max is None:
if int(age_min) <= int(user[table_columns[1]]) <= int(age_max):
mask[i] = 1
else:
mask[i] = 1
i = 1
if not sex is None:
if sex.upper() == user[table_columns[2]]:
mask[i] = 1
else:
mask[i] = 1
i = 2
if not orientation is None:
if orientation.upper() == user[table_columns[3]]:
mask[i] = 1
else:
mask[i] = 1
i = 3
if words:
for word in words:
if word in user[table_columns[0]] or word in user[
table_columns[4]] or word in user[table_columns[5]]:
mask[i] = 1
break
else:
mask[i] = 1
if mask == [1, 1, 1, 1]:
results.append(user)
if len(results) >= MAX_FIND_N_RESULTS:
break
# Sort by timestamp
# results.sort(key=lambda user: time.mktime(time.strptime(user[table_columns[6]], '%Y-%m-%d %H:%M:%S')))
results.reverse()
if PRIVATEONLY_FIND:
return [
Message(channel=message.sender_nick,
sender_nick=message.sender_nick,
message=m)
for m in [msg] + list([
", ".join([f"{u}: {user[u]}" for u in user if not "id" in u])
for user in results
] if results else ["No results"])
]
else:
return [msg] + list([
", ".join([f"{u}: {user[u]}" for u in user if not "id" in u])
for user in results
] if results else ["No results"])
def reply(msg, txt):
return Message(msg.nick, message=txt)