from pagure.config import config as pagure_config

  from pagure.lib import model

  try:

      from pagure.lib import get_user

  except ImportError:

  class DistGitAuth(GitAuthHelper):

      """ A Fedora and CentOS dist-Git authentication module. """

      is_dynamic = True

      def __init__(self):

          self.is_debug = pagure_config.get("ACL_DEBUG", False)

          self.global_pr_only = pagure_config.get("PR_ONLY", False)

          self.unspecified_blacklist = [

              re.compile(refre)

          self.rcm_group = pagure_config.get("RCM_GROUP")

          self.supported_sigs = set(pagure_config.get("SUPPORTED_SIGS", []))

          self.sig_prefixes = pagure_config.get("SIG_PREFIXES", [])

          self.protected_namespaces = pagure_config.get(

          if pdc_url and PDCClient:

              self.pdcclient = PDCClient(pdc_url, develop=True)

          else:

          if not self.pdcclient:

              # No way to confirm this is a supported branch, not supported

              return None

              # Anything outside of refs/heads is out-of-scope

              return None

          namespace2pdctype = {

          }

          if len(res) == 0:

              # No status

              return None

              # PDC couldn't make up its mind....

              # Should never happen, but just in case...

              raise ValueError("PDC was unable to make up its mind")

      def info(self, msg):

          """ Function to print information.

              return False

          # Do not allow branch deletions

              self.info("Branch deletion is not allowed")

              return False

          self.debug("Blacklists: %s" % self.blacklists)

          self.debug("User: %s" % user)

          self.debug("User groups: %s" % usergroups)

          # We have data, start the actual ACL checking

          if (

                  self.debug("No supported status available")

              if self.block_unspecified:

                  return False

              # Block second level blacklists

              # this is not a fork, only allow pushing if this is a PR merge.

              pr_only = project.settings.get("pull_request_access_only", False)

              if (

                  self.info("A pull request is required for this branch")

                  return False

              500,

              error_code=APIERROR.ENOCODE,

              error="This pagure instance has no PDC_URL configured, please inform"

          )

      else:

          pdc_url = "%s/component-branches/" % pdc_url.rstrip("/")

          "modules": "module",

          "container": "container",

      }

      try:

          pdc_namespace = to_pdc_namespace[namespace]

          raise pagure.exceptions.APIError(

              500,

              error_code=APIERROR.ENOCODE,

          )

      url = "%s?global_component=%s&name=master&type=%s" % (

      _log.info("Querying PDC at: %s", url)

      try:

          raise pagure.exceptions.APIError(

              500,

              error_code=APIERROR.ENOCODE,

          )

      try:

          raise pagure.exceptions.APIError(

              500,

              error_code=APIERROR.ENOCODE,

          )

      return data["results"][0]["active"] == True

          )

      user_grps = set(user_obj.groups)

      if not user_grps.intersection(req_grps):

          raise pagure.exceptions.APIError(

              403,

              400,

              error_code=APIERROR.EINVALIDREQ,

              errors="This project has been retired and cannot be unorphaned "

          )

      try:

      pagure.lib.notify.log(

          repo,

          topic="project.adopt",

      )

      output = {"point_of_contact": repo.user.user}

      """

      if namespace not in ["rpms"]:

          raise pagure.exceptions.APIError(

      repo = _get_repo(repo, namespace=namespace)

      html = pagure.utils.is_true(flask.request.args.get("html", False))

          req = requests.get(url)

          if not req.ok:

              raise pagure.exceptions.APIError(

          data = req.json()

          for release in data.get("releases", []):

                  continue

              if release["state"] in ["pending", "current"]:

                  releases[release["name"]] = release["long_name"]

          page += 1

      # Retrieves the updates of that package in bodhi

      updates = collections.defaultdict(dict)

      _log.info("Calling bodhi at: %s", update_url)

      req = requests.get(update_url)

      if not req.ok:

          raise pagure.exceptions.APIError(

      data = req.json()

      for update in data["updates"]:

              row = "<tr><td scope='row' class='text-align-left'>{release}</td><td>{stable}</td><td>{testing}</td></tr>"

              stable = ""

              if updates.get(release, {}).get("stable"):

              else:

                  # This makes things a little slower and is only needed up until all releases will have gone

                  # through bodhi all the time (ie: up until about F31 is eol).

                  _log.info("Calling mdapi at: %s", mdapi_url)

                  req = requests.get(mdapi_url)

                  if req.ok:

                      _log.info("mdapi returned ok")

                      data = req.json()

              testing = ""

              if updates.get(release, {}).get("testing"):

              row = row.format(

              )

              html_output += row

          html_output += "</table>"