flake8:

  	tox -e flake8

  tag::

  	git tag -a $(TAG)

  	@echo "Tagged with: $(TAG)"

          @return:

              an absolute path to the modified XML

          """

          ename = newxml.getElementsByTagName('name')[0]

          ename.firstChild.nodeValue = self.imgname

          esources = newxml.getElementsByTagName('source')

          if not opts.get('scratch'):

              # fields = ('name', 'version', 'release', 'arch', 'epoch', 'size',

              #    'payloadhash', 'buildtime')

              self.logger.debug('ICICLE: %s' % images['raw']['icicle'])

              for p in icicle.getElementsByTagName('extra'):

                  bits = p.firstChild.nodeValue.split(',')

      if archive['checksum_type'] == koji.CHECKSUM_TYPES['md5']:

          hash = md5_constructor()

      elif archive['checksum_type'] == koji.CHECKSUM_TYPES['sha1']:

      elif archive['checksum_type'] == koji.CHECKSUM_TYPES['sha256']:

          hash = hashlib.sha256()

      else:

  import logging

  import os

  import re

  import shutil

  import stat

  import sys

      safer_move,

  )

  logger = logging.getLogger('koji.hub')

      """

      Generate random hex-string token of length 2 * nbytes

      """

  def get_reservation_token(build_id):

      contents = fixEncoding(contents)

      try:

      except xml.sax.SAXParseException:

          # likely an undefined entity reference, so lets try replacing

          # any entity refs we can find and see if we get something parseable

          handler.reset()

          contents = ENTITY_RE.sub('?', contents)

      for field in fields:

          if field not in util.to_list(values.keys()):

          # do not care about FIPS we need md5 for signatures and older hashes

          # It is still used for *some* security

          kwargs['usedforsecurity'] = False

  # END kojikamid dup #

  from __future__ import absolute_import

  import os

  import platform

  import re

          broot.init()

          rootdir = broot.rootdir()

          # workaround for rpm oddness

          # update buildroot state (so that updateBuildRootList() will work)

          self.session.host.setBuildRootState(broot.id, 'BUILDING')

          try:

  __main__.BuildRoot = kojid.BuildRoot

  import koji

  import runroot

  if six.PY2:

      def tearDown(self):

          runroot.BuildRoot = kojid.BuildRoot

      @mock.patch('platform.uname')

          platform_uname.return_value = ('system', 'node', 'release', 'version', 'machine', 'arch')

          self.session.getBuildConfig.return_value = {

              'id': 456,

          runroot.BuildRoot.assert_called_once_with(self.session, self.t.options,

                  'tag_name', 'x86_64', self.t.id, repo_id=1, setup_dns=True,

                  internal_dev_setup=None)

          self.session.host.setBuildRootState.assert_called_once_with(678, 'BUILDING')

          self.br.mock.assert_has_calls([

              mock.call(['--install', 'rpm_a', 'rpm_b']),

  [tox]

  [testenv:flake8]

  deps =

      {[testenv:py2]commands_pre}

  commands =

      {[testenv:py2]commands}

  from __future__ import absolute_import

  import fnmatch

  import optparse

  import os

  import random

  import socket  # for socket.error and socket.setdefaulttimeout

  import string

  import sys

  import time

  import requests

  import rpm

              url = "%s/%s" % (pathinfo.build(self.info), pathinfo.rpm(self.srpm))

              log("Downloading %s" % url)

              # XXX - this is not really the right place for this

              fn = "%s/%s.src.rpm" % (options.workpath, self.nvr)

              koji.ensuredir(os.path.dirname(fn))

              serverdir = _unique_path('koji-shadow')

              session.uploadWrapper(fn, serverdir, blocksize=65536)

              src = "%s/%s" % (serverdir, os.path.basename(fn))

                  koji.ensuredir(os.path.dirname(dst))

                  os.chown(os.path.dirname(dst), 48, 48)  # XXX - hack

                  log("Downloading %s to %s" % (url, dst))

              finally:

                  os.umask(old_umask)

          else:

              koji.ensuredir(options.workpath)

              dst = "%s/%s" % (options.workpath, fn)

              log("Downloading %s to %s..." % (url, dst))

              log("Uploading %s..." % dst)

              session.uploadWrapper(dst, serverdir, blocksize=65536)

          session.importRPM(serverdir, fn)

              self.logger.debug('Checking external url: %s' % arch_url)

              try:

                  r = requests.get(arch_url, timeout=5)

                  ts_elements = root.iter('{http://linux.duke.edu/metadata/repo}timestamp')

                  arch_ts = max([round(float(child.text)) for child in ts_elements])

                  self.external_repo_ts[arch_url] = arch_ts

          if 'checksum_type' in fileinfo:

              checksum_type = CHECKSUM_TYPES[fileinfo['checksum_type']]  # noqa: F821

              if checksum_type == 'sha1':

              elif checksum_type == 'sha256':

                  checksum = hashlib.sha256()

              elif checksum_type == 'md5':

              raise koji.BuildError('%s does not exist' % local_path)

          if algo == 'sha1':

          elif algo == 'md5':

              sum = koji.util.md5_constructor()

          elif algo == 'sha256':