213 lines
10 KiB
Python
213 lines
10 KiB
Python
"""Access to countdown items through bot commands."""
|
||
|
||
import logging
|
||
import re
|
||
import threading
|
||
import time
|
||
|
||
import irc.client
|
||
import parsedatetime as pdt
|
||
from dateutil.parser import parse
|
||
from dateutil.relativedelta import relativedelta
|
||
from django.utils import timezone
|
||
|
||
from countdown.models import CountdownItem
|
||
from ircbot.lib import Plugin, reply_destination_for_event
|
||
|
||
log = logging.getLogger('countdown.ircplugin')
|
||
|
||
|
||
class Countdown(Plugin):
|
||
"""Report on countdown items."""
|
||
|
||
new_reminder_regex = (r'remind\s+(?P<who>[^\s]+)\s+(?P<when_type>at|in|on)\s+(?P<when>.*?)\s+'
|
||
r'(and\s+every\s+(?P<recurring_period>.*?)\s+)?'
|
||
r'(until\s+(?P<recurring_until>.*?)\s+)?'
|
||
r'(to|that|about)\s+(?P<text>.*)')
|
||
|
||
def __init__(self, bot, connection, event):
|
||
"""Initialize some stuff."""
|
||
self.running_reminders = []
|
||
self.send_reminders = True
|
||
|
||
t = threading.Thread(target=self.reminder_thread)
|
||
t.daemon = True
|
||
t.start()
|
||
|
||
super(Countdown, self).__init__(bot, connection, event)
|
||
|
||
def start(self):
|
||
"""Set up handlers."""
|
||
self.running_reminders = []
|
||
self.send_reminders = True
|
||
|
||
self.connection.reactor.add_global_regex_handler(['pubmsg', 'privmsg'], r'^!countdown\s+list$',
|
||
self.handle_item_list, -20)
|
||
self.connection.reactor.add_global_regex_handler(['pubmsg', 'privmsg'], r'^!countdown\s+(\S+)$',
|
||
self.handle_item_detail, -20)
|
||
|
||
# let this interrupt markov
|
||
self.connection.add_global_handler('pubmsg', self.handle_new_reminder, -50)
|
||
self.connection.add_global_handler('privmsg', self.handle_new_reminder, -50)
|
||
|
||
super(Countdown, self).start()
|
||
|
||
def stop(self):
|
||
"""Tear down handlers."""
|
||
self.running_reminders = []
|
||
self.send_reminders = False
|
||
|
||
self.connection.reactor.remove_global_regex_handler(['pubmsg', 'privmsg'], self.handle_item_list)
|
||
self.connection.reactor.remove_global_regex_handler(['pubmsg', 'privmsg'], self.handle_item_detail)
|
||
|
||
self.connection.remove_global_handler('pubmsg', self.handle_new_reminder)
|
||
self.connection.remove_global_handler('privmsg', self.handle_new_reminder)
|
||
|
||
super(Countdown, self).stop()
|
||
|
||
def reminder_thread(self):
|
||
"""After IRC is started up, begin sending reminders."""
|
||
# TODO: figure out if we need this sleep, which exists so we don't send reminders while still connecting to IRC
|
||
time.sleep(30)
|
||
while self.send_reminders:
|
||
reminders = CountdownItem.objects.filter(is_reminder=True, sent_reminder=False, at_time__lte=timezone.now())
|
||
|
||
for reminder in reminders:
|
||
log.debug("%s @ %s", reminder.reminder_message, reminder.at_time)
|
||
if reminder.at_time <= timezone.now():
|
||
log.info("sending %s to %s", reminder.reminder_message, reminder.reminder_target)
|
||
self.bot.reply(None, reminder.reminder_message, explicit_target=reminder.reminder_target)
|
||
|
||
# if recurring and not hit until, set a new at time, otherwise stop reminding
|
||
if reminder.recurring_until is not None and timezone.now() >= reminder.recurring_until:
|
||
reminder.sent_reminder = True
|
||
elif reminder.recurring_period != '':
|
||
calendar = pdt.Calendar()
|
||
when_t = calendar.parseDT(reminder.recurring_period, reminder.at_time,
|
||
tzinfo=reminder.at_time.tzinfo)[0]
|
||
if reminder.recurring_until is None or when_t <= reminder.recurring_until:
|
||
reminder.at_time = when_t
|
||
else:
|
||
reminder.sent_reminder = True
|
||
else:
|
||
reminder.sent_reminder = True
|
||
reminder.save()
|
||
time.sleep(1)
|
||
|
||
def handle_new_reminder(self, connection, event):
|
||
"""Watch IRC for requests to remind new things, create countdown items."""
|
||
what = event.arguments[0]
|
||
my_nick = connection.get_nickname()
|
||
addressed_my_nick = r'^{0:s}[:,]\s+'.format(my_nick)
|
||
sender_nick = irc.client.NickMask(event.source).nick
|
||
sent_location = reply_destination_for_event(event)
|
||
|
||
in_privmsg = sender_nick == sent_location
|
||
|
||
if re.search(addressed_my_nick, what, re.IGNORECASE) is not None or in_privmsg:
|
||
# we were addressed, were we told to add a reminder?
|
||
trimmed_what = re.sub(addressed_my_nick, '', what)
|
||
log.debug(trimmed_what)
|
||
|
||
match = re.match(self.new_reminder_regex, trimmed_what, re.IGNORECASE)
|
||
if match:
|
||
log.debug("%s is a new reminder request", trimmed_what)
|
||
who = match.group('who')
|
||
when_type = match.group('when_type')
|
||
when = match.group('when')
|
||
recurring_period = match.group('recurring_period')
|
||
recurring_until = match.group('recurring_until')
|
||
text = match.group('text')
|
||
log.debug("%s / %s / %s", who, when, text)
|
||
|
||
item_name = '{0:s}-{1:s}'.format(sender_nick, timezone.now().strftime('%s'))
|
||
|
||
# parse when to send the notification
|
||
if when_type == 'in':
|
||
# relative time
|
||
calendar = pdt.Calendar()
|
||
when_t = calendar.parseDT(when, timezone.localtime(timezone.now()),
|
||
tzinfo=timezone.get_current_timezone())[0]
|
||
else:
|
||
# absolute time
|
||
when_t = timezone.make_aware(parse(when))
|
||
|
||
# parse the person to address, if anyone, when sending the notification
|
||
if who == 'us' or who == sent_location or in_privmsg:
|
||
message = text
|
||
elif who == 'me':
|
||
message = '{0:s}: {1:s}'.format(sender_nick, text)
|
||
else:
|
||
message = '{0:s}: {1:s}'.format(who, text)
|
||
|
||
# replace pronouns and stuff
|
||
if who == 'me':
|
||
message = re.sub(r'\bI\b', r'you', message, flags=re.IGNORECASE)
|
||
message = re.sub(r'\bme\b', r'you', message, flags=re.IGNORECASE)
|
||
message = re.sub(r'\bmy\b', r'your', message, flags=re.IGNORECASE)
|
||
message = re.sub(r'\bmyself\b', r'yourself', message, flags=re.IGNORECASE)
|
||
elif who == 'us':
|
||
message = re.sub(r'\bwe\b', r'you', message, flags=re.IGNORECASE)
|
||
message = re.sub(r'\bus\b', r'you', message, flags=re.IGNORECASE)
|
||
message = re.sub(r'\bour\b', r'your', message, flags=re.IGNORECASE)
|
||
message = re.sub(r'\bourselves\b', r'yourselves', message, flags=re.IGNORECASE)
|
||
|
||
log.debug("%s / %s / %s", item_name, when_t, message)
|
||
|
||
countdown_item = CountdownItem.objects.create(name=item_name, at_time=when_t, is_reminder=True,
|
||
reminder_message=message, reminder_target=sent_location)
|
||
if recurring_period:
|
||
countdown_item.recurring_period = recurring_period
|
||
if recurring_until:
|
||
recurring_until_t = timezone.make_aware(parse(recurring_until))
|
||
countdown_item.recurring_until = recurring_until_t
|
||
countdown_item.save()
|
||
log.info("created countdown item %s", str(countdown_item))
|
||
|
||
if in_privmsg:
|
||
self.bot.reply(event, "ok, i'll message you at {0:s} 14[{1:s}]".format(str(when_t), countdown_item.name))
|
||
else:
|
||
self.bot.reply(event, "ok, i'll message {0:s} at {1:s} 14[{2:s}]".format(sent_location, str(when_t),
|
||
countdown_item.name))
|
||
|
||
return 'NO MORE'
|
||
|
||
def handle_item_detail(self, connection, event, match):
|
||
"""Provide the details of one countdown item."""
|
||
name = match.group(1)
|
||
|
||
if name != 'list':
|
||
try:
|
||
item = CountdownItem.objects.get(name=name)
|
||
rdelta = relativedelta(item.at_time, timezone.now())
|
||
relstr = "{0:s} will occur in ".format(name)
|
||
if rdelta.years != 0:
|
||
relstr += "{0:s} year{1:s} ".format(str(rdelta.years), "s" if abs(rdelta.years) != 1 else "")
|
||
if rdelta.months != 0:
|
||
relstr += "{0:s} month{1:s}, ".format(str(rdelta.months), "s" if abs(rdelta.months) != 1 else "")
|
||
if rdelta.days != 0:
|
||
relstr += "{0:s} day{1:s}, ".format(str(rdelta.days), "s" if abs(rdelta.days) != 1 else "")
|
||
if rdelta.hours != 0:
|
||
relstr += "{0:s} hour{1:s}, ".format(str(rdelta.hours), "s" if abs(rdelta.hours) != 1 else "")
|
||
if rdelta.minutes != 0:
|
||
relstr += "{0:s} minute{1:s}, ".format(str(rdelta.minutes), "s" if abs(rdelta.minutes) != 1 else "")
|
||
if rdelta.seconds != 0:
|
||
relstr += "{0:s} second{1:s}, ".format(str(rdelta.seconds), "s" if abs(rdelta.seconds) != 1 else "")
|
||
# remove trailing comma from output
|
||
reply = relstr[0:-2]
|
||
return self.bot.reply(event, reply)
|
||
except CountdownItem.DoesNotExist:
|
||
return self.bot.reply(event, "countdown item '{0:s}' not found".format(name))
|
||
|
||
def handle_item_list(self, connection, event, match):
|
||
"""List all countdown items."""
|
||
items = CountdownItem.objects.all()
|
||
if len(items) > 0:
|
||
reply = "countdown items: {0:s}".format(", ".join([x.name for x in items]))
|
||
return self.bot.reply(event, reply)
|
||
else:
|
||
return self.bot.reply(event, "no countdown items are configured")
|
||
|
||
|
||
plugin = Countdown
|