Update Dark Sky plugin for new API

This one got a lot more verbose, but I like it more too.  The caching
and formatting methods were moved to a base Handler class, and
individual commands subclass this using its methods as needed.  The
"hoos your weather provider" command doesn't even update the cache
anymore, which is nice.

kayleevc/plugins/darksky.py

@@ -30,7 +30,7 @@ import time
 
 import requests
 
-from .pluginbase import PluginBase
+from . import PluginBase, Handler
 
 
 class Plugin(PluginBase):
@@ -56,51 +56,73 @@ class Plugin(PluginBase):
             self._temp_precision = 0
 
         self.commands = {
-            'whats the temperature': self._temperature,
-            'whats todays low': self._todays_low,
-            'whats todays high': self._todays_high,
-            'whats tomorrows high': self._tomorrows_high,
-            'whats the humidity': self._relative_humidity,
-            'whats the weather': self._current_conditions,
-            'whens sunset': self._sunset_time,
-            'hoos your weather provider': self._provider_credits
+            'whats the temperature': DarkSkyTemperatureHandler,
+            'whats todays high': DarkSkyTodaysHighHandler,
+            'whats todays low': DarkSkyTodaysLowHandler,
+            'whats tomorrows high': DarkSkyTomorrowsHighHandler,
+            'whats the humidity': DarkSkyHumidityHandler,
+            'whats the weather': DarkSkyCurrentConditionsHandler,
+            'whens sunset': DarkSkySunsetHandler,
+            'hoos your weather provider': DarkSkyProviderHandler
         }
 
         self.corpus_strings.update(self.commands)
 
-    def _format_temperature(self, temperature, unit='Fahrenheit'):
-        """Format a temperature for the TTS system"""
-        return '{:.{prec}f} degrees {}'.format(temperature, unit,
-                prec=self._temp_precision)
+    def get_handler(self, text):
+        """Return a handler if a recognized command is heard"""
+        if text in self.corpus_strings:
+            return self.commands[text](1, self._cache_filename,
+                    self._weather_url, self._cache_max_age,
+                    self._temp_precision)
+        else:
+            return None
 
-    def _temperature(self):
-        return self._format_temperature(self.cache['currently']['temperature'])
 
-    def _todays_low(self):
-        return self._format_temperature(
-            self.cache['daily']['data'][0]['temperatureMin'])
+class DarkSkyHandler(Handler):
+    """Base class for Dark Sky plugin handlers"""
 
-    def _todays_high(self):
-        return self._format_temperature(
-            self.cache['daily']['data'][0]['temperatureMax'])
+    def __init__(self, confidence, cache_filename, url, cache_max_age,
+            temp_precision):
+        super().__init__(confidence)
 
-    def _tomorrows_high(self):
-        return self._format_temperature(
-            self.cache['daily']['data'][1]['temperatureMax'])
+        self._cache_filename = cache_filename
+        self._url = url
+        self._cache_max_age = cache_max_age
+        self._temp_precision = temp_precision
 
-    def _relative_humidity(self):
-        return '{:.0f} percent'.format(
-            100 * self.cache['currently']['humidity'])
+    def _update_cache_if_stale(self):
+        try:
+            st = os.stat(self._cache_filename)
+        except FileNotFoundError:
+            # If there's no cache file, we need to get one
+            self._update_cache()
+        else:
+            if time.time() - st.st_mtime > self._cache_max_age:
+                self._update_cache()
 
-    def _current_conditions(self):
-        return '{}, {}, relative humidity {}'.format(
-            self.cache['currently']['summary'],
-            self._temperature(),
-            self._relative_humidity())
+    def _update_cache(self):
+        r = requests.get(self._url, stream=True)
+        if r.status_code == 200:
+            with open(self._cache_filename, 'wb') as f:
+                for chunk in r:
+                    f.write(chunk)
 
-    def _sunset_time(self):
-        # Get the time in a more useful structure
-        t = time.localtime(self.cache['daily']['data'][0]['sunsetTime'])
+    def _read_cache(self):
+        with open(self._cache_filename, 'r') as f:
+            return json.load(f)
+
+    def _format_temperature(self, temperature, unit='Fahrenheit'):
+        """Format a temperature for the TTS system"""
+        return '{:.{prec}f} degrees {}'.format(temperature, unit,
+                prec=self._temp_precision)
+
+    def _format_percent(self, value):
+        """Format a percentage value for the TTS system"""
+        return '{:.0f} percent'.format(100 * value)
+
+    def _format_time(self, epoch_time):
+        """Format a time in seconds since the epoch for the TTS system"""
+        t = time.localtime(epoch_time)
 
         # Format each part of the time to be pronounced nicely
         hour = time.strftime('%I', t)
