examples/reminder/reminder.py

   1 #!/usr/bin/env python3
   2
   3 """
   4 Reminders for upcoming important dates.
   5 """
   6
   7 import datetime
   8 import logging
   9 import os
  10 import re
  11 import sys
  12 from collections import defaultdict
  13 from typing import Dict, List, Optional
  14
  15 from pyutils import argparse_utils, bootstrap, config, string_utils
  16 from pyutils.ansi import fg, reset
  17 from pyutils.datetimes import dateparse_utils as dateparse
  18 from pyutils.files import file_utils
  19 from pyutils.typez import persistent
  20
  21 logger = logging.getLogger(__name__)
  22 cfg = config.add_commandline_args(
  23     f"Main ({__file__})", "Reminder of events, birthdays and anniversaries."
  24 )
  25 cfg.add_argument(
  26     "--reminder_filename",
  27     type=argparse_utils.valid_filename,
  28     default=".reminder",
  29     metavar="FILENAME",
  30     help="Override the .reminder filepath",
  31 )
  32 cfg.add_argument(
  33     "--reminder_cache_file",
  34     type=str,
  35     default=f'{os.environ["HOME"]}/.reminder_cache',
  36     metavar="FILENAME",
  37     help="Override the .reminder cache location",
  38 )
  39 cfg.add_argument(
  40     "-n", "--count", type=int, metavar="COUNT", help="How many events to remind about"
  41 )
  42 cfg.add_argument(
  43     "--days_ahead",
  44     type=int,
  45     metavar="#DAYS",
  46     help="How many days ahead to remind about",
  47 )
  48 cfg.add_argument(
  49     "-d",
  50     "--date",
  51     "--dates",
  52     action="store_true",
  53     help="Also include the date along with the n day countdown",
  54 )
  55 cfg.add_argument(
  56     "--override_timestamp",
  57     nargs=1,
  58     type=argparse_utils.valid_datetime,
  59     help="Don't use the current datetime, use this one instead.",
  60     metavar="DATE/TIME STRING",
  61     default=None,
  62 )
  63
  64
  65 # This decorator handles caching this object's state on disk and feeding the
  66 # state back to new instances of this object at initialization time.  It also
  67 # makes sure that this object is a global singleton in the program.
  68 @persistent.persistent_autoloaded_singleton()
  69 class Reminder(object):
  70     MODE_EVENT = 0
  71     MODE_BIRTHDAY = 1
  72     MODE_ANNIVERSARY = 2
  73
  74     def __init__(
  75         self, cached_state: Optional[Dict[datetime.date, List[str]]] = None
  76     ) -> None:
  77         if not config.config["override_timestamp"]:
  78             self.today = datetime.date.today()
  79         else:
  80             self.today = config.config["override_timestamp"][0].date()
  81             logger.debug(
  82                 'Overriding "now" with %s because of commandline argument.',
  83                 self.today,
  84             )
  85         if cached_state is not None:
  86             self.label_by_date = cached_state
  87             return
  88         self.label_by_date: Dict[datetime.date, List[str]] = defaultdict(list)
  89         self.read_file(config.config["reminder_filename"])
  90
  91     def handle_event_by_adjusting_year_to_now(
  92         self,
  93         parsing_mode: int,
  94         orig_date: datetime.date,
  95         orig_label: str,
  96         saw_overt_year: bool,
  97     ) -> None:
  98         for year in (self.today.year, self.today.year + 1):
  99             label = orig_label
 100             if saw_overt_year:
 101                 delta = year - orig_date.year
 102                 if parsing_mode == Reminder.MODE_BIRTHDAY:
 103                     if delta != 0:
 104                         label += f" ({delta} year{string_utils.pluralize(delta)} old)"
 105                 elif parsing_mode == Reminder.MODE_ANNIVERSARY:
 106                     if delta != 0:
 107                         label += f" ({delta}{string_utils.thify(delta)} anniversary)"
 108             dt = datetime.date(
 109                 year=year,
 110                 month=orig_date.month,
 111                 day=orig_date.day,
 112             )
 113             logger.debug("Date in %d: %s", year, dt)
 114             self.label_by_date[dt].append(label)
 115             logger.debug("%s => %s", dt, label)
 116
 117     def handle_event_with_fixed_year(
 118         self,
 119         orig_date: datetime.date,
 120         orig_label: str,
 121     ) -> None:
 122         logger.debug("Fixed date event...")
 123         self.label_by_date[orig_date].append(orig_label)
 124         logger.debug("%s => %s", orig_date, orig_label)
 125
 126     def read_file(self, filename: str) -> None:
 127         logger.debug("Reading %s:", filename)
 128         date_parser = dateparse.DateParser()
 129         parsing_mode = Reminder.MODE_EVENT
 130         with open(filename) as f:
 131             lines = f.readlines()
 132         for line in lines:
 133             line = line.strip()
 134             line = re.sub(r"#.*$", "", line)
 135             if re.match(r"^ *$", line) is not None:
 136                 continue
 137             logger.debug("> %s", line)
 138             try:
 139                 if "=" in line:
 140                     label, date = line.split("=")
 141                 else:
 142                     print(f"Skipping unparsable line: {line}", file=sys.stderr)
 143                     logger.error("Skipping malformed line: %s", line)
 144                     continue
 145
 146                 if label == "type":
 147                     if "event" in date:
 148                         parsing_mode = Reminder.MODE_EVENT
 149                         logger.debug("--- EVENT MODE ---")
 150                     elif "birthday" in date:
 151                         parsing_mode = Reminder.MODE_BIRTHDAY
 152                         logger.debug("--- BIRTHDAY MODE ---")
 153                     elif "anniversary" in date:
 154                         parsing_mode = Reminder.MODE_ANNIVERSARY
 155                         logger.debug("--- ANNIVERSARY MODE ---")
 156                 else:
 157                     date_parser.parse(date)
 158                     orig_date = date_parser.get_date()
 159                     if orig_date is None:
 160                         print(f"Skipping unparsable date: {line}", file=sys.stderr)
 161                         logger.error("Skipping line with unparsable date")
 162                         continue
 163                     logger.debug("Original date: %s", orig_date)
 164
 165                     overt_year = date_parser.saw_overt_year
 166                     if parsing_mode in (
 167                         Reminder.MODE_BIRTHDAY,
 168                         Reminder.MODE_ANNIVERSARY,
 169                     ) or (parsing_mode == Reminder.MODE_EVENT and not overt_year):
 170                         self.handle_event_by_adjusting_year_to_now(
 171                             parsing_mode, orig_date, label, overt_year
 172                         )
 173                     else:
 174                         self.handle_event_with_fixed_year(orig_date, label)
 175
 176             except Exception:
 177                 logger.exception("Skipping malformed line: %s", line)
 178                 print(f"Skipping unparsable line: {line}", file=sys.stderr)
 179
 180     def remind(
 181         self, count: Optional[int], days_ahead: Optional[int], say_date: bool
 182     ) -> None:
 183         need_both = False
 184         if count is not None and days_ahead is not None:
 185             need_both = True
 186             seen = 0
 187
 188         for date in sorted(self.label_by_date.keys()):
 189             delta = date - self.today
 190             d = delta.days
 191             if d >= 0:
 192                 if days_ahead is not None:
 193                     if d > days_ahead:
 194                         if not need_both:
 195                             return
 196                         seen |= 1
 197                         if seen == 3:
 198                             return
 199                 labels = self.label_by_date[date]
 200                 for label in labels:
 201                     if d > 1:
 202                         if d <= 3:
 203                             msg = f"{fg('blaze orange')}{d} days{reset()} until {label}"
 204                         elif d <= 7:
 205                             msg = f"{fg('peach orange')}{d} days{reset()} until {label}"
 206                         else:
 207                             msg = f"{d} days until {label}"
 208                     elif d == 1:
 209                         msg = f"{fg('outrageous orange')}Tomorrow{reset()} is {label}"
 210                     else:
 211                         assert d == 0
 212                         msg = f"{fg('red')}Today{reset()} is {label}"
 213                     if say_date:
 214                         msg += f" {fg('battleship gray')}on {date.strftime('%A, %B %-d')}{reset()}"
 215                     print(msg)
 216                     if count is not None:
 217                         count -= 1
 218                         if count <= 0:
 219                             if not need_both:
 220                                 return
 221                             seen |= 2
 222                             if seen == 3:
 223                                 return
 224
 225     @classmethod
 226     def load(cls):
 227         if not config.config["override_timestamp"]:
 228             now = datetime.datetime.now()
 229         else:
 230             now = config.config["override_timestamp"][0]
 231             logger.debug(
 232                 'Overriding "now" with %s because of commandline argument.', now
 233             )
 234
 235         cache_ts = file_utils.get_file_mtime_as_datetime(
 236             config.config["reminder_cache_file"]
 237         )
 238         if cache_ts is None:
 239             return None
 240
 241         # If the cache was already written today...
 242         if (
 243             now.day == cache_ts.day
 244             and now.month == cache_ts.month
 245             and now.year == cache_ts.year
 246         ):
 247             reminder_ts = file_utils.get_file_mtime_as_datetime(
 248                 config.config["reminder_filename"]
 249             )
 250
 251             # ...and the .reminder file wasn't updated since the cache write...
 252             if reminder_ts <= cache_ts:
 253                 import pickle
 254
 255                 with open(config.config["reminder_cache_file"], "rb") as rf:
 256                     reminder_data = pickle.load(rf)
 257                     return cls(reminder_data)
 258         return None
 259
 260     def save(self):
 261         import pickle
 262
 263         with file_utils.CreateFileWithMode(
 264             config.config["reminder_cache_file"], filesystem_mode=0o600, open_mode="wb"
 265         ) as wf:
 266             pickle.dump(
 267                 self.label_by_date,
 268                 wf,
 269                 pickle.HIGHEST_PROTOCOL,
 270             )
 271
 272
 273 @bootstrap.initialize
 274 def main() -> None:
 275     reminder = Reminder()
 276     count = config.config["count"]
 277     days_ahead = config.config["days_ahead"]
 278     reminder.remind(count, days_ahead, config.config["date"])
 279     return None
 280
 281
 282 if __name__ == "__main__":
 283     main()