Emacs calendar

pip3 install icalevents recurring_ical_events pypandoc requests pytz

import requests
import http.cookiejar as cookielib
import os
cj = cookielib.MozillaCookieJar(os.path.expanduser('~/.cache/meetup-cookies.txt'))
cj.load()
data = requests.get('https://www.meetup.com/emacs-sf/events/ical', cookies=cj)
print(data)

import requests
import http.cookiejar as cookielib
import os
from urllib.request import urlopen
import icalendar
import datetime
from dateutil.relativedelta import *
import recurring_ical_events
import pytz
import re
import pypandoc
import subprocess
import sys
import csv
import requests

INCLUDE_MEETUPS = True
INCLUDE_OTHER_ICALS = True

cj = cookielib.MozillaCookieJar(os.path.expanduser('~/.cache/meetup-cookies.txt'))
cj.load()

#                 'Singapore': 'Emacs-SG',
other_meetups = {'EmacsNYC': 'New-York-Emacs-Meetup',
                 'EmacsSF (in person)': 'Emacs-SF',
                 'EmacsATX': 'EmacsATX',
                 'Pelotas, Brazil': 'Pelotas-Emacs-Meetup',
                 'Emacs FFM': 'emacs-ffm',
                 'London Emacs (in person)': 'London-Emacs-Hacking',
                 'London Emacs Lisp': 'London-Emacs-Lisp-Meetup',
                 # 'Finland': 'Finland-Emacs-User-Group',
                 'Delhi': 'Emacs-Delhi'}
other_icals = [ {'name': 'Atelier Emacs (in French)',
                 'source': 'https://mobilizon.fr/@communaute_emacs_francophone/feed/ics'},
                {'name': 'Emacs APAC',
                 'source': 'https://emacs-apac.gitlab.io/announcements/index.ics'},
                {'name': 'Emacs Paris',
                 'source': 'https://emacs-doctor.com/emacs-paris-meetups.ics',
                 'url':'https://emacs-doctor.com/'},
                {'name': 'M-x Research',
                'url': 'https://m-x-research.github.io/',
                'source': 'https://calendar.google.com/calendar/ical/o0tiadljp5dq7lkb51mnvnrh04%40group.calendar.google.com/public/basic.ics',
                'summary_re': r'^M-x Research - '},
                {'name': 'Emacs.si (in person)',
                'url': 'https://dogodki.kompot.si/@emacssi',
                'source': 'https://dogodki.kompot.si/@emacssi/feed/ics'}
               ]
# https://www.meetup.com/Emacs-SF/events/ical/',
all_timezones = []

def summarized_event(e, timezones):
  s = ''
  times = None
  if re.search('in[ -]person|v #živo|au Bib', e['SUMMARY']):
    m = re.search("Event time:(.*?)([<\n]|$)", e.get('description') or '')
    if m:
      s += '- ' + m.group(1).strip()
    elif e['DTSTART'].dt.tzinfo:
      tz = e['DTSTART'].dt.tzinfo
      times = [[e['DTSTART'].dt.astimezone(tz), tz.zone, e['DTSTART'].dt.astimezone(tz).utcoffset()]]
    else:
      s += '- see event for details'
  else:
    times = [[e['DTSTART'].dt.astimezone(pytz.timezone(t)), t, e['DTSTART'].dt.astimezone(pytz.timezone(t)).utcoffset()] for t in timezones]
    times.sort(key=lambda x: x[2])
  if times:
    for i, t in enumerate(times):
      if i == 0 or t[0].day != times[i - 1][0].day:
         if i > 0:
           s += " -- "
         s += t[0].strftime('%a %b %-d %H%M') + " " + t[1]
      else:
         s += " - " + t[0].strftime('%H%M') + " " + t[1]
  if e['LOCATION']:
    return "- %s %s %s" % (e['SUMMARY'], e['LOCATION'], s)
  else:
    return "- %s %s" % (e['SUMMARY'], s)

link = "https://calendar.google.com/calendar/ical/c_rkq3fc6u8k1nem23qegqc90l6c%40group.calendar.google.com/public/basic.ics"
f = urlopen(link)
cal = icalendar.Calendar.from_ical(f.read())
start_date = datetime.date(datetime.date.today().year, datetime.date.today().month, 1)

