text_prompt
stringlengths 100
17.7k
⌀ | code_prompt
stringlengths 7
9.86k
⌀ |
|---|---|
<SYSTEM_TASK:>
Add ``repo`` to ``team``.
<END_TASK>
<USER_TASK:>
Description:
def add_repo(self, repo, team):
"""Add ``repo`` to ``team``.
.. note::
This method is of complexity O(n). This iterates over all teams in
your organization and only adds the repo when the team name
matches the team parameter above. If you want constant time, you
should retrieve the team and call ``add_repo`` on that team
directly.
:param str repo: (required), form: 'user/repo'
:param str team: (required), team name
""" |
for t in self.iter_teams():
if team == t.name:
return t.add_repo(repo)
return False |
<SYSTEM_TASK:>
Create a repository for this organization if the authenticated user
<END_TASK>
<USER_TASK:>
Description:
def create_repo(self,
name,
description='',
homepage='',
private=False,
has_issues=True,
has_wiki=True,
has_downloads=True,
team_id=0,
auto_init=False,
gitignore_template=''):
"""Create a repository for this organization if the authenticated user
is a member.
:param str name: (required), name of the repository
:param str description: (optional)
:param str homepage: (optional)
:param bool private: (optional), If ``True``, create a private
repository. API default: ``False``
:param bool has_issues: (optional), If ``True``, enable issues for
this repository. API default: ``True``
:param bool has_wiki: (optional), If ``True``, enable the wiki for
this repository. API default: ``True``
:param bool has_downloads: (optional), If ``True``, enable downloads
for this repository. API default: ``True``
:param int team_id: (optional), id of the team that will be granted
access to this repository
:param bool auto_init: (optional), auto initialize the repository.
:param str gitignore_template: (optional), name of the template; this
is ignored if auto_int = False.
:returns: :class:`Repository <github3.repos.Repository>`
.. warning: ``name`` should be no longer than 100 characters
""" |
url = self._build_url('repos', base_url=self._api)
data = {'name': name, 'description': description,
'homepage': homepage, 'private': private,
'has_issues': has_issues, 'has_wiki': has_wiki,
'has_downloads': has_downloads, 'auto_init': auto_init,
'gitignore_template': gitignore_template}
if team_id > 0:
data.update({'team_id': team_id})
json = self._json(self._post(url, data), 201)
return Repository(json, self) if json else None |
<SYSTEM_TASK:>
Conceal ``login``'s membership in this organization.
<END_TASK>
<USER_TASK:>
Description:
def conceal_member(self, login):
"""Conceal ``login``'s membership in this organization.
:returns: bool
""" |
url = self._build_url('public_members', login, base_url=self._api)
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Assuming the authenticated user owns this organization,
<END_TASK>
<USER_TASK:>
Description:
def create_team(self, name, repo_names=[], permission=''):
"""Assuming the authenticated user owns this organization,
create and return a new team.
:param str name: (required), name to be given to the team
:param list repo_names: (optional) repositories, e.g.
['github/dotfiles']
:param str permission: (optional), options:
- ``pull`` -- (default) members can not push or administer
repositories accessible by this team
- ``push`` -- members can push and pull but not administer
repositories accessible by this team
- ``admin`` -- members can push, pull and administer
repositories accessible by this team
:returns: :class:`Team <Team>`
""" |
data = {'name': name, 'repo_names': repo_names,
'permission': permission}
url = self._build_url('teams', base_url=self._api)
json = self._json(self._post(url, data), 201)
return Team(json, self._session) if json else None |
<SYSTEM_TASK:>
Edit this organization.
<END_TASK>
<USER_TASK:>
Description:
def edit(self,
billing_email=None,
company=None,
email=None,
location=None,
name=None):
"""Edit this organization.
:param str billing_email: (optional) Billing email address (private)
:param str company: (optional)
:param str email: (optional) Public email address
:param str location: (optional)
:param str name: (optional)
:returns: bool
""" |
json = None
data = {'billing_email': billing_email, 'company': company,
'email': email, 'location': location, 'name': name}
self._remove_none(data)
if data:
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Check if the user with login ``login`` is a public member.
<END_TASK>
<USER_TASK:>
Description:
def is_public_member(self, login):
"""Check if the user with login ``login`` is a public member.
:returns: bool
""" |
url = self._build_url('public_members', login, base_url=self._api)
return self._boolean(self._get(url), 204, 404) |
<SYSTEM_TASK:>
Iterate over repos for this organization.
<END_TASK>
<USER_TASK:>
Description:
def iter_repos(self, type='', number=-1, etag=None):
"""Iterate over repos for this organization.
:param str type: (optional), accepted values:
('all', 'public', 'member', 'private', 'forks', 'sources'), API
default: 'all'
:param int number: (optional), number of members to return. Default:
-1 will return all available.
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Repository <github3.repos.Repository>`
""" |
url = self._build_url('repos', base_url=self._api)
params = {}
if type in ('all', 'public', 'member', 'private', 'forks', 'sources'):
params['type'] = type
return self._iter(int(number), url, Repository, params, etag) |
<SYSTEM_TASK:>
Iterate over teams that are part of this organization.
<END_TASK>
<USER_TASK:>
Description:
def iter_teams(self, number=-1, etag=None):
"""Iterate over teams that are part of this organization.
:param int number: (optional), number of teams to return. Default: -1
returns all available teams.
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Team <Team>`\ s
""" |
url = self._build_url('teams', base_url=self._api)
return self._iter(int(number), url, Team, etag=etag) |
<SYSTEM_TASK:>
Make ``login``'s membership in this organization public.
<END_TASK>
<USER_TASK:>
Description:
def publicize_member(self, login):
"""Make ``login``'s membership in this organization public.
:returns: bool
""" |
url = self._build_url('public_members', login, base_url=self._api)
return self._boolean(self._put(url), 204, 404) |
<SYSTEM_TASK:>
Returns Team object with information about team specified by
<END_TASK>
<USER_TASK:>
Description:
def team(self, team_id):
"""Returns Team object with information about team specified by
``team_id``.
:param int team_id: (required), unique id for the team
:returns: :class:`Team <Team>`
""" |
json = None
if int(team_id) > 0:
url = self._build_url('teams', str(team_id))
json = self._json(self._get(url), 200)
return Team(json, self._session) if json else None |
<SYSTEM_TASK:>
Edit the user's membership.
<END_TASK>
<USER_TASK:>
Description:
def edit(self, state):
"""Edit the user's membership.
:param str state: (required), the state the membership should be in.
Only accepts ``"active"``.
:returns: itself
""" |
if state and state.lower() == 'active':
data = dumps({'state': state.lower()})
json = self._json(self._patch(self._api, data=data))
self._update_attributes(json)
return self |
<SYSTEM_TASK:>
Users with push access to the repository can delete a release.
<END_TASK>
<USER_TASK:>
Description:
def delete(self):
"""Users with push access to the repository can delete a release.
:returns: True if successful; False if not successful
""" |
url = self._api
return self._boolean(
self._delete(url, headers=Release.CUSTOM_HEADERS),
204,
404
) |
<SYSTEM_TASK:>
Users with push access to the repository can edit a release.
<END_TASK>
<USER_TASK:>
Description:
def edit(self, tag_name=None, target_commitish=None, name=None, body=None,
draft=None, prerelease=None):
"""Users with push access to the repository can edit a release.
If the edit is successful, this object will update itself.
:param str tag_name: (optional), Name of the tag to use
:param str target_commitish: (optional), The "commitish" value that
determines where the Git tag is created from. Defaults to the
repository's default branch.
:param str name: (optional), Name of the release
:param str body: (optional), Description of the release
:param boolean draft: (optional), True => Release is a draft
:param boolean prerelease: (optional), True => Release is a prerelease
:returns: True if successful; False if not successful
""" |
url = self._api
data = {
'tag_name': tag_name,
'target_commitish': target_commitish,
'name': name,
'body': body,
'draft': draft,
'prerelease': prerelease,
}
self._remove_none(data)
r = self._session.patch(
url, data=json.dumps(data), headers=Release.CUSTOM_HEADERS
)
successful = self._boolean(r, 200, 404)
if successful:
# If the edit was successful, let's update the object.
self.__init__(r.json(), self)
return successful |
<SYSTEM_TASK:>
Iterate over the assets available for this release.
<END_TASK>
<USER_TASK:>
Description:
def iter_assets(self, number=-1, etag=None):
"""Iterate over the assets available for this release.
:param int number: (optional), Number of assets to return
:param str etag: (optional), last ETag header sent
:returns: generator of :class:`Asset <Asset>` objects
""" |
url = self._build_url('assets', base_url=self._api)
return self._iter(number, url, Asset, etag=etag) |
<SYSTEM_TASK:>
Upload an asset to this release.
<END_TASK>
<USER_TASK:>
Description:
def upload_asset(self, content_type, name, asset):
"""Upload an asset to this release.
All parameters are required.
:param str content_type: The content type of the asset. Wikipedia has
a list of common media types
:param str name: The name of the file
:param asset: The file or bytes object to upload.
:returns: :class:`Asset <Asset>`
""" |
headers = Release.CUSTOM_HEADERS.copy()
headers.update({'Content-Type': content_type})
url = self.upload_urlt.expand({'name': name})
r = self._post(url, data=asset, json=False, headers=headers,
verify=False)
if r.status_code in (201, 202):
return Asset(r.json(), self)
raise GitHubError(r) |
<SYSTEM_TASK:>
Download the data for this asset.
<END_TASK>
<USER_TASK:>
Description:
def download(self, path=''):
"""Download the data for this asset.
:param path: (optional), path where the file should be saved
to, default is the filename provided in the headers and will be
written in the current directory.
it can take a file-like object as well
:type path: str, file
:returns: bool -- True if successful, False otherwise
""" |
headers = {
'Accept': 'application/octet-stream'
}
resp = self._get(self._api, allow_redirects=False, stream=True,
headers=headers)
if resp.status_code == 302:
# Amazon S3 will reject the redirected request unless we omit
# certain request headers
headers.update({
'Content-Type': None,
})
with self._session.no_auth():
resp = self._get(resp.headers['location'], stream=True,
headers=headers)
if self._boolean(resp, 200, 404):
stream_response_to_file(resp, path)
return True
return False |
<SYSTEM_TASK:>
Edit this asset.
<END_TASK>
<USER_TASK:>
Description:
def edit(self, name, label=None):
"""Edit this asset.
:param str name: (required), The file name of the asset
:param str label: (optional), An alternate description of the asset
:returns: boolean
""" |
if not name:
return False
edit_data = {'name': name, 'label': label}
self._remove_none(edit_data)
r = self._patch(
self._api,
data=json.dumps(edit_data),
headers=Release.CUSTOM_HEADERS
)
successful = self._boolean(r, 200, 404)
if successful:
self.__init__(r.json(), self)
return successful |
<SYSTEM_TASK:>
List status of all configured SNS-SQS message buses and instances subscribed to them.
<END_TASK>
<USER_TASK:>
Description:
def ls(args):
"""
List status of all configured SNS-SQS message buses and instances subscribed to them.
""" |
table = []
queues = list(resources.sqs.queues.filter(QueueNamePrefix="github"))
max_age = datetime.now(tzutc()) - timedelta(days=15)
for topic in resources.sns.topics.all():
account_id = ARN(topic.arn).account_id
try:
bucket = resources.s3.Bucket("deploy-status-{}".format(account_id))
status_objects = bucket.objects.filter(Prefix=ARN(topic.arn).resource)
recent_status_objects = {o.key: o for o in status_objects if o.last_modified > max_age}
except ClientError:
continue
if ARN(topic.arn).resource.startswith("github"):
for queue in queues:
queue_name = os.path.basename(queue.url)
if queue_name.startswith(ARN(topic.arn).resource):
row = dict(Topic=topic, Queue=queue)
status_object = bucket.Object(os.path.join(queue_name, "status"))
if status_object.key not in recent_status_objects:
continue
try:
github, owner, repo, events, instance = os.path.dirname(status_object.key).split("-", 4)
status = json.loads(status_object.get()["Body"].read().decode("utf-8"))
row.update(status, Owner=owner, Repo=repo, Instance=instance,
Updated=status_object.last_modified)
except Exception:
pass
table.append(row)
args.columns = ["Owner", "Repo", "Instance", "Status", "Ref", "Commit", "Updated", "Topic", "Queue"]
page_output(tabulate(table, args)) |
<SYSTEM_TASK:>
Given an IAM role or instance name, attach an IAM policy granting
<END_TASK>
<USER_TASK:>
Description:
def grant(args):
"""
Given an IAM role or instance name, attach an IAM policy granting
appropriate permissions to subscribe to deployments. Given a
GitHub repo URL, create and record deployment keys for the repo
and any of its private submodules, making the keys accessible to
the IAM role.
""" |
try:
role = resources.iam.Role(args.iam_role_or_instance)
role.load()
except ClientError:
role = get_iam_role_for_instance(args.iam_role_or_instance)
role.attach_policy(PolicyArn=ensure_deploy_iam_policy().arn)
for private_repo in [args.repo] + list(private_submodules(args.repo)):
gh_owner_name, gh_repo_name = parse_repo_name(private_repo)
secret = secrets.put(argparse.Namespace(secret_name="deploy.{}.{}".format(gh_owner_name, gh_repo_name),
iam_role=role.name,
instance_profile=None,
iam_group=None,
iam_user=None,
generate_ssh_key=True))
get_repo(private_repo).create_key(__name__ + "." + role.name, secret["ssh_public_key"])
logger.info("Created deploy key %s for IAM role %s to access GitHub repo %s",
secret["ssh_key_fingerprint"], role.name, private_repo) |
<SYSTEM_TASK:>
Delete this file.
<END_TASK>
<USER_TASK:>
Description:
def delete(self, message, branch=None, committer=None, author=None):
"""Delete this file.
:param str message: (required), commit message to describe the removal
:param str branch: (optional), branch where the file exists.
Defaults to the default branch of the repository.
: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>`
""" |
json = None
if message:
data = {'message': message, 'sha': self.sha, 'branch': branch,
'committer': validate_commmitter(committer),
'author': validate_commmitter(author)}
self._remove_none(data)
json = self._json(self._delete(self._api, data=dumps(data)), 200)
if 'commit' in json:
json = Commit(json['commit'], self)
return json |
<SYSTEM_TASK:>
Update this file.
<END_TASK>
<USER_TASK:>
Description:
def update(self, message, content, branch=None, committer=None,
author=None):
"""Update this file.
:param str message: (required), commit message to describe the update
:param str content: (required), content to update the file with
:param str branch: (optional), branch where the file exists.
Defaults to the default branch of the repository.
: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 content and not isinstance(content, bytes):
raise ValueError( # (No coverage)
'content must be a bytes object') # (No coverage)
json = None
if message and content:
content = b64encode(content).decode('utf-8')
data = {'message': message, 'content': content, 'branch': branch,
'sha': self.sha,
'committer': validate_commmitter(committer),
'author': validate_commmitter(author)}
self._remove_none(data)
json = self._json(self._put(self._api, data=dumps(data)), 200)
if 'content' in json and 'commit' in json:
self.__init__(json['content'], self)
json = Commit(json['commit'], self)
return json |
<SYSTEM_TASK:>
Edit this gist.
<END_TASK>
<USER_TASK:>
Description:
def edit(self, description='', files={}):
"""Edit this gist.
:param str description: (optional), description of the gist
:param dict files: (optional), files that make up this gist; the
key(s) should be the file name(s) and the values should be another
(optional) dictionary with (optional) keys: 'content' and
'filename' where the former is the content of the file and the
latter is the new name of the file.
:returns: bool -- whether the edit was successful
""" |
data = {}
json = None
if description:
data['description'] = description
if files:
data['files'] = files
if data:
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Fork this gist.
<END_TASK>
<USER_TASK:>
Description:
def fork(self):
"""Fork this gist.
:returns: :class:`Gist <Gist>` if successful, ``None`` otherwise
""" |
url = self._build_url('forks', base_url=self._api)
json = self._json(self._post(url), 201)
return Gist(json, self) if json else None |
<SYSTEM_TASK:>
Check to see if this gist is starred by the authenticated user.
<END_TASK>
<USER_TASK:>
Description:
def is_starred(self):
"""Check to see if this gist is starred by the authenticated user.
:returns: bool -- True if it is starred, False otherwise
""" |
url = self._build_url('star', base_url=self._api)
return self._boolean(self._get(url), 204, 404) |
<SYSTEM_TASK:>
Iter over the commits on this gist.
<END_TASK>
<USER_TASK:>
Description:
def iter_commits(self, number=-1, etag=None):
"""Iter over the commits on this gist.
These commits will be requested from the API and should be the same as
what is in ``Gist.history``.
.. versionadded:: 0.6
.. versionchanged:: 0.9
Added param ``etag``.
:param int number: (optional), number of commits to iterate over.
Default: -1 will iterate over all commits associated with this
gist.
:param str etag: (optional), ETag from a previous request to this
endpoint.
:returns: generator of
:class:`GistHistory <github3.gists.history.GistHistory>`
""" |
url = self._build_url('commits', base_url=self._api)
return self._iter(int(number), url, GistHistory) |
<SYSTEM_TASK:>
Iterator of forks of this gist.
<END_TASK>
<USER_TASK:>
Description:
def iter_forks(self, number=-1, etag=None):
"""Iterator of forks of this gist.
.. versionchanged:: 0.9
Added params ``number`` and ``etag``.
:param int number: (optional), number of forks to iterate over.
Default: -1 will iterate over all forks of this gist.
:param str etag: (optional), ETag from a previous request to this
endpoint.
:returns: generator of :class:`Gist <Gist>`
""" |
url = self._build_url('forks', base_url=self._api)
return self._iter(int(number), url, Gist, etag=etag) |
<SYSTEM_TASK:>
Star this gist.
<END_TASK>
<USER_TASK:>
Description:
def star(self):
"""Star this gist.
:returns: bool -- True if successful, False otherwise
""" |
url = self._build_url('star', base_url=self._api)
return self._boolean(self._put(url), 204, 404) |
<SYSTEM_TASK:>
Un-star this gist.
<END_TASK>
<USER_TASK:>
Description:
def unstar(self):
"""Un-star this gist.
:returns: bool -- True if successful, False otherwise
""" |
url = self._build_url('star', base_url=self._api)
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Transfer files to or from EC2 instance.
<END_TASK>
<USER_TASK:>
Description:
def scp(args):
"""
Transfer files to or from EC2 instance.
Use "--" to separate scp args from aegea args:
aegea scp -- -r local_dir instance_name:~/remote_dir
""" |
if args.scp_args[0] == "--":
del args.scp_args[0]
user_or_hostname_chars = string.ascii_letters + string.digits
for i, arg in enumerate(args.scp_args):
if arg[0] in user_or_hostname_chars and ":" in arg:
hostname, colon, path = arg.partition(":")
username, at, hostname = hostname.rpartition("@")
hostname = resolve_instance_public_dns(hostname)
if not (username or at):
try:
username, at = get_linux_username(), "@"
except Exception:
logger.info("Unable to determine IAM username, using local username")
args.scp_args[i] = username + at + hostname + colon + path
os.execvp("scp", ["scp"] + args.scp_args) |
<SYSTEM_TASK:>
List S3 buckets. See also "aws s3 ls". Use "aws s3 ls NAME" to list bucket contents.
<END_TASK>
<USER_TASK:>
Description:
def ls(args):
"""
List S3 buckets. See also "aws s3 ls". Use "aws s3 ls NAME" to list bucket contents.
""" |
table = []
for bucket in filter_collection(resources.s3.buckets, args):
bucket.LocationConstraint = clients.s3.get_bucket_location(Bucket=bucket.name)["LocationConstraint"]
cloudwatch = resources.cloudwatch
bucket_region = bucket.LocationConstraint or "us-east-1"
if bucket_region != cloudwatch.meta.client.meta.region_name:
cloudwatch = boto3.Session(region_name=bucket_region).resource("cloudwatch")
data = get_cloudwatch_metric_stats("AWS/S3", "NumberOfObjects",
start_time=datetime.utcnow() - timedelta(days=2),
end_time=datetime.utcnow(), period=3600, BucketName=bucket.name,
StorageType="AllStorageTypes", resource=cloudwatch)
bucket.NumberOfObjects = int(data["Datapoints"][-1]["Average"]) if data["Datapoints"] else None
data = get_cloudwatch_metric_stats("AWS/S3", "BucketSizeBytes",
start_time=datetime.utcnow() - timedelta(days=2),
end_time=datetime.utcnow(), period=3600, BucketName=bucket.name,
StorageType="StandardStorage", resource=cloudwatch)
bucket.BucketSizeBytes = format_number(data["Datapoints"][-1]["Average"]) if data["Datapoints"] else None
table.append(bucket)
page_output(tabulate(table, args)) |
<SYSTEM_TASK:>
Update this label.
<END_TASK>
<USER_TASK:>
Description:
def update(self, name, color):
"""Update this label.
:param str name: (required), new name of the label
:param str color: (required), color code, e.g., 626262, no leading '#'
:returns: bool
""" |
json = None
if name and color:
if color[0] == '#':
color = color[1:]
json = self._json(self._patch(self._api, data=dumps({
'name': name, 'color': color})), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Set the Basic Auth credentials on this Session.
<END_TASK>
<USER_TASK:>
Description:
def basic_auth(self, username, password):
"""Set the Basic Auth credentials on this Session.
:param str username: Your GitHub username
:param str password: Your GitHub password
""" |
if not (username and password):
return
self.auth = (username, password)
# Disable token authentication
self.headers.pop('Authorization', None) |
<SYSTEM_TASK:>
Return the client credentials.
<END_TASK>
<USER_TASK:>
Description:
def retrieve_client_credentials(self):
"""Return the client credentials.
:returns: tuple(client_id, client_secret)
""" |
client_id = self.params.get('client_id')
client_secret = self.params.get('client_secret')
return (client_id, client_secret) |
<SYSTEM_TASK:>
Use an application token for authentication.
<END_TASK>
<USER_TASK:>
Description:
def token_auth(self, token):
"""Use an application token for authentication.
:param str token: Application token retrieved from GitHub's
/authorizations endpoint
""" |
if not token:
return
self.headers.update({
'Authorization': 'token {0}'.format(token)
})
# Unset username/password so we stop sending them
self.auth = None |
<SYSTEM_TASK:>
Unset authentication temporarily as a context manager.
<END_TASK>
<USER_TASK:>
Description:
def no_auth(self):
"""Unset authentication temporarily as a context manager.""" |
old_basic_auth, self.auth = self.auth, None
old_token_auth = self.headers.pop('Authorization', None)
yield
self.auth = old_basic_auth
if old_token_auth:
self.headers['Authorization'] = old_token_auth |
<SYSTEM_TASK:>
Edit this hook.
<END_TASK>
<USER_TASK:>
Description:
def edit(self, config={}, events=[], add_events=[], rm_events=[],
active=True):
"""Edit this hook.
:param dict config: (optional), key-value pairs of settings for this
hook
:param list events: (optional), which events should this be triggered
for
:param list add_events: (optional), events to be added to the list of
events that this hook triggers for
:param list rm_events: (optional), events to be remvoed from the list
of events that this hook triggers for
:param bool active: (optional), should this event be active
:returns: bool
""" |
data = {'config': config, 'active': active}
if events:
data['events'] = events
if add_events:
data['add_events'] = add_events
if rm_events:
data['remove_events'] = rm_events
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Decorator to note which object methods require authorization.
<END_TASK>
<USER_TASK:>
Description:
def requires_auth(func):
"""Decorator to note which object methods require authorization.""" |
@wraps(func)
def auth_wrapper(self, *args, **kwargs):
auth = False
if hasattr(self, '_session'):
auth = (self._session.auth or
self._session.headers.get('Authorization'))
if auth:
return func(self, *args, **kwargs)
else:
from .models import GitHubError
# Mock a 401 response
r = generate_fake_error_response(
'{"message": "Requires authentication"}'
)
raise GitHubError(r)
return auth_wrapper |
<SYSTEM_TASK:>
Require client_id and client_secret to be associated.
<END_TASK>
<USER_TASK:>
Description:
def requires_app_credentials(func):
"""Require client_id and client_secret to be associated.
This is used to note and enforce which methods require a client_id and
client_secret to be used.
""" |
@wraps(func)
def auth_wrapper(self, *args, **kwargs):
client_id, client_secret = self._session.retrieve_client_credentials()
if client_id and client_secret:
return func(self, *args, **kwargs)
else:
from .models import GitHubError
# Mock a 401 response
r = generate_fake_error_response(
'{"message": "Requires username/password authentication"}'
)
raise GitHubError(r)
return auth_wrapper |
<SYSTEM_TASK:>
Get information about authorization ``id``.
<END_TASK>
<USER_TASK:>
Description:
def authorization(self, id_num):
"""Get information about authorization ``id``.
:param int id_num: (required), unique id of the authorization
:returns: :class:`Authorization <Authorization>`
""" |
json = None
if int(id_num) > 0:
url = self._build_url('authorizations', str(id_num))
json = self._json(self._get(url), 200)
return Authorization(json, self) if json else None |
<SYSTEM_TASK:>
Obtain an authorization token from the GitHub API for the GitHub
<END_TASK>
<USER_TASK:>
Description:
def authorize(self, login, password, scopes=None, note='', note_url='',
client_id='', client_secret=''):
"""Obtain an authorization token from the GitHub API for the GitHub
API.
:param str login: (required)
:param str password: (required)
:param list scopes: (optional), 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
:returns: :class:`Authorization <Authorization>`
""" |
json = None
# TODO: Break this behaviour in 1.0 (Don't rely on self._session.auth)
auth = None
if self._session.auth:
auth = self._session.auth
elif login and password:
auth = (login, password)
if auth:
url = self._build_url('authorizations')
data = {'note': note, 'note_url': note_url,
'client_id': client_id, 'client_secret': client_secret}
if scopes:
data['scopes'] = scopes
with self._session.temporary_basic_auth(*auth):
json = self._json(self._post(url, data=data), 201)
return Authorization(json, self) if json else None |
<SYSTEM_TASK:>
OAuth applications can use this method to check token validity
<END_TASK>
<USER_TASK:>
Description:
def check_authorization(self, access_token):
"""OAuth applications can use this method to check token validity
without hitting normal rate limits because of failed login attempts.
If the token is valid, it will return True, otherwise it will return
False.
:returns: bool
""" |
p = self._session.params
auth = (p.get('client_id'), p.get('client_secret'))
if access_token and auth:
url = self._build_url('applications', str(auth[0]), 'tokens',
str(access_token))
resp = self._get(url, auth=auth, params={
'client_id': None, 'client_secret': None
})
return self._boolean(resp, 200, 404)
return False |
<SYSTEM_TASK:>
Create a new gist.
<END_TASK>
<USER_TASK:>
Description:
def create_gist(self, description, files, public=True):
"""Create a new gist.
If no login was provided, it will be anonymous.
:param str description: (required), description of gist
:param dict files: (required), file names with associated dictionaries
for content, e.g. ``{'spam.txt': {'content': 'File contents
...'}}``
:param bool public: (optional), make the gist public if True
:returns: :class:`Gist <github3.gists.Gist>`
""" |
new_gist = {'description': description, 'public': public,
'files': files}
url = self._build_url('gists')
json = self._json(self._post(url, data=new_gist), 201)
return Gist(json, self) if json else None |
<SYSTEM_TASK:>
Create an issue on the project 'repository' owned by 'owner'
<END_TASK>
<USER_TASK:>
Description:
def create_issue(self,
owner,
repository,
title,
body=None,
assignee=None,
milestone=None,
labels=[]):
"""Create an issue on the project 'repository' owned by 'owner'
with title 'title'.
body, assignee, milestone, labels are all optional.
:param str owner: (required), login of the owner
:param str repository: (required), repository name
:param str title: (required), Title of issue to be created
:param str body: (optional), The text of the issue, markdown
formatted
:param str assignee: (optional), Login of person 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>` object, ``m.number`` is what you pass
here.)
:param list labels: (optional), List of label names.
:returns: :class:`Issue <github3.issues.Issue>` if successful, else
None
""" |
repo = None
if owner and repository and title:
repo = self.repository(owner, repository)
if repo:
return repo.create_issue(title, body, assignee, milestone, labels)
# Regardless, something went wrong. We were unable to create the
# issue
return None |
<SYSTEM_TASK:>
Create a new key for the authenticated user.
<END_TASK>
<USER_TASK:>
Description:
def create_key(self, title, key):
"""Create a new key for the authenticated user.
:param str title: (required), key title
:param key: (required), actual key contents, accepts path as a string
or file-like object
:returns: :class:`Key <github3.users.Key>`
""" |
created = None
if title and key:
url = self._build_url('user', 'keys')
req = self._post(url, data={'title': title, 'key': key})
json = self._json(req, 201)
if json:
created = Key(json, self)
return created |
<SYSTEM_TASK:>
Delete user key pointed to by ``key_id``.
<END_TASK>
<USER_TASK:>
Description:
def delete_key(self, key_id):
"""Delete user key pointed to by ``key_id``.
:param int key_id: (required), unique id used by Github
:returns: bool
""" |
key = self.key(key_id)
if key:
return key.delete()
return False |
<SYSTEM_TASK:>
Retrieves a dictionary of all of the emojis that GitHub supports.
<END_TASK>
<USER_TASK:>
Description:
def emojis(self):
"""Retrieves a dictionary of all of the emojis that GitHub supports.
:returns: dictionary where the key is what would be in between the
colons and the value is the URL to the image, e.g., ::
{
'+1': 'https://github.global.ssl.fastly.net/images/...',
# ...
}
""" |
url = self._build_url('emojis')
return self._json(self._get(url), 200) |
<SYSTEM_TASK:>
List GitHub's timeline resources in Atom format.
<END_TASK>
<USER_TASK:>
Description:
def feeds(self):
"""List GitHub's timeline resources in Atom format.
:returns: dictionary parsed to include URITemplates
""" |
url = self._build_url('feeds')
json = self._json(self._get(url), 200)
del json['ETag']
del json['Last-Modified']
urls = [
'timeline_url', 'user_url', 'current_user_public_url',
'current_user_url', 'current_user_actor_url',
'current_user_organization_url',
]
for url in urls:
json[url] = URITemplate(json[url])
links = json.get('_links', {})
for d in links.values():
d['href'] = URITemplate(d['href'])
return json |
<SYSTEM_TASK:>
Make the authenticated user follow login.
<END_TASK>
<USER_TASK:>
Description:
def follow(self, login):
"""Make the authenticated user follow login.
:param str login: (required), user to follow
:returns: bool
""" |
resp = False
if login:
url = self._build_url('user', 'following', login)
resp = self._boolean(self._put(url), 204, 404)
return resp |
<SYSTEM_TASK:>
Gets the gist using the specified id number.
<END_TASK>
<USER_TASK:>
Description:
def gist(self, id_num):
"""Gets the gist using the specified id number.
:param int id_num: (required), unique id of the gist
:returns: :class:`Gist <github3.gists.Gist>`
""" |
url = self._build_url('gists', str(id_num))
json = self._json(self._get(url), 200)
return Gist(json, self) if json else None |
<SYSTEM_TASK:>
Returns the list of available templates.
<END_TASK>
<USER_TASK:>
Description:
def gitignore_templates(self):
"""Returns the list of available templates.
:returns: list of template names
""" |
url = self._build_url('gitignore', 'templates')
return self._json(self._get(url), 200) or [] |
<SYSTEM_TASK:>
Check if the authenticated user is following login.
<END_TASK>
<USER_TASK:>
Description:
def is_following(self, login):
"""Check if the authenticated user is following login.
:param str login: (required), login of the user to check if the
authenticated user is checking
:returns: bool
""" |
json = False
if login:
url = self._build_url('user', 'following', login)
json = self._boolean(self._get(url), 204, 404)
return json |
<SYSTEM_TASK:>
Iterate over every repository in the order they were created.
<END_TASK>
<USER_TASK:>
Description:
def iter_all_repos(self, number=-1, since=None, etag=None, per_page=None):
"""Iterate over every repository in the order they were created.
:param int number: (optional), number of repositories to return.
Default: -1, returns all of them
:param int since: (optional), last repository id seen (allows
restarting this iteration)
:param str etag: (optional), ETag from a previous request to the same
endpoint
:param int per_page: (optional), number of repositories to list per
request
:returns: generator of :class:`Repository <github3.repos.Repository>`
""" |
url = self._build_url('repositories')
return self._iter(int(number), url, Repository,
params={'since': since, 'per_page': per_page},
etag=etag) |
<SYSTEM_TASK:>
Iterate over every user in the order they signed up for GitHub.
<END_TASK>
<USER_TASK:>
Description:
def iter_all_users(self, number=-1, etag=None, per_page=None):
"""Iterate over every user in the order they signed up for GitHub.
:param int number: (optional), number of users to return. Default: -1,
returns all of them
:param str etag: (optional), ETag from a previous request to the same
endpoint
:param int per_page: (optional), number of users to list per request
:returns: generator of :class:`User <github3.users.User>`
""" |
url = self._build_url('users')
return self._iter(int(number), url, User,
params={'per_page': per_page}, etag=etag) |
<SYSTEM_TASK:>
Iterate over authorizations for the authenticated user. This will
<END_TASK>
<USER_TASK:>
Description:
def iter_authorizations(self, number=-1, etag=None):
"""Iterate over authorizations for the authenticated user. This will
return a 404 if you are using a token for authentication.
:param int number: (optional), number of authorizations to return.
Default: -1 returns all available authorizations
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Authorization <Authorization>`\ s
""" |
url = self._build_url('authorizations')
return self._iter(int(number), url, Authorization, etag=etag) |
<SYSTEM_TASK:>
Iterate over email addresses for the authenticated user.
<END_TASK>
<USER_TASK:>
Description:
def iter_emails(self, number=-1, etag=None):
"""Iterate over email addresses for the authenticated user.
:param int number: (optional), number of email addresses to return.
Default: -1 returns all available email addresses
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of dicts
""" |
url = self._build_url('user', 'emails')
return self._iter(int(number), url, dict, etag=etag) |
<SYSTEM_TASK:>
Iterate over public events.
<END_TASK>
<USER_TASK:>
Description:
def iter_events(self, number=-1, etag=None):
"""Iterate over public events.
: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
""" |
url = self._build_url('events')
return self._iter(int(number), url, Event, etag=etag) |
<SYSTEM_TASK:>
If login is provided, iterate over a generator of followers of that
<END_TASK>
<USER_TASK:>
Description:
def iter_followers(self, login=None, number=-1, etag=None):
"""If login is provided, iterate over a generator of followers of that
login name; otherwise return a generator of followers of the
authenticated user.
:param str login: (optional), login of the user to check
:param int number: (optional), number of followers to return. Default:
-1 returns all followers
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`User <github3.users.User>`\ s
""" |
if login:
return self.user(login).iter_followers()
return self._iter_follow('followers', int(number), etag=etag) |
<SYSTEM_TASK:>
If login is provided, iterate over a generator of users being
<END_TASK>
<USER_TASK:>
Description:
def iter_following(self, login=None, number=-1, etag=None):
"""If login is provided, iterate over a generator of users being
followed by login; otherwise return a generator of people followed by
the authenticated user.
:param str login: (optional), login of the user to check
:param int number: (optional), number of people to return. Default: -1
returns all people you follow
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`User <github3.users.User>`\ s
""" |
if login:
return self.user(login).iter_following()
return self._iter_follow('following', int(number), etag=etag) |
<SYSTEM_TASK:>
Iterate over the user's notification.
<END_TASK>
<USER_TASK:>
Description:
def iter_notifications(self, all=False, participating=False, number=-1,
etag=None):
"""Iterate over the user's notification.
:param bool all: (optional), iterate over all notifications
:param bool participating: (optional), only iterate over notifications
in which the user is participating
:param int number: (optional), how many notifications to return
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`Thread <github3.notifications.Thread>`
""" |
params = None
if all:
params = {'all': all}
elif participating:
params = {'participating': participating}
url = self._build_url('notifications')
return self._iter(int(number), url, Thread, params, etag=etag) |
<SYSTEM_TASK:>
Iterate over the organnization's issues if the authenticated user
<END_TASK>
<USER_TASK:>
Description:
def iter_org_issues(self, name, filter='', state='', labels='', sort='',
direction='', since=None, number=-1, etag=None):
"""Iterate over the organnization's issues if the authenticated user
belongs to it.
:param str name: (required), name of the organization
:param str filter: accepted values:
('assigned', 'created', 'mentioned', 'subscribed')
api-default: 'assigned'
:param str state: accepted values: ('open', 'closed')
api-default: 'open'
:param str labels: comma-separated list of label names, e.g.,
'bug,ui,@high'
:param str sort: accepted values: ('created', 'updated', 'comments')
api-default: created
:param str direction: accepted values: ('asc', 'desc')
api-default: 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. Default:
-1, returns all available issues
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Issue <github3.issues.Issue>`
""" |
url = self._build_url('orgs', name, 'issues')
# issue_params will handle the since parameter
params = issue_params(filter, state, labels, sort, direction, since)
return self._iter(int(number), url, Issue, params, etag) |
<SYSTEM_TASK:>
Iterate over public organizations for login if provided; otherwise
<END_TASK>
<USER_TASK:>
Description:
def iter_orgs(self, login=None, number=-1, etag=None):
"""Iterate over public organizations for login if provided; otherwise
iterate over public and private organizations for the authenticated
user.
:param str login: (optional), user whose orgs you wish to list
:param int number: (optional), number of organizations to return.
Default: -1 returns all available organizations
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of
:class:`Organization <github3.orgs.Organization>`\ s
""" |
if login:
url = self._build_url('users', login, 'orgs')
else:
url = self._build_url('user', 'orgs')
return self._iter(int(number), url, Organization, etag=etag) |
<SYSTEM_TASK:>
List public repositories for the authenticated user.
<END_TASK>
<USER_TASK:>
Description:
def iter_repos(self, type=None, sort=None, direction=None, number=-1,
etag=None):
"""List public repositories for the authenticated user.
.. versionchanged:: 0.6
Removed the login parameter for correctness. Use iter_user_repos
instead
:param str type: (optional), accepted values:
('all', 'owner', 'public', 'private', '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
""" |
url = self._build_url('user', 'repos')
params = {}
if type in ('all', 'owner', 'public', 'private', 'member'):
params.update(type=type)
if sort in ('created', 'updated', 'pushed', 'full_name'):
params.update(sort=sort)
if direction in ('asc', 'desc'):
params.update(direction=direction)
return self._iter(int(number), url, Repository, params, etag) |
<SYSTEM_TASK:>
Iterate over repositories starred by ``login`` or the authenticated
<END_TASK>
<USER_TASK:>
Description:
def iter_starred(self, login=None, sort=None, direction=None, number=-1,
etag=None):
"""Iterate over repositories starred by ``login`` or the authenticated
user.
.. versionchanged:: 0.5
Added sort and direction parameters (optional) as per the change in
GitHub's API.
:param str login: (optional), name of user whose stars you want to see
:param str sort: (optional), either 'created' (when the star was
created) or 'updated' (when the repository was last pushed to)
:param str direction: (optional), either 'asc' or 'desc'. Default:
'desc'
: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>`
""" |
if login:
return self.user(login).iter_starred(sort, direction)
params = {'sort': sort, 'direction': direction}
self._remove_none(params)
url = self._build_url('user', 'starred')
return self._iter(int(number), url, Repository, params, etag) |
<SYSTEM_TASK:>
Iterate over repositories subscribed to by ``login`` or the
<END_TASK>
<USER_TASK:>
Description:
def iter_subscriptions(self, login=None, number=-1, etag=None):
"""Iterate over repositories subscribed to by ``login`` or the
authenticated user.
:param str login: (optional), name of user whose subscriptions you want
to see
: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>`
""" |
if login:
return self.user(login).iter_subscriptions()
url = self._build_url('user', 'subscriptions')
return self._iter(int(number), url, Repository, etag=etag) |
<SYSTEM_TASK:>
Gets the authenticated user's teams across all of organizations.
<END_TASK>
<USER_TASK:>
Description:
def iter_user_teams(self, number=-1, etag=None):
"""Gets the authenticated user's teams across all of organizations.
List all of the teams across all of the organizations to which the
authenticated user belongs. This method requires user or repo scope
when authenticating via OAuth.
:returns: generator of :class:`Team <github3.orgs.Team>` objects
""" |
url = self._build_url('user', 'teams')
return self._iter(int(number), url, Team, etag=etag) |
<SYSTEM_TASK:>
Logs the user into GitHub for protected API calls.
<END_TASK>
<USER_TASK:>
Description:
def login(self, username=None, password=None, token=None,
two_factor_callback=None):
"""Logs the user into GitHub for protected API calls.
:param str username: login name
:param str password: password for the login
:param str token: OAuth token
:param func two_factor_callback: (optional), function you implement to
provide the Two Factor Authentication code to GitHub when necessary
""" |
if username and password:
self._session.basic_auth(username, password)
elif token:
self._session.token_auth(token)
# The Session method handles None for free.
self._session.two_factor_auth_callback(two_factor_callback) |
<SYSTEM_TASK:>
Retrieve the user's membership in the specified organization.
<END_TASK>
<USER_TASK:>
Description:
def membership_in(self, organization):
"""Retrieve the user's membership in the specified organization.""" |
url = self._build_url('user', 'memberships', 'orgs',
str(organization))
json = self._json(self._get(url), 200)
return Membership(json, self) |
<SYSTEM_TASK:>
Returns a dictionary with arrays of addresses in CIDR format
<END_TASK>
<USER_TASK:>
Description:
def meta(self):
"""Returns a dictionary with arrays of addresses in CIDR format
specifying theaddresses that the incoming service hooks will originate
from.
.. versionadded:: 0.5
""" |
url = self._build_url('meta')
return self._json(self._get(url), 200) |
<SYSTEM_TASK:>
Returns an easter egg of the API.
<END_TASK>
<USER_TASK:>
Description:
def octocat(self, say=None):
"""Returns an easter egg of the API.
:params str say: (optional), pass in what you'd like Octocat to say
:returns: ascii art of Octocat
""" |
url = self._build_url('octocat')
req = self._get(url, params={'s': say})
return req.content if req.ok else '' |
<SYSTEM_TASK:>
Returns a Organization object for the login name
<END_TASK>
<USER_TASK:>
Description:
def organization(self, login):
"""Returns a Organization object for the login name
:param str login: (required), login name of the org
:returns: :class:`Organization <github3.orgs.Organization>`
""" |
url = self._build_url('orgs', login)
json = self._json(self._get(url), 200)
return Organization(json, self) if json else None |
<SYSTEM_TASK:>
List organizations of which the user is a current or pending member.
<END_TASK>
<USER_TASK:>
Description:
def organization_memberships(self, state=None, number=-1, etag=None):
"""List organizations of which the user is a current or pending member.
:param str state: (option), state of the membership, i.e., active,
pending
:returns: iterator of :class:`Membership <github3.orgs.Membership>`
""" |
params = None
url = self._build_url('user', 'memberships', 'orgs')
if state is not None and state.lower() in ('active', 'pending'):
params = {'state': state.lower()}
return self._iter(int(number), url, Membership,
params=params,
etag=etag) |
<SYSTEM_TASK:>
Returns a Repository object for the specified combination of
<END_TASK>
<USER_TASK:>
Description:
def repository(self, owner, repository):
"""Returns a Repository object for the specified combination of
owner and repository
:param str owner: (required)
:param str repository: (required)
:returns: :class:`Repository <github3.repos.Repository>`
""" |
json = None
if owner and repository:
url = self._build_url('repos', owner, repository)
json = self._json(self._get(url), 200)
return Repository(json, self) if json else None |
<SYSTEM_TASK:>
Revoke specified authorization for an OAuth application.
<END_TASK>
<USER_TASK:>
Description:
def revoke_authorization(self, access_token):
"""Revoke specified authorization for an OAuth application.
Revoke all authorization tokens created by your application. This will
only work if you have already called ``set_client_id``.
:param str access_token: (required), the access_token to revoke
:returns: bool -- True if successful, False otherwise
""" |
client_id, client_secret = self._session.retrieve_client_credentials()
url = self._build_url('applications', str(client_id), 'tokens',
access_token)
with self._session.temporary_basic_auth(client_id, client_secret):
response = self._delete(url, params={'client_id': None,
'client_secret': None})
return self._boolean(response, 204, 404) |
<SYSTEM_TASK:>
Find code via the code search API.
<END_TASK>
<USER_TASK:>
Description:
def search_code(self, query, sort=None, order=None, per_page=None,
text_match=False, number=-1, etag=None):
"""Find code via the code search API.
The query can contain any combination of the following supported
qualifiers:
- ``in`` Qualifies which fields are searched. With this qualifier you
can restrict the search to just the file contents, the file path, or
both.
- ``language`` Searches code based on the language it’s written in.
- ``fork`` Specifies that code from forked repositories should be
searched. Repository forks will not be searchable unless the fork
has more stars than the parent repository.
- ``size`` Finds files that match a certain size (in bytes).
- ``path`` Specifies the path that the resulting file must be at.
- ``extension`` Matches files with a certain extension.
- ``user`` or ``repo`` Limits searches to a specific user or
repository.
For more information about these qualifiers, see: http://git.io/-DvAuA
:param str query: (required), a valid query as described above, e.g.,
``addClass in:file language:js repo:jquery/jquery``
:param str sort: (optional), how the results should be sorted;
option(s): ``indexed``; default: best match
:param str order: (optional), the direction of the sorted results,
options: ``asc``, ``desc``; default: ``desc``
:param int per_page: (optional)
:param bool text_match: (optional), if True, return matching search
terms. See http://git.io/iRmJxg for more information
:param int number: (optional), number of repositories to return.
Default: -1, returns all available repositories
:param str etag: (optional), previous ETag header value
:return: generator of :class:`CodeSearchResult
<github3.search.CodeSearchResult>`
""" |
params = {'q': query}
headers = {}
if sort == 'indexed':
params['sort'] = sort
if sort and order in ('asc', 'desc'):
params['order'] = order
if text_match:
headers = {
'Accept': 'application/vnd.github.v3.full.text-match+json'
}
url = self._build_url('search', 'code')
return SearchIterator(number, url, CodeSearchResult, self, params,
etag, headers) |
<SYSTEM_TASK:>
Find issues by state and keyword
<END_TASK>
<USER_TASK:>
Description:
def search_issues(self, query, sort=None, order=None, per_page=None,
text_match=False, number=-1, etag=None):
"""Find issues by state and keyword
The query can contain any combination of the following supported
qualifers:
- ``type`` With this qualifier you can restrict the search to issues
or pull request only.
- ``in`` Qualifies which fields are searched. With this qualifier you
can restrict the search to just the title, body, comments, or any
combination of these.
- ``author`` Finds issues created by a certain user.
- ``assignee`` Finds issues that are assigned to a certain user.
- ``mentions`` Finds issues that mention a certain user.
- ``commenter`` Finds issues that a certain user commented on.
- ``involves`` Finds issues that were either created by a certain user,
assigned to that user, mention that user, or were commented on by
that user.
- ``state`` Filter issues based on whether they’re open or closed.
- ``labels`` Filters issues based on their labels.
- ``language`` Searches for issues within repositories that match a
certain language.
- ``created`` or ``updated`` Filters issues based on times of creation,
or when they were last updated.
- ``comments`` Filters issues based on the quantity of comments.
- ``user`` or ``repo`` Limits searches to a specific user or
repository.
For more information about these qualifiers, see: http://git.io/d1oELA
:param str query: (required), a valid query as described above, e.g.,
``windows label:bug``
:param str sort: (optional), how the results should be sorted;
options: ``created``, ``comments``, ``updated``;
default: best match
:param str order: (optional), the direction of the sorted results,
options: ``asc``, ``desc``; default: ``desc``
:param int per_page: (optional)
:param bool text_match: (optional), if True, return matching search
terms. See http://git.io/QLQuSQ for more information
:param int number: (optional), number of issues to return.
Default: -1, returns all available issues
:param str etag: (optional), previous ETag header value
:return: generator of :class:`IssueSearchResult
<github3.search.IssueSearchResult>`
""" |
params = {'q': query}
headers = {}
if sort in ('comments', 'created', 'updated'):
params['sort'] = sort
if order in ('asc', 'desc'):
params['order'] = order
if text_match:
headers = {
'Accept': 'application/vnd.github.v3.full.text-match+json'
}
url = self._build_url('search', 'issues')
return SearchIterator(number, url, IssueSearchResult, self, params,
etag, headers) |
<SYSTEM_TASK:>
Find users via the Search API.
<END_TASK>
<USER_TASK:>
Description:
def search_users(self, query, sort=None, order=None, per_page=None,
text_match=False, number=-1, etag=None):
"""Find users via the Search API.
The query can contain any combination of the following supported
qualifers:
- ``type`` With this qualifier you can restrict the search to just
personal accounts or just organization accounts.
- ``in`` Qualifies which fields are searched. With this qualifier you
can restrict the search to just the username, public email, full
name, or any combination of these.
- ``repos`` Filters users based on the number of repositories they
have.
- ``location`` Filter users by the location indicated in their
profile.
- ``language`` Search for users that have repositories that match a
certain language.
- ``created`` Filter users based on when they joined.
- ``followers`` Filter users based on the number of followers they
have.
For more information about these qualifiers see: http://git.io/wjVYJw
:param str query: (required), a valid query as described above, e.g.,
``tom repos:>42 followers:>1000``
:param str sort: (optional), how the results should be sorted;
options: ``followers``, ``repositories``, or ``joined``; default:
best match
:param str order: (optional), the direction of the sorted results,
options: ``asc``, ``desc``; default: ``desc``
:param int per_page: (optional)
:param bool text_match: (optional), if True, return matching search
terms. See http://git.io/_V1zRwa for more information
:param int number: (optional), number of search results to return;
Default: -1 returns all available
:param str etag: (optional), ETag header value of the last request.
:return: generator of :class:`UserSearchResult
<github3.search.UserSearchResult>`
""" |
params = {'q': query}
headers = {}
if sort in ('followers', 'repositories', 'joined'):
params['sort'] = sort
if order in ('asc', 'desc'):
params['order'] = order
if text_match:
headers = {
'Accept': 'application/vnd.github.v3.full.text-match+json'
}
url = self._build_url('search', 'users')
return SearchIterator(number, url, UserSearchResult, self, params,
etag, headers) |
<SYSTEM_TASK:>
Make the authenticated user stop following login
<END_TASK>
<USER_TASK:>
Description:
def unfollow(self, login):
"""Make the authenticated user stop following login
:param str login: (required)
:returns: bool
""" |
resp = False
if login:
url = self._build_url('user', 'following', login)
resp = self._boolean(self._delete(url), 204, 404)
return resp |
<SYSTEM_TASK:>
If authenticated as this user, update the information with
<END_TASK>
<USER_TASK:>
Description:
def update_user(self, name=None, email=None, blog=None,
company=None, location=None, hireable=False, bio=None):
"""If authenticated as this user, update the information with
the information provided in the parameters. All parameters are
optional.
:param str name: e.g., 'John Smith', not login name
:param str email: e.g., '[email protected]'
:param str blog: e.g., 'http://www.example.com/jsmith/blog'
:param str company: company name
:param str location: where you are located
:param bool hireable: defaults to False
:param str bio: GitHub flavored markdown
:returns: bool
""" |
user = self.user()
return user.update(name, email, blog, company, location, hireable,
bio) |
<SYSTEM_TASK:>
Returns a User object for the specified login name if
<END_TASK>
<USER_TASK:>
Description:
def user(self, login=None):
"""Returns a User object for the specified login name if
provided. If no login name is provided, this will return a User
object for the authenticated user.
:param str login: (optional)
:returns: :class:`User <github3.users.User>`
""" |
if login:
url = self._build_url('users', login)
else:
url = self._build_url('user')
json = self._json(self._get(url), 200)
return User(json, self._session) if json else None |
<SYSTEM_TASK:>
Returns a quote from the Zen of GitHub. Yet another API Easter Egg
<END_TASK>
<USER_TASK:>
Description:
def zen(self):
"""Returns a quote from the Zen of GitHub. Yet another API Easter Egg
:returns: str
""" |
url = self._build_url('zen')
resp = self._get(url)
return resp.content if resp.status_code == 200 else '' |
<SYSTEM_TASK:>
This is a simple way to get statistics about your system.
<END_TASK>
<USER_TASK:>
Description:
def admin_stats(self, option):
"""This is a simple way to get statistics about your system.
:param str option: (required), accepted values: ('all', 'repos',
'hooks', 'pages', 'orgs', 'users', 'pulls', 'issues',
'milestones', 'gists', 'comments')
:returns: dict
""" |
stats = {}
if option.lower() in ('all', 'repos', 'hooks', 'pages', 'orgs',
'users', 'pulls', 'issues', 'milestones',
'gists', 'comments'):
url = self._build_url('enterprise', 'stats', option.lower())
stats = self._json(self._get(url), 200)
return stats |
<SYSTEM_TASK:>
Update this key.
<END_TASK>
<USER_TASK:>
Description:
def update(self, title, key):
"""Update this key.
:param str title: (required), title of the key
:param str key: (required), text of the key file
:returns: bool
""" |
json = None
if title and key:
data = {'title': title, 'key': key}
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Add the email addresses in ``addresses`` to the authenticated
<END_TASK>
<USER_TASK:>
Description:
def add_email_addresses(self, addresses=[]):
"""Add the email addresses in ``addresses`` to the authenticated
user's account.
:param list addresses: (optional), email addresses to be added
:returns: list of email addresses
""" |
json = []
if addresses:
url = self._build_url('user', 'emails')
json = self._json(self._post(url, data=addresses), 201)
return json |
<SYSTEM_TASK:>
Delete the email addresses in ``addresses`` from the
<END_TASK>
<USER_TASK:>
Description:
def delete_email_addresses(self, addresses=[]):
"""Delete the email addresses in ``addresses`` from the
authenticated user's account.
:param list addresses: (optional), email addresses to be removed
:returns: bool
""" |
url = self._build_url('user', 'emails')
return self._boolean(self._delete(url, data=dumps(addresses)),
204, 404) |
<SYSTEM_TASK:>
Checks if this user is following ``login``.
<END_TASK>
<USER_TASK:>
Description:
def is_following(self, login):
"""Checks if this user is following ``login``.
:param str login: (required)
:returns: bool
""" |
url = self.following_urlt.expand(other_user=login)
return self._boolean(self._get(url), 204, 404) |
<SYSTEM_TASK:>
Iterate over events performed by this user.
<END_TASK>
<USER_TASK:>
Description:
def iter_events(self, public=False, number=-1, etag=None):
"""Iterate over events performed by this user.
:param bool public: (optional), only list public events for the
authenticated user
: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: list of :class:`Event <github3.events.Event>`\ s
""" |
path = ['events']
if public:
path.append('public')
url = self._build_url(*path, base_url=self._api)
return self._iter(int(number), url, Event, etag=etag) |
<SYSTEM_TASK:>
Iterate over the followers of this user.
<END_TASK>
<USER_TASK:>
Description:
def iter_followers(self, number=-1, etag=None):
"""Iterate over the followers of this user.
:param int number: (optional), number of followers to return. Default:
-1 returns all available
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`User <User>`\ s
""" |
url = self._build_url('followers', base_url=self._api)
return self._iter(int(number), url, User, etag=etag) |
<SYSTEM_TASK:>
Iterate over the public keys of this user.
<END_TASK>
<USER_TASK:>
Description:
def iter_keys(self, number=-1, etag=None):
"""Iterate over the public keys of this user.
.. versionadded:: 0.5
:param int number: (optional), number of keys to return. Default: -1
returns all available keys
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Key <Key>`\ s
""" |
url = self._build_url('keys', base_url=self._api)
return self._iter(int(number), url, Key, etag=etag) |
<SYSTEM_TASK:>
Iterate over events as they appear on the user's organization
<END_TASK>
<USER_TASK:>
Description:
def iter_org_events(self, org, number=-1, etag=None):
"""Iterate over events as they appear on the user's organization
dashboard. You must be authenticated to view this.
:param str org: (required), name of the organization
: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: list of :class:`Event <github3.events.Event>`\ s
""" |
url = ''
if org:
url = self._build_url('events', 'orgs', org, base_url=self._api)
return self._iter(int(number), url, Event, etag=etag) |
<SYSTEM_TASK:>
Iterate over organizations the user is member of
<END_TASK>
<USER_TASK:>
Description:
def iter_orgs(self, number=-1, etag=None):
"""Iterate over organizations the user is member of
:param int number: (optional), number of organizations to return.
Default: -1 returns all available organization
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: list of :class:`Event <github3.orgs.Organization>`\ s
""" |
# Import here, because a toplevel import causes an import loop
from .orgs import Organization
url = self._build_url('orgs', base_url=self._api)
return self._iter(int(number), url, Organization, etag=etag) |
<SYSTEM_TASK:>
Iterate over repositories starred by this user.
<END_TASK>
<USER_TASK:>
Description:
def iter_starred(self, sort=None, direction=None, number=-1, etag=None):
"""Iterate over repositories starred by this user.
.. versionchanged:: 0.5
Added sort and direction parameters (optional) as per the change in
GitHub's API.
:param int number: (optional), number of starred repos to return.
Default: -1, returns all available repos
:param str sort: (optional), either 'created' (when the star was
created) or 'updated' (when the repository was last pushed to)
:param str direction: (optional), either 'asc' or 'desc'. Default:
'desc'
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Repository <github3.repos.Repository>`
""" |
from .repos import Repository
params = {'sort': sort, 'direction': direction}
self._remove_none(params)
url = self.starred_urlt.expand(owner=None, repo=None)
return self._iter(int(number), url, Repository, params, etag) |
<SYSTEM_TASK:>
Iterate over repositories subscribed to by this user.
<END_TASK>
<USER_TASK:>
Description:
def iter_subscriptions(self, number=-1, etag=None):
"""Iterate over repositories subscribed to by this user.
:param int number: (optional), number of subscriptions to return.
Default: -1, returns all available
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Repository <github3.repos.Repository>`
""" |
from .repos import Repository
url = self._build_url('subscriptions', base_url=self._api)
return self._iter(int(number), url, Repository, etag=etag) |
<SYSTEM_TASK:>
If authenticated as this user, update the information with
<END_TASK>
<USER_TASK:>
Description:
def update(self, name=None, email=None, blog=None, company=None,
location=None, hireable=False, bio=None):
"""If authenticated as this user, update the information with
the information provided in the parameters.
:param str name: e.g., 'John Smith', not login name
:param str email: e.g., '[email protected]'
:param str blog: e.g., 'http://www.example.com/jsmith/blog'
:param str company:
:param str location:
:param bool hireable: defaults to False
:param str bio: GitHub flavored markdown
:returns: bool
""" |
user = {'name': name, 'email': email, 'blog': blog,
'company': company, 'location': location,
'hireable': hireable, 'bio': bio}
self._remove_none(user)
url = self._build_url('user')
json = self._json(self._patch(url, data=dumps(user)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Delete subscription for this thread.
<END_TASK>
<USER_TASK:>
Description:
def delete_subscription(self):
"""Delete subscription for this thread.
:returns: bool
""" |
url = self._build_url('subscription', base_url=self._api)
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Set the user's subscription for this thread
<END_TASK>
<USER_TASK:>
Description:
def set_subscription(self, subscribed, ignored):
"""Set the user's subscription for this thread
:param bool subscribed: (required), determines if notifications should
be received from this thread.
:param bool ignored: (required), determines if notifications should be
ignored from this thread.
:returns: :class:`Subscription <Subscription>`
""" |
url = self._build_url('subscription', base_url=self._api)
sub = {'subscribed': subscribed, 'ignored': ignored}
json = self._json(self._put(url, data=dumps(sub)), 200)
return Subscription(json, self) if json else None |
<SYSTEM_TASK:>
Checks the status of the user's subscription to this thread.
<END_TASK>
<USER_TASK:>
Description:
def subscription(self):
"""Checks the status of the user's subscription to this thread.
:returns: :class:`Subscription <Subscription>`
""" |
url = self._build_url('subscription', base_url=self._api)
json = self._json(self._get(url), 200)
return Subscription(json, self) if json else None |
<SYSTEM_TASK:>
Set the user's subscription for this subscription
<END_TASK>
<USER_TASK:>
Description:
def set(self, subscribed, ignored):
"""Set the user's subscription for this subscription
:param bool subscribed: (required), determines if notifications should
be received from this thread.
:param bool ignored: (required), determines if notifications should be
ignored from this thread.
""" |
sub = {'subscribed': subscribed, 'ignored': ignored}
json = self._json(self._put(self._api, data=dumps(sub)), 200)
self.__init__(json, self._session) |
<SYSTEM_TASK:>
Add ``login`` as a collaborator to a repository.
<END_TASK>
<USER_TASK:>
Description:
def add_collaborator(self, login):
"""Add ``login`` as a collaborator to a repository.
:param str login: (required), login of the user
:returns: bool -- True if successful, False otherwise
""" |
resp = False
if login:
url = self._build_url('collaborators', login, base_url=self._api)
resp = self._boolean(self._put(url), 204, 404)
return resp |
<SYSTEM_TASK:>
Get the tarball or zipball archive for this repo at ref.
<END_TASK>
<USER_TASK:>
Description:
def archive(self, format, path='', ref='master'):
"""Get the tarball or zipball archive for this repo at ref.
See: http://developer.github.com/v3/repos/contents/#get-archive-link
:param str format: (required), accepted values: ('tarball',
'zipball')
:param path: (optional), path where the file should be saved
to, default is the filename provided in the headers and will be
written in the current directory.
it can take a file-like object as well
:type path: str, file
:param str ref: (optional)
:returns: bool -- True if successful, False otherwise
""" |
resp = None
if format in ('tarball', 'zipball'):
url = self._build_url(format, ref, base_url=self._api)
resp = self._get(url, allow_redirects=True, stream=True)
if resp and self._boolean(resp, 200, 404):
stream_response_to_file(resp, path)
return True
return False |
<SYSTEM_TASK:>
Returns a single Asset.
<END_TASK>
<USER_TASK:>
Description:
def asset(self, id):
"""Returns a single Asset.
:param int id: (required), id of the asset
:returns: :class:`Asset <github3.repos.release.Asset>`
""" |
data = None
if int(id) > 0:
url = self._build_url('releases', 'assets', str(id),
base_url=self._api)
data = self._json(self._get(url, headers=Release.CUSTOM_HEADERS),
200)
return Asset(data, self) if data else None |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.