coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

                    coeff = 0;
    *pcoefficient_x = coeff;
    // get exponent
    tmp = x >> EXPONENT_SHIFT_LARGE64;
    *pexponent_x = (int) (tmp & EXPONENT_MASK64);
    return coeff;
  }
  // exponent
  tmp = x >> EXPONENT_SHIFT_SMALL64;

            

Reported by Cppcheck.

              # OTHER DEALINGS IN THE SOFTWARE.

import argparse
from bokeh.layouts import column
from bokeh.models import ColumnDataSource, CustomJS, HoverTool, FixedTicker
from bokeh.models import  LabelSet, Legend, LegendItem
from bokeh.models import NumeralTickFormatter, OpenURL, Range1d, TapTool
from bokeh.models.annotations import Label
from bokeh.plotting import figure, output_file, reset_output, save, show

            

Reported by Pylint.

              
import argparse
from bokeh.layouts import column
from bokeh.models import ColumnDataSource, CustomJS, HoverTool, FixedTicker
from bokeh.models import  LabelSet, Legend, LegendItem
from bokeh.models import NumeralTickFormatter, OpenURL, Range1d, TapTool
from bokeh.models.annotations import Label
from bokeh.plotting import figure, output_file, reset_output, save, show
from bokeh.resources import CDN

            

Reported by Pylint.

              import argparse
from bokeh.layouts import column
from bokeh.models import ColumnDataSource, CustomJS, HoverTool, FixedTicker
from bokeh.models import  LabelSet, Legend, LegendItem
from bokeh.models import NumeralTickFormatter, OpenURL, Range1d, TapTool
from bokeh.models.annotations import Label
from bokeh.plotting import figure, output_file, reset_output, save, show
from bokeh.resources import CDN
from multiprocessing import Process, Queue, Array

            

Reported by Pylint.

              from bokeh.layouts import column
from bokeh.models import ColumnDataSource, CustomJS, HoverTool, FixedTicker
from bokeh.models import  LabelSet, Legend, LegendItem
from bokeh.models import NumeralTickFormatter, OpenURL, Range1d, TapTool
from bokeh.models.annotations import Label
from bokeh.plotting import figure, output_file, reset_output, save, show
from bokeh.resources import CDN
from multiprocessing import Process, Queue, Array
import multiprocessing

            

Reported by Pylint.

              from bokeh.models import ColumnDataSource, CustomJS, HoverTool, FixedTicker
from bokeh.models import  LabelSet, Legend, LegendItem
from bokeh.models import NumeralTickFormatter, OpenURL, Range1d, TapTool
from bokeh.models.annotations import Label
from bokeh.plotting import figure, output_file, reset_output, save, show
from bokeh.resources import CDN
from multiprocessing import Process, Queue, Array
import multiprocessing
import numpy as np

            

Reported by Pylint.

              from bokeh.models import  LabelSet, Legend, LegendItem
from bokeh.models import NumeralTickFormatter, OpenURL, Range1d, TapTool
from bokeh.models.annotations import Label
from bokeh.plotting import figure, output_file, reset_output, save, show
from bokeh.resources import CDN
from multiprocessing import Process, Queue, Array
import multiprocessing
import numpy as np
import os

            

Reported by Pylint.

              from bokeh.models import NumeralTickFormatter, OpenURL, Range1d, TapTool
from bokeh.models.annotations import Label
from bokeh.plotting import figure, output_file, reset_output, save, show
from bokeh.resources import CDN
from multiprocessing import Process, Queue, Array
import multiprocessing
import numpy as np
import os
import pandas as pd

            

Reported by Pylint.

              import multiprocessing
import numpy as np
import os
import pandas as pd
import subprocess
import sys
import traceback
import time


            

Reported by Pylint.

                          except ValueError:
                print(color.BOLD + color.RED +
                      "Could not parse seconds since Epoch on first line" +
                      + color.END);
            return 1;
        else:
            return 0;