end_date = datetime.date(datetime.date.today().year + 1, datetime.date.today().month, 1)

for event in cal.walk():
  if event.name == 'VEVENT' and not '(ignore)' in event.name:
    if isinstance(event['DTSTART'].dt, datetime.datetime):
      event['UID'] = str(event['DTSTART'].dt.timestamp()) + '-' + event['UID']
    elif isinstance(event['DTSTART'].dt, datetime.date):
      event['UID'] = str(datetime.datetime.combine(event['DTSTART'].dt, datetime.time.min)) + '-' + event['UID']
    if event.get('location') == '':
      match = re.search(r'href="([^"]+)"', event.get('description'))
      if not match:
        match = re.search('^(http.*?)(&nbsp;|<br>|\n)', event.get('description'))
      if match:
        event['location'] = match.group(1)
      else:
        print(event.get('description'))
  if event.name == 'VTIMEZONE' and event['TZID'] not in all_timezones:
    all_timezones.append(event['TZID'])

def merge_cal(main_cal, name, url, start_date, end_date, info=None):
  # print('Requesting cal ', url)
  try:
    if 'meetup.com' in url:
      data = requests.get(url, cookies=cj)
    else:
      data = requests.get(url)
    meetup_cal = icalendar.Calendar.from_ical(data.content)
  except Exception as e:
    print("Error with url: %s" % url)
    print(repr(e))
    return
  # Copy the timezone components
  for tz in meetup_cal.walk():
    if tz.name == 'VTIMEZONE' and tz['TZID'] not in all_timezones:
      all_timezones.append(tz['TZID'])
      main_cal.add_component(tz)
  meetup_events = recurring_ical_events.of(meetup_cal).between(start_date, end_date)
  for event in meetup_events:
    low = event['SUMMARY'].lower()
    if info and 'summary_re' in info:
      event['SUMMARY'] = re.sub(info['summary_re'], '', event['SUMMARY'])
    if re.search(r'virtual|hybrid|online', low):
      name = re.sub(r' \(in person\)', '', name)
    event['SUMMARY'] = name + ': ' + event['SUMMARY']
    event['UID'] = str(event['DTSTART'].dt.timestamp()) + '-' + event['UID']
    event['LOCATION'] = ('URL' in event and event['URL']) or (info and ('url' in info) and info['url'])
    main_cal.add_component(event)

def merge_meetup_events(cal, start_date, end_date):
  global other_meetups
  for name, identifier in other_meetups.items():
    url = "https://www.meetup.com/%s/events/ical/" % (identifier)
    merge_cal(cal, name, url, start_date, end_date)

if INCLUDE_MEETUPS:
  merge_meetup_events(cal, start_date, end_date)
if INCLUDE_OTHER_ICALS:
  for item in other_icals:
    merge_cal(cal, item['name'], item['source'], start_date, end_date, item)

def convert_events_to_utc(cal):
  # Convert everything to UTC?
  utc = pytz.timezone('UTC')
  for event in cal.walk():
    if event.name == 'VEVENT' in event.name:
      for attr in ['DTSTART', 'DTEND', 'DTSTAMP', 'RECURRENCE-ID']:
        if attr in event:
          event[attr].dt = event[attr].dt.astimezone(utc)
          event[attr].params.clear()



f = open('emacs-calendar.ics', 'wb')

f.write(cal.to_ical())
f.close()

def get_aware_dt(dt_val):
    if isinstance(dt_val, datetime.date) and not isinstance(dt_val, datetime.datetime):
        dt_val = datetime.datetime.combine(dt_val, datetime.time.min)
    if dt_val.tzinfo is not None and dt_val.tzinfo.utcoffset(dt_val) is not None:
        return dt_val.astimezone(datetime.timezone.utc)
    else:
        return dt_val.replace(tzinfo=datetime.timezone.utc)

events = recurring_ical_events.of(cal).between(start_date, end_date)
events.sort(key=lambda x: get_aware_dt(x['DTSTART'].dt))

