Awesome IRC bot
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

272 lines
9.4 KiB

"""
.. module:: Remind
:synopsis: A module to support reminders
.. moduleauthor:: Dave Pedu <dave@davepedu.com>
"""
from pyircbot.modulebase import ModuleBase, command
from datetime import datetime, timedelta
from threading import Thread
from time import sleep
import re
import pytz
from pyircbot.modules.ModInfo import info
class Remind(ModuleBase):
def __init__(self, bot, moduleName):
ModuleBase.__init__(self, bot, moduleName)
self.db = None
serviceProviders = self.bot.getmodulesbyservice("sqlite")
if not serviceProviders:
self.log.error("Remind: Could not find a valid sqlite service provider")
else:
self.log.info("Remind: Selecting sqlite service provider: %s" % serviceProviders[0])
self.db = serviceProviders[0].opendb("remind.db")
if not self.db.tableExists("reminders"):
self.log.info("Remind: Creating table: reminders")
c = self.db.query("""CREATE TABLE IF NOT EXISTS `reminders` (
`id` INTEGER PRIMARY KEY,
`sender` varchar(64),
`senderch` varchar(64),
`when` timestamp,
`message` varchar(2048)
) ;""")
c.close()
self.disabled = False
# Start monitor thread
self.t = Thread(target=self.monitor_thread)
self.t.daemon = True
self.t.start()
def monitor_thread(self):
while True:
sleep(self.config["precision"])
if self.disabled:
break
self.monitor()
def monitor(self):
remindPeople = self.db.query("SELECT * FROM `reminders` WHERE `when` < ?", (datetime.now(),))
reminders = remindPeople.fetchall()
remindPeople.close()
byrecip = {}
for reminder in reminders:
if not reminder["sender"] in byrecip:
byrecip[reminder["sender"]] = []
byrecip[reminder["sender"]].append(reminder)
reminders_bych = {}
for recip in byrecip:
reminders_pm = []
for reminder in byrecip[recip]:
if reminder["senderch"] == "":
reminders_pm.append(reminder)
else:
if not reminder["senderch"] in reminders_bych:
reminders_bych[reminder["senderch"]] = []
reminders_bych[reminder["senderch"]].append(reminder)
self.sendReminders(reminders_pm, recip, recip)
for channel in reminders_bych:
channelpms_bysender = {}
for chreminder in reminders_bych[channel]:
if not chreminder["sender"] in channelpms_bysender:
channelpms_bysender[chreminder["sender"]] = []
channelpms_bysender[chreminder["sender"]].append(chreminder)
for recip in channelpms_bysender:
self.sendReminders(channelpms_bysender[recip], channel, recip)
# Delete now that it's sent
for item in reminders:
self.db.query("DELETE FROM `reminders` WHERE `id`=?", (item["id"],)).close()
def sendReminders(self, reminders, target, nick):
" Send a set of reminders of the same recipient, to them. Collapse down into one message."
reminder_str = []
for reminder in reminders:
reminder_str.append(reminder["message"])
reminder_str = ", ".join(reminder_str)
if len(reminder_str) > 0:
self.bot.act_PRIVMSG(target, "%s: Reminder: %s" % (nick, reminder_str))
def ondisable(self):
self.disabled = True
@info("remind <time> have the bot remind you", cmds=["remind", "at"])
@command("remind", "at", allow_private=True)
def remindat(self, msg, cmd):
regex = re.compile(r'(\d+):(\d+)(?::(\d+))?([^\s\d]+)? (.*)')
match = regex.match(cmd.args_str)
replyTo = msg.args[0]
try:
hour, minute, second, tz, message = match.groups()
message = message.strip()
assert not message == ""
hour = int(hour)
minute = int(minute)
if second is not None:
second = int(second)
except:
self.bot.act_PRIVMSG(replyTo, "%s: .at - Remind at a time. Example: .at 20:45EST Do your homework!" %
msg.prefix.nick)
return
now = datetime.now()
remindAt = datetime.now()
# if there was timezone, make sure the time we're reminding them at is relative to their timezone
if tz is not None:
try:
theirzone = pytz.timezone(Remind.translateZoneStr(tz))
except:
self.bot.act_PRIVMSG(replyTo, "%s: I don't recognize the timezone '%s'." % (msg.prefix.nick, tz))
return
remindAt = theirzone.localize(remindAt, is_dst=Remind.is_dst(theirzone))
# Set the hour and minute we'll remind them at today.
# If the ends up being in the past, we'll add a day alter
remindAt = remindAt.replace(hour=hour).replace(minute=minute).replace(microsecond=0)
# Set seconds
if second is None:
remindAt = remindAt.replace(second=0)
else:
remindAt = remindAt.replace(second=second)
# if there was timezone, convert remindAt to our zone
if tz is not None:
try:
theirzone = pytz.timezone(Remind.translateZoneStr(tz))
except:
self.bot.act_PRIVMSG(replyTo, "%s: I don't recognize the timezone '%s'." % (msg.prefix.nick, tz))
return
remindAt = remindAt.astimezone(pytz.timezone(self.config["mytimezone"])).replace(tzinfo=None)
# Advance it a day if the time would have been earlier today
while remindAt < now:
remindAt += timedelta(days=1)
timediff = remindAt - datetime.now()
# self.bot.act_PRIVMSG(replyTo, "Time: %s" % str(remindAt))
# self.bot.act_PRIVMSG(replyTo, "Diff: %s" % (timediff))
# Save the reminder
c = self.db.query("INSERT INTO `reminders` (`sender`, `senderch`, `when`, `message`) VALUES (?, ?, ?, ?)", (
msg.prefix.nick,
msg.args[0] if "#" in msg.args[0] else "",
remindAt,
message
))
c.close()
diffHours = int(timediff.seconds / 60 / 60)
diffMins = int((timediff.seconds - diffHours * 60 * 60) / 60)
self.bot.act_PRIVMSG(replyTo, "%s: Ok, will do. Approx %sh%sm to go." %
(msg.prefix.nick, diffHours, diffMins))
@staticmethod
def is_dst(tz):
now = pytz.utc.localize(datetime.utcnow())
return now.astimezone(tz).dst() != timedelta(0)
@staticmethod
def translateZoneStr(zonestr):
translations = {
"EDT": "US/Eastern",
"PDT": "America/Los_Angeles"
}
if zonestr in translations:
return translations[zonestr]
else:
return zonestr
@info("after <duration> <reminder> have the bot remind after", cmds=["after", "in"])
@command("after", "in", allow_private=True)
def remindin(self, msg, cmd):
replyTo = msg.args[0]
if not cmd.args:
self.bot.act_PRIVMSG(replyTo, "%s: .in - Remind after x amount of time. Example: .in 1week5d2h1m Go "
"fuck yourself" % msg.prefix.nick)
return
timepieces = re.compile(r'([0-9]+)([a-zA-Z]+)').findall(cmd.args[0])
if not timepieces:
self.bot.act_PRIVMSG(replyTo, "%s: .in - Remind after x amount of time. Example: .in 1week5d2h1m Go "
"fuck yourself" % msg.prefix.nick)
return
delaySeconds = 0
for match in timepieces:
# ('30', 'm')
if not match[1] in Remind.scaling:
self.bot.act_PRIVMSG(replyTo, "%s: Sorry, I don't understand the time unit '%s'" %
(msg.prefix.nick, match[1]))
return
delaySeconds += (Remind.scaling[match[1]] * int(match[0]))
remindAt = datetime.now() + timedelta(seconds=delaySeconds)
self.db.query("INSERT INTO `reminders` (`sender`, `senderch`, `when`, `message`) VALUES (?, ?, ?, ?)", (
msg.prefix.nick,
msg.args[0] if "#" in msg.args[0] else "",
remindAt,
cmd.args_str[len(cmd.args[0]):].strip()
)).close()
hours = int(delaySeconds / 60 / 60)
minutes = int((delaySeconds - (hours * 60 * 60)) / 60)
self.bot.act_PRIVMSG(replyTo, "%s: Ok, talk to you in approx %sh%sm" % (msg.prefix.nick, hours, minutes))
scaling = {
"years": 365.25 * 24 * 3600,
"year": 365.25 * 24 * 3600,
"yrs": 365.25 * 24 * 3600,
"y": 365.25 * 24 * 3600,
"months": 29.53059 * 24 * 3600,
"month": 29.53059 * 24 * 3600,
"mo": 29.53059 * 24 * 3600,
"weeks": 7 * 24 * 3600,
"week": 7 * 24 * 3600,
"wks": 7 * 24 * 3600,
"wk": 7 * 24 * 3600,
"w": 7 * 24 * 3600,
"days": 24 * 3600,
"day": 24 * 3600,
"d": 24 * 3600,
"hours": 3600,
"hour": 3600,
"hrs": 3600,
"hr": 3600,
"h": 3600,
"minutes": 60,
"minute": 60,
"mins": 60,
"min": 60,
"m": 60,
"seconds": 1,
"second": 1,
"secs": 1,
"sec": 1,
"s": 1,
}