@@ -121,41 +143,85 @@ class Plugin(PluginBase):
         # Put the parts together
         return '{} {} {}'.format(hour, minute, ante_post)
 
-    def _provider_credits(self):
-        return 'Powered by Dark Sky, https:// dark sky .net/ powered by/.'
+    def __call__(self, tts):
+        """Update the cache if necessary and load it"""
+        self._update_cache_if_stale()
+        self.cache = self._read_cache()
 
-    def _update_cache_if_stale(self):
-        try:
-            st = os.stat(self._cache_filename)
-        except FileNotFoundError:
-            # If there's no cache file, we need to get one
-            self._update_cache()
-        else:
-            if time.time() - st.st_mtime > self._cache_max_age:
-                self._update_cache()
 
-    def _update_cache(self):
-        r = requests.get(self._weather_url, stream=True)
-        if r.status_code == 200:
-            with open(self._cache_filename, 'wb') as f:
-                for chunk in r:
-                    f.write(chunk)
+class DarkSkyTemperatureHandler(DarkSkyHandler):
+    """Handler to speak the current temperature"""
 
-    def _read_cache(self):
-        with open(self._cache_filename, 'r') as f:
-            return json.load(f)
+    def __call__(self, tts):
+        """Speak the current temperature"""
+        super().__call__(tts)
+        tts(self._format_temperature(self.cache['currently']['temperature']))
 
-    def confidence(self, text):
-        """Return whether or not the command can be handled"""
-        return 1 if text in self.corpus_strings else 0
-
-    def handle(self, text):
-        """Speak reasonably up-to-date weather information"""
-        # Is there a matching command?
-        if self.confidence(text):
-            self._update_cache_if_stale()
-            self.cache = self._read_cache()
-            self.emit('tts', self.commands[text]())
-            return True
-        else:
-            return False
+
+class DarkSkyTodaysHighHandler(DarkSkyHandler):
+    """Handler to speak today's high temperature"""
+
+    def __call__(self, tts):
+        """Speak today's high"""
+        super().__call__(tts)
+        tts(self._format_temperature(
+            self.cache['daily']['data'][0]['temperatureMax']))
+
+
+class DarkSkyTodaysLowHandler(DarkSkyHandler):
+    """Handler to speak today's low temperature"""
+
+    def __call__(self, tts):
+        """Speak today's low"""
+        super().__call__(tts)
+        tts(self._format_temperature(
+            self.cache['daily']['data'][0]['temperatureMin']))
+
+
+class DarkSkyTomorrowsHighHandler(DarkSkyHandler):
+    """Handler to speak tomorrow's high temperature"""
+
+    def __call__(self, tts):
+        """Speak tomorrow's high"""
+        super().__call__(tts)
+        tts(self._format_temperature(
+            self.cache['daily']['data'][1]['temperatureMax']))
+
+
+class DarkSkyHumidityHandler(DarkSkyHandler):
+    """Handler to speak the current relative humidity"""
+
+    def __call__(self, tts):
+        """Speak the current relative humidity"""
+        super().__call__(tts)
+        tts(self._format_percent(self.cache['currently']['humidity']))
+
+
+class DarkSkyCurrentConditionsHandler(DarkSkyHandler):
+    """Handler to speak the current weather conditions"""
+
+    def __call__(self, tts):
+        """Speak the current weather conditions"""
+        super().__call__(tts)
+        tts('{}, {}, relative humidity {}'.format(
+            self.cache['currently']['summary'],
+            self._format_temperature(self.cache['currently']['temperature']),
+            self._format_percent(self.cache['currently']['humidity'])))
+
+
+class DarkSkySunsetHandler(DarkSkyHandler):
+    """Handler to speak the time of sunset"""
+
+    def __call__(self, tts):
+        """Speak the time of sunset"""
+        super().__call__(tts)
+        tts(self._format_time(self.cache['daily']['data'][0]['sunsetTime']))
+
+
+class DarkSkyProviderHandler(DarkSkyHandler):
+    """Handler to speak information about the weather provider"""
+
+    def __call__(self, tts):
+        """Speak information about the weather provider"""
+        # No need for super since this doesn't need any weather information
+        tts('Powered by Dark Sky, https:// dark sky .net/ powered by/.')