files = {}
org_date = "%Y-%m-%d %a %H:%M" # 2006-11-01 Wed 19:15
# Prepare string for copying
highlight_start = datetime.datetime.now(pytz.UTC)
highlight_end = datetime.datetime.now(pytz.UTC) + relativedelta(weeks=+6)
all_end = datetime.datetime.now(pytz.UTC) + relativedelta(weeks=+1)

org_timezones = [x for x in timezones]
for offset in range(-12, 14):
  if offset < 0:
    org_timezones.append('Etc/GMT+%s' % abs(offset))
  else:
    org_timezones.append('Etc/GMT-%s' % abs(offset))

for t in org_timezones:
  stub = "emacs-calendar-" + re.sub('^.*?/', '', t).lower()
  if 'gmt-' in stub:
    stub = re.sub(r'gmt-', 'gmt+', stub)
  elif 'gmt+' in stub:
    stub = re.sub(r'gmt\+', 'gmt-', stub)
  ical_args = ["ical2html", "-l", "-f", "Times are in " + t, "-z", t, datetime.datetime.today().strftime("%Y%m01"), "P8W", "emacs-calendar.ics"]
  output = subprocess.check_output(ical_args).decode(sys.stdout.encoding)
  changed = re.sub(r'<span class=summary>([^<]+)</span>\n<pre><b class=location>([^<]+)</b></pre>',
                   r'<span class="summary"><a href="\2">\1</a></span>', output)
  f = open(stub + '.html', 'wb')
  f.write(changed.encode(sys.stdout.encoding))
  f.close()
  files[t] = open(stub + '.org', "w")

with open('events.csv', 'w', newline='') as csvfile:
  fieldnames = ['DTSTART', 'DTEND', 'LOCATION', 'SUMMARY', 'TEXT', 'TZID']
  writer = csv.DictWriter(csvfile, fieldnames=fieldnames, extrasaction='ignore')
  writer.writeheader()
  for e in events:
    writer.writerow({**e,
                     'DTSTART': e['DTSTART'].dt.isoformat(),
                     'DTEND': e['DTEND'].dt.isoformat(),
                     'TEXT': summarized_event(e, timezones)
                     })


for e in events:
  if 'DESCRIPTION' not in e:
    e['DESCRIPTION'] = ''
  desc = pypandoc.convert_text(e['DESCRIPTION'], 'org', format='html').replace('\\\\', '')
  if isinstance(e['DTSTART'].dt, datetime.datetime):
    utc = datetime.datetime.fromtimestamp(e['DTSTART'].dt.timestamp(), datetime.UTC)
  else:
    utc = datetime.datetime.fromtimestamp(datetime.datetime.combine(e['DTSTART'].dt, datetime.time.min).timestamp(), datetime.UTC)
  if utc >= highlight_start and utc <= highlight_end:
    if 'Mastering Emacs' in e['DESCRIPTION'] and utc > all_end:
      pass # do nothing
    else:
      print(summarized_event(e, timezones))
  for t in org_timezones:
    zone = pytz.timezone(t)
    if isinstance(e['DTSTART'].dt, datetime.datetime):
      start = e['DTSTART'].dt.astimezone(zone).strftime(org_date)
      end = e['DTEND'].dt.strftime(org_date)
    else:
      start = e['DTSTART'].dt.strftime("%Y-%m-%d %a")
      end = (e['DTEND'].dt - datetime.timedelta(days=1)).strftime("%Y-%m-%d %a")
    files[t].write("""* %s
:PROPERTIES:
:LOCATION: %s
:END:
<%s>--<%s>

%s

""" % (e['SUMMARY'], e['LOCATION'], start, end, desc))

rsync -avze ssh ./ web:/var/www/emacslife.com/calendar/ --exclude=.git

(defun my-summarize-times (time timezones)
  (let (prev-day)
    (mapconcat
     (lambda (tz)
       (let ((cur-day (format-time-string "%a %b %-e" time tz))
             (cur-time (format-time-string "%H%MH %Z" time tz)))
         (if (equal prev-day cur-day)
             cur-time
           (setq prev-day cur-day)
           (concat cur-day " " cur-time))))
     timezones
     " / ")))

