request = _get_request(repo, requestid)

      _check_pull_request_access(request, assignee=True)

      if not form.validate_on_submit():

          raise pagure.exceptions.APIError(

              400, error_code=APIERROR.EINVALIDREQ, errors=form.errors

      _check_token(repo, project_token=False)

      request = _get_request(repo, requestid)

      if form.validate_on_submit():

          comment = form.comment.data

          commit = form.commit.data or None

      request = _get_request(repo, requestid)

      if "status" in get_request_data():

      else:

      if form.validate_on_submit():

          username = form.username.data

          comment = form.comment.data.strip()

          url = form.url.data.strip()

          uid = form.uid.data.strip() if form.uid.data else None

      _check_token(repo)

      request = _get_request(repo, requestid)

      if form.validate_on_submit():

          status = is_true(form.status.data)

          try:

      _check_pull_request(repo_to)

      _check_token(repo_from, project_token=False)

      if not form.validate_on_submit():

          raise pagure.exceptions.APIError(

              400, error_code=APIERROR.EINVALIDREQ, errors=form.errors

      request = _get_request(repo, requestid)

      _check_pull_request_access(request, assignee=True)

      if form.validate_on_submit():

          assignee = form.assignee.data or None

          # Create our metadata comment object

      form = pagure.forms.IssueFormSimplied(

          priorities=repo.priorities,

          milestones=repo.milestones,

      )

      if form.validate_on_submit():

          title = form.title.data

      issue = _get_issue(repo, issue_id, issueuid=issue_uid)

      _check_private_issue_access(issue)

      if form.validate_on_submit():

          title = form.title.data.strip()

      status = pagure.lib.query.get_issue_statuses(flask.g.session)

      form = pagure.forms.StatusForm(

      )

      close_status = None

      _check_ticket_access(issue, open_access=open_access)

      form = pagure.forms.MilestoneForm(

      )

      if form.validate_on_submit():

      issue = _get_issue(repo, issueid)

      _check_private_issue_access(issue)

      if form.validate_on_submit():

          comment = form.comment.data

          try:

      open_access = repo.settings.get("open_metadata_access_to_all", False)

      _check_ticket_access(issue, assignee=True, open_access=open_access)

      if form.validate_on_submit():

          assignee = form.assignee.data or None

          # Create our metadata comment object

      issue = _get_issue(repo, issueid)

      _check_private_issue_access(issue)

      if form.validate_on_submit():

          status = is_true(form.status.data)

          try:

          else:

              dbobj = plugin.db_object()

      form.active.data = True

      for field in plugin.form_fields:

          fields.append(getattr(form, field))

      repo = _get_repo(repo, username, namespace)

      _check_token(repo, project_token=False)

      if form.validate_on_submit():

          tag_name = form.tag.data

          tag_description = form.tag_description.data

          flask.request.values.get("with_commits", False)

      )

      created = None

      if form.validate_on_submit():

          user_obj = pagure.lib.query.get_user(

      if user:

          namespaces.extend([grp for grp in user.groups])

      if form.validate_on_submit():

          name = form.name.data

          description = form.description.data

      """

      output = {}

      if form.validate_on_submit():

          repo = form.repo.data

          username = form.username.data or None

      except ValueError:

          raise pagure.exceptions.APIError(404, error_code=APIERROR.ENOCOMMIT)

      if form.validate_on_submit():

          username = form.username.data

          comment = form.comment.data.strip()

          url = form.url.data.strip()

          uid = form.uid.data.strip() if form.uid.data else None

      project = _get_repo(repo, username, namespace)

      _check_token(project, project_token=False)

      if form.validate_on_submit():

          acl = form.acl.data

          group = None

          )

      authorized_acls = pagure_config.get("USER_ACLS", [])

      if form.validate_on_submit():

          acls = form.acls.data

          description = form.description.data

  import docutils

  import docutils.core

  import docutils.examples

  import kitchen.text.converters as ktc

  import pagure.lib.encoding_utils

  import pagure.lib.query

              source=rst, writer_name="html", settings_overrides=overrides

          )

      except Exception:

      else:

          html_string = modify_html(html_string)

          return html_string

          safe = True

      elif not ext or (ext and ext in [".text", ".txt"]):

          safe = True

      return output, safe

      api_docs = modify_html(api_docs)

      return api_docs

  import warnings

  import flask

  import pygit2

  from six.moves.urllib.parse import urljoin

  from whitenoise import WhiteNoise

      pagure.lib.query.set_pagure_ci(pagure_config["PAGURE_CI_SERVICES"])

  def create_app(config=None):

      """Create the flask application."""

      app = flask.Flask(__name__)

      app.config = pagure_config

      if config:

          app.config.update(config)

      return all(ord(c) < 128 and ord(c) > 0 for c in s)

  if PYTHON3:

      def is_string(s):

  else:

      def is_string(s):

          try:

          stdin=stdin,

          stdout=subprocess.PIPE,

          stderr=subprocess.PIPE,

      )

      (out, err) = p.communicate(input)

      out = bytes_to_str(out, errors=errors)

          strict_utf8=True,

          email_max_line_length=500,

          max_subject_length=500,

      ):

          super(FilterLinesEnvironmentMixin, self).__init__(**kw)

          self.__strict_utf8 = strict_utf8

          announce_recipients,

          revision_recipients,

          scancommitforcc,

      ):

          super(StaticRecipientsEnvironmentMixin, self).__init__(**kw)

                  config, "commitlist", "mailinglist"

              ),

              scancommitforcc=config.get("scancommitforcc"),

          )

      def _get_recipients(self, config, *names):

          ref_filter_excl_regex,

          ref_filter_do_send_regex,

          ref_filter_dont_send_regex,

      ):

          super(StaticRefFilterEnvironmentMixin, self).__init__(**kw)

              ref_filter_dont_send_regex=self._get_regex(

                  config, "refFilterDontSendRegex"

              ),

          )

          index=True,

      )

      nick = sa.Column(sa.Text, nullable=True, default=None)

      nick_pass = sa.Column(sa.Text, nullable=True, default=None)

      active = sa.Column(sa.Boolean, nullable=False, default=False)

          index=True,

      )

      active = sa.Column(sa.Boolean, nullable=False, default=False)

      project = relation(

          index=True,

      )

      active = sa.Column(sa.Boolean, nullable=False, default=False)

      active = sa.Column(sa.Boolean, nullable=False, default=False)

      branches = sa.Column(sa.Text, nullable=True)

      project = relation(

          "Project",

  @internal_access_only

  def pull_request_add_comment():

      """Add a comment to a pull-request."""

      if not pform.validate_on_submit():

          flask.abort(400, description="Invalid request")

      if not request:

          flask.abort(404, description="Pull-request not found")

      if not form.validate_on_submit():

          flask.abort(400, description="Invalid request")

  @internal_access_only

  def ticket_add_comment():

      """Add a comment to an issue."""

      if not pform.validate_on_submit():

          flask.abort(400, description="Invalid request")

              "to view it",

          )

      if not form.validate_on_submit():

          flask.abort(400, description="Invalid request")

      if cchardet:

          return encodings

          for prober in detector._charset_probers:

              if hasattr(prober, "probers"):

                  for prober in prober.probers:

          stdout=subprocess.PIPE,

          stderr=subprocess.PIPE,

          cwd=abspath,

      )

      (out, err) = procs.communicate(input)

      retcode = procs.wait()

          input=input,

          keepends=keepends,

          error=error,

      )

      return tags

      """Create a new git tag in the git repositorie of the specified project.

      :arg project: the project in which we want to create a git tag

          target,

          target_obj.type,

          pygit2.Signature(user.fullname, user.default_email),

      )

      return tag

          pull_request,

          repotype,

          is_internal,

      ):

          if is_internal:

              self.info("Internal push allowed")

  def arrow_ts(value):

  class AccessLevels(BASE):

          projects = projects.filter(model.Project.namespace == namespace)

      query = session.query(model.Project).filter(

      )

      if sort == "latest":

              flask_request.endpoint,

              per_page=per_page,

              _external=True,

          )

      prev_page = None

              flask_request.endpoint,

              per_page=per_page,

              _external=True,

          )

      request_args_wo_page.update({key_page: 1})

          flask_request.endpoint,

          per_page=per_page,

          _external=True,

      )

      request_args_wo_page.update({key_page: pages})

          flask_request.endpoint,

          per_page=per_page,

          _external=True,

      )

      return {

          # for each files computes the different algorythm supported

          with open(os.path.join(folder, filename), "rb") as stream:

              while True:

                  if buf:

                      for hasher in algos.values():

                          hasher.update(buf)

              "x-Extra-project_user": project.user if project.is_fork else "",

              "X-Extra-project_namespace": project.namespace,

          },

      )

      # Strip out any headers that cause problems

      form = pagure.forms.RequestPullEditForm(branches=flask.g.branches)

      if form.validate_on_submit():

          if flask.g.fas_user.username == request.user.username:

              request.allow_rebase = form.allow_rebase.data

          flask.g.session.add(request)

              if orig_commit:

                  orig_commit = orig_commit.oid.hex

              commit_start = commit_stop = None

              if diff_commits:

                  commit_stop = diff_commits[0].oid.hex

              except Exception as err:

                  flask.abort(500, description=err)

          repopath = pagure.utils.get_remote_repo_path(remote_git, branch_from)

          if not repopath:

                  user=flask.g.fas_user.username,

              )

                  pagure.lib.query.add_pull_request_comment(

                      flask.g.session,

                      request=request,

          except pygit2.GitError:

              branch_to = "master"

      else:

      return flask.render_template(

          "remote_pull_request.html",

          # Check if the optional field is filled

          if form.assignee.data:

              assignee = form.assignee.data.strip()

          close_status = form.close_status.data or None

          if close_status not in repo.close_status:

              close_status = None

          new_milestone = None

          try:

              if repo.milestones:

          except AttributeError:

              pass

                  no_milestones=no_stone,

                  count=True,

                  status=status,

              )

          else:

              if status.lower() in ["open", "true"]:

              order=order,

              order_key=order_key,

              status=status,

          )

          issues_cnt = pagure.lib.query.search_issues(

              flask.g.session,

              no_milestones=no_stone,

              count=True,

              status=status_count,

          )

          oth_issues_cnt = pagure.lib.query.search_issues(

              flask.g.session,

              no_milestones=no_stone,

              count=True,

              status=other_status_count,

          )

      else:

          issues = pagure.lib.query.search_issues(

              custom_search=custom_search,

              order=order,

              order_key=order_key,

          )

          issues_cnt = pagure.lib.query.search_issues(

              flask.g.session,

              search_pattern=search_pattern,

              custom_search=custom_search,

              count=True,

          )

          oth_issues_cnt = pagure.lib.query.search_issues(

              flask.g.session,

              no_milestones=no_stone,

              count=True,

              status="Open",

          )

      tag_list = pagure.lib.query.get_tags_of_project(flask.g.session, repo)

          total_open=total_open,

          total_closed=total_closed,

          no_milestones=no_stone,

      )

              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,

                  branch=branchname,

                  branchto=form.branch.data,

                  filename=filename,

                  message="%s\n\n%s"

                  % (

                      form.commit_title.data.strip(),

  [tool.black]

  line-length = 79

  include = '\.py?$'

  exclude = '''

  /(