Index: libtaskotron/directives/createrepo_directive.py
===================================================================
--- libtaskotron/directives/createrepo_directive.py
+++ libtaskotron/directives/createrepo_directive.py
@@ -8,8 +8,8 @@
 
 class CreaterepoDirective(BaseDirective):
     def process(self, input_data, env_data):
-        """For the createrepo directive, we're expecting a yaml declaration of the form
-        "createrepo: repodir=/path/to/some/dir"
+        """For the createrepo directive, we're expecting a yaml declaration of
+        the form "createrepo: repodir=/path/to/some/dir"
         """
 
         repodir = input_data['repodir']
Index: libtaskotron/directives/dummy_directive.py
===================================================================
--- libtaskotron/directives/dummy_directive.py
+++ libtaskotron/directives/dummy_directive.py
@@ -21,7 +21,8 @@
         expected_result = input_data['result']
 
         if expected_result.lower() == 'fail':
-            raise TaskotronDirectiveError("This is a dummy directive and configured to fail")
+            raise TaskotronDirectiveError("This is a dummy directive and "
+                                          "configured to fail")
 
         if 'msg' in input_data:
             return input_data['msg']
Index: libtaskotron/directives/koji_directive.py
===================================================================
--- libtaskotron/directives/koji_directive.py
+++ libtaskotron/directives/koji_directive.py
@@ -6,22 +6,26 @@
 directive_class = 'KojiDirective'
 
 class KojiDirective(BaseDirective):
-    """The koji directive interfaces with Koji to facilitate various koji actions.
+    """The koji directive interfaces with Koji to facilitate various koji
+    actions.
 
     format: "koji: command=[download] <command args>
 
     Valid Commands:
 
     download
       Downloads the envr specified as "envr"
-      format: "koji: command=download envr=<envr to download> arch=<desired arch>
+      format:
+        "koji: command=download envr=<envr to download> arch=<desired arch>
     download_tag
       Downloads rpms tagged by "tag"
-      format: "koji: command=download_tag tag=<tag to download> arch=<desired arch>
+      format:
+        "koji: command=download_tag tag=<tag to download> arch=<desired arch>
     """
 
     def __init__(self, koji_session=None):
-        if koji_session == None:
+        super(KojiDirective, self).__init__()
+        if koji_session is None:
             self.koji = KojiClient(koji_session)
         else:
             self.koji = koji_session
@@ -34,33 +38,38 @@
         action = input_data['action']
 
         if not action in valid_actions:
-            raise TaskotronDirectiveError('%s is not a valid command for koji helper' % action)
+            raise TaskotronDirectiveError('%s is not a valid command for koji '
+                                          'helper' % action)
 
         if action == 'download':
             if 'envr' not in input_data or 'arch' not in input_data:
                 detected_args = ', '.join(input_data.keys())
-                raise TaskotronDirectiveError("The koji directive requires both 'envr' and \
-                    'arch' arguments. Detected arguments: %s" % detected_args)
+                raise TaskotronDirectiveError(
+                    "The koji directive requires both 'envr' and 'arch'"
+                    "arguments. Detected arguments: %s" % detected_args)
 
             tmpdir = env_data['workdir']
             envr = input_data['envr']
             arches = [input_data['arch']]
 
-            log.info("getting koji builds for %s (%s) and downloading to %s", envr, arches, tmpdir)
+            log.info("getting koji builds for %s (%s) and downloading to %s",
+                     envr, arches, tmpdir)
             output_data['downloaded_rpms'] = self.koji.get_nvr_rpms(envr,
-                                                                    tmpdir,
-                                                                    arches)
+                                                                tmpdir, arches)
         elif action == 'download_tag':
             if 'tag' not in input_data or 'arch' not in input_data:
                 detected_args = ', '.join(input_data.keys())
-                raise TaskotronDirectiveError("The koji directive requires both 'tag' and \
-                    'arch' arguments. Detected arguments: %s" % detected_args)
+                raise TaskotronDirectiveError(
+                    "The koji directive requires both 'tag' and 'arch' "
+                    "arguments. Detected arguments: %s" % detected_args)
 
             tmpdir = env_data['workdir']
             tag = input_data['tag']
             arches = [input_data['arch']]
 
