Merge pull request #3356 from mwichmann/linty

Fixup some code triggering pylint errors.

26 files changed, 187 insertions, 232 deletions

diff --git a/src/CHANGES.txt b/src/CHANGES.txt
index e3b2d1b..86e98ac 100755
--- a/src/CHANGES.txt
+++ b/src/CHANGES.txt
@@ -17,6 +17,12 @@ RELEASE  VERSION/DATE TO BE FILLED IN LATER
     - Use importlib to dynamically load tool and platform modules instead of imp module
     - sconsign: default to .sconsign.dblite if no filename is specified.
       Be more informative in case of unsupported pickle protocol (py2 only).
+    - assorted fixups for pylint: exception types, redefined functions, 
+      globals, etc.  Some old code removed to resolve issues (hashlib is
+      always present on modern Pythons; no longer need the code for
+      2.5-and-earlier optparse). cmp is not a builtin function in Py3,
+      drop one (unused) use; replace one.  Fix another instance of
+      renaming to SConsEnvironmentError.
 
   From John Doe:
 
diff --git a/src/engine/SCons/ActionTests.py b/src/engine/SCons/ActionTests.py
index efe6e98..042d3dd 100644
--- a/src/engine/SCons/ActionTests.py
+++ b/src/engine/SCons/ActionTests.py
@@ -1554,19 +1554,19 @@ class CommandGeneratorActionTestCase(unittest.TestCase):
         assert c == func_matches[sys.version_info[:2]], "Got\n" + repr(c) + "\nExpected \n" + repr(
             func_matches[sys.version_info[:2]])
 
-        def f_global(target, source, env, for_signature):
+        def f_global2(target, source, env, for_signature):
             return SCons.Action.Action(GlobalFunc, varlist=['XYZ'])
 
-        def f_local(target, source, env, for_signature):
+        def f_local2(target, source, env, for_signature):
             return SCons.Action.Action(LocalFunc, varlist=['XYZ'])
 
         matches_foo = func_matches[sys.version_info[:2]] + b'foo'
 
-        a = self.factory(f_global)
+        a = self.factory(f_global2)
         c = a.get_contents(target=[], source=[], env=env)
         assert c in matches_foo, repr(c)
 
-        a = self.factory(f_local)
+        a = self.factory(f_local2)
         c = a.get_contents(target=[], source=[], env=env)
         assert c in matches_foo, repr(c)
 
diff --git a/src/engine/SCons/BuilderTests.py b/src/engine/SCons/BuilderTests.py
index 847e30a..b03a425 100644
--- a/src/engine/SCons/BuilderTests.py
+++ b/src/engine/SCons/BuilderTests.py
@@ -409,10 +409,6 @@ class BuilderTestCase(unittest.TestCase):
         builder = SCons.Builder.Builder(generator=generator)
         assert builder.action.generator == generator
 
-    def test_get_name(self):
-        """Test the get_name() method
-        """
-
     def test_cmp(self):
         """Test simple comparisons of Builder objects
         """
@@ -552,7 +548,7 @@ class BuilderTestCase(unittest.TestCase):
 
     def test_src_suffix(self):
         """Test Builder creation with a specified source file suffix
-        
+
         Make sure that the '.' separator is appended to the
         beginning if it isn't already present.
         """
@@ -685,7 +681,7 @@ class BuilderTestCase(unittest.TestCase):
                 pass
             if (len(source) == 1 and len(target) == 1):
                 env['CNT'][0] = env['CNT'][0] + 1
-                
+
         env = Environment()
         infiles = []
         outfiles = []
@@ -732,8 +728,8 @@ class BuilderTestCase(unittest.TestCase):
             pass
         else:
             assert 0
-        
-        
+
+
     def test_lists(self):
         """Testing handling lists of targets and source"""
         def function2(target, source, env, tlist = [outfile, outfile2], **kw):
@@ -881,7 +877,7 @@ class BuilderTestCase(unittest.TestCase):
 
         def func(self):
             pass
-        
+
         scanner = SCons.Scanner.Base(func, name='fooscan')
 
         b1 = SCons.Builder.Builder(action='bld', target_scanner=scanner)
@@ -890,8 +886,8 @@ class BuilderTestCase(unittest.TestCase):
 
         assert b1 == b2
         assert b1 != b3
-        
-    def test_src_scanner(slf):
+
+    def test_src_scanner(self):
         """Testing ability to set a source file scanner through a builder."""
         class TestScanner(object):
             def key(self, env):
@@ -1245,7 +1241,7 @@ class BuilderTestCase(unittest.TestCase):
             for t in target:
                 t.builder = nb
             return [nn], source
