"""This class serves as the base for all other Repository objects.

STAR_HEADERS = {

'Accept': 'application/vnd.github.v3.star+json'

}

class_name = '_Repository'

def _update_attributes(self, repo):

self.url = self._api = repo['url']

self.archive_urlt = urit.URITemplate(repo['archive_url'])

self.assignees_urlt = urit.URITemplate(repo['assignees_url'])

self.blobs_urlt = urit.URITemplate(repo['blobs_url'])

self.branches_urlt = urit.URITemplate(repo['branches_url'])

self.collaborators_urlt = urit.URITemplate(repo['collaborators_url'])

self.comments_urlt = urit.URITemplate(repo['comments_url'])

self.commits_urlt = urit.URITemplate(repo['commits_url'])

self.compare_urlt = urit.URITemplate(repo['compare_url'])

self.contents_urlt = urit.URITemplate(repo['contents_url'])

self.contributors_url = repo['contributors_url']

self.deployments_url = repo['deployments_url']

self.description = repo['description']

self.downloads_url = repo['downloads_url']

self.events_url = repo['events_url']

self.fork = repo['fork']

self.forks_url = repo['forks_url']

self.full_name = repo['full_name']

self.git_commits_urlt = urit.URITemplate(repo['git_commits_url'])

self.git_refs_urlt = urit.URITemplate(repo['git_refs_url'])

self.git_tags_urlt = urit.URITemplate(repo['git_tags_url'])

self.hooks_url = repo['hooks_url']

self.html_url = repo['html_url']

self.id = repo['id']

self.issue_comment_urlt = urit.URITemplate(repo['issue_comment_url'])

self.issue_events_urlt = urit.URITemplate(repo['issue_events_url'])

self.issues_urlt = urit.URITemplate(repo['issues_url'])

self.keys_urlt = urit.URITemplate(repo['keys_url'])

self.labels_urlt = urit.URITemplate(repo['labels_url'])

self.languages_url = repo['languages_url']

self.merges_url = repo['merges_url']

self.milestones_urlt = urit.URITemplate(repo['milestones_url'])

self.name = repo['name']

self.notifications_urlt = urit.URITemplate(repo['notifications_url'])

self.owner = users.ShortUser(repo['owner'], self)

self.private = repo['private']

self.pulls_urlt = urit.URITemplate(repo['pulls_url'])

self.releases_urlt = urit.URITemplate(repo['releases_url'])

self.stargazers_url = repo['stargazers_url']

self.statuses_urlt = urit.URITemplate(repo['statuses_url'])

self.subscribers_url = repo['subscribers_url']

self.subscription_url = repo['subscription_url']

self.tags_url = repo['tags_url']

self.teams_url = repo['teams_url']

self.trees_urlt = urit.URITemplate(repo['trees_url'])

def _repr(self):

return '<{0} [{1}]>'.format(self.class_name, self)

def __str__(self):

return self.full_name

def _create_pull(self, data):

self._remove_none(data)

json = None

if data:

url = self._build_url('pulls', base_url=self._api)

json = self._json(self._post(url, data=data), 201)

return self._instance_or_null(pulls.ShortPullRequest, json)

@requires_auth

def add_collaborator(self, username):

"""Add ``username`` as a collaborator to a repository.

if not username:

return False

url = self._build_url('collaborators', str(username),

base_url=self._api)

return self._boolean(self._put(url), 201, 404)

def archive(self, format, path='', ref='master'):

"""Get the tarball or zipball archive for this repo at ref.

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):

utils.stream_response_to_file(resp, path)

return True

return False

def asset(self, id):

"""Return a single 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), 200)

return self._instance_or_null(release.Asset, data)

def assignees(self, number=-1, etag=None):

"""Iterate over all assignees to which an issue may be assigned.

url = self._build_url('assignees', base_url=self._api)

return self._iter(int(number), url, users.ShortUser, etag=etag)

def blob(self, sha):

"""Get the blob indicated by ``sha``.

url = self._build_url('git', 'blobs', sha, base_url=self._api)

json = self._json(self._get(url), 200)

return self._instance_or_null(git.Blob, json)

