X-Git-Url: https://wannabe.guru.org/gitweb/?a=blobdiff_plain;f=kiosk.py;h=bd7137335ea25e5dbae0d8f39a9226c53c9bb19a;hb=7eae23537dcc61565a24d5c957d4325b7337b63a;hp=ffcd7863d1a75f0a9bb67cacc3b0ace27a083322;hpb=e4dca16bbd329afdb587e8488767d88e17777254;p=kiosk.git

diff --git a/kiosk.py b/kiosk.py
index ffcd786..bd71373 100755
--- a/kiosk.py
+++ b/kiosk.py
@@ -1,111 +1,309 @@
 #!/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">
@@ -116,7 +314,7 @@ def emit_wrapped(f, filename) -> None:
   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,
@@ -151,7 +349,9 @@ def emit_wrapped(f, filename) -> None:
       }
     }
   }
-
+""")
+    f.write(
+"""
   // Operate the clock at the top of the page.
   function runClock() {
     var today = new Date();
@@ -168,7 +368,9 @@ def emit_wrapped(f, filename) -> None:
     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;
@@ -199,7 +401,10 @@ def emit_wrapped(f, filename) -> None:
   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() {
@@ -229,14 +434,16 @@ def emit_wrapped(f, filename) -> None:
         });
       }, 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) {
@@ -250,10 +457,13 @@ def emit_wrapped(f, filename) -> None:
         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">&nbsp;</DIV>
@@ -269,13 +479,19 @@ def emit_wrapped(f, filename) -> None:
         <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;
@@ -289,51 +505,124 @@ def emit_wrapped(f, filename) -> None:
         </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}&nbsp;</TD>
+    <TD {style}>&nbsp;{last}&nbsp;</TD>
+    <TD {style}><CENTER>&nbsp;{count}&nbsp;</CENTER></TD>
+    <TD {style}>&nbsp;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(
@@ -341,4 +630,10 @@ if __name__ == "__main__":
             )
             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)