(defun my-org-summarize-event-in-timezones (timezones)
  (interactive (list (or timezones my-timezones)))
  (save-window-excursion
    (save-excursion
      (when (derived-mode-p 'org-agenda-mode) (org-agenda-goto))
      (when (re-search-forward org-element--timestamp-regexp nil (save-excursion (org-end-of-subtree) (point)))
        (goto-char (match-beginning 0))
        (let* ((times (org-element-timestamp-parser))
               (start-time (org-timestamp-to-time (org-timestamp-split-range times)))
               (event-time-from-body
                (save-excursion
                  (when  (re-search-forward "Event time: \\(.+\\)"
                                            (save-excursion (org-end-of-subtree) (point))
                                            t)
                    (match-string 1))))
               (msg (format "%s - %s - %s"
                            (org-get-heading t t t t)

                            (or event-time-from-body (my-summarize-times start-time timezones))
                            ;; (cond
                            ;;  ((time-less-p (org-timestamp-to-time (org-timestamp-split-range times t)) (current-time))
                            ;;   "(past)")
                            ;;  ((time-less-p (current-time) start-time)
                            ;;   (concat "in " (format-seconds "%D %H %M%Z" (time-subtract start-time (current-time)))))
                            ;;  (t "(ongoing)"))
                            (org-entry-get (point) "LOCATION"))))
          (if (called-interactively-p 'any)
              (progn
                (message "%s" msg)
                (kill-new msg))
            msg))))))

(defun my-summarize-upcoming-events (limit timezones)
  (interactive (list (org-read-date nil t) my-timezones))
  (let (result)
    (with-current-buffer (find-file-noselect "~/sync/emacs-calendar/emacs-calendar-toronto.org")
      (goto-char (point-min))
      (org-map-entries
       (lambda ()
         (save-excursion
           (when (re-search-forward org-element--timestamp-regexp nil (save-excursion (org-end-of-subtree) (point)))
             (goto-char (match-beginning 0))
             (let ((time (org-timestamp-to-time (org-timestamp-split-range (org-element-timestamp-parser)))))
               (when (and (time-less-p (current-time) time)
                          (time-less-p time limit))
                 (setq result (cons
                               (cons time
                                     (my-org-summarize-event-in-timezones timezones)) result)))))))))
    (setq result (mapconcat
                  (lambda (o) (format "- %s" (cdr  o)))
                  (sort result (lambda (a b)
                                 (time-less-p (car a) (car b))
                                 ))
                  "\n"))
    (if (interactive-p)
        (insert result)
      result)))

(defun my-announce-on-irc (channels message host port)
  (with-temp-buffer
    (insert "PASS " erc-password "\n"
            "USER " erc-nick "\n"
            "NICK " erc-nick "\n"
            (mapconcat (lambda (o)
                         (format "PRIVMSG %s :%s\n" o message))
                       channels "")
            "QUIT\n")
    (call-process-region (point-min) (point-max) "ncat" nil 0 nil
                         "--ssl" host (number-to-string port))))

(defun my-announce-on-irc-and-twitter (time channels message host port)
  (when (< (time-to-seconds (subtract-time (current-time) time)) (* 5 60))
    (shell-command-to-string (format
                              (if my-laptop-p
                                  "zsh -l -c 'rvm use 2.4.1; t update %s'"
                                "bash -l -c 't update %s'")
                              (shell-quote-argument message)))
    (my-announce-on-irc channels message host port)))

(defun my-schedule-announcement (time message)
  (interactive (list (org-read-date t t) (read-string "Message: ")))
  (run-at-time time nil #'my-announce-on-irc-and-twitter time '("#emacs" "#emacsconf") message erc-server erc-port))

(defun my-org-table-as-alist (table)
  "Convert TABLE to an alist. Remember to set :colnames no."
  (let ((headers (seq-map 'intern (car table))))
    (cl-loop for x in (cdr table) collect (-zip headers x))))

(defun my-schedule-announcements-for-upcoming-emacs-meetups ()
  (interactive)
  (cancel-function-timers #'my-announce-on-irc-and-twitter)
  (let ((events (my-org-table-as-alist (pcsv-parse-file "events.csv")))
        (now (current-time))
        (before-limit (time-add (current-time) (seconds-to-time (* 14 24 60 60)))))
    (mapc (lambda (o)
            (unless (string-match "in person\\|workshop" (alist-get 'SUMMARY o))
              (let* ((start-time (encode-time (parse-time-string (alist-get 'DTSTART o))))
                     (fifteen-minutes-before (seconds-to-time (- (time-to-seconds start-time) (* 15 60)))))
                (when (and (time-less-p now fifteen-minutes-before)
                           (time-less-p fifteen-minutes-before before-limit))
                  (my-schedule-announcement fifteen-minutes-before
                                            (format "In 15 minutes: %s - see %s for details"
                                                    (alist-get 'SUMMARY o)
                                                    (alist-get 'LOCATION o))))
                (when (and (time-less-p now start-time)
                           (time-less-p start-time before-limit))
                  (my-schedule-announcement start-time
                                            (format "Starting now: %s - see %s for details"
                                                    (alist-get 'SUMMARY o)
                                                    (alist-get 'LOCATION o)))))))
          events)))

(use-package oddmuse
:load-path "~/vendor/oddmuse-el"
:if my-laptop-p
:ensure nil
:config (oddmuse-mode-initialize)
:hook (oddmuse-mode-hook .
          (lambda ()
            (unless (string-match "question" oddmuse-post)
              (when (string-match "EmacsWiki" oddmuse-wiki)
                (setq oddmuse-post (concat "uihnscuskc=1;" oddmuse-post)))
              (when (string-match "OddmuseWiki" oddmuse-wiki)
                (setq oddmuse-post (concat "ham=1;" oddmuse-post)))))))

(let* ((file "/home/sacha/sync/emacs-calendar/emacs-calendar-toronto.org")
       (time-format "%M %H %d %m")
       (bbb-meetups "OrgMeetup\\|Emacs Berlin\\|Emacs APAC")
       (scale-up "/home/sacha/bin/bbb-testing")
       (scale-down "/home/sacha/bin/bbb-dormant"))
  (mapconcat
   (lambda (o)
     (let ((start-time (format-time-string time-format (- (car o) 3600 )))
           (end-time (format-time-string time-format (+ (car o) (* 6 3600)))))
       (format "# %s\n%s * %s\n%s * %s\n"
               (cdr o)
               start-time
               scale-up
               end-time
               scale-down)))
   (delq nil
         (with-temp-buffer
           (insert-file-contents file)
           (org-mode)
           (goto-char (point-min))
           (org-map-entries
            (lambda ()
              (when (and
                     (string-match bbb-meetups (org-entry-get (point) "ITEM"))
                     (re-search-forward org-tr-regexp (save-excursion (org-end-of-subtree)) t))
                (let ((time (match-string 0)))
                  (cons (org-time-string-to-seconds time)
                        (format "%s - %s" (org-entry-get (point) "ITEM") time)))))
            "LEVEL=1")))
   "\n"))

#+begin_src sh :dir "/ssh:xu4:~" :results silent
crontab bbb.crontab
#+end_src

(defun my-prepare-calendar-for-export ()
  (interactive)
  (with-current-buffer (find-file-noselect "~/sync/emacs-calendar/README.org")
    (save-restriction
      (widen)
      (goto-char (point-min))
      (re-search-forward "#\\+NAME: event-summary")
      (org-ctrl-c-ctrl-c)
      (org-export-to-file 'html "README.html")
      ;; (unless my-laptop-p (my-schedule-announcements-for-upcoming-emacs-meetups))
      ;; update the crontab
      (goto-char (org-find-property "CUSTOM_ID" "crontab"))
      (org-babel-execute-subtree)
      (when my-laptop-p
        (org-babel-goto-named-result "event-summary")
        (re-search-forward "^- ")
        (goto-char (match-beginning 0))
        (let ((events (org-babel-read-result)))
          (oddmuse-edit "EmacsWiki" "Usergroups")
          (goto-char (point-min))
          (delete-region (progn (re-search-forward "== Upcoming events ==\n\n") (match-end 0))
                         (progn (re-search-forward "^$") (match-beginning 0)))
          (save-excursion (insert (mapconcat (lambda (s) (concat "* " s "\n")) events ""))))))))
(my-prepare-calendar-for-export)