import inspect

  from koji.plugin import callback

  from rpmautospec import process_distgit

  def _steal_buildroot_object_from_frame_stack():

      buildroot = frame_info = frame = stack = None

      try:

          return

      if not process_distgit.needs_processing(srcdir):

          return

      buildroot = kwargs.get("buildroot")

      if not buildroot:

          buildroot = _steal_buildroot_object_from_frame_stack()

      br_packages = buildroot.getPackageList()

      if not any(p["name"] == "python3-rpmautospec" for p in br_packages):

          buildroot.mock(["--install", "python3-rpmautospec"])

      srcdir_within = buildroot.path_without_to_within(srcdir)

      buildroot.mock(

      )

          repo = match.group("repo")

          commit = match.group("commit")

          if not repo or not commit:

              return

      else:

          _log.info("No source for this build, skipping.")

  from .misc import run_command

  from .py2compat.tagging import unescape_tag

  _log = logging.getLogger(__name__)

      if target:

          cmd.extend(["--", target])

      return run_command(cmd, cwd=path).decode("UTF-8").strip().split("\n")

      specified commit and returns the output from git

      """

      cmd = ["git", "show", "--no-patch", "--format=%P|%H|%ct|%aN <%aE>|%s", commithash]

      return run_command(cmd, cwd=path).decode("UTF-8").strip().split("\n")

  def git_get_changed_files(path: str, commithash: str) -> typing.List[str]:

      """ Returns the list of files changed in the specified commit. """

      cmd = ["git", "diff-tree", "--no-commit-id", "--name-only", "-r", commithash]

      return run_command(cmd, cwd=path).decode("UTF-8").strip().split("\n")

  def git_get_tags(path: str) -> typing.Mapping[str, str]:

      """ Returns a dict containing for each commit tagged the corresponding tag. """

      cmd = ["git", "show-ref", "--tags", "--head"]

      tags_list = run_command(cmd, cwd=path).decode("UTF-8").strip().split("\n")

      output = {}

      with tempfile.TemporaryDirectory(prefix="rpmautospec-") as workdir:

          repocopy = f"{workdir}/{name}"

          shutil.copytree(repopath, repocopy)

          lines = []

          # Get all the tags in the repo

              info = git_get_commit_info(repocopy, commit)

              if len(info) > 1:

                  # Ignore merge commits

                  continue

              _, commithash, commit_ts, author_info, commit_summary = info[0].split("|", 4)

                  # they will be cut down anyway when the RPM gets built, so

                  # the gap between the commits we are gathering here and the

                  # ones in the `changelog` file can be ignored.

                  break

              files_changed = git_get_changed_files(repocopy, commit)

                      )

                  last_author = author_info

              else:

          # Last entries

          output.append(entry)

      repopath = args.worktree_path

      changelog = produce_changelog(repopath)

  import argparse

  import sys

  from . import changelog, process_distgit, release, tag_package

  subcmd_modules_by_name = {}

      global subcmd_modules_by_name

      parser = argparse.ArgumentParser(

          default="https://koji.fedoraproject.org/kojihub",

      )

      # parsers for sub-commands

  def main():

      args = get_cli_args(sys.argv[1:])

      if args.subcommand:

          subcmd_module = subcmd_modules_by_name[args.subcommand]

          sys.exit(subcmd_module.main(args))

      try:

          output = subprocess.check_output(command, cwd=cwd, stderr=subprocess.PIPE)

      except subprocess.CalledProcessError as e:

          raise

      return output

          shutil.copy2(tmp_specfile.name, specfile_name)

      if not actions:

          actions = ["process-specfile"]

              retval = processing_necessary

          # Only print output if explicitly requested

              features_used = []

              if has_autorel:

                  features_used.append("%autorel")

                  features_used.append("%autochangelog")

              if not features_used:

              else:

      if "process-specfile" in actions and processing_necessary:

          process_specfile(srcdir, dist, session, has_autorel, has_autochangelog, changelog_lineno)

      dist = args.dist

      kojiclient = koji_init(args.koji_url)

          return 0

      else:

          return 1

  from itertools import chain

  import logging

  import re

  import typing

  from .misc import (

                  n_builds += 1

      if not last_build:

          return

      pkgrel, middle, minorbump = parse_release_tag(last_build["release"])

      try:

          n_builds = max([pkgrel + 1, n_builds])

      except TypeError:

          pass

  def holistic_heuristic_calculate_release(

  ):

      match = disttag_re.match(dist)

      if not match:

      distcode = match.group("distcode")

      pkgdistver = int(match.group("distver"))

          builds_per_distver[distver].append(build)

      if not builds_per_distver:

          return

      for builds in builds_per_distver.values():

      )

      higher_bound_builds_nvr = [b["nvr"] for b in higher_bound_builds]

      lower_bound_rpmvercmp_key = rpmvercmp_key(lower_bound)

      else:

          higher_bound = higher_bound_nvr = None

      new_evr = holistic_heuristic_calculate_release(dist, evr, lower_bound, higher_bound)

      if new_evr["epoch"]:

      else:

          new_evr_str = f"{new_evr['version']}-{new_evr['release']}"

      release = new_evr["release"]

          owner_name = build["owner_name"]

          # Ignore modular builds, account for staging

          if owner_name.startswith("mbs/") and owner_name.endswith(".fedoraproject.org"):

              continue

          commit = None

              try:

                  task = [t for t in tasks if t["method"] == "buildSRPMFromSCM"][0]

              except IndexError:

                      "Ignoring build without buildSRPMFromSCM task, or any task at all, "

                  )

                  continue

              command = ["git", "tag", tag, commit]

              try:

                  run_command(command, cwd=repopath)

              else:

          else:

              buildroot.mock.assert_any_call(["--install", "python3-rpmautospec"])

  import json

  import os.path

  from unittest import mock

      """Test the rpmautospec.release module"""

      @pytest.mark.parametrize("test_data", data_as_test_parameters(test_data))

          with open(

              os.path.join(

                  __here__,

          mock_client.getPackageID.assert_called_once()

          mock_client.listBuilds.assert_called_once()

  from unittest import mock

  import pytest

      @mock.patch("rpmautospec.tag_package.run_command")

      @mock.patch("rpmautospec.tag_package.koji_init")

      @mock.patch("rpmautospec.tag_package.get_package_builds")

          """Test the tag_package.main() under various conditions."""

          phenomena = [p.strip() for p in phenomena.split(",")]

          koji_init.return_value = kojiclient = mock.Mock()

          get_package_builds.return_value = test_builds = get_test_builds(phenomena)

              tag = f"build/{nevr}"

              run_command.assert_called_once_with(["git", "tag", tag, commit], cwd=repopath)

              if "tagcmdfails" in phenomena:

              else: