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

@requires_auth

def add_email_addresses(self, addresses=[]):

"""Add the email addresses in ``addresses`` to the authenticated

json = []

if addresses:

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

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

return [users.Email(email) for email in json] if json else []

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, users.ShortUser, 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=''):

"""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

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

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

return self._instance_or_null(Authorization, json)

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)

if repo is not None:

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

return self._instance_or_null(Issue, None)

@requires_auth

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

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

json = None

if title and key:

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

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

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

json = self._json(req, 201)

return self._instance_or_null(users.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 delete_email_addresses(self, addresses=[]):

"""Delete the email addresses in ``addresses`` from the

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

return self._boolean(self._delete(url, data=json.dumps(addresses)),

204, 404)

@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, users.Email, 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, include_cache_info=False)

@requires_basic_auth

def feeds(self):

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

def replace_href(feed_dict):

if not feed_dict:

return feed_dict

ret_dict = {}

# Let's pluck out what we're most interested in, the href value

href = feed_dict.pop('href', None)

# Then we update the return dictionary with the rest of the values

ret_dict.update(feed_dict)

if href is not None:

# So long as there is something to template, let's template it

ret_dict['href'] = URITemplate(href)

return ret_dict

url = self._build_url('feeds')

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

if json is None: # If something went wrong, get out early

return None

# We have a response body to parse

feeds = {}

# Let's pop out the old links so we don't have to skip them below

old_links = json.pop('_links', {})

_links = {}

# If _links is in the response JSON, iterate over that and recreate it

# so that any templates contained inside can be turned into

# URITemplates

for key, value in old_links.items():

if isinstance(value, list):

# If it's an array/list of links, let's replace that with a

# new list of links

_links[key] = [replace_href(d) for d in value]

else:

# Otherwise, just use the new value

_links[key] = replace_href(value)

# Start building up our return dictionary

feeds['_links'] = _links

for key, value in json.items():

# This should roughly be the same logic as above.

if isinstance(value, list):

feeds[key] = [URITemplate(v) for v in value]

else:

feeds[key] = URITemplate(value)

return feeds

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

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

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

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

@requires_auth

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

r"""Iterate over followers of the authenticated user.

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

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

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

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

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

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

@requires_auth

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

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

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

return self._iter(int(number), url, users.ShortUser, 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(users.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, users.Key, etag=etag)

def license(self, name):

"""Retrieve the license specified by the name.

url = self._build_url('licenses', name)

json = self._json(self._get(url, headers=License.CUSTOM_HEADERS), 200)

return self._instance_or_null(License, json)

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

"""Iterate over open source licenses.

url = self._build_url('licenses')

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

headers=License.CUSTOM_HEADERS)

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

"""Retrieve the info for the authenticated user.

url = self._build_url('user')

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

return self._instance_or_null(users.AuthenticatedUser, 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-]+\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))