def processFile(fname, dumpCleanDataBool):

            

Reported by Pylint.

                          elif (units == "ns"):
                threshold = unitsPerNanosecond * number;
            elif (units == "stdev"):
                threshold = -units;
                # We record it as negative, so that we know
                # this is a standard deviation. We will compute
                # the actual value once we know the average.
            else:
                print(color.BOLD + color.RED +

            

Reported by Pylint.

              from unittest import TestSuite
import warnings

from extras import safe_hasattr, try_imports

Queue = try_imports(['Queue.Queue', 'queue.Queue'])

from testtools import (
    CopyStreamResult,

            

Reported by Pylint.

              
    def test_fresh_result_is_successful(self):
        # A result is considered successful before any tests are run.
        result = self.makeResult()
        self.assertTrue(result.wasSuccessful())

    def test_addError_is_failure(self):
        # addError fails the test run.
        result = self.makeResult()

            

Reported by Pylint.

                  def test_fresh_result_is_successful(self):
        # A result is considered successful before any tests are run.
        result = self.makeResult()
        self.assertTrue(result.wasSuccessful())

    def test_addError_is_failure(self):
        # addError fails the test run.
        result = self.makeResult()
        result.startTest(self)

            

Reported by Pylint.

              
    def test_addError_is_failure(self):
        # addError fails the test run.
        result = self.makeResult()
        result.startTest(self)
        result.addError(self, an_exc_info)
        result.stopTest(self)
        self.assertFalse(result.wasSuccessful())


            

Reported by Pylint.

                      result.startTest(self)
        result.addError(self, an_exc_info)
        result.stopTest(self)
        self.assertFalse(result.wasSuccessful())

    def test_addFailure_is_failure(self):
        # addFailure fails the test run.
        result = self.makeResult()
        result.startTest(self)

            

Reported by Pylint.

              
    def test_addFailure_is_failure(self):
        # addFailure fails the test run.
        result = self.makeResult()
        result.startTest(self)
        result.addFailure(self, an_exc_info)
        result.stopTest(self)
        self.assertFalse(result.wasSuccessful())


            

Reported by Pylint.

                      result.startTest(self)
        result.addFailure(self, an_exc_info)
        result.stopTest(self)
        self.assertFalse(result.wasSuccessful())

    def test_addSuccess_is_success(self):
        # addSuccess does not fail the test run.
        result = self.makeResult()
        result.startTest(self)

            

Reported by Pylint.

              
    def test_addSuccess_is_success(self):
        # addSuccess does not fail the test run.
        result = self.makeResult()
        result.startTest(self)
        result.addSuccess(self)
        result.stopTest(self)
        self.assertTrue(result.wasSuccessful())


            

Reported by Pylint.

                      result.startTest(self)
        result.addSuccess(self)
        result.stopTest(self)
        self.assertTrue(result.wasSuccessful())

    def test_stop_sets_shouldStop(self):
        result = self.makeResult()
        result.stop()
        self.assertTrue(result.shouldStop)

            

Reported by Pylint.

                      self.assertTrue(result.wasSuccessful())

    def test_stop_sets_shouldStop(self):
        result = self.makeResult()
        result.stop()
        self.assertTrue(result.shouldStop)


class Python27Contract(Python26Contract):

            

Reported by Pylint.

                      """Called to make sure a Node is a Dir.  Since we're an
        Entry, we can morph into one."""
        if self.__class__ is not klass:
            self.__class__ = klass
            self._morph()
            self.clear()

    # The following methods can get called before the Taskmaster has
    # had a chance to call disambiguate() directly to see if this Entry

            

Reported by Pylint.

                              setattr(self, key, value)

    def __eq__(self, other):
        return self.csig == other.csig and self.timestamp == other.timestamp and self.size == other.size

    def __ne__(self, other):
        return not self.__eq__(other)



            

Reported by Pylint.

                      # heald in dependency_map. Currently only used with
        # MD5-timestamp decider
        if key != 'dependency_map' and hasattr(self, 'dependency_map'):
            del self.dependency_map

        return super(FileBuildInfo, self).__setattr__(key, value)

    def convert_to_sconsign(self):
        """

            

Reported by Pylint.

                          print("dup: removing existing target {}".format(self))
        e = Unlink(self, [], None)
        if isinstance(e, SCons.Errors.BuildError):
            raise e

    #
    # Taskmaster interface subsystem
    #


            

Reported by Pylint.

                                      if isinstance(e, SCons.Errors.BuildError):
                            # Likely this should be re-raising exception e
                            # (which would be BuildError)
                            raise e
                        SCons.Node.store_info_map[self.store_info](self)
                    if T: Trace(' 1\n')
                    return 1
            self.changed()
            if T: Trace(' None\n')

            

Reported by Pylint.

                      can use its contents for the csig.
        """
        try:
            return self.cachedir_csig
        except AttributeError:
            pass

        cache = self.get_build_env().get_CacheDir()
        cachedir, cachefile = cache.cachepath(self)

            

Reported by Pylint.

                      """

        try:
            return self.contentsig
        except AttributeError:
            pass

        executor = self.get_executor()


            

Reported by Pylint.

                      Signature should normally be string of hex digits.
        """
        try:
            return self.cachesig
        except AttributeError:
            pass

        # Collect signatures for all children
        children = self.children()

            

Reported by Pylint.

              def sconsign_dir(node):
    """Return the .sconsign file info for this directory,
    creating it first if necessary."""
    if not node._sconsign:
        import SCons.SConsign
        node._sconsign = SCons.SConsign.ForDirectory(node)
    return node._sconsign

_sconsign_map = {0 : sconsign_none,

            

Reported by Pylint.

                  """Return the .sconsign file info for this directory,
    creating it first if necessary."""
    if not node._sconsign:
        import SCons.SConsign
        node._sconsign = SCons.SConsign.ForDirectory(node)
    return node._sconsign

_sconsign_map = {0 : sconsign_none,
                 1 : sconsign_dir}

            

Reported by Pylint.

              
    def test_addError(self):
        class Case(TestCase):
            def test(this):
                this.addDetail("foo", self.get_content())
                1/0
        self.assertDetailsProvided(Case("test"), "addError",
            ["foo", "traceback"])


            

Reported by Pylint.

              
    def test_addFailure(self):
        class Case(TestCase):
            def test(this):
                this.addDetail("foo", self.get_content())
                self.fail('yo')
        self.assertDetailsProvided(Case("test"), "addFailure",
            ["foo", "traceback"])


            

Reported by Pylint.

              
    def test_addSkip(self):
        class Case(TestCase):
            def test(this):
                this.addDetail("foo", self.get_content())
                self.skip('yo')
        self.assertDetailsProvided(Case("test"), "addSkip",
            ["foo", "reason"])


            

Reported by Pylint.

              
    def test_addSucccess(self):
        class Case(TestCase):
            def test(this):
                this.addDetail("foo", self.get_content())
        self.assertDetailsProvided(Case("test"), "addSuccess",
            ["foo"])

    def test_addUnexpectedSuccess(self):

            

Reported by Pylint.

              
    def test_addUnexpectedSuccess(self):
        class Case(TestCase):
            def test(this):
                this.addDetail("foo", self.get_content())
                raise testcase._UnexpectedSuccess()
        self.assertDetailsProvided(Case("test"), "addUnexpectedSuccess",
            ["foo"])


            

Reported by Pylint.

                      self.assertEqual('fred', case.thing)
        self.assertRaises(AttributeError, getattr, case, 'other')
        case.other = 'barbara'
        self.assertEqual('barbara', orig.other)
        del case.thing
        self.assertRaises(AttributeError, getattr, orig, 'thing')


def test_suite():

            

Reported by Pylint.

                  LoggingResult,
    )
try:
    exec('from __future__ import with_statement')
except SyntaxError:
    pass
else:
    from testtools.tests.test_with_with import *


            

Reported by Pylint.

                  LoggingResult,
    )
try:
    exec('from __future__ import with_statement')
except SyntaxError:
    pass
else:
    from testtools.tests.test_with_with import *


            

Reported by Bandit.

              except SyntaxError:
    pass
else:
    from testtools.tests.test_with_with import *


class TestPlaceHolder(TestCase):

    run_test_with = FullStackRunTest

            

Reported by Pylint.

              except SyntaxError:
    pass
else:
    from testtools.tests.test_with_with import *


class TestPlaceHolder(TestCase):

    run_test_with = FullStackRunTest

            

Reported by Pylint.

                      if not SCons.Util.is_Dict(args):
            args = self.ParseFlags(args)
        if not unique:
            self.Append(**args)
            return self
        for key, value in args.items():
            if not value:
                continue
            try:

            

Reported by Pylint.

              
        cachedir_class = self.validate_CacheDir_class()
        try:
            if (path == self._last_CacheDir_path
                    # this checks if the cachedir class type has changed from what the
                    # instantiated cache dir type is. If the are exactly the same we
                    # can just keep using the existing one, otherwise the user is requesting
                    # something new, so we will re-instantiate below.
                    and type(self._last_CacheDir) is cachedir_class):

            

Reported by Pylint.

                                  # instantiated cache dir type is. If the are exactly the same we
                    # can just keep using the existing one, otherwise the user is requesting
                    # something new, so we will re-instantiate below.
                    and type(self._last_CacheDir) is cachedir_class):
                return self._last_CacheDir
        except AttributeError:
            pass

        cd = cachedir_class(path)

            

