"""Stores all the session information.

def __init__(self, username='', password='', token=''):

super(GitHub, self).__init__({})

if token:

self.login(username, token=token)

elif username and password:

self.login(username, password)

def _repr(self):

if self.session.auth:

return '<GitHub [{0[0]}]>'.format(self.session.auth)

return '<GitHub at 0x{0:x}>'.format(id(self))

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

"""Iterate over public events.

url = self._build_url('events')

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

def all_organizations(self, number=-1, since=None, etag=None,

per_page=None):

"""Iterate over every organization in the order they were created.

url = self._build_url('organizations')

return self._iter(int(number), url, Organization,

params={'since': since, 'per_page': per_page},

etag=etag)

def all_repositories(self, number=-1, since=None, etag=None,

per_page=None):

"""Iterate over every repository in the order they were created.

url = self._build_url('repositories')

return self._iter(int(number), url, Repository,

params={'since': since, 'per_page': per_page},

etag=etag)

def all_users(self, number=-1, etag=None, per_page=None, since=None):

"""Iterate over every user in the order they signed up for GitHub.

url = self._build_url('users')

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

params={'per_page': per_page, 'since': since})

@requires_basic_auth

def authorization(self, id_num):

"""Get information about authorization ``id``.

json = None

if int(id_num) > 0:

url = self._build_url('authorizations', str(id_num))

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

return self._instance_or_null(Authorization, json)

@requires_basic_auth

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

"""Iterate over authorizations for the authenticated user. This will

url = self._build_url('authorizations')

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

def authorize(self, username, password, scopes=None, note='', note_url='',

client_id='', client_secret='', fingerprint=''):

"""Obtain an authorization token.

json = None

if username and password:

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

if fingerprint:

data['fingerprint'] = fingerprint

with self.session.temporary_basic_auth(username, password):

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

return self._instance_or_null(Authorization, json)

create_authorization = authorize

def check_authorization(self, access_token):

"""Check an authorization created by a registered application.

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

def create_gist(self, description, files, public=True):

"""Create a new 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 self._instance_or_null(Gist, json)

@requires_auth

def create_issue(self, owner, repository, title, body=None, assignee=None,

milestone=None, labels=[]):

"""Create an issue on the project 'repository' owned by 'owner'

repo = None

if owner and repository and title:

repo = self.repository(owner, repository)

# repo can be None or a NullObject.

# If repo is None, than one of owner, repository, or title were

# False-y. If repo is a NullObject then owner/repository 404's.

if repo is not None:

# If repo is a NullObject then that's most likely because the

# repository was not found (404). In that case, calling the

# create_issue method will still return <NullObject('Repository')>

# which will ideally help the user understand what went wrong.

return repo.create_issue(title, body, assignee, milestone, labels)

return self._instance_or_null(Issue, None)

@requires_auth

def create_key(self, title, key):

"""Create a new key for the authenticated user.

json = 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)

return self._instance_or_null(Key, json)

@requires_auth

def create_repository(self, name, description='', homepage='',

private=False, has_issues=True, has_wiki=True,

auto_init=False, gitignore_template=''):

"""Create a repository for the authenticated user.

url = self._build_url('user', 'repos')

data = {'name': name, 'description': description,

'homepage': homepage, 'private': private,

'has_issues': has_issues, 'has_wiki': has_wiki,

'auto_init': auto_init,

'gitignore_template': gitignore_template}

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

return self._instance_or_null(Repository, json)

@requires_auth

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

"""Iterate over email addresses for the authenticated user.

url = self._build_url('user', 'emails')

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

def emojis(self):

"""Retrieves a dictionary of all of the emojis that GitHub supports.

url = self._build_url('emojis')

return self._json(self._get(url), 200)

@requires_basic_auth

def feeds(self):

"""List GitHub's timeline resources in Atom format.

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

@requires_auth

def follow(self, username):

"""Make the authenticated user follow the provided username.

resp = False

if username:

url = self._build_url('user', 'following', username)

resp = self._boolean(self._put(url), 204, 404)

return resp

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

"""Iterate over users being followed by ``username``.

url = self._build_url('users', username, 'following')

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

@requires_auth

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

"""Iterate over followers of the authenticated user.

url = self._build_url('user', 'followers')

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

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

"""Iterate over followers of ``username``.

url = self._build_url('users', username, 'followers')

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

@requires_auth

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

"""Iterate over users the authenticated user is following.

url = self._build_url('user', 'following')

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

def gist(self, id_num):

"""Retrieve the gist using the specified id number.

url = self._build_url('gists', str(id_num))

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

return self._instance_or_null(Gist, json)

@requires_auth

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

"""Retrieve the authenticated user's gists.

url = self._build_url('gists')

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

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

"""Iterate over the gists owned by a user.

url = self._build_url('users', username, 'gists')

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

def gitignore_template(self, language):

"""Return the template for language.

url = self._build_url('gitignore', 'templates', language)

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

if not json:

return ''

return json.get('source', '')

def gitignore_templates(self):

"""Return the list of available templates.

url = self._build_url('gitignore', 'templates')

return self._json(self._get(url), 200) or []

@requires_auth

def is_following(self, username):

