5ff6e1ce67d9fd7dd03d4604565ba092f85a6e2a
[kiosk.git] / kiosk.py
1 #!/usr/bin/env python3
2
3 import collections
4 from datetime import datetime
5 from difflib import SequenceMatcher
6 import gc
7 import logging
8 import os
9 import re
10 from threading import Thread
11 import time
12 import tracemalloc
13 from typing import Dict, List, Optional, Tuple
14 from queue import Queue
15
16 import astral  # type: ignore
17 from astral.sun import sun  # type: ignore
18 import numpy as np
19 import pvporcupine
20 import pytz
21
22 from pyutils import (
23     bootstrap,
24     config,
25 )
26 from pyutils.datetimes import datetime_utils
27 from pyutils.files import file_utils
28
29 import kiosk_constants
30 import file_writer
31 import renderer_catalog
32 import chooser
33 import listen
34 import trigger_catalog
35
36
37 cfg = config.add_commandline_args(
38     f"Kiosk Server ({__file__})", "A python server that runs a kiosk."
39 )
40 logger = logging.getLogger(__file__)
41
42
43 def thread_janitor() -> None:
44     tracemalloc.start()
45     tracemalloc_target = 0.0
46     gc_target = 0.0
47     gc.enable()
48
49     # Main janitor loop; dump the largest pigs and force regular gcs.
50     while True:
51         now = time.time()
52         if now > tracemalloc_target:
53             tracemalloc_target = now + 30.0
54             snapshot = tracemalloc.take_snapshot()
55             snapshot = snapshot.filter_traces(
56                 (
57                     tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
58                     tracemalloc.Filter(False, "<unknown>"),
59                 )
60             )
61             key_type = "lineno"
62             limit = 10
63             top_stats = snapshot.statistics(key_type)
64             logger.info(f"janitor: Top {limit} lines")
65             for index, stat in enumerate(top_stats[:limit], 1):
66                 frame = stat.traceback[0]
67
68                 # replace "/path/to/module/file.py" with "module/file.py"
69                 filename = os.sep.join(frame.filename.split(os.sep)[-2:])
70                 logger.info(
71                     f"janitor: #{index}: {filename}:{frame.lineno}: {stat.size / 1024:.1f} KiB"
72                 )
73
74             other = top_stats[limit:]
75             if other:
76                 size = sum(stat.size for stat in other)
77                 logger.info(f"janitor: {len(other)} others: {size/1024:.1f} KiB")
78             total = sum(stat.size for stat in top_stats)
79             logger.info(f"janitor: Total allocated size: {total / 1024:.1f} KiB")
80         if now > gc_target:
81             logger.info("janitor: kicking off a manual gc operation now.")
82             gc.collect()
83             gc_target = now + 120.0
84         time.sleep(30.0)
85
86
87 def guess_page(command: str, page_chooser: chooser.chooser) -> str:
88     def normalize_page(page: str) -> str:
89         logger.debug(f"normalize_page input: {page}")
90         page = page.replace("(", " ")
91         page = page.replace("_", " ")
92         page = page.replace(")", " ")
93         page = page.replace(".html", "")
94         page = page.replace("CNNNews", "news")
95         page = page.replace("CNNTechnology", "technology")
96         page = page.replace("gocostco", "costco list")
97         page = page.replace("gohardware", "hardware list")
98         page = page.replace("gohouse", "house list honey do")
99         page = page.replace("gcal", "google calendar events")
100         page = page.replace("mynorthwest", "northwest news")
101         page = page.replace("myq", "myq garage door status")
102         page = page.replace("gomenu", "dinner menu")
103         page = page.replace("gmaps-seattle-unwrapped", "traffic")
104         page = page.replace("gomenu", "dinner menu")
105         page = page.replace("WSJNews", "news")
106         page = page.replace("telma", "telma cabin")
107         page = page.replace("WSJBusiness", "business news")
108         page = re.sub(r"[0-9]+", "", page)
109         logger.debug(f"normalize_page output: {page}")
110         return page
111
112     logger.info(f"No exact match for f{command}; trying to guess...")
113     best_page = None
114     best_score = None
115     for page in page_chooser.get_page_list():
116         npage = normalize_page(page)
117         score = SequenceMatcher(None, command, npage).ratio()
118         if best_score is None or score > best_score:
119             best_page = page
120             best_score = score
121     assert best_page is not None
122     logger.info(f"Best guess for f{command} => {best_page} (score = {best_score})")
123     return best_page
124
125
126 def process_command(
127     command: str, page_history: List[str], page_chooser
128 ) -> Optional[str]:
129     command = command.lower()
130     logger.info(f"Parsing verbal command: {command}")
131     page = None
132     if "hold" in command:
133         page = page_history[0]
134     elif "down" in command:
135         os.system(
136             'xdotool search --onlyvisible "chrom" windowactivate click --repeat 8 5'
137         )
138         return None
139     elif "up" in command:
140         os.system(
141             'xdotool search --onlyvisible "chrom" windowactivate click --repeat 8 4'
142         )
143         return None
144     elif "back" in command:
145         page = page_history[1]
146     elif "skip" in command:
147         while True:
148             (page, _) = page_chooser.choose_next_page()
149             if page == page_history[0]:
150                 logger.debug(f"chooser: {page} is the same as last time!  Try again.")
151             else:
152                 break
153     elif "internal" in command:
154         if "render" in command:
155             page = kiosk_constants.render_stats_pagename
156         else:
157             page = kiosk_constants.render_stats_pagename
158     elif "weather" in command:
159         if "telma" in command or "cabin" in command:
160             page = "weather-telma_3_10800.html"
161         elif "stevens" in command:
162             page = "weather-stevens_3_10800.html"
163         else:
164             page = "weather-home_3_10800.html"
165     elif "cabin" in command:
166         if "list" in command:
167             page = "Cabin-(gocabin)_2_3600.html"
168         else:
169             page = "hidden/cabin_driveway.html"
170     elif "news" in command or "headlines" in command:
171         page = "cnn-CNNNews_4_25900.html"
172     elif "clock" in command or "time" in command:
173         page = "clock_10_none.html"
174     elif "countdown" in command or "countdowns" in command:
175         page = "countdown_3_7200.html"
176     elif "costco" in command:
177         page = "Costco-(gocostco)_2_3600.html"
178     elif "calendar" in command or "events" in command:
179         page = "gcal_3_86400.html"
180     elif "countdown" in command or "countdowns" in command:
181         page = "countdown_3_7200.html"
182     elif "grocery" in command or "groceries" in command:
183         page = "Grocery-(gogrocery)_2_3600.html"
184     elif "hardware" in command:
185         page = "Hardware-(gohardware)_2_3600.html"
186     elif "garage" in command:
187         page = "myq_4_300.html"
188     elif "menu" in command:
189         page = "Menu-(gomenu)_2_3600.html"
190     elif "cron" in command or "health" in command:
191         page = "periodic-health_6_300.html"
192     elif "photo" in command or "picture" in command:
193         page = "photo_23_3600.html"
194     elif "quote" in command or "quotation" in command or "quotes" in command:
195         page = "quotes_4_10800.html"
196     elif "stevens" in command:
197         page = "stevens-conditions_1_86400.html"
198     elif "stock" in command or "stocks" in command:
199         page = "stock_3_86400.html"
200     elif "twitter" in command:
201         page = "twitter_10_3600.html"
202     elif "traffic" in command:
203         page = "gmaps-seattle-unwrapped_5_none.html"
204     elif "front" in command and "door" in command:
205         page = "hidden/frontdoor.html"
206     elif "driveway" in command:
207         page = "hidden/driveway.html"
208     elif "backyard" in command:
209         page = "hidden/backyard.html"
210     else:
211         page = guess_page(command, page_chooser)
212     assert page is not None
213     logger.info(f"Parsed to {page}")
214     return page
215
216
217 def thread_change_current(command_queue: Queue) -> None:
218     page_history = ["", ""]
219     swap_page_target = 0.0
220
221     def filter_news_during_dinnertime(page: str) -> bool:
222         now = datetime.now(tz=pytz.timezone("US/Pacific"))
223         is_dinnertime = now.hour >= 18 and now.hour <= 20
224         return not is_dinnertime or not (
225             "cnn" in page
226             or "news" in page
227             or "mynorthwest" in page
228             or "seattle" in page
229             or "wsj" in page
230         )
231
232     def check_for_command() -> Tuple[Optional[str], Optional[str]]:
233         command = None
234         try:
235             command = command_queue.get(block=False)
236         except Exception:
237             command = None
238
239         if command:
240             logger.info(
241                 f'chooser: We got a verbal command ("{command}"), parsing it...'
242             )
243             page = process_command(command, page_history, page_chooser)
244             if page:
245                 return page, command
246         return None, None
247
248     def choose_page_randomly() -> Tuple[str, bool]:
249         while True:
250             (page, triggered) = page_chooser.choose_next_page()
251             if triggered:
252                 logger.info("chooser: A trigger is active...")
253                 break
254             else:
255                 if page == page_history[0]:
256                     logger.debug(
257                         f"chooser: {page} is the same as last time! Try again."
258                     )
259                 else:
260                     break
261         return (page, triggered)
262
263     page_chooser = chooser.weighted_random_chooser_with_triggers(
264         trigger_catalog.get_triggers(), [filter_news_during_dinnertime]
265     )
266     current_file = os.path.join(kiosk_constants.pages_dir, "current.shtml")
267     emergency_file = os.path.join(kiosk_constants.pages_dir, "reload_immediately.html")
268
269     # Main chooser loop -- note that this executes a couple of times per second
270     # to be responsive to triggers.
271     while True:
272         now = time.time()
273         page = None
274         triggered = False
275         command = None
276
277         # Is there a verbal command to parse?
278         (page, command) = check_for_command()
279         if page and command:
280             triggered = True
281         else:
282             # If not, choose the a (new!) page randomly or respond to a trigger.
283             (page, triggered) = choose_page_randomly()
284
285         # By now we have a page and we may be triggered.
286         if triggered:
287
288             # If we are triggered and the page is new, change the
289             # current page to the new page immediately.
290             if page != page_history[0]:
291                 logger.info(
292                     f"chooser: An emergency page reload to {page} is needed at this time."
293                 )
294                 swap_page_target = now + kiosk_constants.emergency_refresh_period_sec
295
296                 # Set current.shtml to the triggered page.
297                 try:
298                     with open(current_file, "w") as f:
299                         emit(
300                             f,
301                             page,
302                             override_refresh_sec=kiosk_constants.emergency_refresh_period_sec,
303                             command=command,
304                         )
305                     logger.debug(f"chooser: Wrote {current_file}.")
306                 except Exception:
307                     logger.exception(
308                         f"chooser: Unexpected exception; assuming {page} doesn't exist?!"
309                     )
310                     continue
311
312                 # Notify XMLHTTP clients that they need to refresh now.
313                 with open(emergency_file, "w") as f:
314                     f.write(f"Reload, suckers... you HAVE to see {page}!")
315                 logger.debug(f"chooser: Wrote {emergency_file}...")
316
317                 # Fix this hack... maybe read the webserver logs and see if it
318                 # actually was picked up?
319                 time.sleep(0.999)
320                 os.remove(emergency_file)
321                 logger.debug(f"chooser: ...and removed {emergency_file}.")
322                 page_history.insert(0, page)
323                 page_history = page_history[0:10]
324
325         # If we're not triggered, only render a new page if time has expired.
326         elif now >= swap_page_target:
327             logger.info(f"chooser: Nominal choice of {page} as the next to show.")
328             swap_page_target = now + kiosk_constants.refresh_period_sec
329             try:
330                 with open(current_file, "w") as f:
331                     emit(f, page)
332                 logger.debug(f"chooser: Wrote {current_file}.")
333             except Exception:
334                 logger.exception(
335                     f"chooser: Unexpected exception; assuming {page} doesn't exist?!"
336                 )
337                 continue
338             page_history.insert(0, page)
339             page_history = page_history[0:10]
340
341         time.sleep(0.5)
342
343
344 def emit(f, filename: str, *, override_refresh_sec: int = None, command: str = None):
345     if "unwrapped" not in filename:
346         logger.debug(f"Emitting {filename} wrapped.")
347         emit_wrapped(
348             f, filename, override_refresh_sec=override_refresh_sec, command=command
349         )
350     else:
351         logger.debug(f"Emitting {filename} raw.")
352         emit_raw(f, filename)
353
354
355 def emit_raw(f, filename: str):
356     f.write(f'<!--#include virtual="{filename}"-->')
357
358
359 def emit_wrapped(
360     f, filename: str, *, override_refresh_sec: int = None, command: str = None
361 ) -> None:
362     def pick_background_color() -> str:
363         now = datetime_utils.now_pacific()
364         city = astral.LocationInfo("Bellevue", "USA", "US/Pacific", 47.610, -122.201)
365         s = sun(city.observer, date=now, tzinfo=pytz.timezone("US/Pacific"))
366         sunrise_mod = datetime_utils.minute_number(
367             s["sunrise"].hour, s["sunrise"].minute
368         )
369         sunset_mod = datetime_utils.minute_number(s["sunset"].hour, s["sunset"].minute)
370         now_mod = datetime_utils.minute_number(now.hour, now.minute)
371         if now_mod < sunrise_mod or now_mod > (sunset_mod + 45):
372             return "E6B8B8"
373         elif now_mod < (sunrise_mod + 45) or now_mod > (sunset_mod + 120):
374             return "EECDCD"
375         else:
376             return "FFFFFF"
377
378     def get_refresh_period() -> float:
379         if override_refresh_sec is not None:
380             return float(override_refresh_sec * 1000.0)
381         now = datetime.now(tz=pytz.timezone("US/Pacific"))
382         if now.hour < 6:
383             return float(kiosk_constants.refresh_period_night_sec * 1000.0)
384         else:
385             return float(kiosk_constants.refresh_period_sec * 1000.0)
386
387     age = file_utils.describe_file_ctime(f"pages/{filename}")
388     bgcolor = pick_background_color()
389     if command is None:
390         pageid = filename
391     else:
392         pageid = f'"{command}" -> {filename}'
393
394     f.write(
395         """
396 <HEAD>
397   <TITLE>Kitchen Kiosk</TITLE>
398   <LINK rel="stylesheet" type="text/css" href="style.css">
399   <meta name="google" content="notranslate">
400   <SCRIPT TYPE="text/javascript">
401
402   // Zoom the 'contents' div to fit without scrollbars and then make
403   // it visible.
404   function zoomScreen() {
405     z = 285;
406     do {
407       document.getElementById("content").style.zoom = z+"%";
408       var body = document.body;
409       var html = document.documentElement;
410       var height = Math.max(body.scrollHeight,
411                             body.offsetHeight,
412                             html.clientHeight,
413                             html.scrollHeight,
414                             html.offsetHeight);
415       var windowHeight = window.innerHeight;
416       var width = Math.max(body.scrollWidth,
417                            body.offsetWidth,
418                            html.clientWidth,
419                            html.scrollWidth,
420                            html.offsetWidth);
421       var windowWidth = window.innerWidth;
422       var heightRatio = height / windowHeight;
423       var widthRatio = width / windowWidth;
424
425       if (heightRatio <= 1.0 && widthRatio <= 1.0) {
426         break;
427       }
428       z -= 4;
429     } while(z >= 70);
430     document.getElementById("content").style.visibility = "visible";
431   }
432
433   // Load IMG tags with DATA-SRC attributes late.
434   function lateLoadImages() {
435     var image = document.getElementsByTagName('img');
436     for (var i = 0; i < image.length; i++) {
437       if (image[i].getAttribute('DATA-SRC')) {
438         image[i].setAttribute('SRC', image[i].getAttribute('DATA-SRC'));
439       }
440     }
441   }
442 """
443     )
444     f.write(
445         """
446   // Operate the clock at the top of the page.
447   function runClock() {
448     var today = new Date();
449     var h = today.getHours();
450     var ampm = h >= 12 ? 'pm' : 'am';
451     h = h %% 12;
452     h = h ? h : 12; // the hour '0' should be '12'
453     var m = maybeAddZero(today.getMinutes());
454     var colon = ":";
455     if (today.getSeconds() %% 2 == 0) {
456       colon = "<FONT STYLE='color: #%s; font-size: 4vmin; font-weight: bold'>:</FONT>";
457     }
458     document.getElementById("time").innerHTML = h + colon + m + ampm;
459     document.getElementById("date").innerHTML = today.toDateString();
460     var t = setTimeout(function(){runClock()}, 1000);
461   }
462 """
463         % bgcolor
464     )
465     f.write(
466         """
467   // Helper method for running the clock.
468   function maybeAddZero(x) {
469     return (x < 10) ? "0" + x : x;
470   }
471
472   // Do something on page load.
473   function addLoadEvent(func) {
474     var oldonload = window.onload;
475     if (typeof window.onload != 'function') {
476       window.onload = func;
477     } else {
478       window.onload = function() {
479         if (oldonload) {
480           oldonload();
481         }
482         func();
483       }
484     }
485   }
486
487   // Sleep thread helper.
488   const sleep = (milliseconds) => {
489     return new Promise(resolve => setTimeout(resolve, milliseconds))
490   }
491
492   var loadedDate = new Date();
493
494   addLoadEvent(zoomScreen);
495   addLoadEvent(runClock);
496   addLoadEvent(lateLoadImages);
497 """
498     )
499     f.write(
500         """
501   // Runs the countdown line at the bottom and is responsible for
502   // normal page reloads caused by the expiration of a timer.
503   (function countdown() {
504     setTimeout(
505       function() {
506         var now = new Date();
507         var deltaMs = now.getTime() - loadedDate.getTime();
508         var totalMs = %d;
509         var remainingMs = (totalMs - deltaMs);
510
511         if (remainingMs > 0) {
512           var hr = document.getElementById("countdown");
513           var width = (remainingMs / (totalMs - 5000)) * 100.0;
514           if (width <= 100) {
515             hr.style.visibility = "visible";
516             hr.style.width = " ".concat(width, "%%");
517             hr.style.backgroundColor = "maroon";
518           }
519         } else {
520           // Reload unconditionally after 22 sec.
521           window.location.reload(true);
522         }
523
524         // Brief sleep before doing it all over again.
525         sleep(50).then(() => {
526           countdown();
527         });
528       }, 50)
529   })();
530 """
531         % get_refresh_period()
532     )
533     f.write(
534         """
535   function check_reload() {
536     var xhr = new XMLHttpRequest();
537     xhr.open('GET',
538              '%s/reload_immediately.html');
539     xhr.onload =
540       function() {
541         if (xhr.status === 200) {
542           window.location.reload(true);
543         }
544       };
545     xhr.send();
546   }
547
548   // Periodically checks for emergency reload events.
549   setInterval(check_reload, 500);
550   </SCRIPT>
551 </HEAD>
552 """
553         % kiosk_constants.root_url
554     )
555     f.write(f'<BODY BGCOLOR="#{bgcolor}">')
556     f.write(
557         """
558     <TABLE style="height:100%; width:100%" BORDER=0>
559     <TR HEIGHT=30>
560         <TD ALIGN="left">
561             <DIV id="date">&nbsp;</DIV>
562         </TD>
563         <TD ALIGN="center"><FONT COLOR=#bbbbbb>
564             <DIV id="info"></DIV></FONT>
565         </TD>
566         <TD ALIGN="right">
567             <DIV id="time">&nbsp;</DIV>
568         </TD>
569     </TR>
570     <TR STYLE="vertical-align:top">
571         <TD COLSPAN=3>
572             <DIV ID="content" STYLE="zoom: 1; visibility: hidden;">
573               <!-- BEGIN main page contents. -->
574 """
575     )
576     f.write(f'<!--#include virtual="{filename}"-->')
577     f.write(
578         """
579             <!-- END main page contents. -->
580             </DIV>
581             <BR>
582             <DIV STYLE="position: absolute; top:1030px; width:99%">
583             <P ALIGN="right">
584 """
585     )
586     f.write(f"<FONT SIZE=2 COLOR=#bbbbbb>{pageid} @ {age} ago.</FONT>")
587     f.write(
588         """
589             </P>
590             <HR id="countdown" STYLE="width:0px;
591                                       text-align:left;
592                                       margin:0;
593                                       border:none;
594                                       border-width:0;
595                                       height:5px;
596                                       visibility:hidden;
597                                       background-color:#ffffff;">
598             </DIV>
599         </TD>
600     </TR>
601     </TABLE>
602 </BODY>"""
603     )
604
605
606 def renderer_update_internal_stats_page(
607     last_render: Dict[str, datetime],
608     render_counts: collections.Counter,
609     render_times: Dict[str, np.array],
610 ) -> None:
611     logger.info("renderer: Updating internal render statistics page.")
612     with file_writer.file_writer(kiosk_constants.render_stats_pagename) as f:
613         f.write(
614             """
615 <CENTER>
616 <TABLE BORDER=0 WIDTH=95%>
617     <TR>
618     <TH><B>Renderer Name</B></TH>
619     <TH><B>Last Run</B></TH>
620     <TH><B>Num Invocations</B></TH>
621     <TH><B>Render Latency</B></TH>
622     </TR>
623 """
624         )
625         for n, r in enumerate(renderer_catalog.get_renderers()):
626             if n % 2 == 0:
627                 style = 'style="margin: 0; padding: 0; background: #c6b0b0;"'
628             else:
629                 style = 'style="margin: 0; padding: 0; background: #eeeeee;"'
630             name = r.get_name()
631             last = last_render.get(name, None)
632             if last is None:
633                 last = "never"
634             else:
635                 last = last.strftime("%Y/%m/%d %I:%M:%S%P")
636             count = render_counts.get(name, 0)
637             latency = render_times.get(name, np.array([]))
638             p25 = p50 = p75 = p90 = p99 = "N/A"
639             try:
640                 p25 = np.percentile(latency, 25)
641                 p50 = np.percentile(latency, 50)
642                 p75 = np.percentile(latency, 75)
643                 p90 = np.percentile(latency, 90)
644                 p99 = np.percentile(latency, 99)
645                 f.write(
646                     f"""
647     <TR>
648     <TD {style}>{name}&nbsp;</TD>
649     <TD {style}>&nbsp;{last}&nbsp;</TD>
650     <TD {style}><CENTER>&nbsp;{count}&nbsp;</CENTER></TD>
651     <TD {style}>&nbsp;p25={p25:5.2f}, p50={p50:5.2f}, p75={p75:5.2f}, p90={p90:5.2f}, p99={p99:5.2f}</TD>
652     </TR>
653 """
654                 )
655             except IndexError:
656                 pass
657         f.write("</TABLE>")
658
659
660 def thread_invoke_renderers() -> None:
661     render_times: Dict[str, np.array] = {}
662     render_counts: collections.Counter = collections.Counter()
663     last_render: Dict[str, datetime] = {}
664
665     # Touch the internal render page now to signal that we're alive.
666     renderer_update_internal_stats_page(last_render, render_counts, render_times)
667
668     # Main renderer loop
669     while True:
670         logger.info("renderer: invoking all overdue renderers in catalog...")
671         for r in renderer_catalog.get_renderers():
672             name = r.get_name()
673             now = time.time()
674             logger.info(f"renderer: Invoking {name}'s render method.")
675             try:
676                 r.render()
677             except Exception as e:
678                 logger.exception(e)
679                 logger.error(
680                     f"renderer: Unexpected and unhandled exception ({e}) in {name}, swallowing it."
681                 )
682                 continue
683
684             # Increment the count of render operations per renderer.
685             render_counts[name] += 1
686
687             # Keep track of the last time we invoked each renderer.
688             last_render[name] = datetime_utils.now_pacific()
689
690             # Record how long each render operation takes and warn if very long.
691             delta = time.time() - now
692             times = render_times.get(name, np.array([]))
693             times = np.insert(times, 0, delta)
694             render_times[name] = times
695             if delta > 1.0:
696                 hdr = "renderer: "
697                 logger.warning(
698                     f"""
699 {hdr} Warning: {name}'s rendering took {delta:5.2f}s.
700 {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}
701 """
702                 )
703
704         # Update a page about internal stats of renderers.
705         renderer_update_internal_stats_page(last_render, render_counts, render_times)
706         logger.info("renderer: having a little nap...")
707         time.sleep(kiosk_constants.render_period_sec)
708
709
710 @bootstrap.initialize
711 def main() -> None:
712     command_queue: Queue = Queue()
713     changer_thread: Optional[Thread] = None
714     renderer_thread: Optional[Thread] = None
715     janitor_thread: Optional[Thread] = None
716     hotword_thread: Optional[Thread] = None
717     while True:
718         if hotword_thread is None or not hotword_thread.is_alive():
719             if hotword_thread is None:
720                 logger.info("watchdog: Starting up the hotword detector thread...")
721             else:
722                 logger.warning(
723                     "watchdog: The hotword detector thread seems to have died; restarting it and hoping for the best."
724                 )
725             keyword_paths = [pvporcupine.KEYWORD_PATHS[x] for x in ["bumblebee"]]
726             sensitivities = [0.7] * len(keyword_paths)
727             listener = listen.HotwordListener(
728                 command_queue,
729                 keyword_paths,
730                 sensitivities,
731             )
732             hotword_thread = Thread(target=listener.listen_forever, args=())
733             hotword_thread.start()
734
735         if changer_thread is None or not changer_thread.is_alive():
736             if changer_thread is None:
737                 logger.info("watchdog: Starting up the current page changer thread...")
738             else:
739                 logger.warning(
740                     "watchdog: The current page changer thread seems to have died; restarting it and hoping for the best."
741                 )
742             changer_thread = Thread(target=thread_change_current, args=(command_queue,))
743             changer_thread.start()
744
745         if renderer_thread is None or not renderer_thread.is_alive():
746             if renderer_thread is None:
747                 logger.info("watchdog: Starting up the page renderer thread...")
748             else:
749                 logger.warning(
750                     "watchdog: The page renderer thread seems to have died; restarting it and hoping for the best."
751                 )
752             renderer_thread = Thread(target=thread_invoke_renderers, args=())
753             renderer_thread.start()
754
755         if janitor_thread is None or not janitor_thread.is_alive():
756             if janitor_thread is None:
757                 logger.info("watchdog: Starting up the memory janitor thread...")
758             else:
759                 logger.warning(
760                     "watchdog: The memory janitor thread seems to have died; restarting it and hoping for the best."
761                 )
762             janitor_thread = Thread(target=thread_janitor, args=())
763             janitor_thread.start()
764
765         # Have a little break and then check to make sure all threads are still alive.
766         logger.debug("watchdog: having a little nap.")
767         time.sleep(kiosk_constants.check_threads_period_sec)
768
769
770 if __name__ == "__main__":
771     main()