Reported by Pylint.

                                  # can just keep using the existing one, otherwise the user is requesting
                    # something new, so we will re-instantiate below.
                    and type(self._last_CacheDir) is cachedir_class):
                return self._last_CacheDir
        except AttributeError:
            pass

        cd = cachedir_class(path)
        self._last_CacheDir_path = path

            

Reported by Pylint.

              semi_deepcopy = SCons.Util.semi_deepcopy
semi_deepcopy_dict = SCons.Util.semi_deepcopy_dict

def alias_builder(env, target, source):
    pass

AliasBuilder = SCons.Builder.Builder(action = alias_builder,
                                     target_factory = SCons.Node.Alias.default_ans.Alias,
                                     source_factory = SCons.Node.FS.Entry,

            

Reported by Pylint.

              semi_deepcopy = SCons.Util.semi_deepcopy
semi_deepcopy_dict = SCons.Util.semi_deepcopy_dict

def alias_builder(env, target, source):
    pass

AliasBuilder = SCons.Builder.Builder(action = alias_builder,
                                     target_factory = SCons.Node.Alias.default_ans.Alias,
                                     source_factory = SCons.Node.FS.Entry,

            

Reported by Pylint.

              semi_deepcopy = SCons.Util.semi_deepcopy
semi_deepcopy_dict = SCons.Util.semi_deepcopy_dict

def alias_builder(env, target, source):
    pass

AliasBuilder = SCons.Builder.Builder(action = alias_builder,
                                     target_factory = SCons.Node.Alias.default_ans.Alias,
                                     source_factory = SCons.Node.FS.Entry,

            

Reported by Pylint.

                  #'HOST_CPU',
    ]

def copy_non_reserved_keywords(dict):
    result = semi_deepcopy(dict)
    for k in list(result.keys()):
        if k in reserved_construction_var_names:
            msg = "Ignoring attempt to set reserved variable `$%s'"
            SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg % k)

            

Reported by Pylint.

                          del result[k]
    return result

def _set_reserved(env, key, value):
    msg = "Ignoring attempt to set reserved variable `$%s'"
    SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg % key)