-            
+
         builder=SCons.Builder.Builder(action='foo',
                                       emitter=emit,
                                       target_factory=MyNode,
@@ -1321,7 +1317,7 @@ class BuilderTestCase(unittest.TestCase):
         builder2 = SCons.Builder.Builder(action='foo',
                                          emitter='$EMITTERLIST',
                                          node_factory=MyNode)
-                                         
+
         env = Environment(EMITTERLIST = [emit2a, emit2b])
 
         tgts = builder2(env, target='target-2', source='aaa.2')
@@ -1419,7 +1415,7 @@ class BuilderTestCase(unittest.TestCase):
         b6 = SCons.Builder.Builder(action='foo')
         assert isinstance(b4, SCons.Builder.CompositeBuilder)
         assert isinstance(b4.action, SCons.Action.CommandGeneratorAction)
-        
+
         env = Environment(BUILDERS={'bldr1': b1,
                                     'bldr2': b2,
                                     'bldr3': b3,
@@ -1481,7 +1477,7 @@ class CompositeBuilderTestCase(unittest.TestCase):
 
         tgt = builder(env, source=[])
         assert tgt == [], tgt
-        
+
         assert isinstance(builder, SCons.Builder.CompositeBuilder)
         assert isinstance(builder.action, SCons.Action.CommandGeneratorAction)
 
diff --git a/src/engine/SCons/CacheDir.py b/src/engine/SCons/CacheDir.py
index ab23f31..3d8e7bd 100644
--- a/src/engine/SCons/CacheDir.py
+++ b/src/engine/SCons/CacheDir.py
@@ -111,7 +111,7 @@ def CachePushFunc(target, source, env):
             # has beaten us creating the directory.
             if not fs.isdir(cachedir):
                 msg = errfmt % (str(target), cachefile)
-                raise SCons.Errors.EnvironmentError(msg)
+                raise SCons.Errors.SConsEnvironmentError(msg)
 
     try:
         if fs.islink(t.get_internal_path()):
@@ -177,8 +177,8 @@ class CacheDir(object):
                         # If someone else is trying to create the directory at
                         # the same time as me, bad things will happen
                         msg = "Failed to create cache directory " + path
-                        raise SCons.Errors.EnvironmentError(msg)
-                        
+                        raise SCons.Errors.SConsEnvironmentError(msg)
+
                 self.config['prefix_len'] = 2
                 if not os.path.exists(config_file):
                     try:
@@ -186,15 +186,15 @@ class CacheDir(object):
                             json.dump(self.config, config)
                     except:
                         msg = "Failed to write cache configuration for " + path
-                        raise SCons.Errors.EnvironmentError(msg)
+                        raise SCons.Errors.SConsEnvironmentError(msg)
         else:
             try:
                 with open(config_file) as config:
                     self.config = json.load(config)
             except ValueError:
                 msg = "Failed to read cache configuration for " + path
-                raise SCons.Errors.EnvironmentError(msg)
-            
+                raise SCons.Errors.SConsEnvironmentError(msg)
+
 
     def CacheDebug(self, fmt, target, cachefile):
         if cache_debug != self.current_cache_debug:
diff --git a/src/engine/SCons/DefaultsTests.py b/src/engine/SCons/DefaultsTests.py
index e04d1eb..2cbad70 100644
--- a/src/engine/SCons/DefaultsTests.py
+++ b/src/engine/SCons/DefaultsTests.py
@@ -69,11 +69,11 @@ class DefaultsTestCase(unittest.TestCase):
         test.write(file, "test\n")
         try:
             mkdir_func(file)
-        except os.error as e:
+        except OSError as e:
             pass
         else:
-            fail("expected os.error")
-        
+            self.fail("expected OSError")
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/src/engine/SCons/EnvironmentTests.py b/src/engine/SCons/EnvironmentTests.py
index 760e8d3..347c410 100644
--- a/src/engine/SCons/EnvironmentTests.py
+++ b/src/engine/SCons/EnvironmentTests.py
@@ -74,7 +74,7 @@ def diff_dict(d1, d2):
                    s2 = s2 + "    " + repr(k) + " : " + repr(d2[k]) + "\n"
            else:
                s1 = s1 + "    " + repr(k) + " : " + repr(d1[k]) + "\n"
-        elif k in env2:
+        elif k in d2:
            s2 = s2 + "    " + repr(k) + " : " + repr(d2[k]) + "\n"
     s1 = s1 + "}\n"
     s2 = s2 + "}\n"
@@ -263,39 +263,39 @@ class SubstitutionTestCase(unittest.TestCase):
         nodes = env.arg2nodes("Util.py UtilTests.py", Factory)
         assert len(nodes) == 1, nodes
         assert isinstance(nodes[0], X)
-        assert nodes[0].name == "Util.py UtilTests.py"
+        assert nodes[0].name == "Util.py UtilTests.py", nodes[0].name
 
         nodes = env.arg2nodes(u"Util.py UtilTests.py", Factory)
         assert len(nodes) == 1, nodes
         assert isinstance(nodes[0], X)
-        assert nodes[0].name == u"Util.py UtilTests.py"
+        assert nodes[0].name == u"Util.py UtilTests.py", nodes[0].name
 
         nodes = env.arg2nodes(["Util.py", "UtilTests.py"], Factory)
         assert len(nodes) == 2, nodes
         assert isinstance(nodes[0], X)
         assert isinstance(nodes[1], X)
-        assert nodes[0].name == "Util.py"
-        assert nodes[1].name == "UtilTests.py"
+        assert nodes[0].name == "Util.py", nodes[0].name
+        assert nodes[1].name == "UtilTests.py", nodes[1].name
 
         n1 = Factory("Util.py")
         nodes = env.arg2nodes([n1, "UtilTests.py"], Factory)
         assert len(nodes) == 2, nodes
         assert isinstance(nodes[0], X)
         assert isinstance(nodes[1], X)
-        assert nodes[0].name == "Util.py"
-        assert nodes[1].name == "UtilTests.py"
+        assert nodes[0].name == "Util.py", nodes[0].name
+        assert nodes[1].name == "UtilTests.py", nodes[1].name
 
         class SConsNode(SCons.Node.Node):
             pass
         nodes = env.arg2nodes(SConsNode())
         assert len(nodes) == 1, nodes
-        assert isinstance(nodes[0], SConsNode), node
+        assert isinstance(nodes[0], SConsNode), nodes[0]
 
         class OtherNode(object):
             pass
         nodes = env.arg2nodes(OtherNode())
         assert len(nodes) == 1, nodes
-        assert isinstance(nodes[0], OtherNode), node
+        assert isinstance(nodes[0], OtherNode), nodes[0]
 
         def lookup_a(str, F=Factory):
             if str[0] == 'a':
@@ -484,7 +484,7 @@ class SubstitutionTestCase(unittest.TestCase):
 
         env = SubstitutionEnvironment(AAA = '$BBB', BBB = '$CCC', CCC = 'c')
         l = env.subst_list("$AAA ${AAA}A ${AAA}B $BBB")
-        assert l == [["c", "cA", "cB", "c"]], mystr
+        assert l == [["c", "cA", "cB", "c"]], l
 
         env = SubstitutionEnvironment(AAA = '$BBB', BBB = '$CCC', CCC = [ 'a', 'b\nc' ])
         lst = env.subst_list([ "$AAA", "B $CCC" ])
@@ -1195,7 +1195,7 @@ env4.builder1.env, env3)
         test_it('foo.bar')
         test_it('foo-bar')
 
-    def test_autogenerate(dict):
+    def test_autogenerate(self):
         """Test autogenerating variables in a dictionary."""
 
         drive, p = os.path.splitdrive(os.getcwd())
@@ -1206,9 +1206,9 @@ env4.builder1.env, env3)
             drive, path = os.path.splitdrive(path)
             return drive.lower() + path
 
-        env = dict.TestEnvironment(LIBS = [ 'foo', 'bar', 'baz' ],
-                          LIBLINKPREFIX = 'foo',
-                          LIBLINKSUFFIX = 'bar')
+        env = self.TestEnvironment(LIBS = [ 'foo', 'bar', 'baz' ],
+                                   LIBLINKPREFIX = 'foo',
+                                   LIBLINKSUFFIX = 'bar')
 
         def RDirs(pathlist, fs=env.fs):
             return fs.Dir('xx').Rfindalldirs(pathlist)
@@ -3272,11 +3272,11 @@ def generate(env):
         s = e.src_builder()
         assert s is None, s
 
-    def test_SourceSignatures(type):
+    def test_SourceSignatures(self):
         """Test the SourceSignatures() method"""
         import SCons.Errors
 
-        env = type.TestEnvironment(M = 'MD5', T = 'timestamp')
+        env = self.TestEnvironment(M = 'MD5', T = 'timestamp')
 
         exc_caught = None
         try:
@@ -3312,7 +3312,7 @@ def generate(env):
 
     def test_Split(self):
         """Test the Split() method"""
-        env = self.TestEnvironment(FOO='fff', BAR='bbb')
+        env = self.TestEnvironment(FOO = 'fff', BAR = 'bbb')
         s = env.Split("foo bar")
         assert s == ["foo", "bar"], s
         s = env.Split("$FOO bar")
@@ -3326,11 +3326,11 @@ def generate(env):
         s = env.Split("$FOO$BAR")
         assert s == ["fffbbb"], s
 
-    def test_TargetSignatures(type):
+    def test_TargetSignatures(self):
         """Test the TargetSignatures() method"""
         import SCons.Errors
 
-        env = type.TestEnvironment(B = 'build', C = 'content')
+        env = self.TestEnvironment(B='build', C='content')
 
         exc_caught = None
         try:
@@ -3397,7 +3397,7 @@ def generate(env):
 
 
 
-    def test_Environment_global_variable(type):
+    def test_Environment_global_variable(self):
         """Test setting Environment variable to an Environment.Base subclass"""
         class MyEnv(SCons.Environment.Base):
             def xxx(self, string):
diff --git a/src/engine/SCons/Executor.py b/src/engine/SCons/Executor.py
index 01d01cd..6c68e09 100644
--- a/src/engine/SCons/Executor.py
+++ b/src/engine/SCons/Executor.py
@@ -41,10 +41,10 @@ from SCons.compat import with_metaclass, NoSlotsPyPy
 class Batch(object):
     """Remembers exact association between targets
     and sources of executor."""
-    
+
     __slots__ = ('targets',
                  'sources')
-    
+
     def __init__(self, targets=[], sources=[]):
         self.targets = targets
         self.sources = sources
@@ -127,13 +127,13 @@ def execute_action_list(obj, target, kw):
         status = act(*args, **kw)
         if isinstance(status, SCons.Errors.BuildError):
             status.executor = obj
-            raise status
+            raise status    # TODO pylint E0702: raising int not allowed
         elif status:
             msg = "Error %s" % status
             raise SCons.Errors.BuildError(
-                errstr=msg, 
+                errstr=msg,
                 node=obj.batches[0].targets,
-                executor=obj, 
+                executor=obj,
                 action=act)
     return status
 
@@ -597,7 +597,7 @@ class Null(object, with_metaclass(NoSlotsPyPy)):
     disassociate Builders from Nodes entirely, so we're not
     going to worry about unit tests for this--at least for now.
     """
-    
+
     __slots__ = ('pre_actions',
                  'post_actions',
                  'env',
@@ -613,7 +613,7 @@ class Null(object, with_metaclass(NoSlotsPyPy)):
                  'action_list',
                  '_do_execute',
                  '_execute_str')
-    
+
     def __init__(self, *args, **kw):
         if SCons.Debug.track_instances: logInstanceCreation(self, 'Executor.Null')
         self.batches = [Batch(kw['targets'][:], [])]
@@ -649,7 +649,7 @@ class Null(object, with_metaclass(NoSlotsPyPy)):
         """Morph this Null executor to a real Executor object."""
         batches = self.batches
         self.__class__ = Executor
-        self.__init__([])            
+        self.__init__([])
         self.batches = batches
 
     # The following methods require morphing this Null Executor to a
diff --git a/src/engine/SCons/JobTests.py b/src/engine/SCons/JobTests.py
index 325c0e1..26e3d37 100644
--- a/src/engine/SCons/JobTests.py
+++ b/src/engine/SCons/JobTests.py
@@ -73,7 +73,7 @@ class DummyLock(object):
     def release(self):
         pass
 
-class NoThreadsException(object):
+class NoThreadsException(Exception):
     "raised by the ParallelTestCase if threads are not supported"
 
     def __str__(self):
@@ -206,7 +206,7 @@ class Taskmaster(object):
         self.parallel_list = [0] * (n+1)
         self.found_parallel = False
         self.Task = Task
-        
+
         # 'guard' guards 'task_begin_list' and 'task_end_list'
         try:
             import threading
diff --git a/src/engine/SCons/Node/FSTests.py b/src/engine/SCons/Node/FSTests.py
index 23ec48e..d09e6da 100644
--- a/src/engine/SCons/Node/FSTests.py
+++ b/src/engine/SCons/Node/FSTests.py
@@ -1072,7 +1072,7 @@ class FSTestCase(_tempdirTestCase):
 
             def Dir_test(lpath, path_, abspath_, up_path_, sep=sep, func=_do_Dir_test):
                 return func(lpath, path_, abspath_, up_path_, sep)
-            
+
             Dir_test('/',           '/',           '/',               '/')
             Dir_test('',            './',          sub_dir,           sub)
             Dir_test('foo',         'foo/',        sub_dir_foo,       './')
@@ -1834,7 +1834,7 @@ class FSTestCase(_tempdirTestCase):
         # Should be a normalized Windows UNC path as below.
         assert str(f) == r'\\servername\C$\foo', \
         'UNC path %s got looked up as %s'%(path, f)
- 
+
     def test_unc_drive_letter(self):
         """Test drive-letter lookup for windows UNC-style directories"""
         if sys.platform not in ('win32',):
@@ -3534,11 +3534,11 @@ class clearTestCase(unittest.TestCase):
         e = fs.Entry('e')
         assert not e.exists()
         assert not e.rexists()
-        assert str(e) == 'e', str(d)
+        assert str(e) == 'e', str(e)
         e.clear()
         assert not e.exists()
         assert not e.rexists()
-        assert str(e) == 'e', str(d)
+        assert str(e) == 'e', str(e)
 
         d = fs.Dir(test.workpath('d'))
         test.subdir('d')
diff --git a/src/engine/SCons/Node/NodeTests.py b/src/engine/SCons/Node/NodeTests.py
index 7d347ac..678e03e 100644
--- a/src/engine/SCons/Node/NodeTests.py
+++ b/src/engine/SCons/Node/NodeTests.py
@@ -271,7 +271,7 @@ class NodeInfoBaseTestCase(unittest.TestCase):
 
         f = ni1.format()
         assert f == ['x', 'y', 'z'], f
- 
+
         field_list = ['xxx', 'zzz', 'aaa']
 
         f = ni1.format(field_list)
@@ -751,7 +751,7 @@ class NodeTestCase(unittest.TestCase):
         e = node.exists()
         assert e == 1, e
 
-    def test_exists(self):
+    def test_exists_repo(self):
         """Test evaluating whether a Node exists locally or in a repository.
         """
         node = SCons.Node.Node()
diff --git a/src/engine/SCons/Node/__init__.py b/src/engine/SCons/Node/__init__.py
index 131953b..b9aca96 100644
--- a/src/engine/SCons/Node/__init__.py
+++ b/src/engine/SCons/Node/__init__.py
@@ -103,9 +103,9 @@ implicit_deps_changed = 0
 
 # A variable that can be set to an interface-specific function be called
 # to annotate a Node with information about its creation.
-def do_nothing(node): pass
+def do_nothing_node(node): pass
 
-Annotate = do_nothing
+Annotate = do_nothing_node
 
 # Gets set to 'True' if we're running in interactive mode. Is
 # currently used to release parts of a target's info during
diff --git a/src/engine/SCons/Platform/PlatformTests.py b/src/engine/SCons/Platform/PlatformTests.py
index 3f42eae..d157c3f 100644
--- a/src/engine/SCons/Platform/PlatformTests.py
+++ b/src/engine/SCons/Platform/PlatformTests.py
@@ -110,7 +110,7 @@ class PlatformTestCase(unittest.TestCase):
             p = SCons.Platform.Platform('_does_not_exist_')
         except SCons.Errors.UserError:
             pass
-        else:
+        else:   # TODO pylint E0704: bare raise not inside except
             raise
 
         env = Environment()
diff --git a/src/engine/SCons/SConf.py b/src/engine/SCons/SConf.py
index b123c11..c3f93db 100644
--- a/src/engine/SCons/SConf.py
+++ b/src/engine/SCons/SConf.py
@@ -247,6 +247,7 @@ class SConfBuildTask(SCons.Taskmaster.AlwaysTask):
         # ConfigureCacheError and if yes, reraise the exception
         exc_type = self.exc_info()[0]
         if issubclass(exc_type, SConfError):
+            # TODO pylint E0704: bare raise not inside except
             raise
         elif issubclass(exc_type, SCons.Errors.BuildError):
             # we ignore Build Errors (occurs, when a test doesn't pass)
diff --git a/src/engine/SCons/Script/Main.py b/src/engine/SCons/Script/Main.py
index f3475f2..fdcd252 100644
--- a/src/engine/SCons/Script/Main.py
+++ b/src/engine/SCons/Script/Main.py
@@ -68,6 +68,20 @@ import SCons.Warnings
 
 import SCons.Script.Interactive
 
+# Global variables
+first_command_start = None
+last_command_end = None
+print_objects = 0
+print_memoizer = 0
+print_stacktrace = 0
+print_time = 0
+sconscript_time = 0
+cumulative_command_time = 0
+exit_status = 0   # final exit status, assume success by default
+this_build_status = 0   # "exit status" of an individual build
+num_jobs = None
+delayed_warnings = []
+
 
 def fetch_win32_parallel_msg():
     # A subsidiary function that exists solely to isolate this import
@@ -87,15 +101,14 @@ def revert_io():
     sys.stderr = sys.__stderr__
     sys.stdout = sys.__stdout__
 
+
 class SConsPrintHelpException(Exception):
     pass
 
+
 display = SCons.Util.display
 progress_display = SCons.Util.DisplayEngine()
 
-first_command_start = None
-last_command_end = None
-
 
 class Progressor(object):
     prev = ''
@@ -443,19 +456,6 @@ def python_version_deprecated(version=sys.version_info):
     return version < deprecated_python_version
 
 
-# Global variables
-
-print_objects = 0
-print_memoizer = 0
-print_stacktrace = 0
-print_time = 0
-sconscript_time = 0
-cumulative_command_time = 0
-exit_status = 0 # final exit status, assume success by default
-this_build_status = 0 # "exit status" of an individual build
-num_jobs = None
-delayed_warnings = []
-
 class FakeOptionParser(object):
     """
     A do-nothing option parser, used for the initial OptionsParser variable.
diff --git a/src/engine/SCons/Script/SConsOptions.py b/src/engine/SCons/Script/SConsOptions.py
index 37dd644..01d365d 100644
--- a/src/engine/SCons/Script/SConsOptions.py
+++ b/src/engine/SCons/Script/SConsOptions.py
@@ -226,39 +226,8 @@ class SConsOption(optparse.Option):
             fmt = "option %s: nargs='?' is incompatible with short options"
             raise SCons.Errors.UserError(fmt % self._short_opts[0])
 
-    try:
-        _orig_CONST_ACTIONS = optparse.Option.CONST_ACTIONS
-
-        _orig_CHECK_METHODS = optparse.Option.CHECK_METHODS
-
-    except AttributeError:
-        # optparse.Option had no CONST_ACTIONS before Python 2.5.
-
-        _orig_CONST_ACTIONS = ("store_const",)
-
-        def _check_const(self):
-            if self.action not in self.CONST_ACTIONS and self.const is not None:
-                raise OptionError(
-                    "'const' must not be supplied for action %r" % self.action,
-                    self)
-
-        # optparse.Option collects its list of unbound check functions
-        # up front.  This sucks because it means we can't just override
-        # the _check_const() function like a normal method, we have to
-        # actually replace it in the list.  This seems to be the most
-        # straightforward way to do that.
-
-        _orig_CHECK_METHODS = [optparse.Option._check_action,
-                     optparse.Option._check_type,
-                     optparse.Option._check_choice,
-                     optparse.Option._check_dest,
-                     _check_const,
-                     optparse.Option._check_nargs,
-                     optparse.Option._check_callback]
-
-    CHECK_METHODS = _orig_CHECK_METHODS + [_check_nargs_optional]
-
-    CONST_ACTIONS = _orig_CONST_ACTIONS + optparse.Option.TYPED_ACTIONS
+    CHECK_METHODS = optparse.Option.CHECK_METHODS + [_check_nargs_optional]
+    CONST_ACTIONS = optparse.Option.CONST_ACTIONS + optparse.Option.TYPED_ACTIONS
 
 class SConsOptionGroup(optparse.OptionGroup):
     """
@@ -364,7 +333,7 @@ class SConsOptionParser(optparse.OptionParser):
         in self.largs, so that any value overridden on the
         command line is immediately available if the user turns
         around and does a GetOption() right away.
-        
+
         We mimic the processing of the single args
         in the original OptionParser._process_args(), but here we
         allow exact matches for long-opts only (no partial
@@ -375,7 +344,7 @@ class SConsOptionParser(optparse.OptionParser):
         command-line arguments that
           1. haven't been processed so far (self.largs), but
           2. are possibly not added to the list of options yet.
-          
+
         So, when we only have a value for "--myargument" yet,
         a command-line argument of "--myarg=test" would set it.
         Responsible for this behaviour is the method
@@ -384,7 +353,7 @@ class SConsOptionParser(optparse.OptionParser):
         be unique.
         This would lead to further confusion, because we might want
         to add another option "--myarg" later on (see issue #2929).
-        
+
         """
         rargs = []
         largs_restore = []
@@ -401,7 +370,7 @@ class SConsOptionParser(optparse.OptionParser):
                     if "=" in l:
                         # Split into option and value
                         lopt = l.split("=", 1)
-                        
+
                     if lopt[0] in self._long_opt:
                         # Argument is already known
                         rargs.append('='.join(lopt))
@@ -416,7 +385,7 @@ class SConsOptionParser(optparse.OptionParser):
                         skip = True
                     else:
                         rargs.append(l)
-        
+
         # Parse the filtered list
         self.parse_args(rargs, self.values)
         # Restore the list of remaining arguments for the
diff --git a/src/engine/SCons/SubstTests.py b/src/engine/SCons/SubstTests.py
index a111e4b..f6fe1ec 100644
--- a/src/engine/SCons/SubstTests.py
+++ b/src/engine/SCons/SubstTests.py
@@ -132,6 +132,7 @@ class SubstTestCase(unittest.TestCase):
         def __str__(self):
             return self.value
 
+    # only use of this is currently commented out below
     def function_foo(arg):
         pass
 
@@ -1046,7 +1047,7 @@ class scons_subst_list_TestCase(SubstTestCase):
         node = scons_subst_list("$NODE", env, mode=SUBST_SIG, conv=s, gvars=gvars)
         assert node == [[n1]], node
 
-    def test_subst_list_overriding_gvars(self):
+    def test_subst_list_overriding_gvars2(self):
         """Test scons_subst_list():  supplying an overriding gvars dictionary"""
         env = DummyEnv({'XXX' : 'xxx'})
         result = scons_subst_list('$XXX', env, gvars=env.Dictionary())
diff --git a/src/engine/SCons/Taskmaster.py b/src/engine/SCons/Taskmaster.py
index 1522ca2..4892026 100644
--- a/src/engine/SCons/Taskmaster.py
+++ b/src/engine/SCons/Taskmaster.py
@@ -27,10 +27,10 @@ import sys
 __doc__ = """
     Generic Taskmaster module for the SCons build engine.
     =====================================================
-    
+
     This module contains the primary interface(s) between a wrapping user
     interface and the SCons build engine.  There are two key classes here:
-    
+
     Taskmaster
     ----------
         This is the main engine for walking the dependency graph and
@@ -477,7 +477,7 @@ class Task(object):
                 for s in t.side_effects:
                     if s.get_state() == NODE_EXECUTING:
                         s.set_state(NODE_NO_STATE)
-                        
+
                     # The side-effects may have been transferred to
                     # NODE_NO_STATE by executed_with{,out}_callbacks, but was
                     # not taken out of the waiting parents/pending children
@@ -551,7 +551,7 @@ class Task(object):
         try:
             exc_type, exc_value, exc_traceback = exc
         except ValueError:
-            exc_type, exc_value = exc
+            exc_type, exc_value = exc  # pylint: disable=unbalanced-tuple-unpacking
             exc_traceback = None
 
         # raise exc_type(exc_value).with_traceback(exc_traceback)
diff --git a/src/engine/SCons/Tool/MSCommon/netframework.py b/src/engine/SCons/Tool/MSCommon/netframework.py
index 787d008..b40576a 100644
--- a/src/engine/SCons/Tool/MSCommon/netframework.py
+++ b/src/engine/SCons/Tool/MSCommon/netframework.py
@@ -68,7 +68,7 @@ def query_versions():
             # sequence comparison in python is lexicographical
             # which is exactly what we want.
             # Note we sort backwards so the highest version is first.
-            return cmp(bbl,aal)
+            return (aal > bbl) - (aal < bbl)
 
         versions.sort(versrt)
     else:
diff --git a/src/engine/SCons/Tool/ToolTests.py b/src/engine/SCons/Tool/ToolTests.py
index 4bc5106..f005143 100644
--- a/src/engine/SCons/Tool/ToolTests.py
+++ b/src/engine/SCons/Tool/ToolTests.py
@@ -67,14 +67,14 @@ class ToolTestCase(unittest.TestCase):
             SCons.Tool.Tool()
         except TypeError:
             pass
-        else:
+        else:   # TODO pylint E0704: bare raise not inside except
             raise
 
         try:
             p = SCons.Tool.Tool('_does_not_exist_')
         except SCons.Errors.SConsEnvironmentError:
             pass
-        else:
+        else:   # TODO pylint E0704: bare raise not inside except
             raise
 
 
diff --git a/src/engine/SCons/Tool/intelc.py b/src/engine/SCons/Tool/intelc.py
index 17e7f31..1f3fcea 100644
--- a/src/engine/SCons/Tool/intelc.py
+++ b/src/engine/SCons/Tool/intelc.py
@@ -37,7 +37,7 @@ __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
 import math, sys, os.path, glob, string, re
 
 is_windows = sys.platform == 'win32'
-is_win64 = is_windows and (os.environ['PROCESSOR_ARCHITECTURE'] == 'AMD64' or 
+is_win64 = is_windows and (os.environ['PROCESSOR_ARCHITECTURE'] == 'AMD64' or
                            ('PROCESSOR_ARCHITEW6432' in os.environ and
                             os.environ['PROCESSOR_ARCHITEW6432'] == 'AMD64'))
 is_linux = sys.platform.startswith('linux')
@@ -113,11 +113,6 @@ def check_abi(abi):
               (abi, list(valid_abis.keys())))
     return abi
 
-def vercmp(a, b):
-    """Compare strings as floats,
-    but Intel changed Linux naming convention at 9.0"""
-    return cmp(linux_ver_normalize(b), linux_ver_normalize(a))
-
 def get_version_from_list(v, vlist):
     """See if we can match v (string) in vlist (list of strings)
     Linux has to match in a fuzzy way."""
@@ -293,7 +288,7 @@ def get_all_compiler_versions():
             m = re.search(r'([0-9]{0,4})(?:_sp\d*)?\.([0-9][0-9.]*)$', d)
             if m:
                 versions.append("%s.%s"%(m.group(1), m.group(2)))
-            
+
     def keyfunc(str):
         """Given a dot-separated version string, return a tuple of ints representing it."""
         return [int(x) for x in str.split('.')]
@@ -383,7 +378,7 @@ def get_intel_compiler_top(version, abi):
                     top = d
                     break
             return top
-                    
+
         top = find_in_2016style_dir(version) or find_in_2011style_dir(version) or find_in_2010style_dir(version) or find_in_2008style_dir(version)
         # print "INTELC: top=",top
         if not top:
diff --git a/src/engine/SCons/Tool/packaging/__init__.py b/src/engine/SCons/Tool/packaging/__init__.py
index 3c2c2f4..5795396 100644
--- a/src/engine/SCons/Tool/packaging/__init__.py
+++ b/src/engine/SCons/Tool/packaging/__init__.py
@@ -38,8 +38,8 @@ import os
 import importlib
 
 __all__ = [
-    'src_targz', 'src_tarbz2', 'src_xz', 'src_zip',
-    'targz', 'tarbz2', 'xz', 'zip',
+    'src_targz', 'src_tarbz2', 'src_tarxz', 'src_zip',
+    'targz', 'tarbz2', 'tarxz', 'zip',
     'rpm', 'msi', 'ipk',
 ]
 
diff --git a/src/engine/SCons/Tool/packaging/ipk.py b/src/engine/SCons/Tool/packaging/ipk.py
index 2ecaa9b..fe3f49b 100644
--- a/src/engine/SCons/Tool/packaging/ipk.py
+++ b/src/engine/SCons/Tool/packaging/ipk.py
@@ -3,7 +3,7 @@
 
 #
 # __COPYRIGHT__
-# 
+#
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
@@ -117,17 +117,17 @@ def build_specfiles(source, target, env):
     #
     #
     opened_files={}
-    def open_file(needle, haystack):
+    def open_file(needle, haystack=None):
         try:
             return opened_files[needle]
         except KeyError:
             files = filter(lambda x: x.get_path().rfind(needle) != -1, haystack)
             # Py3: filter returns an iterable, not a list
             file = list(files)[0]
-            opened_files[needle]=open(file.get_abspath(), 'w')
+            opened_files[needle] = open(file.get_abspath(), 'w')
             return opened_files[needle]
 
-    control_file=open_file('control', target)
+    control_file = open_file('control', target)
 
     if 'X_IPK_DESCRIPTION' not in env:
         env['X_IPK_DESCRIPTION']="%s\n %s"%(env['SUMMARY'],
@@ -149,7 +149,7 @@ Description: $X_IPK_DESCRIPTION
     control_file.write(env.subst(content))
 
     #
-    # now handle the various other files, which purpose it is to set post-, 
+    # now handle the various other files, which purpose it is to set post-,
     # pre-scripts and mark files as config files.
     #
     # We do so by filtering the source files for files which are marked with
@@ -161,14 +161,14 @@ Description: $X_IPK_DESCRIPTION
     # into the same named file.
     #
     for f in [x for x in source if 'PACKAGING_CONFIG' in dir(x)]:
-        config=open_file('conffiles')
+        config = open_file('conffiles')
         config.write(f.PACKAGING_INSTALL_LOCATION)
         config.write('\n')
 
     for str in 'POSTRM PRERM POSTINST PREINST'.split():
         name="PACKAGING_X_IPK_%s"%str
         for f in [x for x in source if name in dir(x)]:
-            file=open_file(name)
+            file = open_file(name)
             file.write(env[str])
 
     #
diff --git a/src/engine/SCons/Tool/xgettext.py b/src/engine/SCons/Tool/xgettext.py
index e4a17ca..936924b 100644
--- a/src/engine/SCons/Tool/xgettext.py
+++ b/src/engine/SCons/Tool/xgettext.py
@@ -26,6 +26,23 @@ Tool specific initialization of `xgettext` tool.
 
 __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
 
+import os
+import re
+import subprocess
+import sys
+
+import SCons.Action
+import SCons.Node.FS
+import SCons.Tool
+import SCons.Util
+from SCons.Builder import BuilderBase
+from SCons.Environment import _null
+from SCons.Platform.cygwin import CYGWIN_DEFAULT_PATHS
+from SCons.Platform.mingw import MINGW_DEFAULT_PATHS
+from SCons.Tool.GettextCommon import _POTargetFactory
+from SCons.Tool.GettextCommon import RPaths, _detect_xgettext
+from SCons.Tool.GettextCommon import _xgettext_exists
+
 
 #############################################################################
 class _CmdRunner(object):
@@ -41,10 +58,6 @@ class _CmdRunner(object):
         self.commandstr = commandstr
 
     def __call__(self, target, source, env):
-        import SCons.Action
-        import subprocess
-        import os
-        import sys
         kw = {
             'stdin': 'devnull',
             'stdout': subprocess.PIPE,
@@ -57,11 +70,10 @@ class _CmdRunner(object):
         self.out, self.err = proc.communicate()
         self.status = proc.wait()
         if self.err:
-            sys.stderr.write(unicode(self.err))
+            sys.stderr.write(SCons.Util.UnicodeType(self.err))
         return self.status
 
     def strfunction(self, target, source, env):
-        import os
         comstr = self.commandstr
         if env.subst(comstr, target=target, source=source) == "":
             comstr = self.command
@@ -74,9 +86,6 @@ class _CmdRunner(object):
 #############################################################################
 def _update_pot_file(target, source, env):
     """ Action function for `POTUpdate` builder """
-    import re
-    import os
-    import SCons.Action
     nop = lambda target, source, env: 0
 
     # Save scons cwd and os cwd (NOTE: they may be different. After the job, we
@@ -154,10 +163,6 @@ def _update_pot_file(target, source, env):
 #############################################################################
 
 #############################################################################
-from SCons.Builder import BuilderBase
-
-
-#############################################################################
 class _POTBuilder(BuilderBase):
     def _execute(self, env, target, source, *args):
         if not target:
@@ -175,10 +180,6 @@ class _POTBuilder(BuilderBase):
 def _scan_xgettext_from_files(target, source, env, files=None, path=None):
     """ Parses `POTFILES.in`-like file and returns list of extracted file names.
     """
-    import re
-    import SCons.Util
-    import SCons.Node.FS
-
     if files is None:
         return 0
     if not SCons.Util.is_List(files):
@@ -230,10 +231,6 @@ def _scan_xgettext_from_files(target, source, env, files=None, path=None):
 #############################################################################
 def _pot_update_emitter(target, source, env):
     """ Emitter function for `POTUpdate` builder """
-    from SCons.Tool.GettextCommon import _POTargetFactory
-    import SCons.Util
-    import SCons.Node.FS
-
     if 'XGETTEXTFROM' in env:
         xfrom = env['XGETTEXTFROM']
     else:
@@ -261,10 +258,6 @@ def _pot_update_emitter(target, source, env):
 #############################################################################
 
 #############################################################################
-from SCons.Environment import _null
-
-
-#############################################################################
 def _POTUpdateBuilderWrapper(env, target=None, source=_null, **kw):
     return env._POTUpdateBuilder(target, source, **kw)
 
@@ -274,8 +267,6 @@ def _POTUpdateBuilderWrapper(env, target=None, source=_null, **kw):
 #############################################################################
 def _POTUpdateBuilder(env, **kw):
     """ Creates `POTUpdate` builder object """
-    import SCons.Action
-    from SCons.Tool.GettextCommon import _POTargetFactory
     kw['action'] = SCons.Action.Action(_update_pot_file, None)
     kw['suffix'] = '$POTSUFFIX'
     kw['target_factory'] = _POTargetFactory(env, alias='$POTUPDATE_ALIAS').File
@@ -288,13 +279,6 @@ def _POTUpdateBuilder(env, **kw):
 #############################################################################
 def generate(env, **kw):
     """ Generate `xgettext` tool """
-    import sys
-    import os
-    import SCons.Util
-    import SCons.Tool
-    from SCons.Tool.GettextCommon import RPaths, _detect_xgettext
-    from SCons.Platform.mingw import MINGW_DEFAULT_PATHS
-    from SCons.Platform.cygwin import CYGWIN_DEFAULT_PATHS
 
     if sys.platform == 'win32':
         xgettext = SCons.Tool.find_program_path(env, 'xgettext', default_paths=MINGW_DEFAULT_PATHS + CYGWIN_DEFAULT_PATHS )
@@ -359,7 +343,6 @@ def generate(env, **kw):
 #############################################################################
 def exists(env):
     """ Check, whether the tool exists """
-    from SCons.Tool.GettextCommon import _xgettext_exists
     try:
         return _xgettext_exists(env)
     except:
diff --git a/src/engine/SCons/Util.py b/src/engine/SCons/Util.py
index 07f62ea..baf972f 100644
--- a/src/engine/SCons/Util.py
+++ b/src/engine/SCons/Util.py
@@ -33,6 +33,7 @@ import re
 import types
 import codecs
 import pprint
+import hashlib
 
 PY3 = sys.version_info[0] == 3
 
@@ -656,13 +657,15 @@ except ImportError:
             pass
         RegError = _NoError
 
-WinError = None
+
 # Make sure we have a definition of WindowsError so we can
 # run platform-independent tests of Windows functionality on
 # platforms other than Windows.  (WindowsError is, in fact, an
 # OSError subclass on Windows.)
+
 class PlainWindowsError(OSError):
     pass
+
 try:
     WinError = WindowsError
 except NameError:
@@ -1176,10 +1179,13 @@ def unique(s):
 # ASPN: Python Cookbook: Remove duplicates from a sequence
 # First comment, dated 2001/10/13.
 # (Also in the printed Python Cookbook.)
+# This not currently used, in favor of the next function...
 
 def uniquer(seq, idfun=None):
-    if idfun is None:
-        def idfun(x): return x
+    def default_idfun(x):
+        return x
+    if not idfun:
+        idfun = default_idfun
     seen = {}
     result = []
     for item in seq:
@@ -1444,56 +1450,54 @@ def RenameFunction(function, name):
                         function.__defaults__)
 
 
-md5 = False
+if hasattr(hashlib, 'md5'):
+    md5 = True
 
+    def MD5signature(s):
+        """
+        Generate md5 signature of a string
 
-def MD5signature(s):
-    return str(s)
+        :param s: either string or bytes. Normally should be bytes
+        :return: String of hex digits representing the signature
+        """
+        m = hashlib.md5()
 
+        try:
+            m.update(to_bytes(s))
+        except TypeError as e:
+            m.update(to_bytes(str(s)))
 
-def MD5filesignature(fname, chunksize=65536):
-    with open(fname, "rb") as f:
-        result = f.read()
-    return result
+        return m.hexdigest()
 
-try:
-    import hashlib
-except ImportError:
-    pass
+    def MD5filesignature(fname, chunksize=65536):
+        """
+        Generate the md5 signature of a file
+
+        :param fname: file to hash
+        :param chunksize: chunk size to read
+        :return: String of Hex digits representing the signature
+        """
+        m = hashlib.md5()
+        f = open(fname, "rb")
+        while True:
+            blck = f.read(chunksize)
+            if not blck:
+                break
+            m.update(to_bytes(blck))
+        f.close()
+        return m.hexdigest()
 else:
-    if hasattr(hashlib, 'md5'):
-        md5 = True
+    # if md5 algorithm not available, just return data unmodified
+    # could add alternative signature scheme here
+    md5 = False
 
-        def MD5signature(s):
-            """
-            Generate a String of Hex digits representing the md5 signature of the string
-            :param s: either string or bytes. Normally should be bytes
-            :return: String of hex digits
-            """
-            m = hashlib.md5()
+    def MD5signature(s):
+        return str(s)
 
-            try:
-                m.update(to_bytes(s))
-            except TypeError as e:
-                m.update(to_bytes(str(s)))
-
-            return m.hexdigest()
-
-        def MD5filesignature(fname, chunksize=65536):
-            """
-            :param fname:
-            :param chunksize:
-            :return: String of Hex digits
-            """
-            m = hashlib.md5()
-            f = open(fname, "rb")
-            while True:
-                blck = f.read(chunksize)
-                if not blck:
-                    break
-                m.update(to_bytes(blck))
-            f.close()
-            return m.hexdigest()
+    def MD5filesignature(fname, chunksize=65536):
+        with open(fname, "rb") as f:
+            result = f.read()
+        return result
 
 
 def MD5collect(signatures):
diff --git a/src/engine/SCons/compat/__init__.py b/src/engine/SCons/compat/__init__.py
index 83b084a..d34243e 100644
--- a/src/engine/SCons/compat/__init__.py
+++ b/src/engine/SCons/compat/__init__.py
@@ -113,28 +113,28 @@ except AttributeError:
     # intern into the sys package
     sys.intern = intern
 
-# Preparing for 3.x. UserDict, UserList, UserString are in
-# collections for 3.x, but standalone in 2.7.x
+# UserDict, UserList, UserString are in # collections for 3.x,
+# but standalone in 2.7.x. Monkey-patch into collections for 2.7.
 import collections
 
 try:
     collections.UserDict
 except AttributeError:
-    exec ('from UserDict import UserDict as _UserDict')
+    from UserDict import UserDict as _UserDict
     collections.UserDict = _UserDict
     del _UserDict
 
 try:
     collections.UserList
 except AttributeError:
-    exec ('from UserList import UserList as _UserList')
+    from UserList import UserList as _UserList
     collections.UserList = _UserList
     del _UserList
 
 try:
     collections.UserString
 except AttributeError:
-    exec ('from UserString import UserString as _UserString')
+    from UserString import UserString as _UserString
     collections.UserString = _UserString
     del _UserString
 
diff --git a/src/engine/SCons/cpp.py b/src/engine/SCons/cpp.py
index a413690..c1172aa 100644
--- a/src/engine/SCons/cpp.py
+++ b/src/engine/SCons/cpp.py
@@ -165,7 +165,7 @@ def CPP_to_Python(s):
     """
     s = CPP_to_Python_Ops_Expression.sub(CPP_to_Python_Ops_Sub, s)
     for expr, repl in CPP_to_Python_Eval_List:
-        s = expr.sub(repl, s)
+        s = re.sub(expr, repl, s)
     return s