LABEL org.opencontainers.image.authors="pagure community"

  LABEL org.opencontainers.image.url="https://pagure.io/pagure"

  LABEL org.opencontainers.image.authors="pagure community"

  LABEL org.opencontainers.image.url="https://pagure.io/pagure"

  ARG repo=https://pagure.io/pagure.git

  ARG branch=master

  ARG repo=https://pagure.io/pagure.git

  ARG branch=master

               "branch in current directory, can also be overridden by "

               "using the BRANCH environment variable",

      )

      return parser

                  container_volume,

                  branch="{}".format(os.environ.get("BRANCH") or args.branch),

                  repo="{}".format(os.environ.get("REPO") or args.repo),

              ):

                  base_build = True

              else:

  Requires:           python%{python_pkgversion}-flask-oidc

  Requires:           python%{python_pkgversion}-kitchen

  Requires:           python%{python_pkgversion}-markdown

  Requires:           python%{python_pkgversion}-munch

  Requires:           python%{python_pkgversion}-pillow

  Requires:           python%{python_pkgversion}-psutil

      if not ((is_repo_committer(repo) and request.allow_rebase) or can_rebase):

          raise pagure.exceptions.APIError(

              403,

          )

      task = pagure.lib.tasks.rebase_pull_request.delay(

      output["plugins"] = []

          if dbobj:

              form = plugin.form(obj=dbobj)

              fields = _filter_fields(plugin)

      # Get the explicit watch statuses

      for watcher in repo.watchers:

          if watcher.watch_issues or watcher.watch_commits:

              )

          else:

              if watcher.user.username in watching_users_to_watch_level:

              {

                  "name": p.name,

                  "namespace": p.namespace,

                  "description": p.description,

              }

              for p in projects

              session.add(user)

              session.commit()

      print("## Issue Comments")

      if comments:

      if config["ENABLE_DOCS"]:

          config["DOCS_FOLDER"] = os.path.join(config["GIT_FOLDER"], "docs")

      else:

      if config["ENABLE_TICKETS"]:

          config["TICKETS_FOLDER"] = os.path.join(

              config["GIT_FOLDER"], "tickets"

  from binaryornot.helpers import is_binary_string

  from whitenoise import WhiteNoise

  import pagure.config

  import pagure.doc_utils

  import pagure.exceptions

      else:

          flask.abort(

              404,

                  "No content found in the repository, you may want to read "

                  'the <a href="'

                  'https://docs.pagure.org/pagure/usage/using_doc.html">'

          # execution will go through the else clause, making the Pagure

          # authentication machinery pick the user up

          if not oidc.user_loggedin:

          else:

              flask.session["oidc_logintime"] = time.time()

              fas_user_from_oidc()

              authenticated = pagure.utils.authenticated()

      ssh_key = wtforms.StringField(

          "SSH Key",

          # TODO: Add an ssh key validator?

      )

      msg = dict(

          authors=[author],

          agent=user,

      )

      if subject == "branch":

          msg["branch"] = refname

              authors=list(authors),

              changed_files=changed_files,

              agent=user,

              pull_request_id=pr_id,

          )

  except ImportError:

      from flask_wtf import Form as FlaskForm

  from pagure.hooks import BaseHook, BaseRunner

  from pagure.lib.model import BASE, Project

  except ImportError:

      from flask_wtf import Form as FlaskForm

  from pagure.hooks import BaseHook, RequiredIf

  from pagure.lib.model import BASE, Project

  except ImportError:

      from flask_wtf import Form as FlaskForm

  from pagure.config import config as pagure_config

  from pagure.hooks import BaseHook, BaseRunner, RequiredIf

  except ImportError:

      from flask_wtf import Form as FlaskForm

  import pagure.config

  import pagure.lib.tasks_mirror

  except ImportError:

      from flask_wtf import Form as FlaskForm

  import pagure.lib.login

  from pagure.hooks import BaseHook, BaseRunner, RequiredIf

  except ImportError:

      from flask_wtf import Form as FlaskForm

  import pagure.lib.git

  from pagure.hooks import BaseHook, BaseRunner, RequiredIf

      from flask_wtf import Form as FlaskForm

  from sqlalchemy.exc import SQLAlchemyError

  import pagure.config

  import pagure.lib.git

  except ImportError:

      from flask_wtf import Form as FlaskForm

  from pagure.hooks import BaseHook, BaseRunner

  from pagure.lib.model import BASE, Project

  except ImportError:

      from flask_wtf import Form as FlaskForm

  import pagure.lib.git

  import pagure.lib.tasks_services

  except ImportError:

      from flask_wtf import Form as FlaskForm

  import pagure.lib.git

  import pagure.lib.tasks_services

  except ImportError:

      from flask_wtf import Form as FlaskForm

  import pagure.config

  import pagure.lib.git

  except ImportError:

      from flask_wtf import Form as FlaskForm

  import pagure

  from pagure.hooks import BaseHook, BaseRunner

                      "Branch %s could not be found in the repo %s"

                      % (

                          request.branch_from,

                      )

                  )

              "pagure_authorized_keys": PagureGitAuth,

          }[backend]

      else:

      _log.debug("Returning helper %r from backend key %r" % (cls, backend))

      GIT_AUTH_BACKEND_NAME = backend

  from sqlalchemy.exc import SQLAlchemyError

  from sqlalchemy.orm import (

      backref,

      scoped_session,

      sessionmaker,

      validates,

              "full_url": self.full_url,

              "description": self.description,

              "namespace": self.namespace,

              "date_created": arrow_ts(self.date_created),

              "date_modified": arrow_ts(self.date_modified),

              "user": self.user.to_json(public=public),

              "tags": self.tags_text,

              "depends": ["%s" % item for item in self.depending_text],

              "blocks": ["%s" % item for item in self.blocking_text],

              "priority": self.priority,

              "milestone": self.milestone,

              "custom_fields": custom_fields,

              "full_url": self.full_url,

          }

              "date_created": arrow_ts(self.date_created),

              "user": self.user.to_json(public=public),

              "edited_on": arrow_ts(self.edited_on) if self.edited_on else None,

              "notification": self.notification,

              "reactions": self.reactions,

          }

              "branch": self.branch,

              "project": self.project.to_json(public=public, api=api),

              "branch_from": self.branch_from,

              "remote_git": self.remote_git,

              "date_created": arrow_ts(self.date_created),

              "updated_on": arrow_ts(self.updated_on),

              "last_updated": arrow_ts(self.last_updated),

              "closed_at": arrow_ts(self.closed_at) if self.closed_at else None,

              "user": self.user.to_json(public=public),

              "status": self.status,

              "commit_start": self.commit_start,

              "commit_stop": self.commit_stop,

              "initial_comment": self.initial_comment,

              "cached_merge_status": self.merge_status or "unknown",

              "threshold_reached": self.threshold_reached,

              "date_created": arrow_ts(self.date_created),

              "user": self.user.to_json(public=public),

              "edited_on": arrow_ts(self.edited_on) if self.edited_on else None,

              "notification": self.notification,

              "reactions": self.reactions,

          }

          else:

              attrs["img"] = filter_img_src

      if ignore:

          for tag in ignore:

              if tag in tags:

      # newer bleach allow to customize the protocol supported

      if tuple(bleach_v) >= (1, 5, 0):  # pragma: no cover

          kwargs["protocols"] = protocols

      return bleach.clean(text, **kwargs)

      project_name=None,

      pr_uid=None,

  ):

      """Triggers a new run of the CI system on the specified pull-request."""

      pagure.lib.plugins.get_plugin("Pagure CI")

              md.inlinePatterns["striked"] = StrikeThroughPattern(

                  STRIKE_THROUGH_RE

              )

          def _new_markdown_way():

              idx = md.inlinePatterns.get_index_for_name("autolink")

                  "ui_ns.view_repo",

                  repo=projects[0].name,

                  namespace=projects[0].namespace,

              )

          )

  import flask

  import flask_fas_openid

  from sqlalchemy.exc import SQLAlchemyError

  import pagure.lib.query

                          flask.url_for(

                              "ui_ns.view_file",

                              repo=prequest.project_from.name,

                              namespace=prequest.project_from.namespace,

                              identifier=prequest.branch_from,

                              filename=filename,

                                  namespace=comment.parent.project.namespace,

                                  requestid=comment.parent.id,

                                  commentid=comment.id,

                              ),

                              "requestid": comment.parent.id,

                              "commentid": comment.id,

  import flask

  import munch

  from flask_oidc import OpenIDConnect

  from sqlalchemy.exc import SQLAlchemyError

              pagure_config["OIDC_PAGURE_SSH_KEY"],

              pagure_config["OIDC_PAGURE_GROUPS"],

          ]

          info = oidc.user_getinfo(

              [email_key, fulln_key, usern_key, ssh_key, groups_key]

          )

          username = info.get(usern_key)

          if not username:

              fb = pagure_config["OIDC_PAGURE_USERNAME_FALLBACK"]

              if fb == "email":

  import logging

  import flask

  from sqlalchemy.exc import SQLAlchemyError

  import pagure.exceptions

  import flask

  import kitchen.text.converters as ktc

  import pygit2

  import six

  import werkzeug.utils

              pagure.lib.query.add_token_to_user(

                  flask.g.session,

                  repo,

                  acls=form.acls.data,

                  username=flask.g.fas_user.username,

                  expiration_date=form.expiration_date.data,

          except SQLAlchemyError as err:  # pragma: no cover

              flask.g.session.rollback()

              _log.exception(err)

                  "Token could not be revoked,"

                  ' please <a href="/about">contact an administrator</a>'

              )

  from functools import wraps

  import flask

  import pygit2

  import six

  import werkzeug.utils

          elif auth_method == "fas" and not flask.g.fas_user.cla_done:

              flask.session["_requires_fpca"] = True

              flask.flash(

                      'You must <a href="https://accounts.fedoraproject'

                      '.org/">sign the FPCA</a> (Fedora Project '

                      "Contributor Agreement) to use pagure"

  fedmsg <= 1.1.2

  mock <= 4.0.3

  pagure-messages >= 0.0.1

  # Used for when working from a virtualenv.

  # Use this file by running "$ pip install -r requirements.txt"