Run pyformat on all the toolchain-utils files.

This gets rid of a lot of lint issues.
Ran by doing this:

for f in *.py; do echo -n "$f " ; if [ -x $f ]; then pyformat -i
--remove_trailing_comma --yapf --force_quote_type=double $f ; else
pyformat -i --remove_shebang --remove_trailing_comma --yapf
--force_quote_type=double $f ; fi ; done

BUG=chromium:567921
TEST=Ran simple crosperf run.

Change-Id: I59778835fdaa5f706d2e1765924389f9e97433d1
Reviewed-on: https://chrome-internal-review.googlesource.com/242031
Reviewed-by: Luis Lozano <llozano@chromium.org>
Commit-Queue: Luis Lozano <llozano@chromium.org>
Tested-by: Luis Lozano <llozano@chromium.org>
Reviewed-by: Yunlian Jiang <yunlian@google.com>

5 files changed, 183 insertions, 193 deletions

diff --git a/automation/clients/helper/android.py b/automation/clients/helper/android.py
index fc068aca..7ff2ac1c 100644
--- a/automation/clients/helper/android.py
+++ b/automation/clients/helper/android.py
@@ -1,7 +1,4 @@
-#!/usr/bin/python
-#
 # Copyright 2011 Google Inc. All Rights Reserved.
