rewrite: Initial rewrite skeleton.
Remove modules that will no longer be required. Move pending modules to pending-rewrite folders.
This commit is contained in:
@@ -1,5 +0,0 @@
|
||||
from .module import module
|
||||
|
||||
from . import commands
|
||||
from . import data
|
||||
from . import reminder
|
||||
@@ -1,264 +0,0 @@
|
||||
import re
|
||||
import asyncio
|
||||
import datetime
|
||||
import discord
|
||||
|
||||
from meta import sharding
|
||||
from utils.lib import parse_dur, parse_ranges, multiselect_regex
|
||||
|
||||
from .module import module
|
||||
from .data import reminders
|
||||
from .reminder import Reminder
|
||||
|
||||
|
||||
reminder_regex = re.compile(
|
||||
r"""
|
||||
(^)?(?P<type> (?: \b in) | (?: every))
|
||||
\s*(?P<duration> (?: day| hour| (?:\d+\s*(?:(?:d|h|m|s)[a-zA-Z]*)?(?:\s|and)*)+))
|
||||
(?:(?(1) (?:, | ; | : | \. | to)? | $))
|
||||
""",
|
||||
re.IGNORECASE | re.VERBOSE | re.DOTALL
|
||||
)
|
||||
|
||||
reminder_limit = 20
|
||||
|
||||
|
||||
@module.cmd(
|
||||
name="remindme",
|
||||
desc="Ask me to remind you about important tasks.",
|
||||
group="Productivity",
|
||||
aliases=('reminders', 'reminder'),
|
||||
flags=('remove', 'clear')
|
||||
)
|
||||
async def cmd_remindme(ctx, flags):
|
||||
"""
|
||||
Usage``:
|
||||
{prefix}remindme in <duration> to <task>
|
||||
{prefix}remindme every <duration> to <task>
|
||||
{prefix}reminders
|
||||
{prefix}reminders --clear
|
||||
{prefix}reminders --remove
|
||||
Description:
|
||||
Ask {ctx.client.user.name} to remind you about important tasks.
|
||||
Examples``:
|
||||
{prefix}remindme in 2h 20m, Revise chapter 1
|
||||
{prefix}remindme every hour, Drink water!
|
||||
{prefix}remindme Anatomy class in 8h 20m
|
||||
"""
|
||||
# TODO: (FUTURE) every day at 9:00
|
||||
|
||||
if flags['remove']:
|
||||
# Do removal stuff
|
||||
rows = reminders.fetch_rows_where(
|
||||
userid=ctx.author.id,
|
||||
_extra="ORDER BY remind_at ASC"
|
||||
)
|
||||
if not rows:
|
||||
return await ctx.reply("You have no reminders to remove!")
|
||||
|
||||
live = [Reminder(row.reminderid) for row in rows]
|
||||
|
||||
if not ctx.args:
|
||||
lines = []
|
||||
num_field = len(str(len(live) - 1))
|
||||
for i, reminder in enumerate(live):
|
||||
lines.append(
|
||||
"`[{:{}}]` | {}".format(
|
||||
i,
|
||||
num_field,
|
||||
reminder.formatted
|
||||
)
|
||||
)
|
||||
|
||||
description = '\n'.join(lines)
|
||||
description += (
|
||||
"\n\nPlease select the reminders to remove, or type `c` to cancel.\n"
|
||||
"(For example, respond with `1, 2, 3` or `1-3`.)"
|
||||
)
|
||||
embed = discord.Embed(
|
||||
description=description,
|
||||
colour=discord.Colour.orange(),
|
||||
timestamp=datetime.datetime.utcnow()
|
||||
).set_author(
|
||||
name="Reminders for {}".format(ctx.author.display_name),
|
||||
icon_url=ctx.author.avatar_url
|
||||
)
|
||||
|
||||
out_msg = await ctx.reply(embed=embed)
|
||||
|
||||
def check(msg):
|
||||
valid = msg.channel == ctx.ch and msg.author == ctx.author
|
||||
valid = valid and (re.search(multiselect_regex, msg.content) or msg.content.lower() == 'c')
|
||||
return valid
|
||||
|
||||
try:
|
||||
message = await ctx.client.wait_for('message', check=check, timeout=60)
|
||||
except asyncio.TimeoutError:
|
||||
await out_msg.delete()
|
||||
await ctx.error_reply("Session timed out. No reminders were deleted.")
|
||||
return
|
||||
|
||||
try:
|
||||
await out_msg.delete()
|
||||
await message.delete()
|
||||
except discord.HTTPException:
|
||||
pass
|
||||
|
||||
if message.content.lower() == 'c':
|
||||
return
|
||||
|
||||
to_delete = [
|
||||
live[index].reminderid
|
||||
for index in parse_ranges(message.content) if index < len(live)
|
||||
]
|
||||
else:
|
||||
to_delete = [
|
||||
live[index].reminderid
|
||||
for index in parse_ranges(ctx.args) if index < len(live)
|
||||
]
|
||||
|
||||
if not to_delete:
|
||||
return await ctx.error_reply("Nothing to delete!")
|
||||
|
||||
# Delete the selected reminders
|
||||
Reminder.delete(*to_delete)
|
||||
|
||||
# Ack
|
||||
await ctx.embed_reply(
|
||||
"{tick} Reminder{plural} deleted.".format(
|
||||
tick='✅',
|
||||
plural='s' if len(to_delete) > 1 else ''
|
||||
)
|
||||
)
|
||||
elif flags['clear']:
|
||||
# Do clear stuff
|
||||
rows = reminders.fetch_rows_where(
|
||||
userid=ctx.author.id,
|
||||
)
|
||||
if not rows:
|
||||
return await ctx.reply("You have no reminders to remove!")
|
||||
|
||||
Reminder.delete(*(row.reminderid for row in rows))
|
||||
await ctx.embed_reply(
|
||||
"{tick} Reminders cleared.".format(
|
||||
tick='✅',
|
||||
)
|
||||
)
|
||||
elif ctx.args:
|
||||
# Add a new reminder
|
||||
|
||||
content = None
|
||||
duration = None
|
||||
repeating = None
|
||||
|
||||
# First parse it
|
||||
match = re.search(reminder_regex, ctx.args)
|
||||
if match:
|
||||
repeating = match.group('type').lower() == 'every'
|
||||
|
||||
duration_str = match.group('duration').lower()
|
||||
if duration_str.isdigit():
|
||||
duration = int(duration_str)
|
||||
elif duration_str == 'day':
|
||||
duration = 24 * 60 * 60
|
||||
elif duration_str == 'hour':
|
||||
duration = 60 * 60
|
||||
else:
|
||||
duration = parse_dur(duration_str)
|
||||
|
||||
content = (ctx.args[:match.start()] + ctx.args[match.end():]).strip()
|
||||
if content.startswith('to '):
|
||||
content = content[3:].strip()
|
||||
else:
|
||||
# Legacy parsing, without requiring "in" at the front
|
||||
splits = ctx.args.split(maxsplit=1)
|
||||
if len(splits) == 2 and splits[0].isdigit():
|
||||
repeating = False
|
||||
duration = int(splits[0]) * 60
|
||||
content = splits[1].strip()
|
||||
|
||||
# Sanity checking
|
||||
if not duration or not content:
|
||||
return await ctx.error_reply(
|
||||
"Sorry, I didn't understand your reminder!\n"
|
||||
"See `{prefix}help remindme` for usage and examples.".format(prefix=ctx.best_prefix)
|
||||
)
|
||||
|
||||
# Don't allow rapid repeating reminders
|
||||
if repeating and duration < 10 * 60:
|
||||
return await ctx.error_reply(
|
||||
"You can't have a repeating reminder shorter than `10` minutes!"
|
||||
)
|
||||
|
||||
# Check the user doesn't have too many reminders already
|
||||
count = reminders.select_one_where(
|
||||
userid=ctx.author.id,
|
||||
select_columns=("COUNT(*)",)
|
||||
)[0]
|
||||
if count > reminder_limit:
|
||||
return await ctx.error_reply(
|
||||
"Sorry, you have reached your maximum of `{}` reminders!".format(reminder_limit)
|
||||
)
|
||||
|
||||
# Create reminder
|
||||
reminder = Reminder.create(
|
||||
userid=ctx.author.id,
|
||||
content=content,
|
||||
message_link=ctx.msg.jump_url,
|
||||
interval=duration if repeating else None,
|
||||
remind_at=datetime.datetime.utcnow() + datetime.timedelta(seconds=duration)
|
||||
)
|
||||
|
||||
# Schedule reminder
|
||||
if sharding.shard_number == 0:
|
||||
reminder.schedule()
|
||||
|
||||
# Ack
|
||||
embed = discord.Embed(
|
||||
title="Reminder Created!",
|
||||
colour=discord.Colour.orange(),
|
||||
description="Got it! I will remind you <t:{}:R>.".format(reminder.timestamp),
|
||||
timestamp=datetime.datetime.utcnow()
|
||||
)
|
||||
await ctx.reply(embed=embed)
|
||||
elif ctx.alias.lower() == 'remindme':
|
||||
# Show hints about adding reminders
|
||||
...
|
||||
else:
|
||||
# Show formatted list of reminders
|
||||
rows = reminders.fetch_rows_where(
|
||||
userid=ctx.author.id,
|
||||
_extra="ORDER BY remind_at ASC"
|
||||
)
|
||||
if not rows:
|
||||
return await ctx.reply("You have no reminders!")
|
||||
|
||||
live = [Reminder(row.reminderid) for row in rows]
|
||||
|
||||
lines = []
|
||||
num_field = len(str(len(live) - 1))
|
||||
for i, reminder in enumerate(live):
|
||||
lines.append(
|
||||
"`[{:{}}]` | {}".format(
|
||||
i,
|
||||
num_field,
|
||||
reminder.formatted
|
||||
)
|
||||
)
|
||||
|
||||
description = '\n'.join(lines)
|
||||
embed = discord.Embed(
|
||||
description=description,
|
||||
colour=discord.Colour.orange(),
|
||||
timestamp=datetime.datetime.utcnow()
|
||||
).set_author(
|
||||
name="{}'s reminders".format(ctx.author.display_name),
|
||||
icon_url=ctx.author.avatar_url
|
||||
).set_footer(
|
||||
text=(
|
||||
"Click a reminder twice to jump to the context!\n"
|
||||
"For more usage and examples see {}help reminders"
|
||||
).format(ctx.best_prefix)
|
||||
)
|
||||
|
||||
await ctx.reply(embed=embed)
|
||||
@@ -1,8 +0,0 @@
|
||||
from data.interfaces import RowTable
|
||||
|
||||
|
||||
reminders = RowTable(
|
||||
'reminders',
|
||||
('reminderid', 'userid', 'remind_at', 'content', 'message_link', 'interval', 'created_at', 'title', 'footer'),
|
||||
'reminderid'
|
||||
)
|
||||
@@ -1,4 +0,0 @@
|
||||
from LionModule import LionModule
|
||||
|
||||
|
||||
module = LionModule("Reminders")
|
||||
@@ -1,234 +0,0 @@
|
||||
import asyncio
|
||||
import datetime
|
||||
import logging
|
||||
import discord
|
||||
|
||||
from meta import client, sharding
|
||||
from utils.lib import strfdur
|
||||
|
||||
from .data import reminders
|
||||
from .module import module
|
||||
|
||||
|
||||
class Reminder:
|
||||
__slots__ = ('reminderid', '_task')
|
||||
|
||||
_live_reminders = {} # map reminderid -> Reminder
|
||||
|
||||
def __init__(self, reminderid):
|
||||
self.reminderid = reminderid
|
||||
|
||||
self._task = None
|
||||
|
||||
@classmethod
|
||||
def create(cls, **kwargs):
|
||||
row = reminders.create_row(**kwargs)
|
||||
return cls(row.reminderid)
|
||||
|
||||
@classmethod
|
||||
def fetch(cls, *reminderids):
|
||||
"""
|
||||
Fetch an live reminders associated to the given reminderids.
|
||||
"""
|
||||
return [
|
||||
cls._live_reminders[reminderid]
|
||||
for reminderid in reminderids
|
||||
if reminderid in cls._live_reminders
|
||||
]
|
||||
|
||||
@classmethod
|
||||
def delete(cls, *reminderids):
|
||||
"""
|
||||
Cancel and delete the given reminders in an idempotent fashion.
|
||||
"""
|
||||
# Cancel the rmeinders
|
||||
for reminderid in reminderids:
|
||||
if reminderid in cls._live_reminders:
|
||||
cls._live_reminders[reminderid].cancel()
|
||||
|
||||
# Remove from data
|
||||
if reminderids:
|
||||
return reminders.delete_where(reminderid=reminderids)
|
||||
else:
|
||||
return []
|
||||
|
||||
@property
|
||||
def data(self):
|
||||
return reminders.fetch(self.reminderid)
|
||||
|
||||
@property
|
||||
def timestamp(self):
|
||||
"""
|
||||
True unix timestamp for (next) reminder time.
|
||||
"""
|
||||
return int(self.data.remind_at.replace(tzinfo=datetime.timezone.utc).timestamp())
|
||||
|
||||
@property
|
||||
def user(self):
|
||||
"""
|
||||
The discord.User that owns this reminder, if we can find them.
|
||||
"""
|
||||
return client.get_user(self.data.userid)
|
||||
|
||||
@property
|
||||
def formatted(self):
|
||||
"""
|
||||
Single-line string format for the reminder, intended for an embed.
|
||||
"""
|
||||
content = self.data.content
|
||||
trunc_content = content[:50] + '...' * (len(content) > 50)
|
||||
|
||||
if self.data.interval:
|
||||
interval = self.data.interval
|
||||
if interval == 24 * 60 * 60:
|
||||
interval_str = "day"
|
||||
elif interval == 60 * 60:
|
||||
interval_str = "hour"
|
||||
elif interval % (24 * 60 * 60) == 0:
|
||||
interval_str = "`{}` days".format(interval // (24 * 60 * 60))
|
||||
elif interval % (60 * 60) == 0:
|
||||
interval_str = "`{}` hours".format(interval // (60 * 60))
|
||||
else:
|
||||
interval_str = "`{}`".format(strfdur(interval))
|
||||
|
||||
repeat = "(Every {})".format(interval_str)
|
||||
else:
|
||||
repeat = ""
|
||||
|
||||
return "<t:{timestamp}:R>, [{content}]({jump_link}) {repeat}".format(
|
||||
jump_link=self.data.message_link,
|
||||
content=trunc_content,
|
||||
timestamp=self.timestamp,
|
||||
repeat=repeat
|
||||
)
|
||||
|
||||
def cancel(self):
|
||||
"""
|
||||
Cancel the live reminder waiting task, if it exists.
|
||||
Does not remove the reminder from data. Use `Reminder.delete` for this.
|
||||
"""
|
||||
if self._task and not self._task.done():
|
||||
self._task.cancel()
|
||||
self._live_reminders.pop(self.reminderid, None)
|
||||
|
||||
def schedule(self):
|
||||
"""
|
||||
Schedule this reminder to be executed.
|
||||
"""
|
||||
asyncio.create_task(self._schedule())
|
||||
self._live_reminders[self.reminderid] = self
|
||||
|
||||
async def _schedule(self):
|
||||
"""
|
||||
Execute this reminder after a sleep.
|
||||
Accepts cancellation by aborting the scheduled execute.
|
||||
"""
|
||||
# Calculate time left
|
||||
remaining = (self.data.remind_at - datetime.datetime.utcnow()).total_seconds()
|
||||
|
||||
# Create the waiting task and wait for it, accepting cancellation
|
||||
self._task = asyncio.create_task(asyncio.sleep(remaining))
|
||||
try:
|
||||
await self._task
|
||||
except asyncio.CancelledError:
|
||||
return
|
||||
await self._execute()
|
||||
|
||||
async def _execute(self):
|
||||
"""
|
||||
Execute the reminder.
|
||||
"""
|
||||
if not self.data:
|
||||
# Reminder deleted elsewhere
|
||||
return
|
||||
|
||||
if self.data.userid in client.user_blacklist():
|
||||
self.delete(self.reminderid)
|
||||
return
|
||||
|
||||
userid = self.data.userid
|
||||
|
||||
# Build the message embed
|
||||
embed = discord.Embed(
|
||||
title="You asked me to remind you!" if self.data.title is None else self.data.title,
|
||||
colour=discord.Colour.orange(),
|
||||
description=self.data.content,
|
||||
timestamp=datetime.datetime.utcnow()
|
||||
)
|
||||
|
||||
if self.data.message_link:
|
||||
embed.add_field(name="Context?", value="[Click here]({})".format(self.data.message_link))
|
||||
|
||||
if self.data.interval:
|
||||
embed.add_field(
|
||||
name="Next reminder",
|
||||
value="<t:{}:R>".format(
|
||||
self.timestamp + self.data.interval
|
||||
)
|
||||
)
|
||||
|
||||
if self.data.footer:
|
||||
embed.set_footer(text=self.data.footer)
|
||||
|
||||
# Update the reminder data, and reschedule if required
|
||||
if self.data.interval:
|
||||
next_time = self.data.remind_at + datetime.timedelta(seconds=self.data.interval)
|
||||
rows = reminders.update_where(
|
||||
{'remind_at': next_time},
|
||||
reminderid=self.reminderid
|
||||
)
|
||||
self.schedule()
|
||||
else:
|
||||
rows = self.delete(self.reminderid)
|
||||
if not rows:
|
||||
# Reminder deleted elsewhere
|
||||
return
|
||||
|
||||
# Send the message, if possible
|
||||
if not (user := client.get_user(userid)):
|
||||
try:
|
||||
user = await client.fetch_user(userid)
|
||||
except discord.HTTPException:
|
||||
pass
|
||||
if user:
|
||||
try:
|
||||
await user.send(embed=embed)
|
||||
except discord.HTTPException:
|
||||
# Nothing we can really do here. Maybe tell the user about their reminder next time?
|
||||
pass
|
||||
|
||||
|
||||
async def reminder_poll(client):
|
||||
"""
|
||||
One client/shard must continually poll for new or deleted reminders.
|
||||
"""
|
||||
# TODO: Clean this up with database signals or IPC
|
||||
while True:
|
||||
await asyncio.sleep(60)
|
||||
|
||||
client.log(
|
||||
"Running new reminder poll.",
|
||||
context="REMINDERS",
|
||||
level=logging.DEBUG
|
||||
)
|
||||
|
||||
rids = {row.reminderid for row in reminders.fetch_rows_where()}
|
||||
|
||||
to_delete = (rid for rid in Reminder._live_reminders if rid not in rids)
|
||||
Reminder.delete(*to_delete)
|
||||
|
||||
[Reminder(rid).schedule() for rid in rids if rid not in Reminder._live_reminders]
|
||||
|
||||
|
||||
@module.launch_task
|
||||
async def schedule_reminders(client):
|
||||
if sharding.shard_number == 0:
|
||||
rows = reminders.fetch_rows_where()
|
||||
for row in rows:
|
||||
Reminder(row.reminderid).schedule()
|
||||
client.log(
|
||||
"Scheduled {} reminders.".format(len(rows)),
|
||||
context="LAUNCH_REMINDERS"
|
||||
)
|
||||
if sharding.sharded:
|
||||
asyncio.create_task(reminder_poll(client))
|
||||
Reference in New Issue
Block a user