move_and_symlink,

      multi_fnmatch,

      safer_move,

  )

  try:

      Blocked packages/groups can alternatively also be listed if incl_blocked is set to True

      """

      groups = get_tag_groups(tag, event, inherit, incl_pkgs, incl_reqs)

      for group in groups:

          # filter blocked entries and collapse to a list

          if 'packagelist' in group:

              if incl_blocked:

              else:

                  group['packagelist'] = [x for x in group['packagelist'].values()

                                          if not x['blocked']]

          if 'grouplist' in group:

              if incl_blocked:

              else:

                  group['grouplist'] = [x for x in group['grouplist'].values()

                                        if not x['blocked']]

              # in a perfect world, this list would only include canonical

              # arches, but not all admins will undertand that.

              ret[koji.canonArch(arch)] = 1

  def get_active_tasks(host=None):

          'package': build['name'],

          'version': build['version'],

          'release': build['release'],

          'import': True,

          'import_type': 'rpm',

      }

              idx.setdefault(row['id'], row)

          if limit is not None and len(idx) > limit:

              break

      if lazy and ret['rpms']:

          return ret

              idx.setdefault(row['id'], row)

          if limit is not None and len(idx) > limit:

              break

      if lazy and ret['archives']:

          return ret

          if from_tag:

              for email in get_notification_recipients(build, from_tag['id'], state):

                  recipients[email] = 1

      if len(recipients_uniq) > 0 and not (is_successful and ignore_success):

          task_id = make_task('tagNotification',

                              [recipients_uniq, is_successful, tag_id, from_id, build_id, user_id,

          if not self.data and not self.rawdata:

              return "-- incomplete update: no assigns"

          parts = ['INSERT INTO %s ' % self.table]

          parts.append("(%s) " % ', '.join(columns))

          values = []

          for key in columns:

              del data['create_event']

              del data['creator_id']

          clauses = ["%s = %%(%s)s" % (k, k) for k in data]

                                 clauses=clauses, values=data)

          if query.execute():

              return True

              # lookup tag id

              tag = get_tag_id(tag, strict=True)

          for mapping in [stops, jumps]:

                  mapping[int(key)] = mapping[key]

          return readFullInheritance(tag, event, reverse, stops, jumps)

          scratchdir = koji.pathinfo.scratch()

          username = get_user(task.getOwner())['name']

          destdir = joinpath(scratchdir, username, 'task_%s' % task_id)

              for filename in files:

                  if reldir:

                      relpath = joinpath(reldir, filename)

          scratchdir = koji.pathinfo.scratch()

          username = get_user(task.getOwner())['name']

          destdir = joinpath(scratchdir, username, 'task_%s' % task_id)

              filename = joinpath(koji.pathinfo.task(results['task_id']), relpath)

              dest = joinpath(destdir, relpath)

              move_and_symlink(filename, dest, create_dir=True)

                              build = get_build(build_id)

                              logger.error("g:a:v supplied by build %(nvr)s", build)

                              logger.error("Build supplies %i archives: %r",

                          if tag_archive:

                              logger.error("Size mismatch, br: %i, db: %i",

                                           fileinfo['size'], tag_archive['size'])

          return args

      def system_listMethods(self):

      def system_methodSignature(self, method):

          # it is not possible to autogenerate this data

  import koji

  import kojiweb.util

  from koji.server import ServerRedirect

  from kojiweb.util import _genHTML, _getValidTokens, _initValues

          if builds > maxBuilds:

              maxBuilds = builds

      values['order'] = order

  import koji

  import koji.util

  from koji.server import ServerError, ServerRedirect

  class URLNotFound(ServerError):

          if isinstance(result, str):

              headers.setdefault('content-length', ('Content-Length', str(len(result))))

          headers.setdefault('content-type', ('Content-Type', 'text/html'))

          self.logger.debug("Headers:")

          self.logger.debug(koji.util.LazyString(pprint.pformat, [headers]))

          start_response(status, headers)