p_ars=gl.project_accessrequests.list(project_id=1)

g_ars=gl.group_accessrequests.list(group_id=1)

p_ars=project.accessrequests.list()

g_ars=group.accessrequests.list()

p_ar=gl.project_accessrequests.get(user_id,project_id=1)

g_ar=gl.group_accessrequests.get(user_id,group_id=1)

p_ar=project.accessrequests.get(user_id)

g_ar=group.accessrequests.get(user_id)

p_ar=gl.project_accessrequests.create({},project_id=1)

g_ar=gl.group_accessrequests.create({},group_id=1)

p_ar=project.accessrequests.create({})

g_ar=group.accessrequests.create({})

gl.project_accessrequests.delete(user_id,project_id=1)

gl.group_accessrequests.delete(user_id,group_id=1)

project.accessrequests.delete(user_id)

group.accessrequests.delete(user_id)

Access requests

Use:class:`~gitlab.objects.ProjectAccessRequest` and

:class:`~gitlab.objects.GroupAccessRequest` objects to manipulate access

requests for projects and groups. The

:attr:`gitlab.Gitlab.project_accessrequests`,

:attr:`gitlab.Gitlab.group_accessrequests`,:attr:`Project.accessrequests

<gitlab.objects.Project.accessrequests>` and:attr:`Group.accessrequests

<gitlab.objects.Group.accessrequests>` manager objects provide helper

functions.

Users can request access to groups and projects.

When access is granted the user should be given a numerical access level. The

following constants are provided to represent the access levels:

* ``gitlab.GUEST_ACCESS``: ``10``

* ``gitlab.REPORTER_ACCESS``: ``20``

* ``gitlab.DEVELOPER_ACCESS``: ``30``

* ``gitlab.MASTER_ACCESS``: ``40``

* ``gitlab.OWNER_ACCESS``: ``50``

References

* v4 API:

+:class:`gitlab.v4.objects.ProjectAccessRequest`

+:class:`gitlab.v4.objects.ProjectAccessRequestManager`

+:attr:`gitlab.v4.objects.Project.accessrequests`

+:class:`gitlab.v4.objects.GroupAccessRequest`

+:class:`gitlab.v4.objects.GroupAccessRequestManager`

+:attr:`gitlab.v4.objects.Group.accessrequests`

* v3 API:

+:class:`gitlab.v3.objects.ProjectAccessRequest`

+:class:`gitlab.v3.objects.ProjectAccessRequestManager`

+:attr:`gitlab.v3.objects.Project.accessrequests`

+:attr:`gitlab.Gitlab.project_accessrequests`

+:class:`gitlab.v3.objects.GroupAccessRequest`

+:class:`gitlab.v3.objects.GroupAccessRequestManager`

+:attr:`gitlab.v3.objects.Group.accessrequests`

+:attr:`gitlab.Gitlab.group_accessrequests`

* GitLab API: https://docs.gitlab.com/ce/api/access_requests.html

Examples

branches=gl.project_branches.list(project_id=1)

branches=project.branches.list()

branch=gl.project_branches.get(project_id=1,id='master')

branch=project.branches.get('master')

branch=gl.project_branches.create({'branch_name':'feature1',

'ref':'master'},

project_id=1)

branch=project.branches.create({'branch':'feature1',

'ref':'master'})

branch=project.branches.create({'branch_name':'feature1',

'ref':'master'})

gl.project_branches.delete(project_id=1,id='feature1')

project.branches.delete('feature1')

branch.delete()

Branches

To create:class:`~gitlab.objects.ProjectBranch` objects use the

:attr:`gitlab.Gitlab.project_branches` or:attr:`Project.branches

<gitlab.objects.Project.branches>` managers.

* v4 API:

+:class:`gitlab.v4.objects.ProjectBranch`

+:class:`gitlab.v4.objects.ProjectBranchManager`

+:attr:`gitlab.v4.objects.Project.branches`

* v3 API:

+:class:`gitlab.v3.objects.ProjectBranch`

+:class:`gitlab.v3.objects.ProjectBranchManager`

+:attr:`gitlab.v3.objects.Project.branches`

* GitLab API: https://docs.gitlab.com/ce/api/branches.html

Examples

Get the list of branches for a repository:

..literalinclude::branches.py

:start-after: # protect

:end-before: # end protect

..note::

By default, developers will not be able to push or merge into

protected branches. This can be changed by passing ``developers_can_push``

or ``developers_can_merge`` like so:

``branch.protect(developers_can_push=False, developers_can_merge=True)``

By default, developers are not authorized to push or merge into protected

branches. This can be changed by passing ``developers_can_push`` or

``developers_can_merge``:

..code-block::python

variables=gl.project_variables.list(project_id=1)

variables=project.variables.list()

var=gl.project_variables.get(var_key,project_id=1)

var=project.variables.get(var_key)

var=gl.project_variables.create({'key':'key1','value':'value1'},

project_id=1)

var=project.variables.create({'key':'key1','value':'value1'})

gl.project_variables.delete(var_key)

project.variables.delete()

project.variables.delete(var_key)

var.delete()

triggers=gl.project_triggers.list(project_id=1)

triggers=project.triggers.list()

trigger=gl.project_triggers.get(trigger_token,project_id=1)

trigger=project.triggers.get(trigger_token)

trigger=gl.project_triggers.create({},project_id=1)

trigger=project.triggers.create({})

gl.project_triggers.delete(trigger_token)

project.triggers.delete()

project.triggers.delete(trigger_token)

trigger.delete()

builds=gl.project_builds.list(project_id=1)

builds=project.builds.list()

builds=project.builds.list()# v3

jobs=project.jobs.list()# v4

commit=gl.project_commits.get(commit_sha,project_id=1)

builds=commit.builds()

build=gl.project_builds.get(build_id,project_id=1)

project.builds.get(build_id)

project.builds.get(build_id)# v3

project.jobs.get(job_id)# v4

build.artifacts()

build_or_job.artifacts()

self._fd.write(chunk)

target=Foo()

build.artifacts(streamed=True,action=target)

build_or_job.artifacts(streamed=True,action=target)

del(target)# flushes data on disk

build.keep_artifacts()

build_or_job.keep_artifacts()

build.trace()

build_or_job.trace()

build.cancel()

build.retry()

build_or_job.cancel()

build_or_job.retry()

build.erase()

build_or_job.erase()

build.play()

build_or_job.play()

p=gl.projects.get(project_id)

p.trigger_build('master',trigger_token,

{'extra_var1':'foo','extra_var2':'bar'})

project.trigger_build('master',trigger_token,

{'extra_var1':'foo','extra_var2':'bar'})