renderer.py

   1 import time
   2 from datetime import datetime
   3
   4 class renderer(object):
   5     """Base class for something that can render."""
   6     def render(self):
   7         pass
   8
   9 class abstaining_renderer(renderer):
  10     """A renderer that doesn't do it all the time."""
  11     def __init__(self, name_to_timeout_dict):
  12         self.name_to_timeout_dict = name_to_timeout_dict;
  13         self.last_runs = {}
  14         for key in name_to_timeout_dict:
  15             self.last_runs[key] = 0
  16
  17     def should_render(self, keys_to_skip):
  18         now = time.time()
  19         for key in self.name_to_timeout_dict:
  20             if key in keys_to_skip:
  21                 continue
  22             if (now - self.last_runs[key]) > self.name_to_timeout_dict[key]:
  23                 return key
  24         return None
  25
  26     def render(self):
  27         tries = {}
  28         keys_to_skip = set()
  29         while True:
  30             key = self.should_render(keys_to_skip)
  31             if key == None:
  32                 break
  33             if key in tries:
  34                 tries[key] += 1
  35             else:
  36                 tries[key] = 0
  37
  38             if tries[key] > 5:
  39                 print(('Too many retries for "%s.%s", giving up for now' % (
  40                     key, self.__class__)))
  41                 keys_to_skip.add(key)
  42             else:
  43                 msg = 'renderer: periodic render event for "%s.%s"' % (
  44                     key, self.__class__)
  45                 if (tries[key] > 1):
  46                     msg = msg + " (try %d)" % tries[key]
  47                 print(msg)
  48                 if (self.periodic_render(key)):
  49                     self.last_runs[key] = time.time()
  50
  51     def periodic_render(self, key):
  52         pass
  53
  54 class debuggable_abstaining_renderer(abstaining_renderer):
  55     def __init__(self, name_to_timeout_dict, debug):
  56         super(debuggable_abstaining_renderer, self).__init__(name_to_timeout_dict);
  57         self.debug = debug
  58
  59     def debug_prefix(self):
  60         return "none"
  61
  62     def being_debugged(self):
  63         return self.debug
  64
  65     def debug_print(self, template, *args):
  66         try:
  67             if self.being_debugged():
  68                 if args:
  69                     msg = template.format(args)
  70                 else:
  71                     msg = template
  72
  73                 # current date and time
  74                 now = datetime.now()
  75                 timestamp = now.strftime("%d-%b-%Y (%H:%M:%S.%f)")
  76                 print("%s(%s): %s" % (self.debug_prefix(), timestamp, msg))
  77         except Exception as e:
  78             print("Exception in debug_print!")
  79             print(e)