# Nothing to do here, move right along

          return

      # First remove deploykeys that no longer exist

      keyfiles = ['deploykey_%s_%s.pub' %

                  (werkzeug.secure_filename(project.fullname),

              repo=issue_blocked.project,

              repofolder=ticketfolder)

          if not issue.private:

              pagure.lib.notify.log(

                  issue.project,

              repo=issue_blocked.project,

              repofolder=ticketfolder)

          if not issue.private:

              pagure.lib.notify.log(

                  issue.project,

      # check for change

      no_change_in_tag = old_tag.tag == new_tag \

      if no_change_in_tag:

          raise pagure.exceptions.PagureException(

              'No change.  Old tag "%s(%s)[%s]" is the same as '

              issue, repo=issue.project, repofolder=ticketfolder)

      msgs = []

      pagure.lib.notify.log(

          project,

          topic='project.tag.edited',

      # If we dupe keys, gitolite might choke.

      ssh_search_key = ssh_short_key.split(' ')[1]

      if session.query(model.DeployKey).filter(

          raise pagure.exceptions.PagureException(

              'Deploy key already exists.'

          )

      new_user_obj = get_user(session, new_user)

      user_obj = get_user(session, user)

      users.add(project.user.user)

      if new_user in users:

              'You are not allowed to add a group of users to this project'

          )

      if new_group in groups:

          raise pagure.exceptions.PagureException(

      if repo:

          raise pagure.exceptions.RepoExistsException(

              'The project repo "%s" already exists in the database' % (

          )

      project = model.Project(

                  )

          elif str(assignee).lower() in ['true', '1']:

              query = query.filter(

              )

          else:

              query = query.filter(

              )

      if author is not None:

          query = query.filter(

          if isinstance(milestones, basestring):

              milestones = [milestones]

          query = query.filter(

              (model.Issue.milestone.in_(milestones))

          )

      elif no_milestones:

          # Asking for issues without a milestone

          query = query.filter(

          )

      elif milestones is not None and milestones != []:

          # Asking for a single specific milestone

                  )

          elif str(assignee).lower() in ['true', '1']:

              query = query.filter(

              )

          else:

              query = query.filter(

              )

      if author is not None:

  def reset_status_pull_request(session, project):

      ''' Reset the status of all opened Pull-Requests of a project.

      '''

          model.PullRequest

      ).filter(

          model.PullRequest.project_id == project.id

      toadd = set(depends) - set(issue.depends_text)

      torm = set(issue.depends_text) - set(depends)

      messages = []

      # Add issue depending

      for depend in sorted([int(i) for i in toadd]):

              # we should never be in this case but better safe than sorry...

              continue

          add_issue_dependency(

              session,

              issue=issue,

      if text:

          try:

              text = md_processor.convert(text)

              LOG.debug(

                  'A markdown error occured while processing: ``%s``',

                  str(text))

      attrs['table'] = ['class']

      attrs['span'] = ['class', 'id']

      attrs['div'] = ['class']

          attrs['img'] = filter_img_src

      tags = bleach.ALLOWED_TAGS + [

          'p', 'br', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',

          'col', 'pre', 'img', 'hr', 'dl', 'dt', 'dd', 'span',

          'kbd', 'var', 'del', 'cite',

      ]

      """

      if pattern is None:

          return {}, None

      def finalize_token(token, custom_search):

          if ':' in token:

              # This was a "key:value" parameter

  from chardet import universaldetector

  _log = logging.getLogger(__name__)

      refname = '%s:refs/heads/%s' % (branch_ref.name, request.branch)

      if (

              (merge is not None and merge.is_uptodate)

              (merge is None and

               mergecode & pygit2.GIT_MERGE_ANALYSIS_UP_TO_DATE)):

      elif (

              (merge is not None and merge.is_fastforward)

              (merge is None and

               mergecode & pygit2.GIT_MERGE_ANALYSIS_FASTFORWARD)):

          raise pagure.exceptions.PagureException(

              'Fork is empty, there are no commits to request pulling')

          raise pagure.exceptions.PagureException(

              'The branch into which this pull-request was to be merged: %s '

              'seems to no longer be present in this repo' % request.branch)

  import pagure.exceptions

  import pagure.lib

  BUILD_STATS = {

  """

  import datetime

  import collections

  CONVENTION = {

      "ix": 'ix_%(table_name)s_%(column_0_label)s',

      # Checks are currently buggy and prevent us from naming them correctly

      "fk": "%(table_name)s_%(column_0_name)s_fkey",

      "pk": "%(table_name)s_pkey",

      "uq": "%(table_name)s_%(column_0_name)s_key",

          secondaryjoin="pagure_group.c.id==projects_groups.c.group_id",

          backref=backref(

              "projects",

          )

      )

              'deploykeys', cascade="delete, delete-orphan", single_parent=True)

          )

  class Issue(BASE):

                      link, filename, display_name = extract_info(line)

                      attachments.append(

                          (link, filename, display_name,

          if self.comments:

              # Check the comments for attachments

              for comment in self.comments:

                          link, filename, display_name = extract_info(line)

                          attachments.append(

                              (link, filename, display_name,

                               str(comment.id)))

          return attachments

      issue = relation(

          'Issue', foreign_keys=[issue_uid], remote_side=[Issue.uid],

          backref=backref(

          )

      key = relation(

          'IssueKeys', foreign_keys=[key_id], remote_side=[IssueKeys.id],

          backref=backref('values', cascade="delete, delete-orphan")

  class Tag(BASE):

          return 'TagIssue(issue:%s, tag:%s)' % (self.issue.id, self.tag)

  class TagColored(BASE):

      """ Stores the colored tags.

      )

      pull_request = relation(

          backref=backref(

              'watchers', cascade="delete, delete-orphan",

          ),