# projects_groups

      group = pagure.lib.search_groups(session, pattern=None,

                                       group_name="rel-eng", group_type=None)

      item = pagure.lib.model.ProjectGroup(

          project_id=repo.id,

          group_id=group.id

      group = pagure.lib.search_groups(session, pattern=None,

                                       group_name="admin", group_type=None)

      item = pagure.lib.model.ProjectGroup(

          project_id=repo.id,

          group_id=group.id

      ######################################

      # pull_requests

      req = pagure.lib.new_pull_request(

          session=session,

          repo_from=forked_repo,

      ######################################

      # user_projects

      user = pagure.lib.search_user(session, username='foo')

      item = pagure.lib.model.ProjectUser(

          project_id=repo.id,

          user_id=user.id

      session.commit()

      user = pagure.lib.search_user(session, username=username)

      item = pagure.lib.model.ProjectUser(

          project_id=repo.id,

          user_id=user.id

      ######################################

      # issue_to_issue

      all_issues = pagure.lib.search_issues(session, repo)

      pagure.lib.add_issue_dependency(session, all_issues[0],

                                      all_issues[1], 'pingou',

      ######################################

      # tags_issues

      issues = pagure.lib.search_issues(session, repo)

      item = pagure.lib.model.TagIssue(

          issue_uid=issues[0].uid,

      except:

          print('requests folder already deleted')

      result = pagure.lib.fork_project(session, 'foo', repo,

                                       pagure.APP.config['GIT_FOLDER'],

                                       pagure.APP.config['DOCS_FOLDER'],

  Defaults to: ``None``

  EXCLUDE_GROUP_INDEX

  ~~~~~~~~~~~~~~~~~~~

      """ Return the Ticket or Request object based on the path provided.

      """

      (username, namespace, reponame, objtype, objid) = _parse_path(path)

      if repo is None:

          raise PagureEvException("Project '%s' not found" % reponame)

          _log.info('Looking for project: %s%s of user: %s',

                   '%s/' % namespace if namespace else '',

                   repo, username)

              session, repo, user=username, namespace=namespace)

          if not project:

  import logging

  import os

  import trollius

  import trollius_redis

          _log.info('Looking for project: %s%s of %s',

                   '%s/' % namespacerepo if namespace else '',

                   repo, username)

              pagure.SESSION, repo, user=username, namespace=namespace)

          if not project:

      ) or (user in usergrps)

  def generate_user_key_files():

      """ Regenerate the key files used by gitolite.

      """

      # If there isn't a `repo` in the URL path, or if there is but the

      # endpoint called is part of the API, just don't do anything

      if repo:

              SESSION, repo, user=username, namespace=namespace)

          if authenticated():

          if not flask.g.repo \

              and APP.config.get('OLD_VIEW_COMMIT_ENABLED', False) \

      if pattern is not None and not pattern.endswith('*'):

          pattern += '*'

      if not project_obj:

          output = {'output': 'notok', 'error': 'Project not found'}

          jsonout = flask.jsonify(output)

      """

          SESSION, repo, user=username, namespace=namespace)

      if not project:

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

      """

          SESSION, repo, user=username, namespace=namespace)

      if repo is None:

      """

          SESSION, repo, user=username, namespace=namespace)

      if repo is None:

      """  # noqa

      output = {}

          SESSION, repo, user=username, namespace=namespace)

      if repo is None:

      """  # noqa

      output = {}

          SESSION, repo, user=username, namespace=namespace)

      if repo is None:

          }

      """  # noqa

          SESSION, repo, user=username, namespace=namespace)

      output = {}

      if repo is None:

          }

      """  # noqa

          SESSION, repo, user=username, namespace=namespace)

      output = {}

      if repo is None:

      :raises pagure.exceptions.APIError: when repository doesn't exists or is disabled

      :return: repository name

      """

          SESSION, repo_name, user=username, namespace=namespace)

      if repo is None:

  import pagure

  import pagure.exceptions

  import pagure.lib

  from pagure.api import API, api_method, APIERROR, api_login_required

          }

      """

          SESSION, repo, user=username, namespace=namespace)

      if repo is None:

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

      elif str(fork).lower() in ['0', 'false']:

          fork = False

      projects = pagure.lib.search_projects(

      if not projects:

          raise pagure.exceptions.APIError(

          }

      """

          SESSION, repo, user=username, namespace=namespace)

      if repo is None:

          username = form.username.data or None

          namespace = form.namespace.data.strip() or None

              SESSION, repo, user=username, namespace=namespace)

          if repo is None:

              raise pagure.exceptions.APIError(

  # Enables / Disables managing groups via the UI

  ENABLE_GROUP_MNGT = True

  # Enables / Disables showing all the projects by default on the front page

  SHOW_PROJECTS_INDEX = ['repos', 'myrepos', 'myforks']

  from binaryornot.helpers import is_binary_string

  import pagure.doc_utils

  import pagure.exceptions

  import pagure.lib

      if '.' in repo:

          namespace, repo = repo.split('.', 1)

      if not repo:

          flask.abort(404, 'Project not found')

              wtforms.validators.Length(max=255),

          ]

      )

  class ProjectForm(ProjectFormSimplified):

          print('user:', username)

          print('namespace:', namespace)

      for line in sys.stdin:

          if pagure.APP.config.get('HOOK_DEBUG', False):

      project_name = pagure.lib.git.get_repo_name(abspath)

      username = pagure.lib.git.get_username(abspath)

      namespace = pagure.lib.git.get_repo_namespace(abspath)

          pagure.SESSION, project_name, username, namespace=namespace)

      if not project:

          project = project_name

          print 'user:     ', username

          print 'namspaces:', namespace

      if not repo:

          print 'Unknown repo %s of username: %s in namespace %s' % (

              reponame, username, namespace)

          print('user:', username)

          print('namespace:', namespace)

          pagure.SESSION, repo, user=username, namespace=namespace)

      for line in sys.stdin:

                      'commits': commits,

                      'data_type': 'ticket',

                      'agent': os.environ.get('GL_USER'),

              print(

                  'A report will be emailed to you once the load is finished')

          else:

          print 'user:     ', username

          print 'namespace:', namespace

      if not repo:

          print 'Unknown repo %s of username: %s' % (reponame, username)

          sys.exit(1)

      plugin = pagure.lib.plugins.get_plugin('Read the Doc')

      # Get the list of branches

      branches = [

          branch.strip()

          response.status_code = 400

          return response

          pagure.SESSION,

          flask.request.form.get('repo', '').strip() or None,

          namespace=flask.request.form.get('namespace', '').strip() or None,

          response.status_code = 400

          return response

      if repo is None:

          response = flask.jsonify({

          response.status_code = 400

          return response

          pagure.SESSION,

          flask.request.form.get('repo', '').strip() or None,

          user=flask.request.form.get('repouser', '').strip() or None)

   Authors:

     Pierre-Yves Chibon <pingou@pingoured.fr>

  """

  import pygit2

  import pagure.exceptions

  import pagure.lib.git

  import pagure.lib.login

              )

          # Send notification for the event-source server

              REDIS.publish('pagure.%s' % obj.uid, json.dumps(

                  {'added_tags': added_tags}))

              )

          # Send notification for the event-source server

              REDIS.publish('pagure.%s' % issue.uid, json.dumps(

                  {'unassigned': '-'}))

          issue.last_updated = datetime.datetime.utcnow()

          # Send notification for the event-source server

              REDIS.publish('pagure.%s' % issue.uid, json.dumps(

                  {'assigned': assignee_obj.to_json(public=True)}))

              request, repo=request.project, repofolder=requestfolder)

          pagure.lib.notify.notify_assigned_request(request, None, user_obj)

          pagure.lib.notify.log(

              request.project,

              topic='request.assigned.reset',

              )

          # Send notification for the event-source server

              REDIS.publish('pagure.%s' % issue.uid, json.dumps({

                  'added_dependency': issue_blocked.id,

                  'issue_uid': issue.uid,

              )

          # Send notification for the event-source server

              REDIS.publish('pagure.%s' % issue.uid, json.dumps({

                  'removed_dependency': parent_del,

                  'issue_uid': issue.uid,

          )

          # Send notification for the event-source server

              REDIS.publish('pagure.%s' % obj.uid, json.dumps(

                  {'removed_tags': removed_tags}))

              new_tag, new_tag_description, new_tag_color

          )

      )

      pagure.lib.notify.log(

          project,

          topic='project.tag.edited',

          pagure.lib.notify.notify_pull_request_comment(pr_comment, user_obj)

      # Send notification for the event-source server

          comment_text = text2markdown(pr_comment.comment)

          REDIS.publish('pagure.%s' % request.uid, json.dumps({

          }))

          # Send notification to the CI server, if the comment added was a

          if notification and request.status == 'Open' \

              REDIS.publish('pagure.ci', json.dumps({

                  'ci_type': request.project.ci_hook.ci_type,

                  'pr': request.to_json(public=True, with_comments=False)

              redis=REDIS,

          )

          if private:

              REDIS.publish('pagure.%s' % comment.parent.uid, json.dumps({

                  'comment_updated': 'private',

                  description=None, url=None, avatar_email=None,

                  parent_id=None, add_readme=False, userobj=None,

                  prevent_40_chars=False, namespace=None, user_ns=False,

      ''' Create a new project based on the information provided.

      '''

      if (not namespace and name in blacklist) \

              )

      # Repo exists in the DB

      if repo:

          raise pagure.exceptions.RepoExistsException(

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

          avatar_email=avatar_email if avatar_email else None,

          user_id=user_obj.id,

          parent_id=parent_id,

          hook_token=pagure.lib.login.id_generator(40)

      )

      session.add(project)

      )

      # Send notification to the CI server

          REDIS.publish('pagure.ci', json.dumps({

              'ci_type': request.project.ci_hook.ci_type,

              'pr': request.to_json(public=True, with_comments=False)

              redis=REDIS,

          )

          if issue.private:

              REDIS.publish('pagure.%s' % issue.uid, json.dumps({

                  'issue': 'private',

          repo.settings = new_settings

          session.add(repo)

          session.flush()

          pagure.lib.notify.log(