"""Check if the authenticated user is following login.

json = False

if username:

url = self._build_url('user', 'following', username)

json = self._boolean(self._get(url), 204, 404)

return json

@requires_auth

def is_starred(self, username, repo):

"""Check if the authenticated user starred username/repo.

json = False

if username and repo:

url = self._build_url('user', 'starred', username, repo)

json = self._boolean(self._get(url), 204, 404)

return json

def issue(self, username, repository, number):

"""Fetch issue from owner/repository.

json = None

if username and repository and int(number) > 0:

url = self._build_url('repos', username, repository, 'issues',

str(number))

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

return self._instance_or_null(Issue, json)

@requires_auth

def issues(self, filter='', state='', labels='', sort='', direction='',

since=None, number=-1, etag=None):

"""List all of the authenticated user's (and organization's) issues.

url = self._build_url('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)

def issues_on(self, username, repository, milestone=None, state=None,

assignee=None, mentioned=None, labels=None, sort=None,

direction=None, since=None, number=-1, etag=None):

"""List issues on owner/repository. Only owner and repository are

if username and repository:

url = self._build_url('repos', username, repository, 'issues')

params = repo_issue_params(milestone, state, assignee, mentioned,

labels, sort, direction, since)

return self._iter(int(number), url, Issue, params=params,

etag=etag)

return iter([])

@requires_auth

def key(self, id_num):

"""Gets the authenticated user's key specified by id_num.

json = None

if int(id_num) > 0:

url = self._build_url('user', 'keys', str(id_num))

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

return self._instance_or_null(Key, json)

@requires_auth

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

"""Iterate over public keys for the authenticated user.

url = self._build_url('user', 'keys')

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

def login(self, username=None, password=None, token=None,

two_factor_callback=None):

"""Logs the user into GitHub for protected API calls.

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)

def markdown(self, text, mode='', context='', raw=False):

"""Render an arbitrary markdown document.

data = None

json = False

headers = {}

if raw:

url = self._build_url('markdown', 'raw')

data = text

headers['content-type'] = 'text/plain'

else:

url = self._build_url('markdown')

data = {}

if text:

data['text'] = text

if mode in ('markdown', 'gfm'):

data['mode'] = mode

if context:

data['context'] = context

json = True

html = ''

if data:

req = self._post(url, data=data, json=json, headers=headers)

if req.ok:

html = req.text

return html

@requires_auth

def me(self):

"""Retrieves the info for the authenticated user.

url = self._build_url('user')

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

return self._instance_or_null(User, json)

@requires_auth

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

def meta(self):

"""Returns a dictionary with arrays of addresses in CIDR format

url = self._build_url('meta')

return self._json(self._get(url), 200) or {}

@requires_auth

def notifications(self, all=False, participating=False, number=-1,

etag=None):

"""Iterate over the user's notification.

params = None

if all is True:

params = {'all': 'true'}

elif participating is True:

params = {'participating': 'true'}

url = self._build_url('notifications')

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

def octocat(self, say=None):

"""Returns an easter egg of the API.

url = self._build_url('octocat')

req = self._get(url, params={'s': say})

return req.text if req.ok else ''

def organization(self, username):

"""Returns a Organization object for the login name

url = self._build_url('orgs', username)

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

return self._instance_or_null(Organization, json)

@requires_auth

def organization_issues(self, name, filter='', state='', labels='',

sort='', direction='', since=None, number=-1,

etag=None):

"""Iterate over the organization's issues if the authenticated user

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)

@requires_auth

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

"""Iterate over all organizations the authenticated user belongs to.

url = self._build_url('user', 'orgs')

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

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

"""Iterate over organizations with ``username`` as a public member.

if username:

url = self._build_url('users', username, 'orgs')

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

return iter([])

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

"""Retrieve all public gists and iterate over them.

url = self._build_url('gists', 'public')

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

@requires_auth

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

"""List organizations of which the user is a current or pending member.

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)

@requires_auth

def pubsubhubbub(self, mode, topic, callback, secret=''):

"""Create/update a pubsubhubbub hook.

from re import match

m = match('https?://[\w\d\-\.\:]+/\w+/[\w\._-]+/events/\w+', topic)

status = False

if mode and topic and callback and m:

data = [('hub.mode', mode), ('hub.topic', topic),

('hub.callback', callback)]

if secret:

data.append(('hub.secret', secret))

url = self._build_url('hub')

# This is not JSON data. It is meant to be form data

# application/x-www-form-urlencoded works fine here, no need for

# multipart/form-data

status = self._boolean(self._post(url, data=data, json=False), 204,

404)

return status

def pull_request(self, owner, repository, number):

"""Fetch pull_request #:number: from :owner:/:repository

json = None

if int(number) > 0:

url = self._build_url('repos', owner, repository, 'pulls',

str(number))

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

return self._instance_or_null(PullRequest, json)

def rate_limit(self):

"""Returns a dictionary with information from /rate_limit.

url = self._build_url('rate_limit')

return self._json(self._get(url), 200)

@requires_auth

def repositories(self, type=None, sort=None, direction=None, number=-1,

etag=None):

"""List public repositories for the authenticated user.