#!/usr/bin/env python3
+import collections
from datetime import datetime
+import difflib
+import gc
+import linecache
+import logging
import os
+import re
import sys
from threading import Thread
import time
import traceback
-from typing import Optional
+import tracemalloc
+from typing import Optional, List
+from queue import Queue, Empty
+
+import astral # type: ignore
+from astral.sun import sun # type: ignore
+import numpy as np
+import pytz
import constants
+import file_writer
import renderer
import renderer
import renderer_catalog
import chooser
+import listen
import logging
+import pvporcupine
import trigger_catalog
import utils
+logger = logging.getLogger(__file__)
-def filter_news_during_dinnertime(page: str) -> bool:
- now = datetime.now()
- is_dinnertime = now.hour >= 17 and now.hour <= 20
- return not is_dinnertime or not (
- "cnn" in page
- or "news" in page
- or "mynorthwest" in page
- or "seattle" in page
- or "stranger" in page
- or "twitter" in page
- or "wsj" in page
- )
+
+def thread_janitor() -> None:
+ tracemalloc.start()
+ tracemalloc_target = 0.0
+ gc_target = 0.0
+ gc.enable()
+
+ while True:
+ now = time.time()
+ if now > tracemalloc_target:
+ tracemalloc_target = now + 30.0
+ snapshot = tracemalloc.take_snapshot()
+ snapshot = snapshot.filter_traces((
+ tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
+ tracemalloc.Filter(False, "<unknown>"),
+ ))
+ key_type = 'lineno'
+ limit = 10
+ top_stats = snapshot.statistics(key_type)
+ print("janitor: Top %s lines" % limit)
+ for index, stat in enumerate(top_stats[:limit], 1):
+ frame = stat.traceback[0]
+ # replace "/path/to/module/file.py" with "module/file.py"
+ filename = os.sep.join(frame.filename.split(os.sep)[-2:])
+ print("janitor: #%s: %s:%s: %.1f KiB"
+ % (index, filename, frame.lineno, stat.size / 1024))
+ line = linecache.getline(frame.filename, frame.lineno).strip()
+ if line:
+ print('janitor: %s' % line)
+
+ other = top_stats[limit:]
+ if other:
+ size = sum(stat.size for stat in other)
+ print("janitor: %s other: %.1f KiB" % (len(other), size / 1024))
+ total = sum(stat.size for stat in top_stats)
+ print("janitor: Total allocated size: %.1f KiB" % (total / 1024))
+ if now > gc_target:
+ print("janitor: Running gc operation")
+ gc_target = now + 60.0
+ gc.collect()
+ time.sleep(10.0)
+
+
+def guess_page(command: str, page_chooser: chooser.chooser) -> str:
+ best_page = None
+ best_score = None
+ for page in page_chooser.get_page_list():
+ page = page.replace('(', ' ')
+ page = page.replace('_', ' ')
+ page = page.replace(')', ' ')
+ page = page.replace('.html', '')
+ page = page.replace('CNNNews', 'news')
+ page = page.replace('CNNTechnology', 'technology')
+ page = page.replace('gocostco', 'costco list')
+ page = page.replace('gohardware', 'hardware list')
+ page = page.replace('gohouse', 'house list honey do')
+ page = page.replace('gcal', 'google calendar events')
+ page = page.replace('mynorthwest', 'northwest news')
+ page = page.replace('myq', 'myq garage door status')
+ page = page.replace('gomenu', 'dinner menu')
+ page = page.replace('wsdot', 'traffic')
+ page = page.replace('gomenu', 'dinner menu')
+ page = page.replace('WSJNews', 'news')
+ page = page.replace('telma', 'telma cabin')
+ page = page.replace('WSJBusiness', 'business news')
+ page = re.sub(r'[0-9]+', '', page)
+ score = SequenceMatcher(None, command, page).ratio()
+ if best_score is None or score > best_score:
+ best_page = page
+ assert best_page is not None
+ return best_page
+
+
+def process_command(command: str, page_history: List[str], page_chooser) -> str:
+ page = None
+ if 'hold' in command:
+ page = page_history[0]
+ elif 'back' in command:
+ page = page_history[1]
+ elif 'skip' in command:
+ while True:
+ (page, _) = page_chooser.choose_next_page()
+ if page != page_history[0]:
+ break
+ elif 'weather' in command:
+ if 'telma' in command or 'cabin' in command:
+ page = 'weather-telma_3_10800.html'
+ elif 'stevens' in command:
+ page = 'weather-stevens_3_10800.html'
+ else:
+ page = 'weather-home_3_10800.html'
+ elif 'cabin' in command:
+ if 'list' in command:
+ page = 'Cabin-(gocabin)_2_3600.html'
+ else:
+ page = 'hidden/cabin_driveway.html'
+ elif 'news' in command or 'headlines' in command:
+ page = 'cnn-CNNNews_4_25900.html'
+ elif 'clock' in command or 'time' in command:
+ page = 'clock_10_none.html'
+ elif 'countdown' in command or 'countdowns' in command:
+ page = 'countdown_3_7200.html'
+ elif 'costco' in command:
+ page = 'Costco-(gocostco)_2_3600.html'
+ elif 'calendar' in command or 'events' in command:
+ page = 'gcal_3_86400.html'
+ elif 'countdown' in command or 'countdowns' in command:
+ page = 'countdown_3_7200.html'
+ elif 'grocery' in command or 'groceries' in command:
+ page = 'Grocery-(gogrocery)_2_3600.html'
+ elif 'hardware' in command:
+ page = 'Hardware-(gohardware)_2_3600.html'
+ elif 'garage' in command:
+ page = 'myq_4_300.html'
+ elif 'menu' in command:
+ page = 'Menu-(gomenu)_2_3600.html'
+ elif 'cron' in command or 'health' in command:
+ page = 'periodic-health_6_300.html'
+ elif 'photo' in command or 'picture' in command:
+ page = 'photo_23_3600.html'
+ elif 'quote' in command or 'quotation' in command or 'quotes' in command:
+ page = 'quotes_4_10800.html'
+ elif 'stevens' in command:
+ page = 'stevens-conditions_1_86400.html'
+ elif 'stock' in command or 'stocks' in command:
+ page = 'stock_3_86400.html'
+ elif 'twitter' in command:
+ page = 'twitter_10_3600.html'
+ elif 'traffic' in command:
+ page = 'wsdot-bridges_3_none.html'
+ elif 'front' in command and 'door' in command:
+ page = 'hidden/frontdoor.html'
+ elif 'driveway' in command:
+ page = 'hidden/driveway.html'
+ elif 'backyard' in command:
+ page = 'hidden/backyard.html'
+ else:
+ page = guess_page(command, page_chooser)
+ assert page is not None
+ return page
-def thread_change_current() -> None:
+def thread_change_current(command_queue: Queue) -> None:
+ page_history = [ "", "" ]
+ swap_page_target = 0.0
+
+ def filter_news_during_dinnertime(page: str) -> bool:
+ now = datetime.now(tz=pytz.timezone("US/Pacific"))
+ is_dinnertime = now.hour >= 17 and now.hour <= 20
+ return not is_dinnertime or not (
+ "cnn" in page
+ or "news" in page
+ or "mynorthwest" in page
+ or "seattle" in page
+ or "stranger" in page
+ or "twitter" in page
+ or "wsj" in page
+ )
page_chooser = chooser.weighted_random_chooser_with_triggers(
trigger_catalog.get_triggers(), [filter_news_during_dinnertime]
)
- swap_page_target = 0.0
- last_page = ""
+
while True:
now = time.time()
- (page, triggered) = page_chooser.choose_next_page()
+
+ # Check for a verbal command.
+ command = None
+ try:
+ command = command_queue.get(block=False)
+ except Exception:
+ command = None
+ pass
+ if command is not None:
+ triggered = True
+ page = process_command(command, page_history, page_chooser)
+
+ # Else pick a page randomly.
+ else:
+ while True:
+ (page, triggered) = page_chooser.choose_next_page()
+ if triggered or page != page_history[0]:
+ break
if triggered:
print("chooser[%s] - WE ARE TRIGGERED." % utils.timestamp())
- if page != last_page:
+ if page != page_history[0] or (swap_page_target - now) < 10.0:
print(
"chooser[%s] - EMERGENCY PAGE %s LOAD NEEDED"
% (utils.timestamp(), page)
)
- try:
- f = open(os.path.join(constants.pages_dir, "current.shtml"), "w")
- emit_wrapped(f, page)
- f.close()
- except:
- print("chooser[%s] - page does not exist?!" % (utils.timestamp()))
- continue
- last_page = page
- swap_page_target = now + constants.refresh_period_sec
+# try:
+ current = os.path.join(constants.pages_dir, "current.shtml")
+ with open(current, "w") as f:
+ emit_wrapped(f, page, override_refresh_sec = 40, command = command)
+ print(f'Wrote {current}')
+
+ page_history.insert(0, page)
+ page_history = page_history[0:10]
+ swap_page_target = now + 40
+# except:
+# print("chooser[%s] - page does not exist?!" % (utils.timestamp()))
+# continue
# Also notify XMLHTTP clients that they need to refresh now.
- path = os.path.join(constants.pages_dir, "reload_immediately.html")
- f = open(path, "w")
- f.write("Reload, suckers!")
- f.close()
+ emergency_file = os.path.join(constants.pages_dir, "reload_immediately.html")
+ with open(emergency_file, "w") as f:
+ f.write(f'Reload, suckers... you HAVE to see {page}!')
+ print(f'Causing immediate page reload with {emergency_file}...')
# Fix this hack... maybe read the webserver logs and see if it
# actually was picked up?
- time.sleep(0.750)
- os.remove(path)
+ time.sleep(3.0)
+ os.remove(emergency_file)
+ print(f'...and removed {emergency_file}')
elif now >= swap_page_target:
- if page == last_page:
- print(
- (
- "chooser[%s] - nominal choice got the same page..."
- % (utils.timestamp())
- )
- )
- continue
+ assert page != page_history[0]
print("chooser[%s] - nominal choice of %s" % (utils.timestamp(), page))
- try:
- f = open(os.path.join(constants.pages_dir, "current.shtml"), "w")
+# try:
+ with open(os.path.join(constants.pages_dir, "current.shtml"), "w") as f:
emit_wrapped(f, page)
- f.close()
- except:
- print("chooser[%s] - page does not exist?!" % (utils.timestamp()))
- continue
- last_page = page
+ page_history.insert(0, page)
+ page_history = page_history[0:10]
swap_page_target = now + constants.refresh_period_sec
+# except:
+# print("chooser[%s] - page does not exist?!" % (utils.timestamp()))
+# continue
time.sleep(1)
-def emit_wrapped(f, filename) -> None:
+def emit_wrapped(f,
+ filename: str,
+ *,
+ override_refresh_sec: int = None,
+ command: str = None) -> None:
def pick_background_color() -> str:
- now = datetime.now()
- if now.hour <= 6 or now.hour >= 21:
+ now = datetime.now(tz=pytz.timezone("US/Pacific"))
+ city = astral.LocationInfo(
+ "Bellevue", "USA", "US/Pacific", 47.610, -122.201
+ )
+ s = sun(city.observer, date=now, tzinfo=pytz.timezone("US/Pacific"))
+ sunrise_mod = utils.minute_number(s["sunrise"].hour, s["sunrise"].minute)
+ sunset_mod = utils.minute_number(s["sunset"].hour, s["sunset"].minute)
+ now_mod = utils.minute_number(now.hour, now.minute)
+ if now_mod < sunrise_mod or now_mod > (sunset_mod + 45):
return "E6B8B8"
- elif now.hour == 7 or now.hour == 20:
+ elif now_mod < (sunrise_mod + 45) or now_mod > (sunset_mod + 120):
return "EECDCD"
else:
return "FFFFFF"
+ def get_refresh_period() -> float:
+ if override_refresh_sec is not None:
+ return float(override_refresh_sec * 1000.0)
+ now = datetime.now(tz=pytz.timezone("US/Pacific"))
+ if now.hour < 7:
+ return float(constants.refresh_period_night_sec * 1000.0)
+ else:
+ return float(constants.refresh_period_sec * 1000.0)
+
age = utils.describe_age_of_file_briefly(f"pages/{filename}")
bgcolor = pick_background_color()
+ if command is None:
+ pageid = filename
+ else:
+ pageid = f'"{command}" -> {filename}'
+
f.write(
- """
+"""
<HEAD>
<TITLE>Kitchen Kiosk</TITLE>
<LINK rel="stylesheet" type="text/css" href="style.css">
function zoomScreen() {
z = 285;
do {
- document.getElementById("content").style.zoom = z+"%%";
+ document.getElementById("content").style.zoom = z+"%";
var body = document.body;
var html = document.documentElement;
var height = Math.max(body.scrollHeight,
}
}
}
-
+""")
+ f.write(
+"""
// Operate the clock at the top of the page.
function runClock() {
var today = new Date();
document.getElementById("date").innerHTML = today.toDateString();
var t = setTimeout(function(){runClock()}, 1000);
}
-
+""" % bgcolor)
+ f.write(
+"""
// Helper method for running the clock.
function maybeAddZero(x) {
return (x < 10) ? "0" + x : x;
addLoadEvent(zoomScreen);
addLoadEvent(runClock);
addLoadEvent(lateLoadImages);
+""")
+ f.write(
+"""
// Runs the countdown line at the bottom and is responsible for
// normal page reloads caused by the expiration of a timer.
(function countdown() {
});
}, 50)
})();
-
+""" % get_refresh_period())
+ f.write(
+"""
// Periodically checks for emergency reload events.
(function poll() {
setTimeout(
function() {
var xhr = new XMLHttpRequest();
xhr.open('GET',
- 'http://wannabe.house/kiosk/pages/reload_immediately.html');
+ '%s/reload_immediately.html');
xhr.onload =
function() {
if (xhr.status === 200) {
xhr.send();
}, 500);
})();
-</SCRIPT>
+ </SCRIPT>
</HEAD>
-<BODY BGCOLOR="#%s">
- <TABLE style="height:100%%; width:100%%" BORDER=0>
+""" % constants.root_url)
+ f.write(f'<BODY BGCOLOR="#{bgcolor}">')
+ f.write(
+"""
+ <TABLE style="height:100%; width:100%" BORDER=0>
<TR HEIGHT=30>
<TD ALIGN="left">
<DIV id="date"> </DIV>
<TD COLSPAN=3>
<DIV ID="content" STYLE="zoom: 1; visibility: hidden;">
<!-- BEGIN main page contents. -->
-<!--#include virtual=\"%s\"-->
- <!-- END main page contents. -->
+""")
+ f.write(f'<!--#include virtual="{filename}"-->')
+ f.write(
+"""
+ <!-- END main page contents. -->
</DIV>
<BR>
- <DIV STYLE="position: absolute; top:1030px; width:99%%">
+ <DIV STYLE="position: absolute; top:1030px; width:99%">
<P ALIGN="right">
- <FONT SIZE=2 COLOR=#bbbbbb>%s @ %s ago.</FONT>
+""")
+ f.write(f'<FONT SIZE=2 COLOR=#bbbbbb>{pageid} @ {age} ago.</FONT>')
+ f.write(
+"""
</P>
<HR id="countdown" STYLE="width:0px;
text-align:left;
</TD>
</TR>
</TABLE>
-</BODY>"""
- % (
- bgcolor,
- constants.refresh_period_sec * 1000,
- bgcolor,
- filename,
- filename,
- age,
- )
- )
+</BODY>""")
def thread_invoke_renderers() -> None:
+ render_times: Dict[str, np.array] = {}
+ render_counts: collections.Counter = collections.Counter()
+ last_render: Dict[str, datetime] = {}
+
while True:
- print(f"renderer[{utils.timestamp()}]: invoking all renderers in catalog...")
+ print(f'renderer[{utils.timestamp()}]: invoking all overdue renderers in catalog...')
for r in renderer_catalog.get_renderers():
+ name = r.get_name()
now = time.time()
try:
r.render()
except Exception as e:
- traceback.print_exc()
+ traceback.print_exc(file=sys.stdout)
+ logger.exception(e)
print(
- f"renderer[{utils.timestamp()}] unknown exception in {r.get_name()}, swallowing it."
+ f"renderer[{utils.timestamp()}] Unknown exception ({e}) in {name}, swallowing it."
)
+
+ # Increment the count of render operations per renderer.
+ render_counts[name] += 1
+
+ # Keep track of the last time we invoked each renderer.
+ last_render[name] = datetime.now(tz=pytz.timezone("US/Pacific"))
+
+ # Record how long each render operation takes and warn if very long.
delta = time.time() - now
+ times = render_times.get(name, np.array([]))
+ times = np.insert(times, 0, delta)
+ render_times[name] = times
if delta > 1.0:
+ hdr = f'renderer[{utils.timestamp()}]:'
print(
- f"renderer[{utils.timestamp()}]: Warning: {r.get_name()}'s rendering took {delta:%5.2f}s."
- )
+f'''
+{hdr} Warning: {name}'s rendering took {delta:5.2f}s.
+{hdr} FYI: {name}'s render times: p25={np.percentile(times, 25):5.2f}, p50={np.percentile(times, 50):5.2f}, p75={np.percentile(times, 75):5.2f}, p90={np.percentile(times, 90):5.2f}, p99={np.percentile(times, 99):5.2f}
+''')
+
+ # Render a page about internal stats of renderers.
+ print(f'renderer[{utils.timestamp()}]: Updating internal statistics page.')
+ with file_writer.file_writer(constants.internal_stats_pagename) as f:
+ f.write(
+f'''
+<CENTER>
+<TABLE BORDER=0 WIDTH=95%>
+ <TR>
+ <TH><B>Renderer Name</B></TH>
+ <TH><B>Last Run</B></TH>
+ <TH><B>Num Invocations</B></TH>
+ <TH><B>Render Latency</B></TH>
+ </TR>
+''')
+ for n, r in enumerate(renderer_catalog.get_renderers()):
+ if n % 2 == 0:
+ style = 'style="margin: 0; padding: 0; background: #c6b0b0;"'
+ else:
+ style = 'style="margin: 0; padding: 0; background: #eeeeee;"'
+ name = r.get_name()
+ last = last_render.get(name, None)
+ if last is None:
+ last = 'never'
+ else:
+ last = last.strftime('%Y/%m/%d %I:%M:%S%P')
+ count = render_counts.get(name, 0)
+ latency = render_times.get(name, np.array([]))
+ p25 = p50 = p75 = p90 = p99 = 'N/A'
+ try:
+ p25 = np.percentile(latency, 25)
+ p50 = np.percentile(latency, 50)
+ p75 = np.percentile(latency, 75)
+ p90 = np.percentile(latency, 90)
+ p99 = np.percentile(latency, 99)
+ except IndexError:
+ pass
+ f.write(
+f'''
+ <TR>
+ <TD {style}>{name} </TD>
+ <TD {style}> {last} </TD>
+ <TD {style}><CENTER> {count} </CENTER></TD>
+ <TD {style}> p25={p25:5.2f}, p50={p50:5.2f}, p75={p75:5.2f}, p90={p90:5.2f}, p99={p99:5.2f}</TD>
+ </TR>
+''')
+ f.write('</TABLE>')
+
print(
- f"renderer[{utils.timestamp()}]: thread having a little break for {constants.render_period_sec}s..."
+ f"renderer[{utils.timestamp()}]: " +
+ f"thread having a little break for {constants.render_period_sec}s..."
)
time.sleep(constants.render_period_sec)
if __name__ == "__main__":
logging.basicConfig()
+ command_queue: Queue = Queue()
changer_thread: Optional[Thread] = None
renderer_thread: Optional[Thread] = None
+ janitor_thread: Optional[Thread] = None
+ hotword_thread: Optional[Thread] = None
while True:
+ if hotword_thread is None or not hotword_thread.is_alive():
+ keyword_paths = [pvporcupine.KEYWORD_PATHS[x] for x in ["bumblebee"]]
+ sensitivities = [0.7] * len(keyword_paths)
+ listener = listen.HotwordListener(
+ command_queue,
+ keyword_paths,
+ sensitivities,
+ )
+ hotword_thread = Thread(target=listener.listen_forever, args=())
+ hotword_thread.start()
if changer_thread is None or not changer_thread.is_alive():
print(
f"MAIN[{utils.timestamp()}] - (Re?)initializing chooser thread... (wtf?!)"
)
- changer_thread = Thread(target=thread_change_current, args=())
+ changer_thread = Thread(target=thread_change_current, args=(command_queue,))
changer_thread.start()
if renderer_thread is None or not renderer_thread.is_alive():
print(
)
renderer_thread = Thread(target=thread_invoke_renderers, args=())
renderer_thread.start()
+ if janitor_thread is None or not janitor_thread.is_alive():
+ print(
+ f"MAIN[{utils.timestamp()}] - (Re?)initializing janitor thread... (wtf?!)"
+ )
+ janitor_thread = Thread(target=thread_janitor, args=())
+ janitor_thread.start()
time.sleep(60)