diff --git a/molecule/handlers.py b/molecule/handlers.py
index 8de8def..c7f889a 100644
--- a/molecule/handlers.py
+++ b/molecule/handlers.py
@@ -37,16 +37,16 @@ class GenericHandlerInterface:
         self.spec_name = os.path.basename(self.spec_path)
 
     def pre_run(self):
-        raise NotImplementedError("NotImplementedError: this needs to be reimplemented")
+        raise NotImplementedError("this needs to be reimplemented")
 
     def run(self):
-        raise NotImplementedError("NotImplementedError: this needs to be reimplemented")
+        raise NotImplementedError("this needs to be reimplemented")
 
     def post_run(self):
-        raise NotImplementedError("NotImplementedError: this needs to be reimplemented")
+        raise NotImplementedError("this needs to be reimplemented")
 
     def kill(self):
-        raise NotImplementedError("NotImplementedError: this needs to be reimplemented")
+        raise NotImplementedError("this needs to be reimplemented")
 
 class MirrorHandler(GenericHandlerInterface):
 
@@ -54,39 +54,70 @@ class MirrorHandler(GenericHandlerInterface):
         GenericHandlerInterface.__init__(self, *args, **kwargs)
 
     def pre_run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("MirrorHandler"),darkred(self.spec_name),_("executing pre_run"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("MirrorHandler"),darkred(self.spec_name),
+                _("executing pre_run"),
+            )
+        )
 
         # creating destination chroot dir
         self.source_dir = self.metadata['source_chroot']
-        self.dest_dir = os.path.join(self.metadata['destination_chroot'],"chroot",os.path.basename(self.source_dir))
+        self.dest_dir = os.path.join(
+            self.metadata['destination_chroot'],"chroot",
+            os.path.basename(self.source_dir)
+        )
         if not os.path.isdir(self.dest_dir):
             os.makedirs(self.dest_dir,0755)
 
         return 0
 
     def post_run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("MirrorHandler"),darkred(self.spec_name),_("executing post_run"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("MirrorHandler"),darkred(self.spec_name),
+                _("executing post_run"),
+            )
+        )
         return 0
 
     def kill(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("MirrorHandler"),darkred(self.spec_name),_("executing kill"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("MirrorHandler"),darkred(self.spec_name),
+                _("executing kill"),
+            )
+        )
         return 0
 
     def run(self):
 
-        self.Output.updateProgress("[%s|%s] %s" % (blue("MirrorHandler"),darkred(self.spec_name),_("mirroring running"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("MirrorHandler"),darkred(self.spec_name),
+                _("mirroring running"),
+            )
+        )
         # running sync
         args = [self.Config['mirror_syncer']]
         args.extend(self.Config['mirror_syncer_builtin_args'])
         args.extend(self.metadata.get('extra_rsync_parameters',[]))
         args.extend([self.source_dir+"/*",self.dest_dir])
-        self.Output.updateProgress("[%s|%s] %s: %s" % (blue("MirrorHandler"),darkred(self.spec_name),_("spawning"),args,))
+        self.Output.updateProgress("[%s|%s] %s: %s" % (
+                blue("MirrorHandler"),darkred(self.spec_name),
+                _("spawning"),args,
+            )
+        )
         rc = molecule.utils.exec_cmd(args)
         if rc != 0:
-            self.Output.updateProgress("[%s|%s] %s: %s" % (blue("MirrorHandler"),darkred(self.spec_name),_("mirroring failed"),rc,))
+            self.Output.updateProgress("[%s|%s] %s: %s" % (
+                    blue("MirrorHandler"),darkred(self.spec_name),
+                    _("mirroring failed"),rc,
+                )
+            )
             return rc
 
-        self.Output.updateProgress("[%s|%s] %s" % (blue("MirrorHandler"),darkred(self.spec_name),_("mirroring completed successfully"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("MirrorHandler"),darkred(self.spec_name),
+                _("mirroring completed successfully"),
+            )
+        )
         return 0
 
 class ChrootHandler(GenericHandlerInterface):
@@ -95,20 +126,36 @@ class ChrootHandler(GenericHandlerInterface):
         GenericHandlerInterface.__init__(self, *args, **kwargs)
 
     def pre_run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("executing pre_run"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("ChrootHandler"),darkred(self.spec_name),
+                _("executing pre_run"),
+            )
+        )
         self.source_dir = self.metadata['source_chroot']
-        self.dest_dir = os.path.join(self.metadata['destination_chroot'],"chroot",os.path.basename(self.source_dir))
+        self.dest_dir = os.path.join(
+            self.metadata['destination_chroot'],"chroot",
+            os.path.basename(self.source_dir)
+        )
         return 0
 
     def post_run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("executing post_run"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("ChrootHandler"),darkred(self.spec_name),
+                _("executing post_run"),
+            )
+        )
 
         # write release file
         release_file = self.metadata.get('release_file')
         if release_file:
             release_file = os.path.join(self.dest_dir,release_file)
             if os.path.lexists(release_file) and not os.path.isfile(release_file):
-                self.Output.updateProgress("[%s|%s] %s: %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("release file creation failed, not a file"),release_file,))
+                self.Output.updateProgress("[%s|%s] %s: %s" % (
+                        blue("ChrootHandler"),darkred(self.spec_name),
+                        _("release file creation failed, not a file"),
+                        release_file,
+                    )
+                )
                 return 1
             release_string = self.metadata.get('release_string','')
             release_version = self.metadata.get('release_version','')
@@ -120,18 +167,31 @@ class ChrootHandler(GenericHandlerInterface):
                 f.flush()
                 f.close()
             except (IOError,OSError,), e:
-                self.Output.updateProgress("[%s|%s] %s: %s: %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("release file creation failed, system error"),release_file,e,))
+                self.Output.updateProgress("[%s|%s] %s: %s: %s" % (
+                        blue("ChrootHandler"),darkred(self.spec_name),
+                        _("release file creation failed, system error"),
+                        release_file,e,
+                    )
+                )
                 return 1
 
         return 0
 
     def kill(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("executing kill"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("ChrootHandler"),
+                darkred(self.spec_name),_("executing kill"),
+            )
+        )
         return 0
 
     def run(self):
 
-        self.Output.updateProgress("[%s|%s] %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("hooks running"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("ChrootHandler"),darkred(self.spec_name),
+                _("hooks running"),
+            )
+        )
 
         # run inner chroot script
         exec_script = self.metadata.get('inner_chroot_script')
@@ -149,24 +209,40 @@ class ChrootHandler(GenericHandlerInterface):
                     dest_exec = "/%s" % (dest_exec,)
                 rc = molecule.utils.exec_chroot_cmd([dest_exec], self.dest_dir, self.metadata.get('prechroot',[]))
                 if rc != 0:
-                    self.Output.updateProgress("[%s|%s] %s: %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("inner chroot hook failed"),rc,))
+                    self.Output.updateProgress("[%s|%s] %s: %s" % (
+                            blue("ChrootHandler"),darkred(self.spec_name),
+                            _("inner chroot hook failed"),rc,
+                        )
+                    )
                     return rc
 
         # run outer chroot script
         exec_script = self.metadata.get('outer_chroot_script')
         if exec_script:
             os.environ['CHROOT_DIR'] = self.source_dir
-            self.Output.updateProgress("[%s|%s] %s: %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("spawning"),[exec_script],))
+            self.Output.updateProgress("[%s|%s] %s: %s" % (
+                    blue("ChrootHandler"),darkred(self.spec_name),
+                    _("spawning"),[exec_script],
+                )
+            )
             rc = molecule.utils.exec_cmd([exec_script])
             if rc != 0:
-                self.Output.updateProgress("[%s|%s] %s: %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("outer chroot hook failed"),rc,))
+                self.Output.updateProgress("[%s|%s] %s: %s" % (
+                        blue("ChrootHandler"),darkred(self.spec_name),
+                        _("outer chroot hook failed"),rc,
+                    )
+                )
                 return rc
 
         # now remove paths to empty
         empty_paths = self.metadata.get('paths_to_empty',[])
         for mypath in empty_paths:
             mypath = self.dest_dir+mypath
-            self.Output.updateProgress("[%s|%s] %s: %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("emptying dir"),mypath,))
+            self.Output.updateProgress("[%s|%s] %s: %s" % (
+                    blue("ChrootHandler"),darkred(self.spec_name),
+                    _("emptying dir"),mypath,
+                )
+            )
             if os.path.isdir(mypath):
                 molecule.utils.empty_dir(mypath)
 
@@ -174,13 +250,25 @@ class ChrootHandler(GenericHandlerInterface):
         remove_paths = self.metadata.get('paths_to_remove',[])
         for mypath in remove_paths:
             mypath = self.dest_dir+mypath
-            self.Output.updateProgress("[%s|%s] %s: %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("removing dir"),mypath,))
+            self.Output.updateProgress("[%s|%s] %s: %s" % (
+                    blue("ChrootHandler"),darkred(self.spec_name),
+                    _("removing dir"),mypath,
+                )
+            )
             rc = molecule.utils.remove_path(mypath)
             if rc != 0:
-                self.Output.updateProgress("[%s|%s] %s: %s: %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("removal failed for"),mypath,rc,))
+                self.Output.updateProgress("[%s|%s] %s: %s: %s" % (
+                        blue("ChrootHandler"),darkred(self.spec_name),
+                        _("removal failed for"),mypath,rc,
+                    )
+                )
                 return rc
 
-        self.Output.updateProgress("[%s|%s] %s" % (blue("ChrootHandler"),darkred(self.spec_name),_("hooks completed succesfully"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("ChrootHandler"),darkred(self.spec_name),
+                _("hooks completed succesfully"),
+            )
+        )
         return 0
 
 class CdrootHandler(GenericHandlerInterface):
@@ -189,11 +277,25 @@ class CdrootHandler(GenericHandlerInterface):
         GenericHandlerInterface.__init__(self, *args, **kwargs)
 
     def pre_run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("CdrootHandler"),darkred(self.spec_name),_("executing pre_run"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("CdrootHandler"),darkred(self.spec_name),
+                _("executing pre_run"),
+            )
+        )
 
-        self.Output.updateProgress("[%s|%s] %s" % (blue("CdrootHandler"),darkred(self.spec_name),_("preparing environment"),))
-        self.source_chroot = os.path.join(self.metadata['destination_chroot'],"chroot",os.path.basename(self.metadata['source_chroot']))
-        self.dest_root = os.path.join(self.metadata['destination_livecd_root'],"livecd",os.path.basename(self.metadata['source_chroot']))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("CdrootHandler"),darkred(self.spec_name),
+                _("preparing environment"),
+            )
+        )
+        self.source_chroot = os.path.join(
+            self.metadata['destination_chroot'],"chroot",
+            os.path.basename(self.metadata['source_chroot'])
+        )
+        self.dest_root = os.path.join(
+            self.metadata['destination_livecd_root'],"livecd",
+            os.path.basename(self.metadata['source_chroot'])
+        )
         if os.path.isdir(self.dest_root):
             molecule.utils.empty_dir(self.dest_root)
         if not os.path.isdir(self.dest_root):
@@ -202,16 +304,28 @@ class CdrootHandler(GenericHandlerInterface):
         return 0
 
     def post_run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("CdrootHandler"),darkred(self.spec_name),_("executing post_run"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("CdrootHandler"),darkred(self.spec_name),
+                _("executing post_run"),
+            )
+        )
         return 0
 
     def kill(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("CdrootHandler"),darkred(self.spec_name),_("executing kill"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("CdrootHandler"),darkred(self.spec_name),
+                _("executing kill"),
+            )
+        )
         return 0
 
     def run(self):
 
-        self.Output.updateProgress("[%s|%s] %s" % (blue("CdrootHandler"),darkred(self.spec_name),_("compressing chroot"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("CdrootHandler"),darkred(self.spec_name),
+                _("compressing chroot"),
+            )
+        )
         args = [self.Config['chroot_compressor']]
         comp_output = self.Config['chroot_compressor_output_file']
         if "chroot_compressor_output_file" in self.metadata:
@@ -220,12 +334,24 @@ class CdrootHandler(GenericHandlerInterface):
         args.extend([self.source_chroot,comp_output])
         args.extend(self.Config['chroot_compressor_builtin_args'])
         args.extend(self.metadata.get('extra_mksquashfs_parameters',[]))
-        self.Output.updateProgress("[%s|%s] %s: %s" % (blue("CdrootHandler"),darkred(self.spec_name),_("spawning"),args,))
+        self.Output.updateProgress("[%s|%s] %s: %s" % (
+                blue("CdrootHandler"),darkred(self.spec_name),
+                _("spawning"),args,
+            )
+        )
         rc = molecule.utils.exec_cmd(args)
         if rc != 0:
-            self.Output.updateProgress("[%s|%s] %s: %s" % (blue("CdrootHandler"),darkred(self.spec_name),_("chroot compression failed"),rc,))
+            self.Output.updateProgress("[%s|%s] %s: %s" % (
+                    blue("CdrootHandler"),darkred(self.spec_name),
+                    _("chroot compression failed"),rc,
+                )
+            )
             return rc
-        self.Output.updateProgress("[%s|%s] %s" % (blue("CdrootHandler"),darkred(self.spec_name),_("chroot compressed successfully"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("CdrootHandler"),darkred(self.spec_name),
+                _("chroot compressed successfully"),
+            )
+        )
 
         # merge dir
         merge_dir = self.metadata.get('merge_livecd_root')
@@ -266,10 +392,17 @@ class IsoHandler(GenericHandlerInterface):
         GenericHandlerInterface.__init__(self, *args, **kwargs)
 
     def pre_run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("IsoHandler"),darkred(self.spec_name),_("executing pre_run"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("IsoHandler"),darkred(self.spec_name),
+                _("executing pre_run"),
+            )
+        )
 
         # setup paths
-        self.source_path = os.path.join(self.metadata['destination_livecd_root'],"livecd",os.path.basename(self.metadata['source_chroot']))
+        self.source_path = os.path.join(
+            self.metadata['destination_livecd_root'],"livecd",
+            os.path.basename(self.metadata['source_chroot'])
+        )
         dest_iso_dir = self.metadata['destination_iso_directory']
         if not os.path.isdir(dest_iso_dir):
             os.makedirs(dest_iso_dir,0755)
@@ -286,7 +419,10 @@ class IsoHandler(GenericHandlerInterface):
         self.dest_iso = os.path.join(dest_iso_dir,dest_iso_filename)
         self.iso_title = "%s %s %s" % (release_string, release_version, release_desc,)
         self.source_chroot = self.metadata['source_chroot']
-        self.chroot_dir = os.path.join(self.metadata['destination_chroot'],"chroot",os.path.basename(self.source_chroot))
+        self.chroot_dir = os.path.join(
+            self.metadata['destination_chroot'],"chroot",
+            os.path.basename(self.source_chroot)
+        )
 
         # run outer chroot script
         exec_script = self.metadata.get('pre_iso_script')
@@ -294,24 +430,44 @@ class IsoHandler(GenericHandlerInterface):
             os.environ['SOURCE_CHROOT_DIR'] = self.source_chroot
             os.environ['CHROOT_DIR'] = self.chroot_dir
             os.environ['CDROOT_DIR'] = self.source_path
-            self.Output.updateProgress("[%s|%s] %s: %s" % (blue("IsoHandler"),darkred(self.spec_name),_("spawning"),[exec_script],))
+            self.Output.updateProgress("[%s|%s] %s: %s" % (
+                    blue("IsoHandler"),darkred(self.spec_name),
+                    _("spawning"),[exec_script],
+                )
+            )
             rc = molecule.utils.exec_cmd([exec_script])
             if rc != 0:
-                self.Output.updateProgress("[%s|%s] %s: %s" % (blue("IsoHandler"),darkred(self.spec_name),_("outer chroot hook failed"),rc,))
+                self.Output.updateProgress("[%s|%s] %s: %s" % (
+                        blue("IsoHandler"),darkred(self.spec_name),
+                        _("outer chroot hook failed"),rc,
+                    )
+                )
                 return rc
 
         return 0
 
     def post_run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("IsoHandler"),darkred(self.spec_name),_("executing post_run"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("IsoHandler"),darkred(self.spec_name),
+                _("executing post_run"),
+            )
+        )
         return 0
 
     def kill(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("IsoHandler"),darkred(self.spec_name),_("executing kill"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("IsoHandler"),darkred(self.spec_name),
+                _("executing kill"),
+            )
+        )
         return 0
 
     def run(self):
-        self.Output.updateProgress("[%s|%s] %s" % (blue("IsoHandler"),darkred(self.spec_name),_("building ISO image"),))
+        self.Output.updateProgress("[%s|%s] %s" % (
+                blue("IsoHandler"),darkred(self.spec_name),
+                _("building ISO image"),
+            )
+        )
 
         args = [self.Config['iso_builder']]
         args.extend(self.Config['iso_builder_builtin_args'])
@@ -319,13 +475,25 @@ class IsoHandler(GenericHandlerInterface):
         if self.iso_title.strip():
             args.extend(["-V",'"',self.iso_title,'"'])
         args.extend(['-o',self.dest_iso,self.source_path])
-        self.Output.updateProgress("[%s|%s] %s: %s" % (blue("IsoHandler"),darkred(self.spec_name),_("spawning"),args,))
+        self.Output.updateProgress("[%s|%s] %s: %s" % (
+                blue("IsoHandler"),darkred(self.spec_name),
+                _("spawning"),args,
+            )
+        )
         rc = molecule.utils.exec_cmd(args)
         if rc != 0:
-            self.Output.updateProgress("[%s|%s] %s: %s" % (blue("IsoHandler"),darkred(self.spec_name),_("ISO image build failed"),rc,))
+            self.Output.updateProgress("[%s|%s] %s: %s" % (
+                    blue("IsoHandler"),darkred(self.spec_name),
+                    _("ISO image build failed"),rc,
+                )
+            )
             return rc
 
-        self.Output.updateProgress("[%s|%s] %s: %s" % (blue("IsoHandler"),darkred(self.spec_name),_("built ISO image"),self.dest_iso,))
+        self.Output.updateProgress("[%s|%s] %s: %s" % (
+                blue("IsoHandler"),darkred(self.spec_name),
+                _("built ISO image"),self.dest_iso,
+            )
+        )
         return 0
 
 
@@ -349,11 +517,17 @@ class Runner(GenericHandlerInterface):
         self.pre_run()
         count = 0
         maxcount = len(self.execution_order)
-        self.Output.updateProgress( "[%s|%s] %s" % (darkgreen("Runner"),brown(self.spec_name),_("preparing execution"),), count = (count,maxcount,))
+        self.Output.updateProgress( "[%s|%s] %s" % (
+            darkgreen("Runner"),brown(self.spec_name),
+            _("preparing execution"),), count = (count,maxcount,)
+        )
         for myclass in self.execution_order:
 
             count += 1
-            self.Output.updateProgress( "[%s|%s] %s %s" % (darkgreen("Runner"),brown(self.spec_name),_("executing"),str(myclass),), count = (count,maxcount,))
+            self.Output.updateProgress( "[%s|%s] %s %s" % (
+                darkgreen("Runner"),brown(self.spec_name),_("executing"),
+                str(myclass),), count = (count,maxcount,)
+            )
             my = myclass(self.spec_path, self.metadata)
 
             rc = 0
@@ -373,5 +547,9 @@ class Runner(GenericHandlerInterface):
             if rc: return rc
 
         self.post_run()
-        self.Output.updateProgress( "[%s|%s] %s" % (darkgreen("Runner"),brown(self.spec_name),_("All done"),))
+        self.Output.updateProgress( "[%s|%s] %s" % (
+                darkgreen("Runner"),brown(self.spec_name),
+                _("All done"),
+            )
+        )
         return 0