def branch(self, name):

"""Get the branch ``name`` of this repository.

json = None

if name:

url = self._build_url('branches', name, base_url=self._api)

json = self._json(self._get(url,

headers=branch.Branch.PREVIEW_HEADERS),

200)

return self._instance_or_null(branch.Branch, json)

def branches(self, number=-1, protected=False, etag=None):

"""Iterate over the branches in this repository.

url = self._build_url('branches', base_url=self._api)

params = {'protected': '1'} if protected else None

return self._iter(int(number), url, branch.ShortBranch, params,

etag=etag, headers=branch.Branch.PREVIEW_HEADERS)

def code_frequency(self, number=-1, etag=None):

"""Iterate over the code frequency per week.

url = self._build_url('stats', 'code_frequency', base_url=self._api)

return self._iter(int(number), url, list, etag=etag)

def collaborators(self, affiliation='all', number=-1, etag=None):

"""Iterate over the collaborators of this repository.

url = self._build_url('collaborators', base_url=self._api)

affiliations = {'outside', 'direct', 'all'}

if affiliation not in affiliations:

raise ValueError(

(

"Invalid affiliation value {!r} parameter passed, must "

"be 'outside', 'direct', or 'all' (defaults to 'all')."

).format(affiliation)

)

params = {'affiliation': affiliation}

return self._iter(

int(number), url, users.Collaborator, params, etag=etag

)

def comments(self, number=-1, etag=None):

"""Iterate over comments on all commits in the repository.

url = self._build_url('comments', base_url=self._api)

return self._iter(int(number), url, comment.RepoComment, etag=etag)

def commit(self, sha):

"""Get a single (repo) commit.

url = self._build_url('commits', sha, base_url=self._api)

json = self._json(self._get(url), 200)

return self._instance_or_null(commit.RepoCommit, json)

def commit_activity(self, number=-1, etag=None):

"""Iterate over last year of commit activity by week.

url = self._build_url('stats', 'commit_activity', base_url=self._api)

return self._iter(int(number), url, dict, etag=etag)

def commit_comment(self, comment_id):

"""Get a single commit comment.

url = self._build_url('comments', str(comment_id), base_url=self._api)

json = self._json(self._get(url), 200)

return self._instance_or_null(comment.RepoComment, json)

def commits(self, sha=None, path=None, author=None, number=-1, etag=None,

since=None, until=None, per_page=None):

"""Iterate over commits in this repository.

params = {'sha': sha, 'path': path, 'author': author,

'since': utils.timestamp_parameter(since),

'until': utils.timestamp_parameter(until),

'per_page': per_page}

self._remove_none(params)

url = self._build_url('commits', base_url=self._api)

return self._iter(int(number), url, commit.ShortCommit, params, etag)

def compare_commits(self, base, head):

"""Compare two commits.

url = self._build_url('compare', base + '...' + head,

base_url=self._api)

json = self._json(self._get(url), 200)

return self._instance_or_null(comparison.Comparison, json)

def contributor_statistics(self, number=-1, etag=None):

"""Iterate over the contributors list.

url = self._build_url('stats', 'contributors', base_url=self._api)

return self._iter(int(number), url, stats.ContributorStats, etag=etag)

def contributors(self, anon=False, number=-1, etag=None):

"""Iterate over the contributors to this repository.

url = self._build_url('contributors', base_url=self._api)

params = {}

if anon:

params = {'anon': 'true'}

return self._iter(int(number), url, users.Contributor, params, etag)

@requires_auth

def create_blob(self, content, encoding):

"""Create a blob with ``content``.

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

@requires_auth

def create_branch_ref(self, name, sha=None):

"""Create a branch git reference.

ref = "refs/heads/%s" % name

return self.create_ref(ref, sha)

@requires_auth

def create_comment(self, body, sha, path=None, position=None, line=1):

"""Create a comment on a commit.

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 self._instance_or_null(comment.RepoComment, json)

@requires_auth

def create_commit(self, message, tree, parents, author=None,

committer=None):

"""Create a commit on this repository.

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}

self._remove_none(data)

json = self._json(self._post(url, data=data), 201)

