import datetime
import functools
-import os
+import logging
import time
from typing import Any, Dict, List, Optional, Tuple
from dateutil.parser import parse
-import gdata # type: ignore
import gdata_oauth
-from oauth2client.client import AccessTokenRefreshError # type: ignore
import pytz
-import constants
+import kiosk_constants
import file_writer
import globals
import renderer
-import kiosk_secrets as secrets
-class gcal_renderer(renderer.debuggable_abstaining_renderer):
+logger = logging.getLogger(__name__)
+
+
+class gcal_renderer(renderer.abstaining_renderer):
"""A renderer to fetch upcoming events from www.google.com/calendar"""
calendar_whitelist = frozenset(
calendar: str,
) -> None:
if start_time is None:
- assert(end_time is None)
+ assert end_time is None
else:
- assert(isinstance(start_time, datetime.datetime))
+ assert isinstance(start_time, datetime.datetime)
if end_time is not None:
- assert(isinstance(end_time, datetime.datetime))
+ assert isinstance(end_time, datetime.datetime)
self.start_time = start_time
self.end_time = end_time
self.summary = summary
def __eq__(self, that) -> bool:
return (
- self.start_time == that.start_time and
- self.end_time == that.end_time and
- self.summary == that.summary and
- self.calendar == that.calendar
+ self.start_time == that.start_time
+ and self.end_time == that.end_time
+ and self.summary == that.summary
+ and self.calendar == that.calendar
)
def __repr__(self) -> str:
if self.start_time is None:
return "None"
elif (
- self.start_time.hour == 0 and
- self.start_time.minute == 0 and
- self.start_time.second == 0
+ self.start_time.hour == 0
+ and self.start_time.minute == 0
+ and self.start_time.second == 0
):
if self.start_time.year == now.year:
- return datetime.datetime.strftime(
- self.start_time,
- "%a %b %d"
- )
+ return datetime.datetime.strftime(self.start_time, "%a %b %d")
else:
- return datetime.datetime.strftime(
- self.start_time,
- "%a %b %d, %Y"
- )
+ return datetime.datetime.strftime(self.start_time, "%a %b %d, %Y")
else:
dt = self.start_time
zone = dt.tzinfo
- local_dt = dt.replace(tzinfo=zone).astimezone(tz=pytz.timezone('US/Pacific'))
+ local_dt = dt.replace(tzinfo=zone).astimezone(
+ tz=pytz.timezone("US/Pacific")
+ )
if local_dt.year == now.year:
- return datetime.datetime.strftime(
- local_dt, "%a %b %d %I:%M%p"
- )
+ return datetime.datetime.strftime(local_dt, "%a %b %d %I:%M%p")
else:
- return datetime.datetime.strftime(
- local_dt, "%a %b %d, %Y %I:%M%p"
- )
+ return datetime.datetime.strftime(local_dt, "%a %b %d, %Y %I:%M%p")
def __init__(
self, name_to_timeout_dict: Dict[str, int], oauth: gdata_oauth.OAuth
) -> None:
- super(gcal_renderer, self).__init__(name_to_timeout_dict, True)
+ super().__init__(name_to_timeout_dict)
self.oauth = oauth
self.client = self.oauth.calendar_service()
self.sortable_events: List[gcal_renderer.comparable_event] = []
return "gcal"
def periodic_render(self, key: str) -> bool:
- self.debug_print('called for "%s"' % key)
+ logger.debug(f'called for "{key}"')
if key == "Render Upcoming Events":
return self.render_upcoming_events()
elif key == "Look For Triggered Events":
_time_max = now + datetime.timedelta(days=95)
time_min = datetime.datetime.strftime(_time_min, "%Y-%m-%dT%H:%M:%SZ")
time_max = datetime.datetime.strftime(_time_max, "%Y-%m-%dT%H:%M:%SZ")
- self.debug_print(f"time_min is {time_min}")
- self.debug_print(f"time_max is {time_max}")
+ logger.debug(f"time_min is {time_min}")
+ logger.debug(f"time_max is {time_max}")
return (time_min, time_max)
@staticmethod
if isinstance(date, datetime.datetime):
return date
elif isinstance(date, dict):
- if 'dateTime' in date:
- d = date['dateTime']
+ if "dateTime" in date:
+ d = date["dateTime"]
dt = parse(d)
if dt.tzinfo is None:
- dt = dt.replace(tzinfo=None).astimezone(tz=pytz.timezone('US/Pacific'))
+ dt = dt.replace(tzinfo=None).astimezone(
+ tz=pytz.timezone("US/Pacific")
+ )
return dt
- elif 'date' in date:
- d = date['date']
- dt = datetime.datetime.strptime(d, '%Y-%m-%d')
- dt = dt.replace(tzinfo=None).astimezone(tz=pytz.timezone('US/Pacific'))
+ elif "date" in date:
+ d = date["date"]
+ dt = datetime.datetime.strptime(d, "%Y-%m-%d")
+ dt = dt.replace(tzinfo=None).astimezone(tz=pytz.timezone("US/Pacific"))
return dt
- print(f'Not sure what to do with this {date} ({type(date)}), help?!')
+ print(f"Not sure what to do with this {date} ({type(date)}), help?!")
return None
def get_events_from_interesting_calendars(
)
for calendar in calendar_list["items"]:
if calendar["summary"] in gcal_renderer.calendar_whitelist:
- self.debug_print(
- f"{calendar['summary']} is an interesting calendar..."
- )
+ logger.debug(f"******* {calendar['summary']} is an interesting calendar...")
events = (
self.client.events()
.list(
singleEvents=True,
timeMin=time_min,
timeMax=time_max,
- maxResults=50,
+ maxResults=500,
)
.execute()
)
summary = event["summary"]
start = gcal_renderer.parse_date(event["start"])
end = gcal_renderer.parse_date(event["end"])
- self.debug_print(
+ logger.debug(
f" ... event '{summary}' ({event['start']} ({start}) to {event['end']} ({end})"
)
if start is not None and end is not None:
- self.debug_print(f' ... adding {summary} to sortable_events')
+ logger.debug(f" ... adding {summary} to sortable_events")
sortable_events.append(
gcal_renderer.comparable_event(
start, end, summary, calendar["summary"]
or "Holidays" in calendar["summary"]
or "Countdown" in summary
):
- self.debug_print(f" ... adding {summary} to countdown_events")
+ logger.debug(
+ f" ... adding {summary} to countdown_events"
+ )
countdown_events.append(
gcal_renderer.comparable_event(
start, end, summary, calendar["summary"]
(time_min, time_max) = self.get_min_max_timewindow()
try:
# Populate the "Upcoming Events" page.
+ logger.debug("Rendering the Upcoming Events page...")
(
self.sortable_events,
self.countdown_events,
self.sortable_events.sort()
with file_writer.file_writer("gcal_3_86400.html") as f:
f.write(
-f"""
+ """
<h1>Upcoming Calendar Events:</h1>
<hr>
<center>
)
upcoming_sortable_events = self.sortable_events[:12]
for n, event in enumerate(upcoming_sortable_events):
- self.debug_print(f'{n}/12: {event.friendly_name()} / {event.calendar}')
+ logger.debug(f"{n}/12: {event.friendly_name()} / {event.calendar}")
if n % 2 == 0:
color = "#c6b0b0"
else:
color = "#eeeeee"
f.write(
-f"""
+ f"""
<tr>
<td style="margin: 0; padding: 0; background: {color};">
{event.timestamp()}
f.write("</table></center>\n")
# Populate the "Countdown" page.
+ logger.debug("Rendering the Countdowns page")
self.countdown_events.sort()
with file_writer.file_writer("countdown_3_7200.html") as g:
g.write("<h1>Countdowns:</h1><hr><ul>\n")
x = int(delta.total_seconds())
if x > 0:
identifier = "id%d" % count
- days = divmod(x, constants.seconds_per_day)
- hours = divmod(days[1], constants.seconds_per_hour)
- minutes = divmod(hours[1], constants.seconds_per_minute)
+ days = divmod(x, kiosk_constants.seconds_per_day)
+ hours = divmod(days[1], kiosk_constants.seconds_per_hour)
+ minutes = divmod(hours[1], kiosk_constants.seconds_per_minute)
g.write(
- f'<li><SPAN id="%s">%d days, %02d:%02d</SPAN> until %s</li>\n'
+ '<li><SPAN id="%s">%d days, %02d:%02d</SPAN> until %s</li>\n'
% (
identifier,
int(days[0]),
)
timestamps[identifier] = time.mktime(eventstamp.timetuple())
count += 1
- self.debug_print(
+ logger.debug(
"countdown to %s is %dd %dh %dm"
% (name, days[0], hours[0], minutes[0])
)
</script>"""
)
return True
- except (gdata.service.RequestError, AccessTokenRefreshError):
- print("********* TRYING TO REFRESH GCAL CLIENT *********")
-# self.oauth.refresh_token()
-# self.client = self.oauth.calendar_service()
+ except Exception as e:
+ logger.exception(e)
return False
- except:
- raise
def look_for_triggered_events(self) -> bool:
- with file_writer.file_writer(constants.gcal_imminent_pagename) as f:
+ logger.debug("Looking for Imminent Upcoming Calendar events...")
+ with file_writer.file_writer(kiosk_constants.gcal_imminent_pagename) as f:
f.write("<h1>Imminent Upcoming Calendar Events:</h1>\n<hr>\n")
f.write("<center><table width=99%>\n")
now = datetime.datetime.now(pytz.timezone("US/Pacific"))
for event in self.sortable_events:
eventstamp = event.start_time
if eventstamp is None:
- return False
+ continue
delta = eventstamp - now
x = int(delta.total_seconds())
- if x > 0 and x <= constants.seconds_per_minute * 3:
- days = divmod(x, constants.seconds_per_day)
- hours = divmod(days[1], constants.seconds_per_hour)
- minutes = divmod(hours[1], constants.seconds_per_minute)
+ if x > 0 and x < 4 * kiosk_constants.seconds_per_minute:
+ days = divmod(x, kiosk_constants.seconds_per_day)
+ hours = divmod(days[1], kiosk_constants.seconds_per_hour)
+ minutes = divmod(hours[1], kiosk_constants.seconds_per_minute)
eventstamp = event.start_time
name = event.friendly_name()
calendar = event.calendar
+ logger.debug(f"Event {event} ({name}) triggered the page.")
f.write(
f"<LI> {name} ({calendar}) upcoming in {int(minutes[0])} minutes.\n"
)
# Test
+#import kiosk_secrets as secrets
+#import sys
+
+#logger.setLevel(logging.DEBUG)
+#logger.addHandler(logging.StreamHandler(sys.stdout))
#oauth = gdata_oauth.OAuth(secrets.google_client_secret)
#x = gcal_renderer(
-# {"Render Upcoming Events": 10000, "Look For Triggered Events": 1},
-# oauth)
+# {"Render Upcoming Events": 10000, "Look For Triggered Events": 1}, oauth
+#)
#x.periodic_render("Render Upcoming Events")
projects / kiosk.git / blobdiff