from __future__ import division

  import ast

  from collections import defaultdict, OrderedDict

  import fnmatch

  import json

  import logging

  import os

          yumcomps = None

  import koji

  from koji_cli.lib import _, activate_session, parse_arches, \

          _unique_path, _running_in_bg, _progress_callback, watch_tasks, \

          arg_filter, linked_upload, list_task_output_all_volumes, \

          previous = session.queryRPMSigs(rpm_id=rinfo['id'], sigkey=sigkey)

          assert len(previous) <= 1

          if previous:

              if previous[0]['sighash'] == sighash:

                  print(_("Signature already imported: %s") % path)

                  continue

  import fcntl

  import fnmatch

  import functools

  import json

  import logging

  import os

  from koji.util import base64encode

  from koji.util import decode_bytes

  from koji.util import dslice

  from koji.util import move_and_symlink

  from koji.util import multi_fnmatch

  from koji.util import safer_move

  from koji.util import to_list

  from six.moves import range

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

                  # until we change the way we handle checksums, we have to limit this to md5

                  raise koji.GenericError("Unsupported checksum type: %(checksum_type)s" % fileinfo)

              with open(path, 'rb') as fp:

                  while True:

                      contents = fp.read(8192)

                      if not contents:

          # trust values computed on hub (CG_Importer.prep_outputs)

          if not fileinfo or not fileinfo.get('hub.checked_md5'):

              with open(filepath, 'rb') as archivefp:

                  while True:

                      contents = archivefp.read(8192)

                      if not contents:

              continue

          if not os.path.isfile('%s/%s' % (mavendir, mavenfile)):

              continue

              sumfile = mavenfile + ext

              if sumfile not in mavenfiles:

                  sum = sum_constr()

          #we use the sigkey='' to represent unsigned in the db (so that uniqueness works)

      else:

          sigkey = koji.get_sigpacket_key_id(sigkey)

      rpm_id = rinfo['id']

      # - db entry

      q = """SELECT sighash FROM rpmsigs WHERE rpm_id=%(rpm_id)i AND sigkey=%(sigkey)s"""

  def get_verify_class(verify):

      if verify == 'md5':

      elif verify == 'adler32':

          return koji.util.adler32_constructor

      elif verify:

  import six.moves.configparser

  import errno

  from fnmatch import fnmatch

  import six.moves.http_client

  import imp

  import logging

          fo = open(localfile, "rb")  #specify bufsize?

          totalsize = os.path.getsize(localfile)

          ofs = 0

          debug = self.opts.get('debug', False)

          if callback:

              callback(0, totalsize, 0, 0, 0)

                  sz = ofs

              else:

                  offset = ofs

                  sz = size

              del contents

              tries = 0

  import koji.tasks

  import koji.xmlrpcplus

  from koji.tasks import safe_rmtree

                        dslice, to_list, base64encode

  import os

  import signal

  import logging

              break

          data = base64encode(contents)

          del contents

          tries = 0

  from six.moves import zip

  # imported from kojiweb and kojihub

  def deprecated(message):

      """Print deprecation warning"""

  from __future__ import absolute_import

  try:

      import unittest2 as unittest

  except ImportError:

  import kojihub

  from koji import GenericError

  class TestGetVerifyClass(unittest.TestCase):

          kojihub.get_verify_class(None) is None

      def test_get_verify_class_is_md5(self):

      def test_get_verify_class_is_adler32(self):

          kojihub.get_verify_class('adler32') is adler32_constructor

  from __future__ import absolute_import

  from __future__ import division

  import os

  import os.path

  import re

  from kojiweb.util import _initValues

  from kojiweb.util import _genHTML

  from kojiweb.util import _getValidTokens

  from six.moves import range

  import six

      digest_string = value + options['Secret'].value

      if six.PY3:

          digest_string = digest_string.encode('utf-8')

      value = "%s:%s" % (shasum.hexdigest(), value)

      cookies = six.moves.http_cookies.SimpleCookie()

      cookies['user'] = value

      digest_string = value + options['Secret'].value

      if six.PY3:

          digest_string = digest_string.encode('utf-8')

      if shasum.hexdigest() != sig:

          authlogger.warn('invalid user cookie: %s:%s', sig, value)

          return None

  import cgi

  import Cheetah.Template

  import datetime

  import koji

  import os

  import six

  import ssl

      value = user + str(tstamp) + environ['koji.options']['Secret'].value

      if six.PY3:

          value = value.encode('utf-8')

  def _getValidTokens(environ):

      tokens = []