-            log.info("getting koji builds for tag %s and downloading to %s", tag, tmpdir)
-            output_data['downloaded_rpms'] = self.koji.get_tagged_rpms(tag, tmpdir, arches)
+            log.info("getting koji builds for tag %s and downloading to %s",
+                     tag, tmpdir)
+            output_data['downloaded_rpms'] = self.koji.get_tagged_rpms(tag,
+                                                                tmpdir, arches)
 
         return output_data
Index: libtaskotron/directives/python_directive.py
===================================================================
--- libtaskotron/directives/python_directive.py
+++ libtaskotron/directives/python_directive.py
@@ -8,9 +8,9 @@
 
 
 class PythonDirective(BaseDirective):
-    """The python directive is designed to execute a piece of python code as part
-    of task execution. Given a callable name 'dothis_thing', possible implementations
-    in the loaded code could include:
+    """The python directive is designed to execute a piece of python code as
+    part of task execution. Given a callable name 'dothis_thing', possible
+    implementations in the loaded code could include:
 
         class TaskClass(object):
             def my_task(self):
@@ -36,9 +36,11 @@
     And in this third case, you would pass in 'task_method' as the callable arg
 
     format:
-      python: file=<python filename> callable=<method name> [<kwargname>=<kwargvalue>'
+      python:
+        file=<python filename> callable=<method name> [<kwargname>=<kwargvalue>'
       required params: <python filename>, callable
-      optional params: farther key/value pairs, to be passed into the callable as kwargs
+      optional params: farther key/value pairs, to be passed into the callable
+        as kwargs
     """
 
     def _do_getattr(self, module, name):
@@ -72,7 +74,8 @@
         @param filename absolute path to the python file
         """
 
-        task_importname = 'runtask_%s' % os.path.basename(filename).rstrip('.py')
+        task_importname = 'runtask_%s' % os.path.basename(filename).rstrip(
+                                                                        '.py')
         task = imp.load_source(task_importname, filename)
 
         return task_importname, task
@@ -85,30 +88,36 @@
         """
 
         if not os.path.exists(filename):
-            raise TaskotronDirectiveError("The file %s does not exist!" % filename)
+            raise TaskotronDirectiveError("The file %s does not exist!"
+                                          % filename)
 
     def process(self, input_data, env_data):
-        """For the python directive, we're expecting a yaml declaration of the form
-        "python: file=<python file> callable=<method name> [kwarg1=something ...]"
+        """For the python directive, we're expecting a yaml declaration of the
+        form
+        "python:
+            file=<python file> callable=<method name> [kwarg1=something ...]"
 
-        @param input_data dictionary of all kwargs from yaml declaration, including callable and file
+        @param input_data dictionary of all kwargs from yaml declaration,
+            including callable and file
         @param env_data information on the environment in which we're running
-        @return output from the method specified, this is expected to be TAP output
+        @return output from the method specified, this is expected to be TAP
+            output
         """
 
         if 'callable' not in input_data or 'file' not in input_data:
             detected_args = ', '.join(input_data.keys())
-            raise TaskotronDirectiveError("The python directive requires both 'callable' and \
-'file' arguments. Detected arguments: %s" % detected_args)
+            raise TaskotronDirectiveError(
+                "The python directive requires both 'callable' and 'file' "
+                "arguments. Detected arguments: %s" % detected_args)
 
         method_name = input_data.pop('callable')
         basedir = os.path.dirname(env_data['taskfile'])
 
         pyfile = os.path.join(basedir, input_data.pop('file'))
 
         self.checkfile(pyfile)
 
-        task_name, task = self.load_pyfile(pyfile)
+        _, task = self.load_pyfile(pyfile)
 
         output = self.execute(task, method_name, input_data)
 
Index: libtaskotron/file_utils.py
===================================================================
--- libtaskotron/file_utils.py
+++ libtaskotron/file_utils.py
@@ -1,8 +1,9 @@
 import os
 import sys
-import urlgrabber.grabber, urlgrabber.progress
+import urlgrabber.grabber
+import urlgrabber.progress
 from libtaskotron.logger import log
-from exceptions import TaskotronRemoteError
+from libtaskotron.exceptions import TaskotronRemoteError
 
 
 def makedirs(fullpath):
@@ -73,7 +74,7 @@
         try:
             makedirs(os.path.dirname(dest))
         except OSError, e:
-            log.exception("Can't create directory: %s" % dest)
+            log.exception("Can't create directory: %s", dest)
             raise TaskotronRemoteError(e)
 
     # overwrite?
Index: libtaskotron/koji_utils.py
===================================================================
--- libtaskotron/koji_utils.py
+++ libtaskotron/koji_utils.py
@@ -12,7 +12,7 @@
         self.session = koji_session
 
     def get_koji_session(self):
-        if self.session == None:
+        if self.session is None:
             self.session = koji.ClientSession(KOJI_URL)
 
         return self.session
@@ -35,7 +35,8 @@
 
         info = ksession.getBuild(nvr)
         if info is None:
-            raise TaskotronRemoteError("No build information found for %s" % nvr)
+            raise TaskotronRemoteError(
+                "No build information found for %s" % nvr)
 
         baseurl = '/'.join((PKG_URL, info['package_name'],
                             info['version'], info['release']))
@@ -52,7 +53,8 @@
 
         return sorted(urls)
 
-    def get_nvr_rpms(self, nvr, rpm_dir, arches=None, debuginfo=False, src=False):
+    def get_nvr_rpms(self, nvr, rpm_dir, arches=None, debuginfo=False,
+                     src=False):
         '''Retrieve the RPMs associated with a build NVR into the specified
             directory.
 
@@ -90,4 +92,4 @@
         rpms = []
         for nvr in nvrs:
             rpms.append(self.get_nvr_rpms(nvr, dest, arches))
-        return rpms
\ No newline at end of file
+        return rpms
Index: libtaskotron/logger.py
===================================================================
--- libtaskotron/logger.py
+++ libtaskotron/logger.py
@@ -34,7 +34,8 @@
     log.critical(''.join(traceback.format_exception(*exc_info)))
 
 
-def init(name='libtaskotron', level=logging.INFO, stream=True, syslog=False, filelog=None):
+def init(name='libtaskotron', level=logging.INFO, stream=True, syslog=False,
+         filelog=None):
     """Setup a logger
     @param name name of the logger, 'libtaskotron' is default
     @param level level of logging
@@ -50,7 +51,8 @@
     logger.setLevel(level)
     logger.addHandler(logging.NullHandler())
 
-    fmt = '[%(name)s:%(filename)s:%(lineno)d] %(asctime)s %(levelname)-7s %(message)s'
+    fmt = '[%(name)s:%(filename)s:%(lineno)d] '\
+          '%(asctime)s %(levelname)-7s %(message)s'
     datefmt = '%Y-%m-%d %H:%M:%S'
     formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)
 
@@ -61,8 +63,8 @@
         logger.debug("doing stream logging")
 
     if syslog:
-        syslog_handler = logging.handlers.SysLogHandler(
-            address='/dev/log', facility=logging.handlers.SysLogHandler.LOG_LOCAL4)
+        syslog_handler = logging.handlers.SysLogHandler(address='/dev/log',
+                            facility=logging.handlers.SysLogHandler.LOG_LOCAL4)
         syslog_handler.setFormatter(formatter)
         logger.addHandler(syslog_handler)
         logger.debug("doing syslog logging")
@@ -72,6 +74,6 @@
             maxBytes=500000, backupCount=5)
         file_handler.setFormatter(formatter)
         logger.addHandler(file_handler)
-        logger.debug('doing file logging to %s' % filelog)
+        logger.debug('doing file logging to %s', filelog)
 
     return logger
Index: libtaskotron/python_utils.py
===================================================================
--- libtaskotron/python_utils.py
+++ libtaskotron/python_utils.py
@@ -14,4 +14,4 @@
     a list/set/etc of strings.
     '''
     return isinstance(obj, collections.Iterable) and not isinstance(obj,
-                                                         (str, unicode))
+                                                                    basestring)
Index: libtaskotron/runner.py
===================================================================
--- libtaskotron/runner.py
+++ libtaskotron/runner.py
@@ -3,16 +3,15 @@
 import os.path
 import argparse
 import imp
-from jinja2 import Template, Environment
+from jinja2 import Environment
 import copy
 
 from libtaskotron import taskyaml
 from libtaskotron import logger
 from libtaskotron.logger import log
 from libtaskotron.exceptions import TaskotronYamlError
 
-
-class Runner:
+class Runner(object):
     def __init__(self, taskdata, argdata, workdir=None):
         self.taskdata = taskdata
         self.envdata = argdata
@@ -76,7 +75,8 @@
         for key in action:
             if key not in ['name', 'export']:
                 return key
-        raise TaskotronYamlError('no directive found in action %s' % str(action))
+        raise TaskotronYamlError('no directive found in action %s' %
+                                 str(action))
 
     def do_single_action(self, action):
         directive_name = self._extract_directive_from_action(action)
@@ -98,7 +98,8 @@
 
     def do_actions(self):
         if 'task' not in self.taskdata or not self.taskdata['task']:
-            raise TaskotronYamlError("At least one task should be specified in input yaml file")
+            raise TaskotronYamlError("At least one task should be specified"
+                                     " in input yaml file")
 
         for action in self.taskdata['task']:
             self.do_single_action(action)
@@ -108,28 +109,33 @@
             return
 
         if not isinstance(self.taskdata['input'], dict):
-            raise TaskotronYamlError("Input yaml should contain correct 'input' section")
+            raise TaskotronYamlError("Input yaml should contain correct"
+                                     " 'input' section")
 
-        if ('args' not in self.taskdata['input']) or not isinstance(self.taskdata['input']['args'], str):
-            raise TaskotronYamlError("Input yaml should contain correct 'args' section")
+        if ('args' not in self.taskdata['input']) or not isinstance(
+                self.taskdata['input']['args'], str):
+            raise TaskotronYamlError("Input yaml should contain correct"
+                                     " 'args' section")
 
         required_input = self.taskdata['input']['args'].split(',')
 
         for arg in required_input:
             if not arg in self.envdata:
-                raise TaskotronYamlError('Required input arg %s was not defined' % arg)
+                raise TaskotronYamlError('Required input arg %s '
+                                         'was not defined' % arg)
 
     def _validate_env(self):
-        raise NotImplementedError("Environment validation is not yet implemented")
+        raise NotImplementedError("Environment validation is not"
+                                  " yet implemented")
 
 
 def get_argparser():
     parser = argparse.ArgumentParser()
     parser.add_argument("task", nargs=1, help="task to run")
-    parser.add_argument("-a", "--arch", choices=["i386", "x86_64", "armhfp", "noarch"], help="""
-                        Architecture to be used; support arches are x86, x86_64, and armhfp.
-                        If omitted, defaults to noarch.
-                        """)
+    parser.add_argument("-a", "--arch",
+                        choices=["i386", "x86_64", "armhfp", "noarch"], help=""
+                        "Architecture to be used; support arches are x86,\n"
+                        "x86_64, and armhfp.\nIf omitted, defaults to noarch.")
     parser.add_argument("-e", "--envr", help="envr to be used as input")
     parser.add_argument("-t", "--tag", help="koji tag to be used as input")
     return parser
Index: setup.py
===================================================================
--- setup.py
+++ setup.py
@@ -17,5 +17,5 @@
       entry_points=dict(console_scripts=['runtask=libtaskotron.runner:main']),
       install_requires = [
         'PyYAML',
-     ]
-     )
+      ]
+)
Index: testing/conftest.py
===================================================================
--- testing/conftest.py
+++ testing/conftest.py
@@ -19,9 +19,6 @@
 #
 # Author: Tim Flink <tflink@redhat.com>
 
