Use f-strings instead of str.format

Now that I've freed myself from Pythons older than 3.6, I can use
f-strings for very clear and concise string formatting!  That's now how
it's done everywhere except one place in the shell plugin where
str.format is really the right thing to do.

kayleevc/kaylee.py

     def _log_history(self, plugin, text):
         """Log the recognized sentence to the history file"""
         if self.options['history']:
-            self.history.append("{}: {}".format(plugin.name, text))
+            self.history.append(f"{plugin.name}: {text}")
             if len(self.history) > self.options['history']:
                 # Pop off the first item
                 self.history.pop(0)
         if self.options['invalid_sentence_command']:
             subprocess.call(self.options['invalid_sentence_command'],
                             shell=True)
-        print("no matching command {0}".format(text))
+        print(f"no matching command {text}")
 
     def recognizer_finished(self, recognizer, text):
         confidence_heap = queue.PriorityQueue()

kayleevc/plugins/darksky.py

         super().__init__(config, name)
 
         self._cache_filename = os.path.join(config.cache_dir, 'darksky.json')
-        self._weather_url = 'https://api.darksky.net/forecast/{}/{},{}'.format(
-            self.options['api_key'],
-            self.options['latitude'],
-            self.options['longitude']
-        )
+
+        key = self.options['api_key']
+        lat = self.options['latitude']
+        lon = self.options['longitude']
+        self._url = f'https://api.darksky.net/forecast/{key}/{lat},{lon}'
+
         try:
             self._cache_max_age = self.options['cache_max_age']
         except KeyError:
         """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._url, self._cache_max_age,
                     self._temp_precision)
         else:
             return None
 
     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)
+        return f'{temperature:.{self._temp_precision}f} degrees {unit}'
 
     def _format_percent(self, value):
         """Format a percentage value for the TTS system"""
-        return '{:.0f} percent'.format(100 * value)
+        return f'{100*value:.0f} percent'
 
     def _format_time(self, epoch_time):
         """Format a time in seconds since the epoch for the TTS system"""
             ante_post = 'AE ' + ante_post[1]
 
         # Put the parts together
-        return '{} {} {}'.format(hour, minute, ante_post)
+        return f'{hour} {minute} {ante_post}'
 
     def __call__(self, tts):
         """Update the cache if necessary and load it"""
     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'])))
+        summary = self.cache['currently']['summary']
+        temperature = self._format_temperature(
+                self.cache['currently']['temperature'])
+        humidity = self._format_percent(self.cache['currently']['humidity'])
+        tts(f'{summary}, {temperature}, relative humidity {humidity}')
 
 
 class DarkSkySunsetHandler(DarkSkyHandler):

kayleevc/recognizer.py

 
         src = config.options.microphone
         if src:
-            audio_src = 'alsasrc device="hw:{0},0"'.format(src)
+            audio_src = f'alsasrc device="hw:{src},0"'
         else:
             audio_src = 'autoaudiosrc'
 
         # Build the pipeline
         cmd = (
-            audio_src +
-            ' ! audioconvert' +
-            ' ! audioresample' +
-            ' ! pocketsphinx lm=' + config.lang_file + ' dict=' +
-            config.dic_file +
-            ' ! appsink sync=false'
+            f'{audio_src}'
+            f' ! audioconvert'
+            f' ! audioresample'
+            f' ! pocketsphinx lm={config.lang_file} dict={config.dic_file}'
+            f' ! appsink sync=false'
         )
         try:
             self.pipeline = Gst.parse_launch(cmd)