return self._instance_or_null(git.Commit, json)

@requires_auth

def create_deployment(self, ref, required_contexts=None, payload='',

auto_merge=False, description='', environment=None):

"""Create a deployment.

json = None

if ref:

if required_contexts is None:

required_contexts = []

url = self._build_url('deployments', base_url=self._api)

data = {'ref': ref, 'required_contexts': required_contexts,

'payload': payload, 'auto_merge': auto_merge,

'description': description, 'environment': environment}

self._remove_none(data)

json = self._json(self._post(url, data=data),

201)

return self._instance_or_null(deployment.Deployment, json)

@requires_auth

def create_file(self, path, message, content, branch=None,

committer=None, author=None):

"""Create a file in this repository.

if content and not isinstance(content, bytes):

raise ValueError( # (No coverage)

'content must be a bytes object') # (No coverage)

json = None

if path and message and content:

url = self._build_url('contents', path, base_url=self._api)

content = base64.b64encode(content).decode('utf-8')

data = {'message': message, 'content': content, 'branch': branch,

'committer': contents.validate_commmitter(committer),

'author': contents.validate_commmitter(author)}

self._remove_none(data)

json = self._json(self._put(url, data=jsonlib.dumps(data)), 201)

if json and 'content' in json and 'commit' in json:

json['content'] = contents.Contents(

json['content'], self

)

json['commit'] = git.Commit(json['commit'], self)

return json

@requires_auth

def create_fork(self, organization=None):

"""Create a fork of this repository.

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 self._instance_or_null(Repository, json)

@requires_auth

def create_hook(self, name, config, events=['push'], active=True):

"""Create a hook on this repository.

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.Hook(json, self) if json else None

@requires_auth

def create_issue(self,

title,

body=None,

assignee=None,

milestone=None,

labels=None,

assignees=None):

"""Create an issue on this repository.

issue = {'title': title, 'body': body, 'assignee': assignee,

'milestone': milestone, 'labels': labels,

'assignees': assignees}

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 self._instance_or_null(issues.ShortIssue, json)

@requires_auth

def create_key(self, title, key, read_only=False):

"""Create a deploy key.

json = None

if title and key:

data = {'title': title, 'key': key, 'read_only': read_only}

url = self._build_url('keys', base_url=self._api)

json = self._json(self._post(url, data=data), 201)

return self._instance_or_null(users.Key, json)

@requires_auth

def create_label(self, name, color):

"""Create a label for this repository.

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 self._instance_or_null(label.Label, json)

@requires_auth

def create_milestone(self, title, state=None, description=None,

due_on=None):

"""Create a milestone for this repository.

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 self._instance_or_null(milestone.Milestone, json)

@requires_auth

def create_project(self, name, body=None):

"""Create a project for this repository.

url = self._build_url('projects', base_url=self._api)

data = {'name': name, 'body': body}

self._remove_none(data)

json = None

if data:

json = self._json(self._post(

url, data=data, headers=projects.Project.CUSTOM_HEADERS), 201)

return self._instance_or_null(projects.Project, json)

@requires_auth

def create_pull(self, title, base, head, body=None):

"""Create a pull request of ``head`` onto ``base`` branch in this repo.

data = {'title': title, 'body': body, 'base': base,

'head': head}

return self._create_pull(data)

@requires_auth

def create_pull_from_issue(self, issue, base, head):

"""Create a pull request from issue #``issue``.

if int(issue) > 0:

data = {'issue': issue, 'base': base, 'head': head}

return self._create_pull(data)

return None

@requires_auth

def create_ref(self, ref, sha):

"""Create a reference in this repository.

sha = getattr(sha, 'sha', sha)

json = None

if ref and ref.startswith('refs') 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 self._instance_or_null(git.Reference, json)

@requires_auth

def create_release(self, tag_name, target_commitish=None, name=None,

body=None, draft=False, prerelease=False):

"""Create a release for this repository.

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), 201)

return self._instance_or_null(release.Release, json)

@requires_auth

def create_status(self, sha, state, target_url=None, description=None,

context='default'):

"""Create a status object on a commit.