-import pytest
-import re
-
 
 def pytest_addoption(parser):
     """
Index: testing/functest_python_directive.py
===================================================================
--- testing/functest_python_directive.py
+++ testing/functest_python_directive.py
@@ -7,26 +7,31 @@
     def setup_method(self, method):
         self.ref_taskyaml = 'footask.yml'
         self.ref_pyfile = 'some_loadable_test.py'
-        self.ref_env = {'taskfile': os.path.join(os.path.dirname(os.path.abspath(__file__)), self.ref_taskyaml)}
+        self.ref_env = {'taskfile': os.path.join(os.path.dirname(
+            os.path.abspath(__file__)), self.ref_taskyaml)}
         self.test_directive = python_directive.PythonDirective()
 
     def testfunc_task_method(self):
         ref_input = {'file': self.ref_pyfile, 'callable': 'task_method'}
 
-        test_output = self.test_directive.process(copy.copy(ref_input), self.ref_env)
+        test_output = self.test_directive.process(copy.copy(ref_input),
+                                                  self.ref_env)
 
         assert test_output == "I'm a task method!"
 
     def testfunc_class_embedded_call(self):
-        ref_input = {'file': self.ref_pyfile, 'callable': 'embedded_task_target'}
+        ref_input = {'file': self.ref_pyfile,
+                     'callable': 'embedded_task_target'}
 
-        test_output = self.test_directive.process(copy.copy(ref_input), self.ref_env)
+        test_output = self.test_directive.process(copy.copy(ref_input),
+                                                  self.ref_env)
 
         assert test_output == "I'm a __call__ method in a class!"
 
     def testfunc_class_target(self):
         ref_input = {'file': self.ref_pyfile, 'callable': 'task_class_target'}
 
-        test_output = self.test_directive.process(copy.copy(ref_input), self.ref_env)
+        test_output = self.test_directive.process(copy.copy(ref_input),
+                                                  self.ref_env)
 
         assert test_output == "I'm a task class method!"
Index: testing/test_koji_directive.py
===================================================================
--- testing/test_koji_directive.py
+++ testing/test_koji_directive.py
@@ -1,4 +1,3 @@
-import pytest
 from dingus import Dingus
 
 from libtaskotron.directives import koji_directive
@@ -13,22 +12,31 @@
         self.ref_release = '3.fc99'
         self.ref_buildid = 123456
 
-        self.ref_build = {'package_name':self.ref_name, 'version':self.ref_version,
-                     'release':self.ref_release, 'id': self.ref_buildid}
+        self.ref_build = {'package_name': self.ref_name,
+                          'version': self.ref_version,
+                          'release': self.ref_release,
+                          'id': self.ref_buildid}
 
-        self.ref_rpms = [{'name':self.ref_name, 'version':self.ref_version, 'release':self.ref_release, 'nvr':self.ref_nvr, 'arch':self.ref_arch},
-                    {'name':self.ref_name, 'version':self.ref_version, 'release':self.ref_release, 'nvr':self.ref_nvr, 'arch':'src'}]
+        self.ref_rpms = [{'name': self.ref_name, 'version': self.ref_version,
+                          'release': self.ref_release, 'nvr': self.ref_nvr,
+                          'arch': self.ref_arch},
+                    {'name': self.ref_name, 'version': self.ref_version,
+                     'release': self.ref_release, 'nvr': self.ref_nvr,
+                     'arch': 'src'}]
 
         self.ref_tagged = [{'nvr': self.ref_nvr}]
 
-        self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm' % self.ref_nvr
+        self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm'\
+                       % self.ref_nvr
         self.helper = koji_directive.KojiDirective()
 
     def test_parse_download_command(self):
-        self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm' % (self.ref_nvr, self.ref_arch)]
+        self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm'
+                         % (self.ref_nvr, self.ref_arch)]
 
-        ref_input = {'action': 'download', 'arch': self.ref_arch, 'envr': self.ref_nvr}
-        ref_envdata = {'workdir':'/var/tmp/foo'}
+        ref_input = {'action': 'download', 'arch': self.ref_arch,
+                     'envr': self.ref_nvr}
+        ref_envdata = {'workdir': '/var/tmp/foo'}
 
         stub_koji = Dingus(get_nvr_rpms__returns = self.ref_rpms)
 
@@ -43,10 +51,12 @@
         assert requested_nvr == self.ref_nvr
 
     def test_parse_download_tag_command(self):
-        self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm' % (self.ref_nvr, self.ref_arch)]
+        self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm'
+                         % (self.ref_nvr, self.ref_arch)]
 
-        ref_input = {'action': 'download_tag', 'arch': self.ref_arch, 'tag': self.ref_tag}
-        ref_envdata = {'workdir':'/var/tmp/foo'}
+        ref_input = {'action': 'download_tag', 'arch': self.ref_arch,
+                     'tag': self.ref_tag}
+        ref_envdata = {'workdir': '/var/tmp/foo'}
 
         stub_koji = Dingus(get_tagged_rpms__returns=self.ref_rpms)
 
Index: testing/test_koji_utils.py
===================================================================
--- testing/test_koji_utils.py
+++ testing/test_koji_utils.py
@@ -12,25 +12,36 @@
         self.ref_release = '3.fc99'
         self.ref_buildid = 123456
 
-        self.ref_build = {'package_name':self.ref_name, 'version':self.ref_version,
-                     'release':self.ref_release, 'id': self.ref_buildid}
-
-        self.ref_rpms = [{'name':self.ref_name, 'version':self.ref_version, 'release':self.ref_release, 'nvr':self.ref_nvr, 'arch':self.ref_arch},
-                    {'name':self.ref_name, 'version':self.ref_version, 'release':self.ref_release, 'nvr':self.ref_nvr, 'arch':'src'}]
-
-        self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm' % self.ref_nvr
+        self.ref_build = {'package_name': self.ref_name,
+                          'version': self.ref_version,
+                          'release': self.ref_release,
+                          'id': self.ref_buildid}
+
+        self.ref_rpms = [{'name': self.ref_name, 'version': self.ref_version,
+                          'release': self.ref_release, 'nvr': self.ref_nvr,
+                          'arch': self.ref_arch},
+                    {'name': self.ref_name, 'version': self.ref_version,
+                     'release': self.ref_release, 'nvr': self.ref_nvr,
+                     'arch': 'src'}]
+
+        self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm' \
+                       % self.ref_nvr
         self.helper = koji_utils.KojiClient()
 
     def test_get_noarch_rpmurls_from_nvr(self):
-        stub_koji = Dingus(getBuild__returns = self.ref_build, listRPMs__returns = self.ref_rpms)
+        stub_koji = Dingus(getBuild__returns = self.ref_build,
+                           listRPMs__returns = self.ref_rpms)
 
         test_koji = koji_utils.KojiClient(stub_koji)
 
         test_urls = test_koji.nvr_to_urls(self.ref_nvr)
 
         koji_baseurl = koji_utils.PKG_URL
-        ref_urls = ['%s/%s/%s/%s/%s/%s.%s.rpm' % (koji_baseurl, self.ref_name, self.ref_version, self.ref_release, self.ref_arch, self.ref_nvr, self.ref_arch),
-                    '%s/%s/%s/%s/src/%s.src.rpm' % (koji_baseurl, self.ref_name, self.ref_version, self.ref_release, self.ref_nvr),
+        ref_urls = ['%s/%s/%s/%s/%s/%s.%s.rpm' % (koji_baseurl, self.ref_name,
+                        self.ref_version, self.ref_release, self.ref_arch,
+                        self.ref_nvr, self.ref_arch),
+                    '%s/%s/%s/%s/src/%s.src.rpm' % (koji_baseurl, self.ref_name,
+                        self.ref_version, self.ref_release, self.ref_nvr),
                     ]
 
         assert test_urls == ref_urls
@@ -42,7 +53,8 @@
 
         test_koji = koji_utils.KojiClient(stub_koji)
 
-        # this isn't setup to actually return urls since we don't care about that for this test
+        # this isn't setup to actually return urls since we don't care about
+        # that for this test
         # it should throw an exception in this case.
         try:
             test_koji.nvr_to_urls(self.ref_nvr, arches = [self.ref_arch])
Index: testing/test_python_directive.py
===================================================================
--- testing/test_python_directive.py
+++ testing/test_python_directive.py
@@ -57,7 +57,8 @@
 
         test_directive.execute(ref_modulename, ref_methodname, ref_kwargs)
 
-        assert (stub_getattr.calls()[0].name, stub_getattr.calls()[0].args) == ('()', (ref_modulename, ref_methodname))
+        assert (stub_getattr.calls()[0].name, stub_getattr.calls()[0].args) == (
+            '()', (ref_modulename, ref_methodname))
 
     def test_task_method_is_executed(self, monkeypatch):
         ref_modulename = 'foo'
@@ -71,7 +72,8 @@
 
         test_directive.execute(ref_modulename, ref_methodname, ref_kwargs)
 
-        assert (stub_getattr.calls()[1].name, stub_getattr.calls()[1].args, stub_getattr.calls()[1].kwargs) == ('()', (), (ref_kwargs))
+        assert (stub_getattr.calls()[1].name, stub_getattr.calls()[1].args,
+                stub_getattr.calls()[1].kwargs) == ('()', (), ref_kwargs)
 
 
 class TestProcess(object):
@@ -81,52 +83,62 @@
         self.ref_taskyaml = '/path/to/foo/footask.yml'
         self.ref_input = {'file': 'foo.py', 'callable': 'bar', 'kwarg1': 'baz'}
         self.ref_env = {'taskfile': self.ref_taskyaml}
-        self.ref_pyfile = os.path.join(os.path.dirname(self.ref_taskyaml), self.ref_input['file'])
+        self.ref_pyfile = os.path.join(os.path.dirname(self.ref_taskyaml),
+                                       self.ref_input['file'])
 
         self.stub_checkfile = Dingus('checkfile')
         self.stub_imported = Dingus('imported')
-        self.stub_pyload = Dingus('pyload', dostuff__returns=('name', self.stub_imported))
+        self.stub_pyload = Dingus('pyload', dostuff__returns=('name',
+                                                        self.stub_imported))
         self.stub_execute = Dingus('execute')
 
     def test_process_checks_file(self, monkeypatch):
 
 
         test_directive = python_directive.PythonDirective()
         monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)
-        monkeypatch.setattr(test_directive, 'load_pyfile', self.stub_pyload.dostuff)
+        monkeypatch.setattr(test_directive, 'load_pyfile',
+                            self.stub_pyload.dostuff)
         monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
 
-        test_output = test_directive.process(copy.copy(self.ref_input), self.ref_env)
+        test_directive.process(copy.copy(self.ref_input),
+                                             self.ref_env)
 
         checkfile_call = self.stub_checkfile.calls[0]
 
-
-        assert (checkfile_call.name, checkfile_call.args, checkfile_call.kwargs) == ('()', (self.ref_pyfile,), {})
+        assert (checkfile_call.name, checkfile_call.args,
+                checkfile_call.kwargs) == ('()', (self.ref_pyfile,), {})
 
     def test_process_loads_file(self, monkeypatch):
 
         test_directive = python_directive.PythonDirective()
         monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)
-        monkeypatch.setattr(test_directive, 'load_pyfile', self.stub_pyload.dostuff)
+        monkeypatch.setattr(test_directive, 'load_pyfile',
+                            self.stub_pyload.dostuff)
         monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
 
-        test_output = test_directive.process(copy.copy(self.ref_input), self.ref_env)
+        test_directive.process(copy.copy(self.ref_input),
+                                             self.ref_env)
 
         pyload_call = self.stub_pyload.calls[0]
 
-        assert (pyload_call.name, pyload_call.args, pyload_call.kwargs) == ('dostuff', (self.ref_pyfile,), {})
+        assert (pyload_call.name, pyload_call.args, pyload_call.kwargs) == (
+            'dostuff', (self.ref_pyfile,), {})
 
     def test_process_executes(self, monkeypatch):
 
         ref_kwargs = {'kwarg1': 'baz'}
 
         test_directive = python_directive.PythonDirective()
         monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)
-        monkeypatch.setattr(test_directive, 'load_pyfile', self.stub_pyload.dostuff)
+        monkeypatch.setattr(test_directive, 'load_pyfile',
+                            self.stub_pyload.dostuff)
         monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
 
-        test_output = test_directive.process(copy.copy(self.ref_input), self.ref_env)
+        test_directive.process(copy.copy(self.ref_input),
+                                             self.ref_env)
 
         execute_call = self.stub_execute.calls[0]
 
-        assert (execute_call.name, execute_call.args, execute_call.kwargs) == ('()', (self.stub_imported, self.ref_input['callable'], ref_kwargs), {})
\ No newline at end of file
+        assert (execute_call.name, execute_call.args, execute_call.kwargs) == (
+         '()', (self.stub_imported, self.ref_input['callable'], ref_kwargs), {})
\ No newline at end of file
Index: testing/test_python_utils.py
===================================================================
--- testing/test_python_utils.py
+++ testing/test_python_utils.py
@@ -13,7 +13,7 @@
         assert python_utils.listlike([1, 2])
         assert python_utils.listlike(['a', 'b'])
         assert python_utils.listlike(('foo',))
-        assert python_utils.listlike(set(('foo','bar','baz')))
+        assert python_utils.listlike({'foo', 'bar', 'baz'})
         assert python_utils.listlike(set())
         assert python_utils.listlike(())
         assert python_utils.listlike([u'foo', u'bar'])
Index: testing/test_runner.py
===================================================================
--- testing/test_runner.py
+++ testing/test_runner.py
@@ -10,7 +10,6 @@
     def test_yamlrunner_valid_input(self):
         ref_cmd = '-e foo-1.2-3.fc99 -a x86_64 footask.yml'
         ref_argdata = {'input': {'args': 'envr,arch'}}
-        ref_data = {'envr': 'foo-1.2-3.fc99', 'arch': 'x86_64', 'taskfile': 'footask.yml'}
 
         test_parser = runner.get_argparser()
         test_args = vars(test_parser.parse_args(ref_cmd.split()))
@@ -104,7 +103,8 @@
 
 class TestRunnerPrep():
     def test_prep_invalid_commands(self, tmpdir):
-        ref_taskdata = {'preparation': {'turboencabulator':'reduce sinusoidal repleneration'}}
+        ref_taskdata = {'preparation': {'turboencabulator':
+                                            'reduce sinusoidal repleneration'}}
         ref_inputdata = {}
 
         test_runner = runner.Runner(ref_taskdata, ref_inputdata, tmpdir)
@@ -154,11 +154,13 @@
     def test_runner_extract_directive_name(self):
         ref_directivename = 'dummy'
         ref_action = {'name': 'test action',
-                      ref_directivename: {'result': 'pass', 'msg': 'dummy message'}}
+                      ref_directivename: {'result': 'pass',
+                                          'msg': 'dummy message'}}
 
         test_runner = runner.Runner(self.ref_taskdata, self.ref_inputdata)
 
-        test_directivename = test_runner._extract_directive_from_action(ref_action)
+        test_directivename = test_runner._extract_directive_from_action(
+            ref_action)
 
         assert test_directivename == ref_directivename
 
@@ -290,7 +292,8 @@
     def test_runner_render_single_variable(self):
         ref_message = 'This is a variable message'
         ref_messagename = 'variable_messsage'
-        ref_action = {'name': 'test dummy action', 'dummy': {'result': 'pass', 'msg': '{{ %s }}' % ref_messagename}}
+        ref_action = {'name': 'test dummy action', 'dummy':
+            {'result': 'pass', 'msg': '{{ %s }}' % ref_messagename}}
 
         test_runner = runner.Runner(self.ref_taskdata, self.ref_inputdata)
         test_runner.working_data[ref_messagename] = ref_message
