if dsttag is None:

          print("No such tag: %s" % tag)

          sys.exit(1)

      to_add = []

      for package in args[1:]:

          package_id = pkglist.get(package, None)

      dsttag = session.getTag(tag)

      if dsttag is None:

          error("No such tag: %s" % tag)

      ret = 0

      for package in args[1:]:

          package_id = pkglist.get(package, None)

      dsttag = session.getTag(tag)

      if dsttag is None:

          error("No such tag: %s" % tag)

      ret = 0

      for package in args[1:]:

          package_id = pkglist.get(package, None)

      # check pkg list existence

      tag = get_tag(taginfo, strict=True)

      pkg = lookup_package(pkginfo, strict=True)

          raise koji.GenericError("Package %s is not in tag listing for %s" %

                                  (pkg['name'], tag['name']))

      pkglist_add(taginfo, pkginfo, block=True, force=force)

  def readPackageList(tagID=None, userID=None, pkgID=None, event=None, inherit=False,

      """Returns the package list for the specified tag or user.

      One of (tagID,userID,pkgID) must be specified

      Note that the returned data includes blocked entries

      """

      if tagID is None and userID is None and pkgID is None:

          raise koji.GenericError('tag,user, and/or pkg must be specified')

      if tagID is not None:

      if userID is not None:

      if pkgID is not None:

          if isinstance(pkgID, int):

          else:

          # things are simpler for the first tag

          pkgid = p['package_id']

          if with_dups:

                  re_cache[pat] = prog

              re_list.append(prog)

          # same query as before, with different params

              pkgid = p['package_id']

              if not with_dups and pkgid in packages:

                  # previous data supercedes

                       type=None):

      """Returns a list of builds for specified tag

      """

      # build - id pkg_id version release epoch

      # tag_listing - id build_id tag_id

      # regardless of inherit setting, we need to use inheritance to read the

      # package list

      # these values are used for each iteration

      fields = [('tag.id', 'tag_id'), ('tag.name', 'tag_name'), ('build.id', 'id'),

                ('build.id', 'build_id'), ('build.version', 'version'), ('build.release', 'release'),

                ('build.completion_time', 'completion_time'),

                ('build.start_time', 'start_time'),

                ('build.task_id', 'task_id'),

                ('events.id', 'creation_event_id'), ('events.time', 'creation_time'),

                ('volume.id', 'volume_id'), ('volume.name', 'volume_name'),

                ('package.id', 'package_id'), ('package.name', 'package_name'),

                ('package.name', 'name'),

                ("package.name || '-' || build.version || '-' || build.release", 'nvr'),

      if type is None:

          pass

      elif type == 'maven':

          fields.extend([('maven_builds.group_id', 'maven_group_id'),

                         ('maven_builds.artifact_id', 'maven_artifact_id'),

                         ('maven_builds.version', 'maven_version')])

      elif type == 'win':

          fields.append(('win_builds.platform', 'platform'))

      elif type == 'image':

          fields.append(('image_builds.build_id', 'build_id'))

      else:

          btype = lookup_name('btype', type, strict=False)

          if not btype:

              raise koji.GenericError('unsupported build type: %s' % type)

          btype_id = btype['id']

      if package:

      if owner:

      builds = []

      seen = {}   # used to enforce the 'latest' option

      for tagid in taglist:

          # log_error(koji.db._quoteparams(q,locals()))

              pkgid = build['package_id']

              pinfo = packages.get(pkgid, None)

              if pinfo is None or pinfo['blocked']:

      For any parent tags where 'maven_include_all' is true, include all versions

      of a given groupId:artifactId, not just the most-recently-tagged.

      """

      taglist = [tag_id]

      if inherit:

          taglist.extend([link['parent_id'] for link in readFullInheritance(tag_id, event_id)])

      #       see https://pagure.io/koji/issue/588 for background

      rpms, builds = readTaggedRPMS(tag_id, event=event_id, inherit=True, latest=latest)

      groups = readTagGroups(tag_id, event=event_id, inherit=True)

                if pkg['blocked']]

      repodir = koji.pathinfo.repo(repo_id, tinfo['name'])

      os.makedirs(repodir)  # should not already exist

          if fromtag:

              assert_tag_access(fromtag_id, user_id=None, force=force)

          # package list check

          pkg_error = None

          if pkg_id not in pkgs:

              pkg_error = "Package %s not in list for %s" % (build['name'], tag['name'])

          # note: we're just running the quick checks now so we can fail

          #       early if appropriate, rather then waiting for the task

          # Make sure package is on the list for the tag we're adding it to

          pkg_error = None

          if pkg_id not in pkgs:

              pkg_error = "Package %s not in list for tag %s" % (package, tag2)

      getPackage = staticmethod(lookup_package)

      def listPackages(self, tagID=None, userID=None, pkgID=None, prefix=None, inherited=False,

          """List if tagID and/or userID is specified, limit the

          list to packages belonging to the given user or with the

          given tag.

                  pkgID = get_package_id(pkgID, strict=True)

              result_list = list(readPackageList(tagID=tagID, userID=userID, pkgID=pkgID,

                                                 inherit=inherited, with_dups=with_dups,

              if with_dups:

                  # when with_dups=True, readPackageList returns a list of list of dicts

                  # convert it to a list of dicts for consistency

          pkg_id = get_package_id(pkg, strict=False)

          if pkg_id is None or tag_id is None:

              return False

          if pkg_id not in pkgs:

              return False

          else:

          # don't check policy for admins using force

          assert_policy('tag', policy_data, force=force)

          # package list check

          pkg_error = None

          if pkg_id not in pkgs:

              pkg_error = "Package %s not in list for %s" % (build['name'], tag)

          activate_session_mock.assert_called_once_with(session, options)

          session.getUser.assert_called_once_with(owner)

          session.getTag.assert_called_once_with(tag)

          session.packageListAdd.assert_called_once_with(

              tag, package, owner, **kwargs)

          session.multiCall.assert_called_once_with(strict=True)

          self.assertEqual(session.mock_calls,

                           [call.getUser(owner),

                            call.getTag(tag),

                            call.packageListAdd(tag, packages[0], owner, **kwargs),

                            call.packageListAdd(tag, packages[2], owner, **kwargs),

                            call.multiCall(strict=True)])

          activate_session_mock.assert_called_once_with(session, options)

          session.getTag.assert_called_once_with(tag)

          session.listPackages.assert_called_once_with(

          session.packageListBlock.assert_called_once_with(

              tag, package, force=True)

          session.multiCall.assert_called_once_with(strict=True)

          self.assertEqual(

              session.mock_calls, [

                  call.getTag(tag),

                  call.packageListBlock(tag, packages[0]),

                  call.packageListBlock(tag, packages[1]),

                  call.packageListBlock(tag, packages[2]),

          activate_session_mock.assert_called_once_with(session, options)

          session.getTag.assert_called_once_with(tag)

          session.listPackages.assert_called_once_with(

          session.packageListBlock.assert_not_called()

          session.multiCall.assert_not_called()

          # Finally, assert that things were called as we expected.

          activate_session_mock.assert_called_once_with(session, options)

          session.getTag.assert_called_once_with(tag)

          session.packageListRemove.assert_called_once_with(

              tag, package, **kwargs)

          session.multiCall.assert_called_once_with(strict=True)

          activate_session_mock.assert_called_once_with(session, options)

          self.assertEqual(

              session.mock_calls, [

          self.assertNotEqual(rv, 1)

      @mock.patch('sys.stdout', new_callable=six.StringIO)

          activate_session_mock.assert_called_once_with(session, options)

          self.assertEqual(

              session.mock_calls, [

          self.assertNotEqual(rv, 1)

      @mock.patch('sys.stderr', new_callable=six.StringIO)

          # Finally, assert that things were called as we expected.

          activate_session_mock.assert_called_once_with(session, options)

          session.getTag.assert_called_once_with(tag)

          session.packageListRemove.assert_not_called()

          session.multiCall.assert_not_called()

      all = int(all)

      numBuilds = server.count('listTagged', tag=tag['id'], inherit=True)

      values['numPackages'] = numPackages

      values['numBuilds'] = numBuilds