text_prompt
stringlengths 100
17.7k
⌀ | code_prompt
stringlengths 7
9.86k
⌀ |
|---|---|
<SYSTEM_TASK:>
Get the blob indicated by ``sha``.
<END_TASK>
<USER_TASK:>
Description:
def blob(self, sha):
"""Get the blob indicated by ``sha``.
:param str sha: (required), sha of the blob
:returns: :class:`Blob <github3.git.Blob>` if successful, otherwise
None
""" |
url = self._build_url('git', 'blobs', sha, base_url=self._api)
json = self._json(self._get(url), 200)
return Blob(json) if json else None |
<SYSTEM_TASK:>
Get the branch ``name`` of this repository.
<END_TASK>
<USER_TASK:>
Description:
def branch(self, name):
"""Get the branch ``name`` of this repository.
:param str name: (required), branch name
:type name: str
:returns: :class:`Branch <github3.repos.branch.Branch>`
""" |
json = None
if name:
url = self._build_url('branches', name, base_url=self._api)
json = self._json(self._get(url), 200)
return Branch(json, self) if json else None |
<SYSTEM_TASK:>
Get a single commit comment.
<END_TASK>
<USER_TASK:>
Description:
def commit_comment(self, comment_id):
"""Get a single commit comment.
:param int comment_id: (required), id of the comment used by GitHub
:returns: :class:`RepoComment <github3.repos.comment.RepoComment>` if
successful, otherwise None
""" |
url = self._build_url('comments', str(comment_id), base_url=self._api)
json = self._json(self._get(url), 200)
return RepoComment(json, self) if json else None |
<SYSTEM_TASK:>
Compare two commits.
<END_TASK>
<USER_TASK:>
Description:
def compare_commits(self, base, head):
"""Compare two commits.
:param str base: (required), base for the comparison
:param str head: (required), compare this against base
:returns: :class:`Comparison <github3.repos.comparison.Comparison>` if
successful, else None
""" |
url = self._build_url('compare', base + '...' + head,
base_url=self._api)
json = self._json(self._get(url), 200)
return Comparison(json) if json else None |
<SYSTEM_TASK:>
Get the contents of the file pointed to by ``path``.
<END_TASK>
<USER_TASK:>
Description:
def contents(self, path, ref=None):
"""Get the contents of the file pointed to by ``path``.
If the path provided is actually a directory, you will receive a
dictionary back of the form::
{
'filename.md': Contents(), # Where Contents an instance
'github.py': Contents(),
}
:param str path: (required), path to file, e.g.
github3/repo.py
:param str ref: (optional), the string name of a commit/branch/tag.
Default: master
:returns: :class:`Contents <github3.repos.contents.Contents>` or dict
if successful, else None
""" |
url = self._build_url('contents', path, base_url=self._api)
json = self._json(self._get(url, params={'ref': ref}), 200)
if isinstance(json, dict):
return Contents(json, self)
elif isinstance(json, list):
return dict((j.get('name'), Contents(j, self)) for j in json)
return None |
<SYSTEM_TASK:>
Create a blob with ``content``.
<END_TASK>
<USER_TASK:>
Description:
def create_blob(self, content, encoding):
"""Create a blob with ``content``.
:param str content: (required), content of the blob
:param str encoding: (required), ('base64', 'utf-8')
:returns: string of the SHA returned
""" |
sha = ''
if encoding in ('base64', 'utf-8'):
url = self._build_url('git', 'blobs', base_url=self._api)
data = {'content': content, 'encoding': encoding}
json = self._json(self._post(url, data=data), 201)
if json:
sha = json.get('sha')
return sha |
<SYSTEM_TASK:>
Create a comment on a commit.
<END_TASK>
<USER_TASK:>
Description:
def create_comment(self, body, sha, path=None, position=None, line=1):
"""Create a comment on a commit.
:param str body: (required), body of the message
:param str sha: (required), commit id
:param str path: (optional), relative path of the file to comment
on
:param str position: (optional), line index in the diff to comment on
:param int line: (optional), line number of the file to comment on,
default: 1
:returns: :class:`RepoComment <github3.repos.comment.RepoComment>` if
successful, otherwise None
""" |
json = None
if body and sha and (line and int(line) > 0):
data = {'body': body, 'line': line, 'path': path,
'position': position}
self._remove_none(data)
url = self._build_url('commits', sha, 'comments',
base_url=self._api)
json = self._json(self._post(url, data=data), 201)
return RepoComment(json, self) if json else None |
<SYSTEM_TASK:>
Create a commit on this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_commit(self, message, tree, parents, author={}, committer={}):
"""Create a commit on this repository.
:param str message: (required), commit message
:param str tree: (required), SHA of the tree object this
commit points to
:param list parents: (required), SHAs of the commits that were parents
of this commit. If empty, the commit will be written as the root
commit. Even if there is only one parent, this should be an
array.
:param dict author: (optional), if omitted, GitHub will
use the authenticated user's credentials and the current
time. Format: {'name': 'Committer Name', 'email':
'[email protected]', 'date': 'YYYY-MM-DDTHH:MM:SS+HH:00'}
:param dict committer: (optional), if ommitted, GitHub will use the
author parameters. Should be the same format as the author
parameter.
:returns: :class:`Commit <github3.git.Commit>` if successful, else
None
""" |
json = None
if message and tree and isinstance(parents, list):
url = self._build_url('git', 'commits', base_url=self._api)
data = {'message': message, 'tree': tree, 'parents': parents,
'author': author, 'committer': committer}
json = self._json(self._post(url, data=data), 201)
return Commit(json, self) if json else None |
<SYSTEM_TASK:>
Create a deployment.
<END_TASK>
<USER_TASK:>
Description:
def create_deployment(self, ref, force=False, payload='',
auto_merge=False, description='', environment=None):
"""Create a deployment.
:param str ref: (required), The ref to deploy. This can be a branch,
tag, or sha.
:param bool force: Optional parameter to bypass any ahead/behind
checks or commit status checks. Default: False
:param str payload: Optional JSON payload with extra information about
the deployment. Default: ""
:param bool auto_merge: Optional parameter to merge the default branch
into the requested deployment branch if necessary. Default: False
:param str description: Optional short description. Default: ""
:param str environment: Optional name for the target deployment
environment (e.g., production, staging, qa). Default: "production"
:returns: :class:`Deployment <github3.repos.deployment.Deployment>`
""" |
json = None
if ref:
url = self._build_url('deployments', base_url=self._api)
data = {'ref': ref, 'force': force, 'payload': payload,
'auto_merge': auto_merge, 'description': description,
'environment': environment}
self._remove_none(data)
headers = Deployment.CUSTOM_HEADERS
json = self._json(self._post(url, data=data, headers=headers),
201)
return Deployment(json, self) if json else None |
<SYSTEM_TASK:>
Create a fork of this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_fork(self, organization=None):
"""Create a fork of this repository.
:param str organization: (required), login for organization to create
the fork under
:returns: :class:`Repository <Repository>` if successful, else None
""" |
url = self._build_url('forks', base_url=self._api)
if organization:
resp = self._post(url, data={'organization': organization})
else:
resp = self._post(url)
json = self._json(resp, 202)
return Repository(json, self) if json else None |
<SYSTEM_TASK:>
Create a hook on this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_hook(self, name, config, events=['push'], active=True):
"""Create a hook on this repository.
:param str name: (required), name of the hook
:param dict config: (required), key-value pairs which act as settings
for this hook
:param list events: (optional), events the hook is triggered for
:param bool active: (optional), whether the hook is actually
triggered
:returns: :class:`Hook <github3.repos.hook.Hook>` if successful,
otherwise None
""" |
json = None
if name and config and isinstance(config, dict):
url = self._build_url('hooks', base_url=self._api)
data = {'name': name, 'config': config, 'events': events,
'active': active}
json = self._json(self._post(url, data=data), 201)
return Hook(json, self) if json else None |
<SYSTEM_TASK:>
Creates an issue on this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_issue(self,
title,
body=None,
assignee=None,
milestone=None,
labels=None):
"""Creates an issue on this repository.
:param str title: (required), title of the issue
:param str body: (optional), body of the issue
:param str assignee: (optional), login of the user to assign the
issue to
:param int milestone: (optional), id number of the milestone to
attribute this issue to (e.g. ``m`` is a :class:`Milestone
<github3.issues.milestone.Milestone>` object, ``m.number`` is
what you pass here.)
:param labels: (optional), labels to apply to this
issue
:type labels: list of strings
:returns: :class:`Issue <github3.issues.issue.Issue>` if successful,
otherwise None
""" |
issue = {'title': title, 'body': body, 'assignee': assignee,
'milestone': milestone, 'labels': labels}
self._remove_none(issue)
json = None
if issue:
url = self._build_url('issues', base_url=self._api)
json = self._json(self._post(url, data=issue), 201)
return Issue(json, self) if json else None |
<SYSTEM_TASK:>
Create a deploy key.
<END_TASK>
<USER_TASK:>
Description:
def create_key(self, title, key):
"""Create a deploy key.
:param str title: (required), title of key
:param str key: (required), key text
:returns: :class:`Key <github3.users.Key>` if successful, else None
""" |
json = None
if title and key:
data = {'title': title, 'key': key}
url = self._build_url('keys', base_url=self._api)
json = self._json(self._post(url, data=data), 201)
return Key(json, self) if json else None |
<SYSTEM_TASK:>
Create a label for this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_label(self, name, color):
"""Create a label for this repository.
:param str name: (required), name to give to the label
:param str color: (required), value of the color to assign to the
label, e.g., '#fafafa' or 'fafafa' (the latter is what is sent)
:returns: :class:`Label <github3.issues.label.Label>` if successful,
else None
""" |
json = None
if name and color:
data = {'name': name, 'color': color.strip('#')}
url = self._build_url('labels', base_url=self._api)
json = self._json(self._post(url, data=data), 201)
return Label(json, self) if json else None |
<SYSTEM_TASK:>
Create a milestone for this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_milestone(self, title, state=None, description=None,
due_on=None):
"""Create a milestone for this repository.
:param str title: (required), title of the milestone
:param str state: (optional), state of the milestone, accepted
values: ('open', 'closed'), default: 'open'
:param str description: (optional), description of the milestone
:param str due_on: (optional), ISO 8601 formatted due date
:returns: :class:`Milestone <github3.issues.milestone.Milestone>` if
successful, otherwise None
""" |
url = self._build_url('milestones', base_url=self._api)
if state not in ('open', 'closed'):
state = None
data = {'title': title, 'state': state,
'description': description, 'due_on': due_on}
self._remove_none(data)
json = None
if data:
json = self._json(self._post(url, data=data), 201)
return Milestone(json, self) if json else None |
<SYSTEM_TASK:>
Create a pull request of ``head`` onto ``base`` branch in this repo.
<END_TASK>
<USER_TASK:>
Description:
def create_pull(self, title, base, head, body=None):
"""Create a pull request of ``head`` onto ``base`` branch in this repo.
:param str title: (required)
:param str base: (required), e.g., 'master'
:param str head: (required), e.g., 'username:branch'
:param str body: (optional), markdown formatted description
:returns: :class:`PullRequest <github3.pulls.PullRequest>` if
successful, else None
""" |
data = {'title': title, 'body': body, 'base': base,
'head': head}
return self._create_pull(data) |
<SYSTEM_TASK:>
Create a reference in this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_ref(self, ref, sha):
"""Create a reference in this repository.
:param str ref: (required), fully qualified name of the reference,
e.g. ``refs/heads/master``. If it doesn't start with ``refs`` and
contain at least two slashes, GitHub's API will reject it.
:param str sha: (required), SHA1 value to set the reference to
:returns: :class:`Reference <github3.git.Reference>` if successful
else None
""" |
json = None
if ref and ref.count('/') >= 2 and sha:
data = {'ref': ref, 'sha': sha}
url = self._build_url('git', 'refs', base_url=self._api)
json = self._json(self._post(url, data=data), 201)
return Reference(json, self) if json else None |
<SYSTEM_TASK:>
Create a release for this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_release(self, tag_name, target_commitish=None, name=None,
body=None, draft=False, prerelease=False):
"""Create a release for this repository.
:param str tag_name: (required), name to give to the tag
:param str target_commitish: (optional), vague concept of a target,
either a SHA or a branch name.
:param str name: (optional), name of the release
:param str body: (optional), description of the release
:param bool draft: (optional), whether this release is a draft or not
:param bool prerelease: (optional), whether this is a prerelease or
not
:returns: :class:`Release <github3.repos.release.Release>`
""" |
data = {'tag_name': str(tag_name),
'target_commitish': target_commitish,
'name': name,
'body': body,
'draft': draft,
'prerelease': prerelease
}
self._remove_none(data)
url = self._build_url('releases', base_url=self._api)
json = self._json(self._post(
url, data=data, headers=Release.CUSTOM_HEADERS
), 201)
return Release(json, self) |
<SYSTEM_TASK:>
Create a status object on a commit.
<END_TASK>
<USER_TASK:>
Description:
def create_status(self, sha, state, target_url=None, description=None,
context='default'):
"""Create a status object on a commit.
:param str sha: (required), SHA of the commit to create the status on
:param str state: (required), state of the test; only the following
are accepted: 'pending', 'success', 'error', 'failure'
:param str target_url: (optional), URL to associate with this status.
:param str description: (optional), short description of the status
:param str context: (optional), A string label to differentiate this
status from the status of other systems
:returns: the status created if successful
:rtype: :class:`~github3.repos.status.Status`
""" |
json = None
if sha and state:
data = {'state': state, 'target_url': target_url,
'description': description, 'context': context}
url = self._build_url('statuses', sha, base_url=self._api)
self._remove_none(data)
json = self._json(self._post(url, data=data), 201)
return Status(json) if json else None |
<SYSTEM_TASK:>
Create a tag in this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_tag(self, tag, message, sha, obj_type, tagger,
lightweight=False):
"""Create a tag in this repository.
:param str tag: (required), name of the tag
:param str message: (required), tag message
:param str sha: (required), SHA of the git object this is tagging
:param str obj_type: (required), type of object being tagged, e.g.,
'commit', 'tree', 'blob'
:param dict tagger: (required), containing the name, email of the
tagger and the date it was tagged
:param bool lightweight: (optional), if False, create an annotated
tag, otherwise create a lightweight tag (a Reference).
:returns: If lightweight == False: :class:`Tag <github3.git.Tag>` if
successful, else None. If lightweight == True: :class:`Reference
<github3.git.Reference>`
""" |
if lightweight and tag and sha:
return self.create_ref('refs/tags/' + tag, sha)
json = None
if tag and message and sha and obj_type and len(tagger) == 3:
data = {'tag': tag, 'message': message, 'object': sha,
'type': obj_type, 'tagger': tagger}
url = self._build_url('git', 'tags', base_url=self._api)
json = self._json(self._post(url, data=data), 201)
if json:
self.create_ref('refs/tags/' + tag, sha)
return Tag(json) if json else None |
<SYSTEM_TASK:>
Create a tree on this repository.
<END_TASK>
<USER_TASK:>
Description:
def create_tree(self, tree, base_tree=''):
"""Create a tree on this repository.
:param list tree: (required), specifies the tree structure.
Format: [{'path': 'path/file', 'mode':
'filemode', 'type': 'blob or tree', 'sha': '44bfc6d...'}]
:param str base_tree: (optional), SHA1 of the tree you want
to update with new data
:returns: :class:`Tree <github3.git.Tree>` if successful, else None
""" |
json = None
if tree and isinstance(tree, list):
data = {'tree': tree, 'base_tree': base_tree}
url = self._build_url('git', 'trees', base_url=self._api)
json = self._json(self._post(url, data=data), 201)
return Tree(json) if json else None |
<SYSTEM_TASK:>
Delete the file located at ``path``.
<END_TASK>
<USER_TASK:>
Description:
def delete_file(self, path, message, sha, branch=None, committer=None,
author=None):
"""Delete the file located at ``path``.
This is part of the Contents CrUD (Create Update Delete) API. See
http://developer.github.com/v3/repos/contents/#delete-a-file for more
information.
:param str path: (required), path to the file being removed
:param str message: (required), commit message for the deletion
:param str sha: (required), blob sha of the file being removed
:param str branch: (optional), if not provided, uses the repository's
default branch
:param dict committer: (optional), if no information is given the
authenticated user's information will be used. You must specify
both a name and email.
:param dict author: (optional), if omitted this will be filled in with
committer information. If passed, you must specify both a name and
email.
:returns: :class:`Commit <github3.git.Commit>` if successful
""" |
json = None
if path and message and sha:
url = self._build_url('contents', path, base_url=self._api)
data = {'message': message, 'sha': sha, 'branch': branch,
'committer': validate_commmitter(committer),
'author': validate_commmitter(author)}
self._remove_none(data)
json = self._json(self._delete(url, data=dumps(data)), 200)
if json and 'commit' in json:
json = Commit(json['commit'])
return json |
<SYSTEM_TASK:>
Delete the key with the specified id from your deploy keys list.
<END_TASK>
<USER_TASK:>
Description:
def delete_key(self, key_id):
"""Delete the key with the specified id from your deploy keys list.
:returns: bool -- True if successful, False otherwise
""" |
if int(key_id) <= 0:
return False
url = self._build_url('keys', str(key_id), base_url=self._api)
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Edit this repository.
<END_TASK>
<USER_TASK:>
Description:
def edit(self,
name,
description=None,
homepage=None,
private=None,
has_issues=None,
has_wiki=None,
has_downloads=None,
default_branch=None):
"""Edit this repository.
:param str name: (required), name of the repository
:param str description: (optional), If not ``None``, change the
description for this repository. API default: ``None`` - leave
value unchanged.
:param str homepage: (optional), If not ``None``, change the homepage
for this repository. API default: ``None`` - leave value unchanged.
:param bool private: (optional), If ``True``, make the repository
private. If ``False``, make the repository public. API default:
``None`` - leave value unchanged.
:param bool has_issues: (optional), If ``True``, enable issues for
this repository. If ``False``, disable issues for this repository.
API default: ``None`` - leave value unchanged.
:param bool has_wiki: (optional), If ``True``, enable the wiki for
this repository. If ``False``, disable the wiki for this
repository. API default: ``None`` - leave value unchanged.
:param bool has_downloads: (optional), If ``True``, enable downloads
for this repository. If ``False``, disable downloads for this
repository. API default: ``None`` - leave value unchanged.
:param str default_branch: (optional), If not ``None``, change the
default branch for this repository. API default: ``None`` - leave
value unchanged.
:returns: bool -- True if successful, False otherwise
""" |
edit = {'name': name, 'description': description, 'homepage': homepage,
'private': private, 'has_issues': has_issues,
'has_wiki': has_wiki, 'has_downloads': has_downloads,
'default_branch': default_branch}
self._remove_none(edit)
json = None
if edit:
json = self._json(self._patch(self._api, data=dumps(edit)), 200)
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Get a single hook.
<END_TASK>
<USER_TASK:>
Description:
def hook(self, id_num):
"""Get a single hook.
:param int id_num: (required), id of the hook
:returns: :class:`Hook <github3.repos.hook.Hook>` if successful,
otherwise None
""" |
json = None
if int(id_num) > 0:
url = self._build_url('hooks', str(id_num), base_url=self._api)
json = self._json(self._get(url), 200)
return Hook(json, self) if json else None |
<SYSTEM_TASK:>
Check if the user is a possible assignee for an issue on this
<END_TASK>
<USER_TASK:>
Description:
def is_assignee(self, login):
"""Check if the user is a possible assignee for an issue on this
repository.
:returns: :class:`bool`
""" |
if not login:
return False
url = self._build_url('assignees', login, base_url=self._api)
return self._boolean(self._get(url), 204, 404) |
<SYSTEM_TASK:>
Get the issue specified by ``number``.
<END_TASK>
<USER_TASK:>
Description:
def issue(self, number):
"""Get the issue specified by ``number``.
:param int number: (required), number of the issue on this repository
:returns: :class:`Issue <github3.issues.issue.Issue>` if successful,
otherwise None
""" |
json = None
if int(number) > 0:
url = self._build_url('issues', str(number), base_url=self._api)
json = self._json(self._get(url), 200)
return Issue(json, self) if json else None |
<SYSTEM_TASK:>
Get the specified deploy key.
<END_TASK>
<USER_TASK:>
Description:
def key(self, id_num):
"""Get the specified deploy key.
:param int id_num: (required), id of the key
:returns: :class:`Key <github3.users.Key>` if successful, else None
""" |
json = None
if int(id_num) > 0:
url = self._build_url('keys', str(id_num), base_url=self._api)
json = self._json(self._get(url), 200)
return Key(json, self) if json else None |
<SYSTEM_TASK:>
Get the label specified by ``name``
<END_TASK>
<USER_TASK:>
Description:
def label(self, name):
"""Get the label specified by ``name``
:param str name: (required), name of the label
:returns: :class:`Label <github3.issues.label.Label>` if successful,
else None
""" |
json = None
if name:
url = self._build_url('labels', name, base_url=self._api)
json = self._json(self._get(url), 200)
return Label(json, self) if json else None |
<SYSTEM_TASK:>
Iterate over the branches in this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_branches(self, number=-1, etag=None):
"""Iterate over the branches in this repository.
:param int number: (optional), number of branches to return. Default:
-1 returns all branches
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`Branch <github3.repos.branch.Branch>`\ es
""" |
url = self._build_url('branches', base_url=self._api)
return self._iter(int(number), url, Branch, etag=etag) |
<SYSTEM_TASK:>
Iterate over the code frequency per week.
<END_TASK>
<USER_TASK:>
Description:
def iter_code_frequency(self, number=-1, etag=None):
"""Iterate over the code frequency per week.
Returns a weekly aggregate of the number of additions and deletions
pushed to this repository.
:param int number: (optional), number of weeks to return. Default: -1
returns all weeks
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of lists ``[seconds_from_epoch, additions,
deletions]``
.. note:: All statistics methods may return a 202. On those occasions,
you will not receive any objects. You should store your
iterator and check the new ``last_status`` attribute. If it
is a 202 you should wait before re-requesting.
.. versionadded:: 0.7
""" |
url = self._build_url('stats', 'code_frequency', base_url=self._api)
return self._iter(int(number), url, list, etag=etag) |
<SYSTEM_TASK:>
Iterate over comments for a single commit.
<END_TASK>
<USER_TASK:>
Description:
def iter_comments_on_commit(self, sha, number=1, etag=None):
"""Iterate over comments for a single commit.
:param sha: (required), sha of the commit to list comments on
:type sha: str
:param int number: (optional), number of comments to return. Default:
-1 returns all comments
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`RepoComment <github3.repos.comment.RepoComment>`\ s
""" |
url = self._build_url('commits', sha, 'comments', base_url=self._api)
return self._iter(int(number), url, RepoComment, etag=etag) |
<SYSTEM_TASK:>
Iterate over last year of commit activity by week.
<END_TASK>
<USER_TASK:>
Description:
def iter_commit_activity(self, number=-1, etag=None):
"""Iterate over last year of commit activity by week.
See: http://developer.github.com/v3/repos/statistics/
:param int number: (optional), number of weeks to return. Default -1
will return all of the weeks.
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of dictionaries
.. note:: All statistics methods may return a 202. On those occasions,
you will not receive any objects. You should store your
iterator and check the new ``last_status`` attribute. If it
is a 202 you should wait before re-requesting.
.. versionadded:: 0.7
""" |
url = self._build_url('stats', 'commit_activity', base_url=self._api)
return self._iter(int(number), url, dict, etag=etag) |
<SYSTEM_TASK:>
Iterate over commits in this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_commits(self, sha=None, path=None, author=None, number=-1,
etag=None, since=None, until=None):
"""Iterate over commits in this repository.
:param str sha: (optional), sha or branch to start listing commits
from
:param str path: (optional), commits containing this path will be
listed
:param str author: (optional), GitHub login, real name, or email to
filter commits by (using commit author)
:param int number: (optional), number of commits to return. Default:
-1 returns all commits
:param str etag: (optional), ETag from a previous request to the same
endpoint
:param since: (optional), Only commits after this date will
be returned. This can be a `datetime` or an `ISO8601` formatted
date string.
:type since: datetime or string
:param until: (optional), Only commits before this date will
be returned. This can be a `datetime` or an `ISO8601` formatted
date string.
:type until: datetime or string
:returns: generator of
:class:`RepoCommit <github3.repos.commit.RepoCommit>`\ s
""" |
params = {'sha': sha, 'path': path, 'author': author,
'since': timestamp_parameter(since),
'until': timestamp_parameter(until)}
self._remove_none(params)
url = self._build_url('commits', base_url=self._api)
return self._iter(int(number), url, RepoCommit, params, etag) |
<SYSTEM_TASK:>
Iterate over the contributors to this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_contributors(self, anon=False, number=-1, etag=None):
"""Iterate over the contributors to this repository.
:param bool anon: (optional), True lists anonymous contributors as
well
:param int number: (optional), number of contributors to return.
Default: -1 returns all contributors
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`User <github3.users.User>`\ s
""" |
url = self._build_url('contributors', base_url=self._api)
params = {}
if anon:
params = {'anon': True}
return self._iter(int(number), url, User, params, etag) |
<SYSTEM_TASK:>
Iterate over the contributors list.
<END_TASK>
<USER_TASK:>
Description:
def iter_contributor_statistics(self, number=-1, etag=None):
"""Iterate over the contributors list.
See also: http://developer.github.com/v3/repos/statistics/
:param int number: (optional), number of weeks to return. Default -1
will return all of the weeks.
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`ContributorStats <github3.repos.stats.ContributorStats>`
.. note:: All statistics methods may return a 202. On those occasions,
you will not receive any objects. You should store your
iterator and check the new ``last_status`` attribute. If it
is a 202 you should wait before re-requesting.
.. versionadded:: 0.7
""" |
url = self._build_url('stats', 'contributors', base_url=self._api)
return self._iter(int(number), url, ContributorStats, etag=etag) |
<SYSTEM_TASK:>
Iterate over deployments for this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_deployments(self, number=-1, etag=None):
"""Iterate over deployments for this repository.
:param int number: (optional), number of deployments to return.
Default: -1, returns all available deployments
:param str etag: (optional), ETag from a previous request for all
deployments
:returns: generator of
:class:`Deployment <github3.repos.deployment.Deployment>`\ s
""" |
url = self._build_url('deployments', base_url=self._api)
i = self._iter(int(number), url, Deployment, etag=etag)
i.headers.update(Deployment.CUSTOM_HEADERS)
return i |
<SYSTEM_TASK:>
Iterate over forks of this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_forks(self, sort='', number=-1, etag=None):
"""Iterate over forks of this repository.
:param str sort: (optional), accepted values:
('newest', 'oldest', 'watchers'), API default: 'newest'
:param int number: (optional), number of forks to return. Default: -1
returns all forks
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Repository <Repository>`
""" |
url = self._build_url('forks', base_url=self._api)
params = {}
if sort in ('newest', 'oldest', 'watchers'):
params = {'sort': sort}
return self._iter(int(number), url, Repository, params, etag) |
<SYSTEM_TASK:>
Iterate over hooks registered on this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_hooks(self, number=-1, etag=None):
"""Iterate over hooks registered on this repository.
:param int number: (optional), number of hoks to return. Default: -1
returns all hooks
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Hook <github3.repos.hook.Hook>`\ s
""" |
url = self._build_url('hooks', base_url=self._api)
return self._iter(int(number), url, Hook, etag=etag) |
<SYSTEM_TASK:>
Iterate over issues on this repo based upon parameters passed.
<END_TASK>
<USER_TASK:>
Description:
def iter_issues(self,
milestone=None,
state=None,
assignee=None,
mentioned=None,
labels=None,
sort=None,
direction=None,
since=None,
number=-1,
etag=None):
"""Iterate over issues on this repo based upon parameters passed.
.. versionchanged:: 0.9.0
The ``state`` parameter now accepts 'all' in addition to 'open'
and 'closed'.
:param int milestone: (optional), 'none', or '*'
:param str state: (optional), accepted values: ('all', 'open',
'closed')
:param str assignee: (optional), 'none', '*', or login name
:param str mentioned: (optional), user's login name
:param str labels: (optional), comma-separated list of labels, e.g.
'bug,ui,@high'
:param sort: (optional), accepted values:
('created', 'updated', 'comments', 'created')
:param str direction: (optional), accepted values: ('asc', 'desc')
:param since: (optional), Only issues after this date will
be returned. This can be a `datetime` or an `ISO8601` formatted
date string, e.g., 2012-05-20T23:10:27Z
:type since: datetime or string
:param int number: (optional), Number of issues to return.
By default all issues are returned
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Issue <github3.issues.issue.Issue>`\ s
""" |
url = self._build_url('issues', base_url=self._api)
params = {'assignee': assignee, 'mentioned': mentioned}
if milestone in ('*', 'none') or isinstance(milestone, int):
params['milestone'] = milestone
self._remove_none(params)
params.update(
issue_params(None, state, labels, sort, direction,
since)
)
return self._iter(int(number), url, Issue, params, etag) |
<SYSTEM_TASK:>
Iterates over issue events on this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_issue_events(self, number=-1, etag=None):
"""Iterates over issue events on this repository.
:param int number: (optional), number of events to return. Default: -1
returns all available events
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`IssueEvent <github3.issues.event.IssueEvent>`\ s
""" |
url = self._build_url('issues', 'events', base_url=self._api)
return self._iter(int(number), url, IssueEvent, etag=etag) |
<SYSTEM_TASK:>
Iterate over the programming languages used in the repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_languages(self, number=-1, etag=None):
"""Iterate over the programming languages used in the repository.
:param int number: (optional), number of languages to return. Default:
-1 returns all used languages
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of tuples
""" |
url = self._build_url('languages', base_url=self._api)
return self._iter(int(number), url, tuple, etag=etag) |
<SYSTEM_TASK:>
Iterates over the milestones on this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_milestones(self, state=None, sort=None, direction=None,
number=-1, etag=None):
"""Iterates over the milestones on this repository.
:param str state: (optional), state of the milestones, accepted
values: ('open', 'closed')
:param str sort: (optional), how to sort the milestones, accepted
values: ('due_date', 'completeness')
:param str direction: (optional), direction to sort the milestones,
accepted values: ('asc', 'desc')
:param int number: (optional), number of milestones to return.
Default: -1 returns all milestones
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`Milestone <github3.issues.milestone.Milestone>`\ s
""" |
url = self._build_url('milestones', base_url=self._api)
accepted = {'state': ('open', 'closed'),
'sort': ('due_date', 'completeness'),
'direction': ('asc', 'desc')}
params = {'state': state, 'sort': sort, 'direction': direction}
for (k, v) in list(params.items()):
if not (v and (v in accepted[k])): # e.g., '' or None
del params[k]
if not params:
params = None
return self._iter(int(number), url, Milestone, params, etag) |
<SYSTEM_TASK:>
Iterates over events on a network of repositories.
<END_TASK>
<USER_TASK:>
Description:
def iter_network_events(self, number=-1, etag=None):
"""Iterates over events on a network of repositories.
:param int number: (optional), number of events to return. Default: -1
returns all available events
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Event <github3.events.Event>`\ s
""" |
base = self._api.replace('repos', 'networks', 1)
url = self._build_url('events', base_url=base)
return self._iter(int(number), url, Event, etag) |
<SYSTEM_TASK:>
Iterates over the notifications for this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_notifications(self, all=False, participating=False, since=None,
number=-1, etag=None):
"""Iterates over the notifications for this repository.
:param bool all: (optional), show all notifications, including ones
marked as read
:param bool participating: (optional), show only the notifications the
user is participating in directly
:param since: (optional), filters out any notifications updated
before the given time. This can be a `datetime` or an `ISO8601`
formatted date string, e.g., 2012-05-20T23:10:27Z
:type since: datetime or string
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Thread <github3.notifications.Thread>`
""" |
url = self._build_url('notifications', base_url=self._api)
params = {
'all': all,
'participating': participating,
'since': timestamp_parameter(since)
}
for (k, v) in list(params.items()):
if not v:
del params[k]
return self._iter(int(number), url, Thread, params, etag) |
<SYSTEM_TASK:>
Iterate over pages builds of this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_pages_builds(self, number=-1, etag=None):
"""Iterate over pages builds of this repository.
:returns: generator of :class:`PagesBuild
<github3.repos.pages.PagesBuild>`
""" |
url = self._build_url('pages', 'builds', base_url=self._api)
return self._iter(int(number), url, PagesBuild, etag=etag) |
<SYSTEM_TASK:>
List pull requests on repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_pulls(self, state=None, head=None, base=None, sort='created',
direction='desc', number=-1, etag=None):
"""List pull requests on repository.
.. versionchanged:: 0.9.0
- The ``state`` parameter now accepts 'all' in addition to 'open'
and 'closed'.
- The ``sort`` parameter was added.
- The ``direction`` parameter was added.
:param str state: (optional), accepted values: ('all', 'open',
'closed')
:param str head: (optional), filters pulls by head user and branch
name in the format ``user:ref-name``, e.g., ``seveas:debian``
:param str base: (optional), filter pulls by base branch name.
Example: ``develop``.
:param str sort: (optional), Sort pull requests by ``created``,
``updated``, ``popularity``, ``long-running``. Default: 'created'
:param str direction: (optional), Choose the direction to list pull
requests. Accepted values: ('desc', 'asc'). Default: 'desc'
:param int number: (optional), number of pulls to return. Default: -1
returns all available pull requests
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`PullRequest <github3.pulls.PullRequest>`\ s
""" |
url = self._build_url('pulls', base_url=self._api)
params = {}
if state and state.lower() in ('all', 'open', 'closed'):
params['state'] = state.lower()
params.update(head=head, base=base, sort=sort, direction=direction)
self._remove_none(params)
return self._iter(int(number), url, PullRequest, params, etag) |
<SYSTEM_TASK:>
Iterates over references for this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_refs(self, subspace='', number=-1, etag=None):
"""Iterates over references for this repository.
:param str subspace: (optional), e.g. 'tags', 'stashes', 'notes'
:param int number: (optional), number of refs to return. Default: -1
returns all available refs
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Reference <github3.git.Reference>`\ s
""" |
if subspace:
args = ('git', 'refs', subspace)
else:
args = ('git', 'refs')
url = self._build_url(*args, base_url=self._api)
return self._iter(int(number), url, Reference, etag=etag) |
<SYSTEM_TASK:>
Iterates over releases for this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_releases(self, number=-1, etag=None):
"""Iterates over releases for this repository.
:param int number: (optional), number of refs to return. Default: -1
returns all available refs
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`Release <github3.repos.release.Release>`\ s
""" |
url = self._build_url('releases', base_url=self._api)
iterator = self._iter(int(number), url, Release, etag=etag)
iterator.headers.update(Release.CUSTOM_HEADERS)
return iterator |
<SYSTEM_TASK:>
Iterates over the statuses for a specific SHA.
<END_TASK>
<USER_TASK:>
Description:
def iter_statuses(self, sha, number=-1, etag=None):
"""Iterates over the statuses for a specific SHA.
:param str sha: SHA of the commit to list the statuses of
:param int number: (optional), return up to number statuses. Default:
-1 returns all available statuses.
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Status <github3.repos.status.Status>`
""" |
url = ''
if sha:
url = self._build_url('statuses', sha, base_url=self._api)
return self._iter(int(number), url, Status, etag=etag) |
<SYSTEM_TASK:>
Iterates over tags on this repository.
<END_TASK>
<USER_TASK:>
Description:
def iter_tags(self, number=-1, etag=None):
"""Iterates over tags on this repository.
:param int number: (optional), return up to at most number tags.
Default: -1 returns all available tags.
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`RepoTag <github3.repos.tag.RepoTag>`\ s
""" |
url = self._build_url('tags', base_url=self._api)
return self._iter(int(number), url, RepoTag, etag=etag) |
<SYSTEM_TASK:>
Mark all notifications in this repository as read.
<END_TASK>
<USER_TASK:>
Description:
def mark_notifications(self, last_read=''):
"""Mark all notifications in this repository as read.
:param str last_read: (optional), Describes the last point that
notifications were checked. Anything updated since this time will
not be updated. Default: Now. Expected in ISO 8601 format:
``YYYY-MM-DDTHH:MM:SSZ``. Example: "2012-10-09T23:39:01Z".
:returns: bool
""" |
url = self._build_url('notifications', base_url=self._api)
mark = {'read': True}
if last_read:
mark['last_read_at'] = last_read
return self._boolean(self._put(url, data=dumps(mark)),
205, 404) |
<SYSTEM_TASK:>
Perform a merge from ``head`` into ``base``.
<END_TASK>
<USER_TASK:>
Description:
def merge(self, base, head, message=''):
"""Perform a merge from ``head`` into ``base``.
:param str base: (required), where you're merging into
:param str head: (required), where you're merging from
:param str message: (optional), message to be used for the commit
:returns: :class:`RepoCommit <github3.repos.commit.RepoCommit>`
""" |
url = self._build_url('merges', base_url=self._api)
data = {'base': base, 'head': head}
if message:
data['commit_message'] = message
json = self._json(self._post(url, data=data), 201)
return RepoCommit(json, self) if json else None |
<SYSTEM_TASK:>
Get the milestone indicated by ``number``.
<END_TASK>
<USER_TASK:>
Description:
def milestone(self, number):
"""Get the milestone indicated by ``number``.
:param int number: (required), unique id number of the milestone
:returns: :class:`Milestone <github3.issues.milestone.Milestone>`
""" |
json = None
if int(number) > 0:
url = self._build_url('milestones', str(number),
base_url=self._api)
json = self._json(self._get(url), 200)
return Milestone(json, self) if json else None |
<SYSTEM_TASK:>
Get the pull request indicated by ``number``.
<END_TASK>
<USER_TASK:>
Description:
def pull_request(self, number):
"""Get the pull request indicated by ``number``.
:param int number: (required), number of the pull request.
:returns: :class:`PullRequest <github3.pulls.PullRequest>`
""" |
json = None
if int(number) > 0:
url = self._build_url('pulls', str(number), base_url=self._api)
json = self._json(self._get(url), 200)
return PullRequest(json, self) if json else None |
<SYSTEM_TASK:>
Get a reference pointed to by ``ref``.
<END_TASK>
<USER_TASK:>
Description:
def ref(self, ref):
"""Get a reference pointed to by ``ref``.
The most common will be branches and tags. For a branch, you must
specify 'heads/branchname' and for a tag, 'tags/tagname'. Essentially,
the system should return any reference you provide it in the namespace,
including notes and stashes (provided they exist on the server).
:param str ref: (required)
:returns: :class:`Reference <github3.git.Reference>`
""" |
json = None
if ref:
url = self._build_url('git', 'refs', ref, base_url=self._api)
json = self._json(self._get(url), 200)
return Reference(json, self) if json else None |
<SYSTEM_TASK:>
Get a single release.
<END_TASK>
<USER_TASK:>
Description:
def release(self, id):
"""Get a single release.
:param int id: (required), id of release
:returns: :class:`Release <github3.repos.release.Release>`
""" |
json = None
if int(id) > 0:
url = self._build_url('releases', str(id), base_url=self._api)
json = self._json(self._get(url), 200)
return Release(json, self) if json else None |
<SYSTEM_TASK:>
Remove collaborator ``login`` from the repository.
<END_TASK>
<USER_TASK:>
Description:
def remove_collaborator(self, login):
"""Remove collaborator ``login`` from the repository.
:param str login: (required), login name of the collaborator
:returns: bool
""" |
resp = False
if login:
url = self._build_url('collaborators', login, base_url=self._api)
resp = self._boolean(self._delete(url), 204, 404)
return resp |
<SYSTEM_TASK:>
Get a tree.
<END_TASK>
<USER_TASK:>
Description:
def tree(self, sha):
"""Get a tree.
:param str sha: (required), sha of the object for this tree
:returns: :class:`Tree <github3.git.Tree>`
""" |
json = None
if sha:
url = self._build_url('git', 'trees', sha, base_url=self._api)
json = self._json(self._get(url), 200)
return Tree(json, self) if json else None |
<SYSTEM_TASK:>
Update the label ``name``.
<END_TASK>
<USER_TASK:>
Description:
def update_label(self, name, color, new_name=''):
"""Update the label ``name``.
:param str name: (required), name of the label
:param str color: (required), color code
:param str new_name: (optional), new name of the label
:returns: bool
""" |
label = self.label(name)
resp = False
if label:
upd = label.update
resp = upd(new_name, color) if new_name else upd(name, color)
return resp |
<SYSTEM_TASK:>
Returns the total commit counts.
<END_TASK>
<USER_TASK:>
Description:
def weekly_commit_count(self):
"""Returns the total commit counts.
The dictionary returned has two entries: ``all`` and ``owner``. Each
has a fifty-two element long list of commit counts. (Note: ``all``
includes the owner.) ``d['all'][0]`` will be the oldest week,
``d['all'][51]`` will be the most recent.
:returns: dict
.. note:: All statistics methods may return a 202. If github3.py
receives a 202 in this case, it will return an emtpy dictionary.
You should give the API a moment to compose the data and then re
-request it via this method.
..versionadded:: 0.7
""" |
url = self._build_url('stats', 'participation', base_url=self._api)
resp = self._get(url)
if resp.status_code == 202:
return {}
json = self._json(resp, 200)
if json.get('ETag'):
del json['ETag']
if json.get('Last-Modified'):
del json['Last-Modified']
return json |
<SYSTEM_TASK:>
Create a new deployment status for this deployment.
<END_TASK>
<USER_TASK:>
Description:
def create_status(self, state, target_url='', description=''):
"""Create a new deployment status for this deployment.
:param str state: (required), The state of the status. Can be one of
``pending``, ``success``, ``error``, or ``failure``.
:param str target_url: The target URL to associate with this status.
This URL should contain output to keep the user updated while the
task is running or serve as historical information for what
happened in the deployment. Default: ''.
:param str description: A short description of the status. Default: ''.
:return: partial :class:`DeploymentStatus <DeploymentStatus>`
""" |
json = None
if state in ('pending', 'success', 'error', 'failure'):
data = {'state': state, 'target_url': target_url,
'description': description}
response = self._post(self.statuses_url, data=data,
headers=Deployment.CUSTOM_HEADERS)
json = self._json(response, 201)
return DeploymentStatus(json, self) if json else None |
<SYSTEM_TASK:>
Iterate over the deployment statuses for this deployment.
<END_TASK>
<USER_TASK:>
Description:
def iter_statuses(self, number=-1, etag=None):
"""Iterate over the deployment statuses for this deployment.
:param int number: (optional), the number of statuses to return.
Default: -1, returns all statuses.
:param str etag: (optional), the ETag header value from the last time
you iterated over the statuses.
:returns: generator of :class:`DeploymentStatus`\ es
""" |
i = self._iter(int(number), self.statuses_url, DeploymentStatus,
etag=etag)
i.headers = Deployment.CUSTOM_HEADERS
return i |
<SYSTEM_TASK:>
Retrieve the gist at this version.
<END_TASK>
<USER_TASK:>
Description:
def get_gist(self):
"""Retrieve the gist at this version.
:returns: :class:`Gist <github3.gists.gist.Gist>`
""" |
from .gist import Gist
json = self._json(self._get(self._api), 200)
return Gist(json, self) |
<SYSTEM_TASK:>
Update this reference.
<END_TASK>
<USER_TASK:>
Description:
def update(self, sha, force=False):
"""Update this reference.
:param str sha: (required), sha of the reference
:param bool force: (optional), force the update or not
:returns: bool
""" |
data = {'sha': sha, 'force': force}
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Recurse into the tree.
<END_TASK>
<USER_TASK:>
Description:
def recurse(self):
"""Recurse into the tree.
:returns: :class:`Tree <Tree>`
""" |
json = self._json(self._get(self._api, params={'recursive': '1'}),
200)
return Tree(json, self._session) if json else None |
<SYSTEM_TASK:>
Get an Aegea configuration parameter by name
<END_TASK>
<USER_TASK:>
Description:
def get(args):
"""Get an Aegea configuration parameter by name""" |
from . import config
for key in args.key.split("."):
config = getattr(config, key)
print(json.dumps(config)) |
<SYSTEM_TASK:>
Set an Aegea configuration parameter to a given value
<END_TASK>
<USER_TASK:>
Description:
def set(args):
"""Set an Aegea configuration parameter to a given value""" |
from . import config, tweak
class ConfigSaver(tweak.Config):
@property
def config_files(self):
return [config.config_files[2]]
config_saver = ConfigSaver(use_yaml=True, save_on_exit=False)
c = config_saver
for key in args.key.split(".")[:-1]:
try:
c = c[key]
except KeyError:
c[key] = {}
c = c[key]
c[args.key.split(".")[-1]] = json.loads(args.value) if args.json else args.value
config_saver.save() |
<SYSTEM_TASK:>
Obtain an authorization token for the GitHub API.
<END_TASK>
<USER_TASK:>
Description:
def authorize(login, password, scopes, note='', note_url='', client_id='',
client_secret='', two_factor_callback=None):
"""Obtain an authorization token for the GitHub API.
:param str login: (required)
:param str password: (required)
:param list scopes: (required), areas you want this token to apply to,
i.e., 'gist', 'user'
:param str note: (optional), note about the authorization
:param str note_url: (optional), url for the application
:param str client_id: (optional), 20 character OAuth client key for which
to create a token
:param str client_secret: (optional), 40 character OAuth client secret for
which to create the token
:param func two_factor_callback: (optional), function to call when a
Two-Factor Authentication code needs to be provided by the user.
:returns: :class:`Authorization <Authorization>`
""" |
gh = GitHub()
gh.login(two_factor_callback=two_factor_callback)
return gh.authorize(login, password, scopes, note, note_url, client_id,
client_secret) |
<SYSTEM_TASK:>
Construct and return an authenticated GitHub session.
<END_TASK>
<USER_TASK:>
Description:
def login(username=None, password=None, token=None, url=None,
two_factor_callback=None):
"""Construct and return an authenticated GitHub session.
This will return a GitHubEnterprise session if a url is provided.
:param str username: login name
:param str password: password for the login
:param str token: OAuth token
:param str url: (optional), URL of a GitHub Enterprise instance
:param func two_factor_callback: (optional), function you implement to
provide the Two Factor Authentication code to GitHub when necessary
:returns: :class:`GitHub <github3.github.GitHub>`
""" |
g = None
if (username and password) or token:
g = GitHubEnterprise(url) if url is not None else GitHub()
g.login(username, password, token, two_factor_callback)
return g |
<SYSTEM_TASK:>
List the followers of ``username``.
<END_TASK>
<USER_TASK:>
Description:
def iter_followers(username, number=-1, etag=None):
"""List the followers of ``username``.
:param str username: (required), login of the person to list the followers
of
:param int number: (optional), number of followers to return, Default: -1,
return all of them
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`User <github3.users.User>`
""" |
return gh.iter_followers(username, number, etag) if username else [] |
<SYSTEM_TASK:>
List the people ``username`` follows.
<END_TASK>
<USER_TASK:>
Description:
def iter_following(username, number=-1, etag=None):
"""List the people ``username`` follows.
:param str username: (required), login of the user
:param int number: (optional), number of users being followed by username
to return. Default: -1, return all of them
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`User <github3.users.User>`
""" |
return gh.iter_following(username, number, etag) if username else [] |
<SYSTEM_TASK:>
List the organizations associated with ``username``.
<END_TASK>
<USER_TASK:>
Description:
def iter_orgs(username, number=-1, etag=None):
"""List the organizations associated with ``username``.
:param str username: (required), login of the user
:param int number: (optional), number of orgs to return. Default: -1,
return all of the issues
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`Organization <github3.orgs.Organization>`
""" |
return gh.iter_orgs(username, number, etag) if username else [] |
<SYSTEM_TASK:>
List public repositories for the specified ``login``.
<END_TASK>
<USER_TASK:>
Description:
def iter_user_repos(login, type=None, sort=None, direction=None, number=-1,
etag=None):
"""List public repositories for the specified ``login``.
.. versionadded:: 0.6
.. note:: This replaces github3.iter_repos
:param str login: (required)
:param str type: (optional), accepted values:
('all', 'owner', 'member')
API default: 'all'
:param str sort: (optional), accepted values:
('created', 'updated', 'pushed', 'full_name')
API default: 'created'
:param str direction: (optional), accepted values:
('asc', 'desc'), API default: 'asc' when using 'full_name',
'desc' otherwise
:param int number: (optional), number of repositories to return.
Default: -1 returns all repositories
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Repository <github3.repos.Repository>`
objects
""" |
if login:
return gh.iter_user_repos(login, type, sort, direction, number, etag)
return iter([]) |
<SYSTEM_TASK:>
Add labels to this issue.
<END_TASK>
<USER_TASK:>
Description:
def add_labels(self, *args):
"""Add labels to this issue.
:param str args: (required), names of the labels you wish to add
:returns: list of :class:`Label`\ s
""" |
url = self._build_url('labels', base_url=self._api)
json = self._json(self._post(url, data=args), 200)
return [Label(l, self) for l in json] if json else [] |
<SYSTEM_TASK:>
Assigns user ``login`` to this issue. This is a short cut for
<END_TASK>
<USER_TASK:>
Description:
def assign(self, login):
"""Assigns user ``login`` to this issue. This is a short cut for
``issue.edit``.
:param str login: username of the person to assign this issue to
:returns: bool
""" |
if not login:
return False
number = self.milestone.number if self.milestone else None
labels = [str(l) for l in self.labels]
return self.edit(self.title, self.body, login, self.state, number,
labels) |
<SYSTEM_TASK:>
Get a single comment by its id.
<END_TASK>
<USER_TASK:>
Description:
def comment(self, id_num):
"""Get a single comment by its id.
The catch here is that id is NOT a simple number to obtain. If
you were to look at the comments on issue #15 in
sigmavirus24/Todo.txt-python, the first comment's id is 4150787.
:param int id_num: (required), comment id, see example above
:returns: :class:`IssueComment <github3.issues.comment.IssueComment>`
""" |
json = None
if int(id_num) > 0: # Might as well check that it's positive
owner, repo = self.repository
url = self._build_url('repos', owner, repo, 'issues', 'comments',
str(id_num))
json = self._json(self._get(url), 200)
return IssueComment(json) if json else None |
<SYSTEM_TASK:>
Create a comment on this issue.
<END_TASK>
<USER_TASK:>
Description:
def create_comment(self, body):
"""Create a comment on this issue.
:param str body: (required), comment body
:returns: :class:`IssueComment <github3.issues.comment.IssueComment>`
""" |
json = None
if body:
url = self._build_url('comments', base_url=self._api)
json = self._json(self._post(url, data={'body': body}),
201)
return IssueComment(json, self) if json else None |
<SYSTEM_TASK:>
Edit this issue.
<END_TASK>
<USER_TASK:>
Description:
def edit(self, title=None, body=None, assignee=None, state=None,
milestone=None, labels=None):
"""Edit this issue.
:param str title: Title of the issue
:param str body: markdown formatted body (description) of the issue
:param str assignee: login name of user the issue should be assigned
to
:param str state: accepted values: ('open', 'closed')
:param int milestone: the NUMBER (not title) of the milestone to
assign this to [1]_, or 0 to remove the milestone
:param list labels: list of labels to apply this to
:returns: bool
.. [1] Milestone numbering starts at 1, i.e. the first milestone you
create is 1, the second is 2, etc.
""" |
json = None
data = {'title': title, 'body': body, 'assignee': assignee,
'state': state, 'milestone': milestone, 'labels': labels}
self._remove_none(data)
if data:
if 'milestone' in data and data['milestone'] == 0:
data['milestone'] = None
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Iterate over the comments on this issue.
<END_TASK>
<USER_TASK:>
Description:
def iter_comments(self, number=-1):
"""Iterate over the comments on this issue.
:param int number: (optional), number of comments to iterate over
:returns: iterator of
:class:`IssueComment <github3.issues.comment.IssueComment>`\ s
""" |
url = self._build_url('comments', base_url=self._api)
return self._iter(int(number), url, IssueComment) |
<SYSTEM_TASK:>
Iterate over events associated with this issue only.
<END_TASK>
<USER_TASK:>
Description:
def iter_events(self, number=-1):
"""Iterate over events associated with this issue only.
:param int number: (optional), number of events to return. Default: -1
returns all events available.
:returns: generator of
:class:`IssueEvent <github3.issues.event.IssueEvent>`\ s
""" |
url = self._build_url('events', base_url=self._api)
return self._iter(int(number), url, IssueEvent) |
<SYSTEM_TASK:>
Removes label ``name`` from this issue.
<END_TASK>
<USER_TASK:>
Description:
def remove_label(self, name):
"""Removes label ``name`` from this issue.
:param str name: (required), name of the label to remove
:returns: bool
""" |
url = self._build_url('labels', name, base_url=self._api)
# Docs say it should be a list of strings returned, practice says it
# is just a 204/404 response. I'm tenatively changing this until I
# hear back from Support.
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Replace all labels on this issue with ``labels``.
<END_TASK>
<USER_TASK:>
Description:
def replace_labels(self, labels):
"""Replace all labels on this issue with ``labels``.
:param list labels: label names
:returns: bool
""" |
url = self._build_url('labels', base_url=self._api)
json = self._json(self._put(url, data=dumps(labels)), 200)
return [Label(l, self) for l in json] if json else [] |
<SYSTEM_TASK:>
Re-open a closed issue.
<END_TASK>
<USER_TASK:>
Description:
def reopen(self):
"""Re-open a closed issue.
:returns: bool
""" |
assignee = self.assignee.login if self.assignee else ''
number = self.milestone.number if self.milestone else None
labels = [str(l) for l in self.labels]
return self.edit(self.title, self.body, assignee, 'open',
number, labels) |
<SYSTEM_TASK:>
Convert an ISO 8601 formatted string in UTC into a
<END_TASK>
<USER_TASK:>
Description:
def _strptime(self, time_str):
"""Convert an ISO 8601 formatted string in UTC into a
timezone-aware datetime object.""" |
if time_str:
# Parse UTC string into naive datetime, then add timezone
dt = datetime.strptime(time_str, __timeformat__)
return dt.replace(tzinfo=UTC())
return None |
<SYSTEM_TASK:>
Generic iterator for this project.
<END_TASK>
<USER_TASK:>
Description:
def _iter(self, count, url, cls, params=None, etag=None):
"""Generic iterator for this project.
:param int count: How many items to return.
:param int url: First URL to start with
:param class cls: cls to return an object of
:param params dict: (optional) Parameters for the request
:param str etag: (optional), ETag from the last call
""" |
from .structs import GitHubIterator
return GitHubIterator(count, url, cls, self, params, etag) |
<SYSTEM_TASK:>
Number of requests before GitHub imposes a ratelimit.
<END_TASK>
<USER_TASK:>
Description:
def ratelimit_remaining(self):
"""Number of requests before GitHub imposes a ratelimit.
:returns: int
""" |
json = self._json(self._get(self._github_url + '/rate_limit'), 200)
core = json.get('resources', {}).get('core', {})
self._remaining = core.get('remaining', 0)
return self._remaining |
<SYSTEM_TASK:>
Re-retrieve the information for this object and returns the
<END_TASK>
<USER_TASK:>
Description:
def refresh(self, conditional=False):
"""Re-retrieve the information for this object and returns the
refreshed instance.
:param bool conditional: If True, then we will search for a stored
header ('Last-Modified', or 'ETag') on the object and send that
as described in the `Conditional Requests`_ section of the docs
:returns: self
The reasoning for the return value is the following example: ::
repos = [r.refresh() for r in g.iter_repos('kennethreitz')]
Without the return value, that would be an array of ``None``'s and you
would otherwise have to do: ::
repos = [r for i in g.iter_repos('kennethreitz')]
[r.refresh() for r in repos]
Which is really an anti-pattern.
.. versionchanged:: 0.5
.. _Conditional Requests:
http://developer.github.com/v3/#conditional-requests
""" |
headers = {}
if conditional:
if self.last_modified:
headers['If-Modified-Since'] = self.last_modified
elif self.etag:
headers['If-None-Match'] = self.etag
headers = headers or None
json = self._json(self._get(self._api, headers=headers), 200)
if json is not None:
self.__init__(json, self._session)
return self |
<SYSTEM_TASK:>
Edit this comment.
<END_TASK>
<USER_TASK:>
Description:
def edit(self, body):
"""Edit this comment.
:param str body: (required), new body of the comment, Markdown
formatted
:returns: bool
""" |
if body:
json = self._json(self._patch(self._api,
data=dumps({'body': body})), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Ensure the table is valid for converting to grid table.
<END_TASK>
<USER_TASK:>
Description:
def check_table(table):
"""
Ensure the table is valid for converting to grid table.
* The table must a list of lists
* Each row must contain the same number of columns
* The table must not be empty
Parameters
----------
table : list of lists of str
The list of rows of strings to convert to a grid table
Returns
-------
message : str
If no problems are found, this message is empty, otherwise it
tries to describe the problem that was found.
""" |
if not type(table) is list:
return "Table must be a list of lists"
if len(table) == 0:
return "Table must contain at least one row and one column"
for i in range(len(table)):
if not type(table[i]) is list:
return "Table must be a list of lists"
if not len(table[i]) == len(table[0]):
"Each row must have the same number of columns"
return "" |
<SYSTEM_TASK:>
Convert node names into node instances...
<END_TASK>
<USER_TASK:>
Description:
def _translate_nodes(root, *nodes):
"""
Convert node names into node instances...
""" |
#name2node = {[n, None] for n in nodes if type(n) is str}
name2node = dict([[n, None] for n in nodes if type(n) is str])
for n in root.traverse():
if n.name in name2node:
if name2node[n.name] is not None:
raise TreeError("Ambiguous node name: {}".format(str(n.name)))
else:
name2node[n.name] = n
if None in list(name2node.values()):
notfound = [key for key, value in six.iteritems(name2node) if value is None]
raise ValueError("Node names not found: "+str(notfound))
valid_nodes = []
for n in nodes:
if type(n) is not str:
if type(n) is not root.__class__:
raise TreeError("Invalid target node: "+str(n))
else:
valid_nodes.append(n)
valid_nodes.extend(list(name2node.values()))
if len(valid_nodes) == 1:
return valid_nodes[0]
else:
return valid_nodes |
<SYSTEM_TASK:>
Add or update a node's feature.
<END_TASK>
<USER_TASK:>
Description:
def add_feature(self, pr_name, pr_value):
""" Add or update a node's feature. """ |
setattr(self, pr_name, pr_value)
self.features.add(pr_name) |
<SYSTEM_TASK:>
Add or update several features.
<END_TASK>
<USER_TASK:>
Description:
def add_features(self, **features):
""" Add or update several features. """ |
for fname, fvalue in six.iteritems(features):
setattr(self, fname, fvalue)
self.features.add(fname) |
<SYSTEM_TASK:>
Permanently deletes a node's feature.
<END_TASK>
<USER_TASK:>
Description:
def del_feature(self, pr_name):
""" Permanently deletes a node's feature.""" |
if hasattr(self, pr_name):
delattr(self, pr_name)
self.features.remove(pr_name) |
<SYSTEM_TASK:>
Adds a sister to this node. If sister node is not supplied
<END_TASK>
<USER_TASK:>
Description:
def add_sister(self, sister=None, name=None, dist=None):
"""
Adds a sister to this node. If sister node is not supplied
as an argument, a new TreeNode instance will be created and
returned.
""" |
if self.up == None:
raise TreeError("A parent node is required to add a sister")
else:
return self.up.add_child(child=sister, name=name, dist=dist) |
<SYSTEM_TASK:>
Deletes node from the tree structure. Notice that this method
<END_TASK>
<USER_TASK:>
Description:
def delete(self, prevent_nondicotomic=True, preserve_branch_length=False):
"""
Deletes node from the tree structure. Notice that this method
makes 'disappear' the node from the tree structure. This means
that children from the deleted node are transferred to the
next available parent.
Parameters:
-----------
prevent_nondicotomic:
When True (default), delete
function will be execute recursively to prevent single-child
nodes.
preserve_branch_length:
If True, branch lengths of the deleted nodes are transferred
(summed up) to its parent's branch, thus keeping original
distances among nodes.
**Example:**
/ C
root-|
| / B
\--- H |
\ A
> H.delete() will produce this structure:
/ C
|
root-|--B
|
\ A
""" |
parent = self.up
if parent:
if preserve_branch_length:
if len(self.children) == 1:
self.children[0].dist += self.dist
elif len(self.children) > 1:
parent.dist += self.dist
for ch in self.children:
parent.add_child(ch)
parent.remove_child(self)
# Avoids parents with only one child
if prevent_nondicotomic and parent and\
len(parent.children) < 2:
parent.delete(prevent_nondicotomic=False,
preserve_branch_length=preserve_branch_length) |
<SYSTEM_TASK:>
Prunes the topology of a node to conserve only a selected list of leaf
<END_TASK>
<USER_TASK:>
Description:
def prune(self, nodes, preserve_branch_length=False):
"""
Prunes the topology of a node to conserve only a selected list of leaf
internal nodes. The minimum number of nodes that conserve the
topological relationships among the requested nodes will be
retained. Root node is always conserved.
Parameters:
-----------
nodes:
a list of node names or node objects that should be retained
preserve_branch_length:
If True, branch lengths of the deleted nodes are transferred
(summed up) to its parent's branch, thus keeping original distances
among nodes.
**Examples:**
t1 = Tree('(((((A,B)C)D,E)F,G)H,(I,J)K)root;', format=1)
t1.prune(['A', 'B'])
# /-A
# /D /C|
# /F| \-B
# | |
# /H| \-E
# | | /-A
#-root \-G -root
# | \-B
# | /-I
# \K|
# \-J
t1 = Tree('(((((A,B)C)D,E)F,G)H,(I,J)K)root;', format=1)
t1.prune(['A', 'B', 'C'])
# /-A
# /D /C|
# /F| \-B
# | |
# /H| \-E
# | | /-A
#-root \-G -root- C|
# | \-B
# | /-I
# \K|
# \-J
t1 = Tree('(((((A,B)C)D,E)F,G)H,(I,J)K)root;', format=1)
t1.prune(['A', 'B', 'I'])
# /-A
# /D /C|
# /F| \-B
# | |
# /H| \-E /-I
# | | -root
#-root \-G | /-A
# | \C|
# | /-I \-B
# \K|
# \-J
t1 = Tree('(((((A,B)C)D,E)F,G)H,(I,J)K)root;', format=1)
t1.prune(['A', 'B', 'F', 'H'])
# /-A
# /D /C|
# /F| \-B
# | |
# /H| \-E
# | | /-A
#-root \-G -root-H /F|
# | \-B
# | /-I
# \K|
# \-J
""" |
def cmp_nodes(x, y):
# if several nodes are in the same path of two kept nodes,
# only one should be maintained. This prioritize internal
# nodes that are already in the to_keep list and then
# deeper nodes (closer to the leaves).
if n2depth[x] > n2depth[y]:
return -1
elif n2depth[x] < n2depth[y]:
return 1
else:
return 0
to_keep = set(_translate_nodes(self, *nodes))
start, node2path = self.get_common_ancestor(to_keep, get_path=True)
to_keep.add(self)
# Calculate which kept nodes are visiting the same nodes in
# their path to the common ancestor.
n2count = {}
n2depth = {}
for seed, path in six.iteritems(node2path):
for visited_node in path:
if visited_node not in n2depth:
depth = visited_node.get_distance(start, topology_only=True)
n2depth[visited_node] = depth
if visited_node is not seed:
n2count.setdefault(visited_node, set()).add(seed)
# if several internal nodes are in the path of exactly the same kept
# nodes, only one (the deepest) should be maintain.
visitors2nodes = {}
for node, visitors in six.iteritems(n2count):
# keep nodes connection at least two other nodes
if len(visitors)>1:
visitor_key = frozenset(visitors)
visitors2nodes.setdefault(visitor_key, set()).add(node)
for visitors, nodes in six.iteritems(visitors2nodes):
if not (to_keep & nodes):
sorted_nodes = sorted(nodes, key=cmp_to_key(cmp_nodes))
to_keep.add(sorted_nodes[0])
for n in self.get_descendants('postorder'):
if n not in to_keep:
if preserve_branch_length:
if len(n.children) == 1:
n.children[0].dist += n.dist
elif len(n.children) > 1 and n.up:
n.up.dist += n.dist
n.delete(prevent_nondicotomic=False) |
<SYSTEM_TASK:>
Returns an indepent list of sister nodes.
<END_TASK>
<USER_TASK:>
Description:
def get_sisters(self):
""" Returns an indepent list of sister nodes.""" |
if self.up != None:
return [ch for ch in self.up.children if ch != self]
else:
return [] |
<SYSTEM_TASK:>
Returns an iterator over the leaves under this node.
<END_TASK>
<USER_TASK:>
Description:
def iter_leaves(self, is_leaf_fn=None):
""" Returns an iterator over the leaves under this node.""" |
for n in self.traverse(strategy="preorder", is_leaf_fn=is_leaf_fn):
if not is_leaf_fn:
if n.is_leaf():
yield n
else:
if is_leaf_fn(n):
yield n |
<SYSTEM_TASK:>
Returns an iterator over the leaf names under this node.
<END_TASK>
<USER_TASK:>
Description:
def iter_leaf_names(self, is_leaf_fn=None):
"""Returns an iterator over the leaf names under this node.""" |
for n in self.iter_leaves(is_leaf_fn=is_leaf_fn):
yield n.name |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.