-
 """Helper modules for Android toolchain test infrastructure.
 
 Provides following Android toolchain test jobs and commands.
@@ -24,6 +21,7 @@ from automation.common import job
 
 
 class JobsFactory(object):
+
   def __init__(self, gcc_version='4.4.3', build_type='DEVELOPMENT'):
     assert gcc_version in ['4.4.3', '4.6', 'google_main', 'fsf_trunk']
     assert build_type in ['DEVELOPMENT', 'RELEASE']
@@ -46,11 +44,13 @@ class JobsFactory(object):
     new_job = jobs.CreateLinuxJob('AndroidBuildToolchain(%s)' % self.tc_tag,
                                   command)
     new_job.DependsOnFolder(checkout_dir_dep)
-    tc_prefix_dep = job.FolderDependency(
-        new_job, self.commands.toolchain_prefix_dir)
+    tc_prefix_dep = job.FolderDependency(new_job,
+                                         self.commands.toolchain_prefix_dir)
     return new_job, tc_prefix_dep
 
-  def BuildAndroidImage(self, tc_prefix_dep, product='stingray',
+  def BuildAndroidImage(self,
+                        tc_prefix_dep,
+                        product='stingray',
                         branch='ics-release'):
     assert product in ['stingray', 'passion', 'trygon', 'soju']
     assert branch in ['honeycomb-release', 'ics-release']
@@ -89,8 +89,7 @@ class CommandsFactory(object):
     self.gcc_version = gcc_version
     self.binutils_version = '2.21'
     self.gold_version = '2.21'
-    self.toolchain_prefix_dir = 'install-gcc-%s-%s' % (
-        gcc_version, build_type)
+    self.toolchain_prefix_dir = 'install-gcc-%s-%s' % (gcc_version, build_type)
     self.p4client = self._CreatePerforceClient()
     self.scripts = ScriptsFactory(self.gcc_version, self.binutils_version,
                                   self.gold_version)
@@ -105,11 +104,9 @@ class CommandsFactory(object):
                           'google_vendor_src_branch')
 
     # Common views for tools
-    p4view = perforce.View('depot2',
-                           perforce.PathMapping.ListFromPathTuples(
-                               [('gcctools/android/build/...', 'src/build/...'),
-                                ('gcctools/android/Tarballs/...',
-                                 'src/tarballs/...')]))
+    p4view = perforce.View('depot2', perforce.PathMapping.ListFromPathTuples([(
+        'gcctools/android/build/...', 'src/build/...'), (
+            'gcctools/android/Tarballs/...', 'src/tarballs/...')]))
     for mapping in perforce.PathMapping.ListFromPathDict(
         {'gcctools/android': ['tools/scripts/...', 'master/...']}):
       p4view.add(mapping)
@@ -123,13 +120,11 @@ class CommandsFactory(object):
       binutils_branch = mobile_rel_branch
     else:
       binutils_branch = p4_dev_path
-    p4view.add(perforce.PathMapping(binutils_branch, 'src',
-                                    ('binutils/binutils-%s/...' %
-                                     self.binutils_version)))
+    p4view.add(perforce.PathMapping(binutils_branch, 'src', (
+        'binutils/binutils-%s/...' % self.binutils_version)))
     if self.binutils_version != self.gold_version:
-      p4view.add(perforce.PathMapping(binutils_branch, 'src',
-                                      ('binutils/binutils-%s/...' %
-                                       self.gold_version)))
+      p4view.add(perforce.PathMapping(binutils_branch, 'src', (
+          'binutils/binutils-%s/...' % self.gold_version)))
 
     # Add view for gcc if gcc_version is '4.4.3'.
     if self.gcc_version == '4.4.3':
@@ -172,9 +167,11 @@ class CommandsFactory(object):
     gcc_required_dir = os.path.join(self.TOOLCHAIN_SRC_DIR, 'gcc',
                                     'gcc-%s' % self.gcc_version)
 
-    return cmd.Chain(cmd.MakeDir(gcc_required_dir),
-                     cmd.Wrapper(cmd.Chain(svn_co_command, svn_get_revision),
-                                 cwd=gcc_required_dir))
+    return cmd.Chain(
+        cmd.MakeDir(gcc_required_dir),
+        cmd.Wrapper(
+            cmd.Chain(svn_co_command, svn_get_revision),
+            cwd=gcc_required_dir))
 
   def CheckoutAndroidToolchain(self):
     p4client = self.p4client
@@ -187,25 +184,24 @@ class CommandsFactory(object):
     return command
 
   def BuildAndroidToolchain(self):
-    script_cmd = self.scripts.BuildAndroidToolchain(self.toolchain_prefix_dir,
-                                                    self.CHECKOUT_DIR,
-                                                    self.TOOLCHAIN_BUILD_DIR,
-                                                    self.TOOLCHAIN_SRC_DIR)
+    script_cmd = self.scripts.BuildAndroidToolchain(
+        self.toolchain_prefix_dir, self.CHECKOUT_DIR, self.TOOLCHAIN_BUILD_DIR,
+        self.TOOLCHAIN_SRC_DIR)
 
     # Record toolchain and gcc CL number
-    record_cl_cmd = cmd.Copy(os.path.join(self.CHECKOUT_DIR, 'CLNUM*'),
-                             to_dir=self.toolchain_prefix_dir)
-    save_cmd = cmd.Tar(os.path.join('$JOB_TMP', 'results',
-                                    '%s.tar.bz2' % self.toolchain_prefix_dir),
-                       self.toolchain_prefix_dir)
+    record_cl_cmd = cmd.Copy(
+        os.path.join(self.CHECKOUT_DIR, 'CLNUM*'),
+        to_dir=self.toolchain_prefix_dir)
+    save_cmd = cmd.Tar(
+        os.path.join('$JOB_TMP', 'results', '%s.tar.bz2' %
+                     self.toolchain_prefix_dir), self.toolchain_prefix_dir)
     return cmd.Chain(script_cmd, record_cl_cmd, save_cmd)
 
   def _BuildAndroidTree(self, local_android_branch_dir, product):
     target_tools_prefix = os.path.join('$JOB_TMP', self.toolchain_prefix_dir,
                                        'bin', 'arm-linux-androideabi-')
     java_path = '/usr/lib/jvm/java-6-sun/bin'
-    build_cmd = cmd.Shell('make', '-j8',
-                          'PRODUCT-%s-userdebug' % product,
+    build_cmd = cmd.Shell('make', '-j8', 'PRODUCT-%s-userdebug' % product,
                           'TARGET_TOOLS_PREFIX=%s' % target_tools_prefix,
                           'PATH=%s:$PATH' % java_path)
     return cmd.Wrapper(build_cmd, cwd=local_android_branch_dir)
@@ -219,9 +215,8 @@ class CommandsFactory(object):
                          'android_trees')
     remote_android_branch_path = os.path.join(androidtrees_path, branch)
     local_android_branch_dir = os.path.join(self.ANDROID_TREES_DIR, branch)
-    gettree_cmd = cmd.RemoteCopyFrom(androidtrees_host,
-                                     remote_android_branch_path,
-                                     local_android_branch_dir)
+    gettree_cmd = cmd.RemoteCopyFrom(
+        androidtrees_host, remote_android_branch_path, local_android_branch_dir)
 
     # Configure and build the tree
     buildtree_cmd = self._BuildAndroidTree(local_android_branch_dir, product)
@@ -235,8 +230,9 @@ class CommandsFactory(object):
     return cmd.Chain(gettree_cmd, buildtree_cmd, copy_img, compress_img)
 
   def CheckoutScripts(self):
-    p4view = perforce.View('depot2', [perforce.PathMapping(
-        'gcctools/android/tools/...', 'tools/...')])
+    p4view = perforce.View('depot2',
+                           [perforce.PathMapping('gcctools/android/tools/...',
+                                                 'tools/...')])
     p4client = perforce.CommandsFactory(self.TOOLS_DIR, p4view)
     return p4client.SetupAndDo(p4client.Sync(), p4client.Remove())
 
@@ -246,19 +242,15 @@ class CommandsFactory(object):
     base_benchbin_path = ('/usr/local/google2/home/mobiletc-prebuild/'
                           'archive/v3binaries/2011-10-18')
     local_basebenchbin_dir = 'base_benchmark_bin'
-    getbase_cmd = cmd.RemoteCopyFrom(base_benchbin_host,
-                                     base_benchbin_path,
+    getbase_cmd = cmd.RemoteCopyFrom(base_benchbin_host, base_benchbin_path,
                                      local_basebenchbin_dir)
 
     # Build and run benchmark.
     android_arch = 'android_%s' % arch
     run_label = 'normal'
-    benchmark_cmd = self.scripts.RunBenchmark(self.toolchain_prefix_dir,
-                                              self.TOOLS_DIR,
-                                              self.BENCHMARK_OUT_DIR,
-                                              run_label, run_experiment,
-                                              android_arch,
-                                              local_basebenchbin_dir)
+    benchmark_cmd = self.scripts.RunBenchmark(
+        self.toolchain_prefix_dir, self.TOOLS_DIR, self.BENCHMARK_OUT_DIR,
+        run_label, run_experiment, android_arch, local_basebenchbin_dir)
 
     # Extract jobid from BENCHMARK_OUT_DIR/log/jobid_normal.log file.
     # Copy jobid to www server to generate performance dashboard.
@@ -268,6 +260,7 @@ class CommandsFactory(object):
 
 
 class ScriptsFactory(object):
+
   def __init__(self, gcc_version, binutils_version, gold_version):
     self._gcc_version = gcc_version
     self._binutils_version = binutils_version
@@ -292,14 +285,20 @@ class ScriptsFactory(object):
         '--with-gold-version=%s' % self._gold_version,
         '--with-gdb-version=7.1.x-android',
         '--log-path=%s/logs' % '$JOB_HOME',
-        '--android-sysroot=%s' %
-        os.path.join('$JOB_TMP', checkout_dir, 'gcctools', 'android',
-                     'master', 'honeycomb_generic_sysroot'),
+        '--android-sysroot=%s' % os.path.join('$JOB_TMP', checkout_dir,
+                                              'gcctools', 'android', 'master',
+                                              'honeycomb_generic_sysroot'),
         path=os.path.join(checkout_dir, 'gcctools', 'android', 'tools',
                           'scripts'))
 
-  def RunBenchmark(self, toolchain_prefix_dir, checkout_dir, output_dir,
-                   run_label, run_experiment, arch, base_bench_bin=None):
+  def RunBenchmark(self,
+                   toolchain_prefix_dir,
+                   checkout_dir,
+                   output_dir,
+                   run_label,
+                   run_experiment,
+                   arch,
+                   base_bench_bin=None):
     if base_bench_bin:
       base_bench_opt = '--base_benchmark_bin=%s' % base_bench_bin
     else:
diff --git a/automation/clients/helper/chromeos.py b/automation/clients/helper/chromeos.py
index ddfd59fe..e7157451 100644
--- a/automation/clients/helper/chromeos.py
+++ b/automation/clients/helper/chromeos.py
@@ -1,8 +1,6 @@
-#!/usr/bin/python
-#
 # Copyright 2011 Google Inc. All Rights Reserved.
 
-__author__ = "asharif@google.com (Ahmad Sharif)"
+__author__ = 'asharif@google.com (Ahmad Sharif)'
 
 import os.path
 import re
@@ -14,64 +12,54 @@ from automation.common import machine
 
 
 class ScriptsFactory(object):
+
   def __init__(self, chromeos_root, scripts_path):
     self._chromeos_root = chromeos_root
     self._scripts_path = scripts_path
 
   def SummarizeResults(self, logs_path):
-    return cmd.Shell("summarize_results.py",
-                     logs_path,
-                     path=self._scripts_path)
+    return cmd.Shell('summarize_results.py', logs_path, path=self._scripts_path)
 
   def Buildbot(self, config_name):
     buildbot = os.path.join(self._chromeos_root,
-                            "chromite/cbuildbot/cbuildbot.py")
-
-    return cmd.Shell(buildbot,
-                     "--buildroot=%s" % self._chromeos_root,
-                     "--resume",
-                     "--noarchive",
-                     "--noprebuilts",
-                     "--nosync",
-                     "--nouprev",
-                     "--notests",
-                     "--noclean",
-                     config_name)
+                            'chromite/cbuildbot/cbuildbot.py')
+
+    return cmd.Shell(buildbot, '--buildroot=%s' % self._chromeos_root,
+                     '--resume', '--noarchive', '--noprebuilts', '--nosync',
+                     '--nouprev', '--notests', '--noclean', config_name)
 
   def RunBenchmarks(self, board, tests):
-    image_path = os.path.join(self._chromeos_root,
-                              "src/build/images",
-                              board,
-                              "latest/chromiumos_image.bin")
-
-    return cmd.Shell("cros_run_benchmarks.py",
-                     "--remote=$SECONDARY_MACHINES[0]",
-                     "--board=%s" % board,
-                     "--tests=%s" % tests,
-                     "--full_table",
+    image_path = os.path.join(self._chromeos_root, 'src/build/images', board,
+                              'latest/chromiumos_image.bin')
+
+    return cmd.Shell('cros_run_benchmarks.py',
+                     '--remote=$SECONDARY_MACHINES[0]',
+                     '--board=%s' % board,
+                     '--tests=%s' % tests,
+                     '--full_table',
                      image_path,
-                     path="/home/mobiletc-prebuild")
+                     path='/home/mobiletc-prebuild')
 
-  def SetupChromeOS(self, version="latest", use_minilayout=False):
-    setup_chromeos = cmd.Shell("setup_chromeos.py",
-                               "--public",
-                               "--dir=%s" % self._chromeos_root,
-                               "--version=%s" % version,
+  def SetupChromeOS(self, version='latest', use_minilayout=False):
+    setup_chromeos = cmd.Shell('setup_chromeos.py',
+                               '--public',
+                               '--dir=%s' % self._chromeos_root,
+                               '--version=%s' % version,
                                path=self._scripts_path)
 
     if use_minilayout:
-      setup_chromeos.AddOption("--minilayout")
+      setup_chromeos.AddOption('--minilayout')
     return setup_chromeos
 
 
 class CommandsFactory(object):
-  DEPOT2_DIR = "//depot2/"
-  P4_CHECKOUT_DIR = "perforce2/"
-  P4_VERSION_DIR = os.path.join(P4_CHECKOUT_DIR, "gcctools/chromeos/v14")
+  DEPOT2_DIR = '//depot2/'
+  P4_CHECKOUT_DIR = 'perforce2/'
+  P4_VERSION_DIR = os.path.join(P4_CHECKOUT_DIR, 'gcctools/chromeos/v14')
 
-  CHROMEOS_ROOT = "chromeos"
-  CHROMEOS_SCRIPTS_DIR = os.path.join(CHROMEOS_ROOT, "src/scripts")
-  CHROMEOS_BUILDS_DIR = "/home/mobiletc-prebuild/www/chromeos_builds"
+  CHROMEOS_ROOT = 'chromeos'
+  CHROMEOS_SCRIPTS_DIR = os.path.join(CHROMEOS_ROOT, 'src/scripts')
+  CHROMEOS_BUILDS_DIR = '/home/mobiletc-prebuild/www/chromeos_builds'
 
   def __init__(self, chromeos_version, board, toolchain, p4_snapshot):
     self.chromeos_version = chromeos_version
@@ -82,33 +70,34 @@ class CommandsFactory(object):
     self.scripts = ScriptsFactory(self.CHROMEOS_ROOT, self.P4_VERSION_DIR)
 
   def AddBuildbotConfig(self, config_name, config_list):
-    config_header = "add_config(%r, [%s])" % (config_name,
-                                              ", ".join(config_list))
+    config_header = 'add_config(%r, [%s])' % (config_name,
+                                              ', '.join(config_list))
     config_file = os.path.join(self.CHROMEOS_ROOT,
-                               "chromite/cbuildbot/cbuildbot_config.py")
-    quoted_config_header = "%r" % config_header
+                               'chromite/cbuildbot/cbuildbot_config.py')
+    quoted_config_header = '%r' % config_header
     quoted_config_header = re.sub("'", "\\\"", quoted_config_header)
 
-    return cmd.Pipe(cmd.Shell("echo", quoted_config_header),
-                    cmd.Shell("tee", "--append", config_file))
+    return cmd.Pipe(
+        cmd.Shell('echo', quoted_config_header),
+        cmd.Shell('tee', '--append', config_file))
 
   def RunBuildbot(self):
-    config_dict = {"board": self.board,
-                   "build_tests": True,
-                   "chrome_tests": True,
-                   "unittests": False,
-                   "vm_tests": False,
-                   "prebuilts": False,
-                   "latest_toolchain": True,
-                   "useflags": ["chrome_internal"],
-                   "usepkg_chroot": True,
+    config_dict = {'board': self.board,
+                   'build_tests': True,
+                   'chrome_tests': True,
+                   'unittests': False,
+                   'vm_tests': False,
+                   'prebuilts': False,
+                   'latest_toolchain': True,
+                   'useflags': ['chrome_internal'],
+                   'usepkg_chroot': True,
                    self.toolchain: True}
-    config_name = "%s-toolchain-test" % self.board
-    if "arm" in self.board:
-      config_list = ["arm"]
+    config_name = '%s-toolchain-test' % self.board
+    if 'arm' in self.board:
+      config_list = ['arm']
     else:
       config_list = []
-    config_list.extend(["internal", "full", "official", str(config_dict)])
+    config_list.extend(['internal', 'full', 'official', str(config_dict)])
 
     add_config_shell = self.AddBuildbotConfig(config_name, config_list)
     return cmd.Chain(add_config_shell, self.scripts.Buildbot(config_name))
@@ -118,7 +107,7 @@ class CommandsFactory(object):
         self.CheckoutV14Dir(),
         self.SetupChromeOSCheckout(self.chromeos_version, True),
         self.RunBuildbot(),
-        self.scripts.RunBenchmarks(self.board, "BootPerfServer,10:Page,3"))
+        self.scripts.RunBenchmarks(self.board, 'BootPerfServer,10:Page,3'))
 
   def GetP4Snapshot(self, p4view):
     p4client = perforce.CommandsFactory(self.P4_CHECKOUT_DIR, p4view)
@@ -130,38 +119,43 @@ class CommandsFactory(object):
 
   def CheckoutV14Dir(self):
     p4view = perforce.View(self.DEPOT2_DIR, [
-        perforce.PathMapping("gcctools/chromeos/v14/...")])
+        perforce.PathMapping('gcctools/chromeos/v14/...')
+    ])
     return self.GetP4Snapshot(p4view)
 
   def SetupChromeOSCheckout(self, version, use_minilayout=False):
-    version_re = "^\d+\.\d+\.\d+\.[a-zA-Z0-9]+$"
+    version_re = '^\d+\.\d+\.\d+\.[a-zA-Z0-9]+$'
 
     location = os.path.join(self.CHROMEOS_BUILDS_DIR, version)
 
-    if version in ["weekly", "quarterly"]:
-      assert os.path.islink(location), "Symlink %s does not exist." % location
+    if version in ['weekly', 'quarterly']:
+      assert os.path.islink(location), 'Symlink %s does not exist.' % location
 
       location_expanded = os.path.abspath(os.path.realpath(location))
       version = os.path.basename(location_expanded)
 
-    if version in ["top", "latest"] or re.match(version_re, version):
+    if version in ['top', 'latest'] or re.match(version_re, version):
       return self.scripts.SetupChromeOS(version, use_minilayout)
 
-    elif version.endswith("bz2") or version.endswith("gz"):
+    elif version.endswith('bz2') or version.endswith('gz'):
       return cmd.UnTar(location_expanded, self.CHROMEOS_ROOT)
 
     else:
       signature_file_location = os.path.join(location,
-                                             "src/scripts/enter_chroot.sh")
+                                             'src/scripts/enter_chroot.sh')
       assert os.path.exists(signature_file_location), (
-          "Signature file %s does not exist." % signature_file_location)
+          'Signature file %s does not exist.' % signature_file_location)
 
       return cmd.Copy(location, to_dir=self.CHROMEOS_ROOT, recursive=True)
 
 
 class JobsFactory(object):
-  def __init__(self, chromeos_version="top", board="x86-mario",
-               toolchain="trunk", p4_snapshot=""):
+
+  def __init__(self,
+               chromeos_version='top',
+               board='x86-mario',
+               toolchain='trunk',
+               p4_snapshot=''):
     self.chromeos_version = chromeos_version
     self.board = board
     self.toolchain = toolchain
@@ -172,14 +166,15 @@ class JobsFactory(object):
   def BuildAndBenchmark(self):
     command = self.commands.BuildAndBenchmark()
 
-    label = "BuildAndBenchmark(%s,%s,%s)" % (
-        self.toolchain, self.board, self.chromeos_version)
+    label = 'BuildAndBenchmark(%s,%s,%s)' % (self.toolchain, self.board,
+                                             self.chromeos_version)
 
-    machine_label = "chromeos-%s" % self.board
+    machine_label = 'chromeos-%s' % self.board
 
     job = jobs.CreateLinuxJob(label, command)
     job.DependsOnMachine(
-        machine.MachineSpecification(label=machine_label, lock_required=True),
+        machine.MachineSpecification(label=machine_label,
+                                     lock_required=True),
         False)
 
     return job
diff --git a/automation/clients/helper/crosstool.py b/automation/clients/helper/crosstool.py
index f3b24005..80154b25 100644
--- a/automation/clients/helper/crosstool.py
+++ b/automation/clients/helper/crosstool.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python
-#
 # Copyright 2011 Google Inc. All Rights Reserved.
 
 __author__ = 'kbaclawski@google.com (Krystian Baclawski)'
@@ -14,14 +12,15 @@ from automation.common import job
 
 
 class JobsFactory(object):
+
   def __init__(self):
     self.commands = CommandsFactory()
 
   def CheckoutCrosstool(self, target):
     command = self.commands.CheckoutCrosstool()
     new_job = jobs.CreateLinuxJob('CheckoutCrosstool(%s)' % target, command)
-    checkout_dir_dep = job.FolderDependency(
-        new_job, CommandsFactory.CHECKOUT_DIR)
+    checkout_dir_dep = job.FolderDependency(new_job,
+                                            CommandsFactory.CHECKOUT_DIR)
     manifests_dir_dep = job.FolderDependency(
         new_job, os.path.join(self.commands.buildit_path, target), 'manifests')
     return new_job, checkout_dir_dep, manifests_dir_dep
@@ -30,14 +29,14 @@ class JobsFactory(object):
     command = self.commands.BuildRelease(target)
     new_job = jobs.CreateLinuxJob('BuildRelease(%s)' % target, command)
     new_job.DependsOnFolder(checkout_dir)
-    build_tree_dep = job.FolderDependency(
-        new_job, self.commands.buildit_work_dir_path)
+    build_tree_dep = job.FolderDependency(new_job,
+                                          self.commands.buildit_work_dir_path)
     return new_job, build_tree_dep
 
   def RunTests(self, checkout_dir, build_tree_dir, target, board, component):
     command = self.commands.RunTests(target, board, component)
-    new_job = jobs.CreateLinuxJob(
-        'RunTests(%s, %s, %s)' % (target, component, board), command)
+    new_job = jobs.CreateLinuxJob('RunTests(%s, %s, %s)' %
+                                  (target, component, board), command)
     new_job.DependsOnFolder(checkout_dir)
     new_job.DependsOnFolder(build_tree_dir)
     testrun_dir_dep = job.FolderDependency(
@@ -57,24 +56,26 @@ class CommandsFactory(object):
   CHECKOUT_DIR = 'crosstool-checkout-dir'
 
   def __init__(self):
-    self.buildit_path = os.path.join(
-        self.CHECKOUT_DIR, 'gcctools', 'crosstool', 'v15')
+    self.buildit_path = os.path.join(self.CHECKOUT_DIR, 'gcctools', 'crosstool',
+                                     'v15')
 
     self.buildit_work_dir = 'buildit-tmp'
     self.buildit_work_dir_path = os.path.join('$JOB_TMP', self.buildit_work_dir)
-    self.dejagnu_output_path = os.path.join(
-        self.buildit_work_dir_path, 'dejagnu-output')
+    self.dejagnu_output_path = os.path.join(self.buildit_work_dir_path,
+                                            'dejagnu-output')
 
     paths = {
         'gcctools': [
-            'crosstool/v15/...',
-            'scripts/...'],
+            'crosstool/v15/...', 'scripts/...'
+        ],
         'gcctools/google_vendor_src_branch': [
-            'binutils/binutils-2.21/...',
-            'gdb/gdb-7.2.x/...',
-            'zlib/zlib-1.2.3/...'],
+            'binutils/binutils-2.21/...', 'gdb/gdb-7.2.x/...',
+            'zlib/zlib-1.2.3/...'
+        ],
         'gcctools/vendor_src': [
-            'gcc/google/gcc-4_6/...']}
+            'gcc/google/gcc-4_6/...'
+        ]
+    }
 
     p4view = perforce.View('depot2',
                            perforce.PathMapping.ListFromPathDict(paths))
@@ -91,22 +92,21 @@ class CommandsFactory(object):
   def BuildRelease(self, target):
     clnum_path = os.path.join('$JOB_TMP', self.CHECKOUT_DIR, 'CLNUM')
 
-    toolchain_root = os.path.join(
-        '/google/data/rw/projects/toolchains', target, 'unstable')
+    toolchain_root = os.path.join('/google/data/rw/projects/toolchains', target,
+                                  'unstable')
     toolchain_path = os.path.join(toolchain_root, '${CLNUM}')
 
     build_toolchain = cmd.Wrapper(
         cmd.Chain(
-          cmd.MakeDir(toolchain_path),
-          cmd.Shell(
-              'buildit',
-              '--keep-work-dir',
-              '--build-type=release',
-              '--work-dir=%s' % self.buildit_work_dir_path,
-              '--results-dir=%s' % toolchain_path,
-              '--force-release=%s' % '${CLNUM}',
-              target,
-              path='.')),
+            cmd.MakeDir(toolchain_path),
+            cmd.Shell('buildit',
+                      '--keep-work-dir',
+                      '--build-type=release',
+                      '--work-dir=%s' % self.buildit_work_dir_path,
+                      '--results-dir=%s' % toolchain_path,
+                      '--force-release=%s' % '${CLNUM}',
+                      target,
+                      path='.')),
         cwd=self.buildit_path,
         umask='0022',
         env={'CLNUM': '$(< %s)' % clnum_path})
@@ -114,8 +114,7 @@ class CommandsFactory(object):
     # remove all but 10 most recent directories
     remove_old_toolchains_from_x20 = cmd.Wrapper(
         cmd.Pipe(
-            cmd.Shell('ls', '-1', '-r'),
-            cmd.Shell('sed', '-e', '1,10d'),
+            cmd.Shell('ls', '-1', '-r'), cmd.Shell('sed', '-e', '1,10d'),
             cmd.Shell('xargs', 'rm', '-r', '-f')),
         cwd=toolchain_root)
 
@@ -132,13 +131,15 @@ class CommandsFactory(object):
                                  'experimental/users/kbaclawski',
                                  'dejagnu/site.exp')
 
-    build_dir_path = os.path.join(
-        target, 'rpmbuild/BUILD/crosstool*-0.0', 'build-%s' % component)
+    build_dir_path = os.path.join(target, 'rpmbuild/BUILD/crosstool*-0.0',
+                                  'build-%s' % component)
 
     run_dejagnu = cmd.Wrapper(
         cmd.Chain(
             cmd.MakeDir(self.dejagnu_output_path),
-            cmd.Shell('make', 'check', '-k',
+            cmd.Shell('make',
+                      'check',
+                      '-k',
                       '-j $(grep -c processor /proc/cpuinfo)',
                       'RUNTESTFLAGS="%s"' % ' '.join(dejagnu_flags),
                       'DEJAGNU="%s"' % site_exp_file,
@@ -146,8 +147,9 @@ class CommandsFactory(object):
         cwd=os.path.join(self.buildit_work_dir_path, build_dir_path),
         env={'REMOTE_TMPDIR': 'job-$JOB_ID'})
 
-    save_results = cmd.Copy(
-        self.dejagnu_output_path, to_dir='$JOB_TMP/results', recursive=True)
+    save_results = cmd.Copy(self.dejagnu_output_path,
+                            to_dir='$JOB_TMP/results',
+                            recursive=True)
 
     return cmd.Chain(run_dejagnu, save_results)
 
@@ -155,9 +157,12 @@ class CommandsFactory(object):
     sumfiles = [os.path.join('$JOB_TMP', board, '*.sum') for board in boards]
 
     return cmd.Wrapper(
-        cmd.Shell('dejagnu.sh', 'report',
-                  '-m', '$JOB_TMP/manifests/*.xfail',
-                  '-o', '$JOB_TMP/results/report.html',
+        cmd.Shell('dejagnu.sh',
+                  'report',
+                  '-m',
+                  '$JOB_TMP/manifests/*.xfail',
+                  '-o',
+                  '$JOB_TMP/results/report.html',
                   *sumfiles,
                   path='.'),
         cwd='$HOME/automation/clients/report')
diff --git a/automation/clients/helper/jobs.py b/automation/clients/helper/jobs.py
index ea9c9691..96a1c408 100644
--- a/automation/clients/helper/jobs.py
+++ b/automation/clients/helper/jobs.py
@@ -1,13 +1,11 @@
-#!/usr/bin/python
-#
 # Copyright 2010 Google Inc. All Rights Reserved.
 
 from automation.common import job
 from automation.common import machine
 
 
-def CreateLinuxJob(label, command, lock=False, timeout=4*60*60):
+def CreateLinuxJob(label, command, lock=False, timeout=4 * 60 * 60):
   to_return = job.Job(label, command, timeout)
-  to_return.DependsOnMachine(
-      machine.MachineSpecification(os="linux", lock_required=lock))
+  to_return.DependsOnMachine(machine.MachineSpecification(os='linux',
+                                                          lock_required=lock))
   return to_return
diff --git a/automation/clients/helper/perforce.py b/automation/clients/helper/perforce.py
index 1100a1ee..1f2dfe79 100644
--- a/automation/clients/helper/perforce.py
+++ b/automation/clients/helper/perforce.py
@@ -1,5 +1,3 @@
-#!/usr/bin/python
-#
 # Copyright 2011 Google Inc. All Rights Reserved.
 
 __author__ = 'kbaclawski@google.com (Krystian Baclawski)'
@@ -153,17 +151,16 @@ class CommandsFactory(object):
     self.p4config_path = os.path.join(self.checkout_dir, '.p4config')
 
   def Initialize(self):
-    return cmd.Chain(
-        'mkdir -p %s' % self.checkout_dir,
-        'cp ~/.p4config %s' % self.checkout_dir,
-        'chmod u+w %s' % self.p4config_path,
-        'echo "P4PORT=%s" >> %s' % (self.port, self.p4config_path),
-        'echo "P4CLIENT=%s" >> %s' % (self.view.client, self.p4config_path))
+    return cmd.Chain('mkdir -p %s' % self.checkout_dir, 'cp ~/.p4config %s' %
+                     self.checkout_dir, 'chmod u+w %s' % self.p4config_path,
+                     'echo "P4PORT=%s" >> %s' % (self.port, self.p4config_path),
+                     'echo "P4CLIENT=%s" >> %s' %
+                     (self.view.client, self.p4config_path))
 
   def Create(self):
     # TODO(kbaclawski): Could we support value list for options consistently?
-    mappings = ['-a \"%s %s\"' % mapping for mapping in
-                self.view.AbsoluteMappings()]
+    mappings = ['-a \"%s %s\"' % mapping
+                for mapping in self.view.AbsoluteMappings()]
 
     # First command will create client with default mappings.  Second one will
     # replace default mapping with desired.  Unfortunately, it seems that it
@@ -176,14 +173,12 @@ class CommandsFactory(object):
         env={'P4EDITOR': '/bin/true'})
 
   def SaveSpecification(self, filename=None):
-    return cmd.Pipe(
-        cmd.Shell('g4', 'client', '-o'),
-        output=filename)
+    return cmd.Pipe(cmd.Shell('g4', 'client', '-o'), output=filename)
 
   def Sync(self, revision=None):
     sync_arg = '...'
     if revision:
-      sync_arg = "%s@%s" % (sync_arg, revision)
+      sync_arg = '%s@%s' % (sync_arg, revision)
     return cmd.Shell('g4', 'sync', sync_arg)
 
   def SaveCurrentCLNumber(self, filename=None):
@@ -196,14 +191,11 @@ class CommandsFactory(object):
     return cmd.Shell('g4', 'client', '-d', self.view.client)
 
   def SetupAndDo(self, *commands):
-    return cmd.Chain(
-        self.Initialize(),
-        self.InCheckoutDir(self.Create(), *commands))
+    return cmd.Chain(self.Initialize(),
+                     self.InCheckoutDir(self.Create(), *commands))
 
   def InCheckoutDir(self, *commands):
-    return cmd.Wrapper(
-            cmd.Chain(*commands),
-            cwd=self.checkout_dir)
+    return cmd.Wrapper(cmd.Chain(*commands), cwd=self.checkout_dir)
 
   def CheckoutFromSnapshot(self, snapshot):
     cmds = cmd.Chain()
@@ -216,7 +208,8 @@ class CommandsFactory(object):
         local_dir = os.path.join(self.checkout_dir, os.path.dirname(local_path))
 
         cmds.extend([
-            cmd.Shell('mkdir', '-p', local_dir),
-            cmd.Shell('rsync', '-lr', remote_dir, local_dir)])
+            cmd.Shell('mkdir', '-p', local_dir), cmd.Shell(
+                'rsync', '-lr', remote_dir, local_dir)
+        ])
 
     return cmds