+     tag_package.tag_package(srcdir, session, pagure_proxy=pagure_proxy)

+ class CustomArgumentParser(argparse.ArgumentParser):

+     """Custom argument parser class for this program

+ 

+     This overrides the `formatter_class` globally, for all created subparsers.

+     """

+ 

+     def __init__(self, *args, **kwargs):

+         kwargs.setdefault("formatter_class", argparse.ArgumentDefaultsHelpFormatter)

+         super().__init__(*args, **kwargs)

+ 

+ 

+     parser = CustomArgumentParser(prog="rpmautospec")

+ disttag_re = re.compile(r"\.?(?P<distcode>[^\d\.]+)(?P<distver>\d+)")

+ def get_package_builds(pkgname: str) -> List[dict]:

+     # Don't add queryOpts={"order": "-nvr"} or similar, this sorts alphanumerically and and this is

+     # not how EVRs should be sorted.

+     return _kojiclient.listBuilds(pkgid, type="rpm")

+     match = disttag_re.fullmatch(dist)

+ import argparse

+ from .misc import disttag_re, get_package_builds, koji_init, rpmvercmp_key, run_command

+ 

+     tag_latest_group = tag_project_parser.add_mutually_exclusive_group()

+     tag_latest_group.add_argument(

+         "--tag-latest-builds",

+         action="store_true",

+         default=True,

+         help="Tag only the latest existing builds for each dist tag.",

+     )

+     tag_latest_group.add_argument(

+         "--tag-all-builds",

+         action="store_false",

+         dest="tag_latest_builds",

+         default=argparse.SUPPRESS,

+         help="Tag all existing historical builds (slow).",

+     )

+ 

+     tag_project_parser.add_argument("worktree_path", help="Path to the dist-git worktree")

+ 

+ def tag_package(srcdir, session, pagure_proxy=None, tag_latest_builds=True):

+ 

+     disttags_found = set()

+ 

+     # Iterate over builds in reverse ENVR order

+     for build in sorted(get_package_builds(name), key=rpmvercmp_key, reverse=True):

+         if tag_latest_builds:

+             # Check if we've seen a build for the respective dist tag already. If so, skip. The

+             # `disttag_matches` list contains tuples of the distcode, distver groups, but they map

+             # 1:1 to dist tags, so we don't need to process further.

+             disttag_matches = disttag_re.findall(build["release"])

+             if not disttag_matches:

+                 _log.warning("Can't find dist tag for build: %s", build["nvr"])

+                 continue

+ 

+             # The dist tag is the right-most match of the pattern in the release string.

+             disttag = disttag_matches[-1]

+ 

+             if disttag in disttags_found:

+                 _log.debug("Skipping older build: %s", build["nvr"])

+                 continue

+ 

+             disttags_found.add(disttag)

+ 

+     tag_package(

+         args.worktree_path,

+         session,

+         pagure_proxy=pagure_proxy,

+         tag_latest_builds=args.tag_latest_builds,

+     )

+ class MainArgs:

+     """Substitute for argparse.Namespace for tests

+ 

+     This simply returns None for any undefined attribute which is useful for

+     testing the main() functions of subcommands.

+ 

+     Use this instead of Mock or MagicMock objects for parsed arguments in

+     tests.

+     """

+ 

+     def __init__(self, **kwargs):

+         for k, v in kwargs.items():

+             setattr(self, k, v)

+ 

+     def __repr__(self):

+         clsname = self.__class__.__name__

+         kwargs = [

+             f"{attr}={getattr(self, attr)!r}" for attr in dir(self) if not attr.startswith("_")

+         ]

+         return f"{clsname}({', '.join(kwargs)})"

+ 

+     def __getattr__(self, attr):

+         # Set this on the object so it shows up in repr()

+         setattr(self, attr, None)

+         return None

+         tag_package_fn.assert_called_once_with(

+             unpacked_repo_dir, koji_session, pagure_proxy=pagure_proxy

+         )

+ from ..common import MainArgs

+             main_args = MainArgs()

+ from ..common import MainArgs

+     builds = [

+         {

+             "name": "pkgname",

+             "epoch": None,

+             "version": "1.0",

+             "release": f"{relver}.fc{distver}",

+             "nvr": f"pkgname-1.0-{relver}.fc{distver}",

+             "owner_name": "hamburglar",

+             "source": f"git+https://{buildsys_host}/rpms/pkgname#{VALID_HASH}",

+             "build_id": build_id,

+             "task_id": 54321,

+         }

+         for build_id, (distver, relver) in enumerate(

+             ((distver, relver) for distver in (32, 31, 30) for relver in (3, 2, 1)), 123

+         )

+     ]

+ 

+     firstbuild = builds[0]

+     lastbuild = builds[-1]

+             "tagallbuilds",

+             firstbuild["epoch"] = 1

+             firstbuild["owner_name"] = "mbs/mbs.fedoraproject.org"

+             if "source" in firstbuild:

+                 firstbuild["source"] = f"git+https://src.fedoraproject.org/rpms/pkgname#{hash_val}"

+             del firstbuild["source"]

+         elif phenomenon == "releasewithoutdisttag":

+             lastbuild["release"] = "1"

+     return builds

+             "tagallbuilds",

+             "releasewithoutdisttag",

+         main_args = MainArgs()

+         main_args.tag_latest_builds = "tagallbuilds" not in phenomena

+ 

+             # It's always the first build that fails

+             run_command.side_effect = [RuntimeError("lp0 is on fire")] + [0] * len(test_builds)

+             pagure_post.assert_any_call(

+                     "tagname": "build/pkgname-0-1.0-3.fc32",

+             kojiclient.getTaskChildren.assert_any_call(test_builds[0]["task_id"])

+         if "modularbuild" in phenomena:

+             assert any("Ignoring modular build:" in m for m in caplog.messages)

+ 

+                 "tagcmdfails",

+             first_build_skipped = True

+             first_build_skipped = False

+ 

+         build = test_builds[0]

+         nevr = "-".join(

+             str(build[partname]) if build[partname] else "0"

+             for partname in ("name", "epoch", "version", "release")

+         )

+         tag = f"build/{nevr}"

+ 

+         if first_build_skipped:

+             assert all(

+                 c.args != ["git", "tag", "--force", tag, commit] for c in run_command.call_args_list

+         else:

+             run_command.assert_any_call(["git", "tag", "--force", tag, commit], cwd=repopath)

+         if "tagcmdfails" in phenomena:

+             assert "lp0 is on fire" in caplog.text

+ 

+         if not first_build_skipped:

+             assert f"Tagged commit {commit} as {tag}" in caplog.messages

+ 

+         if "tagallbuilds" not in phenomena:

+             assert any("Skipping older build:" in s for s in caplog.messages)

+ 

+         if "releasewithoutdisttag" in phenomena:

+             assert any("Can't find dist tag for build:" in s for s in caplog.messages)