def _set_future_reserved(env, key, value):
    env._dict[key] = value

            

Reported by Pylint.

                          del result[k]
    return result

def _set_reserved(env, key, value):
    msg = "Ignoring attempt to set reserved variable `$%s'"
    SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg % key)

def _set_future_reserved(env, key, value):
    env._dict[key] = value

            

Reported by Pylint.

              import SCons.Util
import SCons.Warnings

from .MSCommon import msvc_exists, msvc_setup_env_once
from SCons.Defaults import processDefines
from SCons.compat import PICKLE_PROTOCOL

##############################################################################
# Below here are the classes and functions for generation of

            

Reported by Pylint.

                              trg = {}
                for key in [k for k in list(self.usrdebg.keys()) if k in src]:
                    trg[key] = str(src[key])
                self.configs[var].debug = trg

    def UserHeader(self):
        encoding = self.env.subst('$MSVSENCODING')
        versionstr = self.versionstr
        self.usrfile.write(self.usrhead % locals())

            

Reported by Pylint.

                              self.configs[var].debug = trg

    def UserHeader(self):
        encoding = self.env.subst('$MSVSENCODING')
        versionstr = self.versionstr
        self.usrfile.write(self.usrhead % locals())

    def UserProject(self):
        pass

            

Reported by Pylint.

              
    def UserHeader(self):
        encoding = self.env.subst('$MSVSENCODING')
        versionstr = self.versionstr
        self.usrfile.write(self.usrhead % locals())

    def UserProject(self):
        pass


            

Reported by Pylint.

                      if not self.createfile:
            return
        try:
            filename = self.dspabs +'.user'
            self.usrfile = open(filename, 'w')
        except IOError as detail:
            raise SCons.Errors.InternalError('Unable to open "' + filename + '" for writing:' + str(detail))
        else:
            self.UserHeader()

            

Reported by Pylint.

              class _GenerateV7User(_UserGenerator):
    """Generates a Project file for MSVS .NET"""
    def __init__(self, dspfile, source, env):
        if self.version_num >= 9.0:
            self.usrhead = V9UserHeader
            self.usrconf = V9UserConfiguration
            self.usrdebg = V9DebugSettings
        _UserGenerator.__init__(self, dspfile, source, env)


            

Reported by Pylint.

                      _UserGenerator.__init__(self, dspfile, source, env)

    def UserProject(self):
        confkeys = sorted(self.configs.keys())
        for kind in confkeys:
            variant = self.configs[kind].variant
            platform = self.configs[kind].platform
            debug = self.configs[kind].debug
            if debug:

            

Reported by Pylint.

                  def UserProject(self):
        confkeys = sorted(self.configs.keys())
        for kind in confkeys:
            variant = self.configs[kind].variant
            platform = self.configs[kind].platform
            debug = self.configs[kind].debug
            if debug:
                debug_settings = '\n'.join(['\t\t\t\t%s="%s"' % (key, xmlify(value))
                                            for key, value in debug.items()

            

Reported by Pylint.

                      confkeys = sorted(self.configs.keys())
        for kind in confkeys:
            variant = self.configs[kind].variant
            platform = self.configs[kind].platform
            debug = self.configs[kind].debug
            if debug:
                debug_settings = '\n'.join(['\t\t\t\t%s="%s"' % (key, xmlify(value))
                                            for key, value in debug.items()
                                            if value is not None])

            

Reported by Pylint.

                      for kind in confkeys:
            variant = self.configs[kind].variant
            platform = self.configs[kind].platform
            debug = self.configs[kind].debug
            if debug:
                debug_settings = '\n'.join(['\t\t\t\t%s="%s"' % (key, xmlify(value))
                                            for key, value in debug.items()
                                            if value is not None])
                self.usrfile.write(self.usrconf % locals())

            

Reported by Pylint.

              from multiprocessing import Process
import numpy as np
import os
import pandas as pd
import sys
import time

# The time units used in the input files is nanoseconds. Presently the
# operation tracking code does not produce data using any other time

            

Reported by Pylint.

              import multiprocessing
from multiprocessing import Process
import numpy as np
import os
import pandas as pd
import sys
import time

# The time units used in the input files is nanoseconds. Presently the

            

Reported by Pylint.

              # operation tracking code does not produce data using any other time
# units.
#
unitsPerSecond = 1000000000;

# We aggregate data for intervals with the duration specified by
# the following variable.
intervalLength = 1;


            

Reported by Pylint.

              
# We aggregate data for intervals with the duration specified by
# the following variable.
intervalLength = 1;

# Each file has a timestamp indicating when the logging began
perFileTimeStamps = {};

# Codes for various colors for printing of informational and error messages.

            

Reported by Pylint.

              intervalLength = 1;

# Each file has a timestamp indicating when the logging began
perFileTimeStamps = {};

# Codes for various colors for printing of informational and error messages.
#
class color:
    PURPLE = '\033[95m'

            

Reported by Pylint.

              #
def assignStackDepths(dataframe):

    stack = [];

    df = dataframe.sort_values(by=['start']);
    df = df.reset_index(drop = True);

    for i in range(len(df.index)):

            

Reported by Pylint.

              
    stack = [];

    df = dataframe.sort_values(by=['start']);
    df = df.reset_index(drop = True);

    for i in range(len(df.index)):

        myEndTime = df.at[i, 'end'];

            

Reported by Pylint.

                  stack = [];

    df = dataframe.sort_values(by=['start']);
    df = df.reset_index(drop = True);

    for i in range(len(df.index)):

        myEndTime = df.at[i, 'end'];


            

Reported by Pylint.

              
    for i in range(len(df.index)):

        myEndTime = df.at[i, 'end'];

        # Pop all items off stack whose end time is earlier than my
        # end time. They are not the callers on my stack, so I don't want to
        # count them.
        #

            

Reported by Pylint.

                      # count them.
        #
        while (len(stack) > 0 and stack[-1] < myEndTime):
            stack.pop();

        df.at[i, 'stackdepth'] = len(stack);
        stack.append(df.at[i, 'end']);

    return df;

            

Reported by Pylint.

                      if callable(action):
            action(*args)
        else:
            os.system(action % args)

    def run_command_list(self, commands, dict):
        """
        Executes a list of commands, substituting values from the
        specified dictionary.

            

Reported by Bandit.

              
    def log_execute(self, command, log):
        command = self.subst(command, self.__dict__)
        p = os.popen(command)
        output = p.read()
        p.close()
        #TODO: convert to subrocess, os.popen is obsolete. This didn't work:
        #process = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True)
        #output = process.stdout.read()

            

Reported by Bandit.

                  name = 'scons-time'
    name_spaces = ' '*len(name)

    def makedict(**kw):
        return kw

    default_settings = makedict(
        chdir               = None,
        config_file         = None,

            

Reported by Pylint.

                  def _do_not_display(self, msg, *args):
        pass

    def display(self, msg, *args):
        """
        Displays the specified message.

        Each message is prepended with a standard prefix of our name
        plus the time.

            

Reported by Pylint.

                  def _do_not_execute(self, action, *args):
        pass

    def execute(self, action, *args):
        """
        Executes the specified action.

        The action is called if it's a callable Python function, and
        otherwise passed to os.system().

            

Reported by Pylint.

                      for action, string, args in commands:
            self.display(string, *args)
            sys.stdout.flush()
            status = self.execute(action, *args)
            if status:
                sys.exit(status)

    def log_display(self, command, log):
        command = self.subst(command, self.__dict__)

            

Reported by Pylint.

                          files.extend(sorted(glob.glob(a)))

        if tail:
            files = files[-tail:]

        return files

    def ascii_table(self, files, columns,
                    line_function, file_function=lambda x: x,

            

Reported by Pylint.

                      """
        Prints out a set of results in Gnuplot format.
        """
        gp = Gnuplotter(self.title, self.key_location)

        for i in sorted(results.keys()):
            try:
                t = self.run_titles[i]
            except IndexError:

            

Reported by Pylint.

                          results[i].sort()
            gp.line(results[i], i+1, t, None, t, fmt=fmt)

        for bar_tuple in self.vertical_bars:
            try:
                x, type, label, comment = bar_tuple
            except ValueError:
                x, type, label = bar_tuple
                comment = label

            

Reported by Pylint.

                          prepare(commands, removals)

        save_scons              = self.scons
        save_scons_wrapper      = self.scons_wrapper
        save_scons_lib_dir      = self.scons_lib_dir

        if self.outdir is None:
            self.outdir = self.orig_cwd
        elif not os.path.isabs(self.outdir):

            

Reported by Pylint.

                      self.print_stats = self.do_nothing
    def enable(self, outfp):
        self.outfp = outfp
        self.append = self.do_append
        self.print_stats = self.do_print
    def do_nothing(self, *args, **kw):
        pass

class CountStats(Stats):

            

Reported by Pylint.

                  def enable(self, outfp):
        self.outfp = outfp
        self.append = self.do_append
        self.print_stats = self.do_print
    def do_nothing(self, *args, **kw):
        pass

class CountStats(Stats):
    def do_append(self, label):

            

Reported by Pylint.

                  parts.append("Copyright (c) 2001 - 2019 The SCons Foundation")
    version = ''.join(parts)

    from . import SConsOptions
    parser = SConsOptions.Parser(version)
    values = SConsOptions.SConsValues(parser.get_default_values())

    OptionsParser = parser


            

Reported by Pylint.

                  # cause warnings about local names shadowing use of the 'SCons'
    # global in nest scopes and UnboundLocalErrors and the like in some
    # versions (2.1) of Python.
    import SCons.Platform.win32
    return SCons.Platform.win32.parallel_msg


def revert_io():
    # This call is added to revert stderr and stdout to the original

            

Reported by Pylint.

                          self.write(' ' * length + '\r')
            self.prev = ''

    def spinner(self, node):
        self.write(self.obj[self.count % len(self.obj)])

    def string(self, node):
        self.write(self.obj)


            

Reported by Pylint.

                  def spinner(self, node):
        self.write(self.obj[self.count % len(self.obj)])

    def string(self, node):
        self.write(self.obj)

    def replace_string(self, node):
        self.write(self.obj.replace(self.target_string, str(node)))


            

Reported by Pylint.

              ProgressObject = SCons.Util.Null()

def Progress(*args, **kw):
    global ProgressObject
    ProgressObject = Progressor(*args, **kw)

# Task control.
#


            

Reported by Pylint.

                  def execute(self):
        if print_time:
            start_time = time.time()
            global first_command_start
            if first_command_start is None:
                first_command_start = start_time
        SCons.Taskmaster.OutOfDateTask.execute(self)
        if print_time:
            global cumulative_command_time

            

Reported by Pylint.

                              first_command_start = start_time
        SCons.Taskmaster.OutOfDateTask.execute(self)
        if print_time:
            global cumulative_command_time
            global last_command_end
            finish_time = time.time()
            last_command_end = finish_time
            cumulative_command_time = cumulative_command_time+finish_time-start_time
            if print_action_timestamps:

            

Reported by Pylint.

                      SCons.Taskmaster.OutOfDateTask.execute(self)
        if print_time:
            global cumulative_command_time
            global last_command_end
            finish_time = time.time()
            last_command_end = finish_time
            cumulative_command_time = cumulative_command_time+finish_time-start_time
            if print_action_timestamps:
                sys.stdout.write("Command execution start timestamp: %s: %f\n"%(str(self.node), start_time))

            

Reported by Pylint.