Fix gkeep renderer's f-strings.

[kiosk.git] / renderer.py

diff --git a/renderer.py b/renderer.py
index 2be7780c1c85ec02808abea8eb55fbd00fdbea57..fa95e346ec7ceb4ffabfd1179057f9fd512bb796 100644 (file)
--- a/renderer.py
+++ b/renderer.py
@@ -1,29 +1,34 @@
-import time
+#!/usr/bin/env python3
+
+from abc import ABC, abstractmethod
 from datetime import datetime
-from decorators import invokation_logged
+from decorators import invocation_logged
+import time
+from typing import Dict, List, Set
 
 
-class renderer(object):
+class renderer(ABC):
     """Base class for something that can render."""
 
-    @invokation_logged
+    @abstractmethod
     def render(self):
         pass
 
+    @abstractmethod
     def get_name(self):
-        return self.__class__.__name__
+        pass
 
 
 class abstaining_renderer(renderer):
     """A renderer that doesn't do it all the time."""
 
-    def __init__(self, name_to_timeout_dict):
+    def __init__(self, name_to_timeout_dict: Dict[str, int]) -> None:
         self.name_to_timeout_dict = name_to_timeout_dict
         self.last_runs = {}
         for key in name_to_timeout_dict:
             self.last_runs[key] = 0
 
-    def should_render(self, keys_to_skip):
+    def should_render(self, keys_to_skip: Set[str]) -> str:
         now = time.time()
         for key in self.name_to_timeout_dict:
             if (
@@ -32,7 +37,8 @@ class abstaining_renderer(renderer):
                 return key
         return None
 
-    def render(self):
+    @invocation_logged
+    def render(self) -> None:
         tries_per_key = {}
         keys_to_skip = set()
         while True:
@@ -59,23 +65,27 @@ class abstaining_renderer(renderer):
                 if self.periodic_render(key):
                     self.last_runs[key] = time.time()
 
-    @invokation_logged
-    def periodic_render(self, key):
+    @invocation_logged
+    @abstractmethod
+    def periodic_render(self, key) -> bool:
         pass
 
+    def get_name(self) -> str:
+        return self.__class__.__name__
+
 
 class debuggable_abstaining_renderer(abstaining_renderer):
-    def __init__(self, name_to_timeout_dict, debug):
+    def __init__(self, name_to_timeout_dict: Dict[str, int], debug: bool) -> None:
         super(debuggable_abstaining_renderer, self).__init__(name_to_timeout_dict)
         self.debug = debug
 
-    def debug_prefix(self):
+    def debug_prefix(self) -> str:
         return self.get_name()
 
-    def being_debugged(self):
+    def being_debugged(self) -> bool:
         return self.debug
 
-    def debug_print(self, template, *args):
+    def debug_print(self, template: str, *args) -> None:
         try:
             if self.being_debugged():
                 if args: