PyGithub/github/AuthenticatedUser.py

# WARNING: this file is generated automaticaly.
# Do not modify it manually, your work would be lost.

# Copyright 2012 Vincent Jacques
# vincent@vincent-jacques.net

# This file is part of PyGithub. http://vincent-jacques.net/PyGithub

# PyGithub is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License
# as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

# PyGithub is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.

# You should have received a copy of the GNU Lesser General Public License along with PyGithub.  If not, see <http://www.gnu.org/licenses/>.

import GithubObject
import PaginatedList

import InputFileContent
import Gist
import Repository
import NamedUser
import Plan
import Organization
import UserKey
import Issue
import Event
import Authorization

class AuthenticatedUser( GithubObject.GithubObject ):
    @property
    def avatar_url( self ):
        self._completeIfNotSet( self._avatar_url )
        return self._NoneIfNotSet( self._avatar_url )

    @property
    def bio( self ):
        self._completeIfNotSet( self._bio )
        return self._NoneIfNotSet( self._bio )

    @property
    def blog( self ):
        self._completeIfNotSet( self._blog )
        return self._NoneIfNotSet( self._blog )

    @property
    def collaborators( self ):
        self._completeIfNotSet( self._collaborators )
        return self._NoneIfNotSet( self._collaborators )

    @property
    def company( self ):
        self._completeIfNotSet( self._company )
        return self._NoneIfNotSet( self._company )

    @property
    def created_at( self ):
        self._completeIfNotSet( self._created_at )
        return self._NoneIfNotSet( self._created_at )

    @property
    def disk_usage( self ):
        self._completeIfNotSet( self._disk_usage )
        return self._NoneIfNotSet( self._disk_usage )

    @property
    def email( self ):
        self._completeIfNotSet( self._email )
        return self._NoneIfNotSet( self._email )

    @property
    def followers( self ):
        self._completeIfNotSet( self._followers )
        return self._NoneIfNotSet( self._followers )

    @property
    def following( self ):
        self._completeIfNotSet( self._following )
        return self._NoneIfNotSet( self._following )

    @property
    def gravatar_id( self ):
        self._completeIfNotSet( self._gravatar_id )
        return self._NoneIfNotSet( self._gravatar_id )

    @property
    def hireable( self ):
        self._completeIfNotSet( self._hireable )
        return self._NoneIfNotSet( self._hireable )

    @property
    def html_url( self ):
        self._completeIfNotSet( self._html_url )
        return self._NoneIfNotSet( self._html_url )

    @property
    def id( self ):
        self._completeIfNotSet( self._id )
        return self._NoneIfNotSet( self._id )

    @property
    def location( self ):
        self._completeIfNotSet( self._location )
        return self._NoneIfNotSet( self._location )

    @property
    def login( self ):
        self._completeIfNotSet( self._login )
        return self._NoneIfNotSet( self._login )

    @property
    def name( self ):
        self._completeIfNotSet( self._name )
        return self._NoneIfNotSet( self._name )

    @property
    def owned_private_repos( self ):
        self._completeIfNotSet( self._owned_private_repos )
        return self._NoneIfNotSet( self._owned_private_repos )

    @property
    def plan( self ):
        self._completeIfNotSet( self._plan )
        return self._NoneIfNotSet( self._plan )

    @property
    def private_gists( self ):
        self._completeIfNotSet( self._private_gists )
        return self._NoneIfNotSet( self._private_gists )

    @property
    def public_gists( self ):
        self._completeIfNotSet( self._public_gists )
        return self._NoneIfNotSet( self._public_gists )

    @property
    def public_repos( self ):
        self._completeIfNotSet( self._public_repos )
        return self._NoneIfNotSet( self._public_repos )

    @property
    def total_private_repos( self ):
        self._completeIfNotSet( self._total_private_repos )
        return self._NoneIfNotSet( self._total_private_repos )

    @property
    def type( self ):
        self._completeIfNotSet( self._type )
        return self._NoneIfNotSet( self._type )

    @property
    def url( self ):
        self._completeIfNotSet( self._url )
        return self._NoneIfNotSet( self._url )

    def add_to_emails( self, *emails ):
        assert all( isinstance( element, ( str, unicode ) ) for element in emails ), emails
        post_parameters = emails
        headers, data = self._requester.requestAndCheck(
            "POST",
            "/user/emails",
            None,
            post_parameters
        )

    def add_to_following( self, following ):
        assert isinstance( following, NamedUser.NamedUser ), following
        headers, data = self._requester.requestAndCheck(
            "PUT",
            "/user/following/" + following._identity,
            None,
            None
        )

    def add_to_starred( self, starred ):
        assert isinstance( starred, Repository.Repository ), starred
        headers, data = self._requester.requestAndCheck(
            "PUT",
            "/user/starred/" + starred._identity,
            None,
            None
        )

    def add_to_watched( self, watched ):
        assert isinstance( watched, Repository.Repository ), watched
        headers, data = self._requester.requestAndCheck(
            "PUT",
            "/user/watched/" + watched._identity,
            None,
            None
        )

    def create_authorization( self, scopes = GithubObject.NotSet, note = GithubObject.NotSet, note_url = GithubObject.NotSet ):
        assert scopes is GithubObject.NotSet or all( isinstance( element, ( str, unicode ) ) for element in scopes ), scopes
        assert note is GithubObject.NotSet or isinstance( note, ( str, unicode ) ), note
        assert note_url is GithubObject.NotSet or isinstance( note_url, ( str, unicode ) ), note_url
        post_parameters = dict()
        if scopes is not GithubObject.NotSet:
            post_parameters[ "scopes" ] = scopes
        if note is not GithubObject.NotSet:
            post_parameters[ "note" ] = note
        if note_url is not GithubObject.NotSet:
            post_parameters[ "note_url" ] = note_url
        headers, data = self._requester.requestAndCheck(
            "POST",
            "/authorizations",
            None,
            post_parameters
        )
        return Authorization.Authorization( self._requester, data, completed = True )

    def create_fork( self, repo ):
        assert isinstance( repo, Repository.Repository ), repo
        headers, data = self._requester.requestAndCheck(
            "POST",
            "/repos/" + repo.owner.login + "/" + repo.name + "/forks",
            None,
            None
        )
        return Repository.Repository( self._requester, data, completed = True )

    def create_gist( self, public, files, description = GithubObject.NotSet ):
        assert isinstance( public, bool ), public
        assert all( isinstance( element, InputFileContent.InputFileContent ) for element in files.itervalues() ), files
        assert description is GithubObject.NotSet or isinstance( description, ( str, unicode ) ), description
        post_parameters = {
            "public": public,
            "files": dict( ( key, value._identity ) for key, value in files.iteritems() ),
        }
        if description is not GithubObject.NotSet:
            post_parameters[ "description" ] = description
        headers, data = self._requester.requestAndCheck(
            "POST",
            "/gists",
            None,
            post_parameters
        )
        return Gist.Gist( self._requester, data, completed = True )

    def create_key( self, title, key ):
        assert isinstance( title, ( str, unicode ) ), title
        assert isinstance( key, ( str, unicode ) ), key
        post_parameters = {
            "title": title,
            "key": key,
        }
        headers, data = self._requester.requestAndCheck(
            "POST",
            "/user/keys",
            None,
            post_parameters
        )
        return UserKey.UserKey( self._requester, data, completed = True )

    def create_repo( self, name, description = GithubObject.NotSet, homepage = GithubObject.NotSet, private = GithubObject.NotSet, has_issues = GithubObject.NotSet, has_wiki = GithubObject.NotSet, has_downloads = GithubObject.NotSet ):
        assert isinstance( name, ( str, unicode ) ), name
        assert description is GithubObject.NotSet or isinstance( description, ( str, unicode ) ), description
        assert homepage is GithubObject.NotSet or isinstance( homepage, ( str, unicode ) ), homepage
        assert private is GithubObject.NotSet or isinstance( private, bool ), private
        assert has_issues is GithubObject.NotSet or isinstance( has_issues, bool ), has_issues
        assert has_wiki is GithubObject.NotSet or isinstance( has_wiki, bool ), has_wiki
        assert has_downloads is GithubObject.NotSet or isinstance( has_downloads, bool ), has_downloads
        post_parameters = {
            "name": name,
        }
        if description is not GithubObject.NotSet:
            post_parameters[ "description" ] = description
        if homepage is not GithubObject.NotSet:
            post_parameters[ "homepage" ] = homepage
        if private is not GithubObject.NotSet:
            post_parameters[ "private" ] = private
        if has_issues is not GithubObject.NotSet:
            post_parameters[ "has_issues" ] = has_issues
        if has_wiki is not GithubObject.NotSet:
            post_parameters[ "has_wiki" ] = has_wiki
        if has_downloads is not GithubObject.NotSet:
            post_parameters[ "has_downloads" ] = has_downloads
        headers, data = self._requester.requestAndCheck(
            "POST",
            "/user/repos",
            None,
            post_parameters
        )
        return Repository.Repository( self._requester, data, completed = True )

    def edit( self, name = GithubObject.NotSet, email = GithubObject.NotSet, blog = GithubObject.NotSet, company = GithubObject.NotSet, location = GithubObject.NotSet, hireable = GithubObject.NotSet, bio = GithubObject.NotSet ):
        assert name is GithubObject.NotSet or isinstance( name, ( str, unicode ) ), name
        assert email is GithubObject.NotSet or isinstance( email, ( str, unicode ) ), email
        assert blog is GithubObject.NotSet or isinstance( blog, ( str, unicode ) ), blog
        assert company is GithubObject.NotSet or isinstance( company, ( str, unicode ) ), company
        assert location is GithubObject.NotSet or isinstance( location, ( str, unicode ) ), location
        assert hireable is GithubObject.NotSet or isinstance( hireable, bool ), hireable
        assert bio is GithubObject.NotSet or isinstance( bio, ( str, unicode ) ), bio
        post_parameters = dict()
        if name is not GithubObject.NotSet:
            post_parameters[ "name" ] = name
        if email is not GithubObject.NotSet:
            post_parameters[ "email" ] = email
        if blog is not GithubObject.NotSet:
            post_parameters[ "blog" ] = blog
        if company is not GithubObject.NotSet:
            post_parameters[ "company" ] = company
        if location is not GithubObject.NotSet:
            post_parameters[ "location" ] = location
        if hireable is not GithubObject.NotSet:
            post_parameters[ "hireable" ] = hireable
        if bio is not GithubObject.NotSet:
            post_parameters[ "bio" ] = bio
        headers, data = self._requester.requestAndCheck(
            "PATCH",
            "/user",
            None,
            post_parameters
        )
        self._useAttributes( data )

    def get_authorization( self, id ):
        assert isinstance( id, int ), id
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/authorizations/" + str( id ),
            None,
            None
        )
        return Authorization.Authorization( self._requester, data, completed = True )

    def get_authorizations( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/authorizations",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Authorization.Authorization,
            self._requester,
            headers,
            data
        )

    def get_emails( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/emails",
            None,
            None
        )
        return data

    def get_events( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/events",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Event.Event,
            self._requester,
            headers,
            data
        )

    def get_followers( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/followers",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            NamedUser.NamedUser,
            self._requester,
            headers,
            data
        )

    def get_following( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/following",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            NamedUser.NamedUser,
            self._requester,
            headers,
            data
        )

    def get_gists( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/gists",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Gist.Gist,
            self._requester,
            headers,
            data
        )

    def get_issues( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/issues",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Issue.Issue,
            self._requester,
            headers,
            data
        )

    def get_key( self, id ):
        assert isinstance( id, int ), id
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/keys/" + str( id ),
            None,
            None
        )
        return UserKey.UserKey( self._requester, data, completed = True )

    def get_keys( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/keys",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            UserKey.UserKey,
            self._requester,
            headers,
            data
        )

    def get_organization_events( self, org ):
        assert isinstance( org, Organization.Organization ), org
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/users/" + self.login + "/events/orgs/" + org.login,
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Event.Event,
            self._requester,
            headers,
            data
        )

    def get_orgs( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/orgs",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Organization.Organization,
            self._requester,
            headers,
            data
        )

    def get_repo( self, name ):
        assert isinstance( name, ( str, unicode ) ), name
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/repos/" + self.login + "/" + name,
            None,
            None
        )
        return Repository.Repository( self._requester, data, completed = True )

    def get_repos( self, type = GithubObject.NotSet, sort = GithubObject.NotSet, direction = GithubObject.NotSet ):
        assert type is GithubObject.NotSet or isinstance( type, ( str, unicode ) ), type
        assert sort is GithubObject.NotSet or isinstance( sort, ( str, unicode ) ), sort
        assert direction is GithubObject.NotSet or isinstance( direction, ( str, unicode ) ), direction
        url_parameters = dict()
        if type is not GithubObject.NotSet:
            url_parameters[ "type" ] = type
        if sort is not GithubObject.NotSet:
            url_parameters[ "sort" ] = sort
        if direction is not GithubObject.NotSet:
            url_parameters[ "direction" ] = direction
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/repos",
            url_parameters,
            None
        )
        return PaginatedList.PaginatedList(
            Repository.Repository,
            self._requester,
            headers,
            data
        )

    def get_starred( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/starred",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Repository.Repository,
            self._requester,
            headers,
            data
        )

    def get_starred_gists( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/gists/starred",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Gist.Gist,
            self._requester,
            headers,
            data
        )

    def get_watched( self ):
        headers, data = self._requester.requestAndCheck(
            "GET",
            "/user/watched",
            None,
            None
        )
        return PaginatedList.PaginatedList(
            Repository.Repository,
            self._requester,
            headers,
            data
        )

    def has_in_following( self, following ):
        assert isinstance( following, NamedUser.NamedUser ), following
        status, headers, data = self._requester.requestRaw(
            "GET",
            "/user/following/" + following._identity,
            None,
            None
        )
        return status == 204

    def has_in_starred( self, starred ):
        assert isinstance( starred, Repository.Repository ), starred
        status, headers, data = self._requester.requestRaw(
            "GET",
            "/user/starred/" + starred._identity,
            None,
            None
        )
        return status == 204

    def has_in_watched( self, watched ):
        assert isinstance( watched, Repository.Repository ), watched
        status, headers, data = self._requester.requestRaw(
            "GET",
            "/user/watched/" + watched._identity,
            None,
            None
        )
        return status == 204

    def remove_from_emails( self, *emails ):
        assert all( isinstance( element, ( str, unicode ) ) for element in emails ), emails
        post_parameters = emails
        headers, data = self._requester.requestAndCheck(
            "DELETE",
            "/user/emails",
            None,
            post_parameters
        )

    def remove_from_following( self, following ):
        assert isinstance( following, NamedUser.NamedUser ), following
        headers, data = self._requester.requestAndCheck(
            "DELETE",
            "/user/following/" + following._identity,
            None,
            None
        )

    def remove_from_starred( self, starred ):
        assert isinstance( starred, Repository.Repository ), starred
        headers, data = self._requester.requestAndCheck(
            "DELETE",
            "/user/starred/" + starred._identity,
            None,
            None
        )

    def remove_from_watched( self, watched ):
        assert isinstance( watched, Repository.Repository ), watched
        headers, data = self._requester.requestAndCheck(
            "DELETE",
            "/user/watched/" + watched._identity,
            None,
            None
        )

    def _initAttributes( self ):
        self._avatar_url = GithubObject.NotSet
        self._bio = GithubObject.NotSet
        self._blog = GithubObject.NotSet
        self._collaborators = GithubObject.NotSet
        self._company = GithubObject.NotSet
        self._created_at = GithubObject.NotSet
        self._disk_usage = GithubObject.NotSet
        self._email = GithubObject.NotSet
        self._followers = GithubObject.NotSet
        self._following = GithubObject.NotSet
        self._gravatar_id = GithubObject.NotSet
        self._hireable = GithubObject.NotSet
        self._html_url = GithubObject.NotSet
        self._id = GithubObject.NotSet
        self._location = GithubObject.NotSet
        self._login = GithubObject.NotSet
        self._name = GithubObject.NotSet
        self._owned_private_repos = GithubObject.NotSet
        self._plan = GithubObject.NotSet
        self._private_gists = GithubObject.NotSet
        self._public_gists = GithubObject.NotSet
        self._public_repos = GithubObject.NotSet
        self._total_private_repos = GithubObject.NotSet
        self._type = GithubObject.NotSet
        self._url = GithubObject.NotSet

    def _useAttributes( self, attributes ):
        if "avatar_url" in attributes: # pragma no branch
            assert attributes[ "avatar_url" ] is None or isinstance( attributes[ "avatar_url" ], ( str, unicode ) ), attributes[ "avatar_url" ]
            self._avatar_url = attributes[ "avatar_url" ]
        if "bio" in attributes: # pragma no branch
            assert attributes[ "bio" ] is None or isinstance( attributes[ "bio" ], ( str, unicode ) ), attributes[ "bio" ]
            self._bio = attributes[ "bio" ]
        if "blog" in attributes: # pragma no branch
            assert attributes[ "blog" ] is None or isinstance( attributes[ "blog" ], ( str, unicode ) ), attributes[ "blog" ]
            self._blog = attributes[ "blog" ]
        if "collaborators" in attributes: # pragma no branch
            assert attributes[ "collaborators" ] is None or isinstance( attributes[ "collaborators" ], int ), attributes[ "collaborators" ]
            self._collaborators = attributes[ "collaborators" ]
        if "company" in attributes: # pragma no branch
            assert attributes[ "company" ] is None or isinstance( attributes[ "company" ], ( str, unicode ) ), attributes[ "company" ]
            self._company = attributes[ "company" ]
        if "created_at" in attributes: # pragma no branch
            assert attributes[ "created_at" ] is None or isinstance( attributes[ "created_at" ], ( str, unicode ) ), attributes[ "created_at" ]
            self._created_at = self._parseDatetime( attributes[ "created_at" ] )
        if "disk_usage" in attributes: # pragma no branch
            assert attributes[ "disk_usage" ] is None or isinstance( attributes[ "disk_usage" ], int ), attributes[ "disk_usage" ]
            self._disk_usage = attributes[ "disk_usage" ]
        if "email" in attributes: # pragma no branch
            assert attributes[ "email" ] is None or isinstance( attributes[ "email" ], ( str, unicode ) ), attributes[ "email" ]
            self._email = attributes[ "email" ]
        if "followers" in attributes: # pragma no branch
            assert attributes[ "followers" ] is None or isinstance( attributes[ "followers" ], int ), attributes[ "followers" ]
            self._followers = attributes[ "followers" ]
        if "following" in attributes: # pragma no branch
            assert attributes[ "following" ] is None or isinstance( attributes[ "following" ], int ), attributes[ "following" ]
            self._following = attributes[ "following" ]
        if "gravatar_id" in attributes: # pragma no branch
            assert attributes[ "gravatar_id" ] is None or isinstance( attributes[ "gravatar_id" ], ( str, unicode ) ), attributes[ "gravatar_id" ]
            self._gravatar_id = attributes[ "gravatar_id" ]
        if "hireable" in attributes: # pragma no branch
            assert attributes[ "hireable" ] is None or isinstance( attributes[ "hireable" ], bool ), attributes[ "hireable" ]
            self._hireable = attributes[ "hireable" ]
        if "html_url" in attributes: # pragma no branch
            assert attributes[ "html_url" ] is None or isinstance( attributes[ "html_url" ], ( str, unicode ) ), attributes[ "html_url" ]
            self._html_url = attributes[ "html_url" ]
        if "id" in attributes: # pragma no branch
            assert attributes[ "id" ] is None or isinstance( attributes[ "id" ], int ), attributes[ "id" ]
            self._id = attributes[ "id" ]
        if "location" in attributes: # pragma no branch
            assert attributes[ "location" ] is None or isinstance( attributes[ "location" ], ( str, unicode ) ), attributes[ "location" ]
            self._location = attributes[ "location" ]
        if "login" in attributes: # pragma no branch
            assert attributes[ "login" ] is None or isinstance( attributes[ "login" ], ( str, unicode ) ), attributes[ "login" ]
            self._login = attributes[ "login" ]
        if "name" in attributes: # pragma no branch
            assert attributes[ "name" ] is None or isinstance( attributes[ "name" ], ( str, unicode ) ), attributes[ "name" ]
            self._name = attributes[ "name" ]
        if "owned_private_repos" in attributes: # pragma no branch
            assert attributes[ "owned_private_repos" ] is None or isinstance( attributes[ "owned_private_repos" ], int ), attributes[ "owned_private_repos" ]
            self._owned_private_repos = attributes[ "owned_private_repos" ]
        if "plan" in attributes: # pragma no branch
            assert attributes[ "plan" ] is None or isinstance( attributes[ "plan" ], dict ), attributes[ "plan" ]
            self._plan = None if attributes[ "plan" ] is None else Plan.Plan( self._requester, attributes[ "plan" ], completed = False )
        if "private_gists" in attributes: # pragma no branch
            assert attributes[ "private_gists" ] is None or isinstance( attributes[ "private_gists" ], int ), attributes[ "private_gists" ]
            self._private_gists = attributes[ "private_gists" ]
        if "public_gists" in attributes: # pragma no branch
            assert attributes[ "public_gists" ] is None or isinstance( attributes[ "public_gists" ], int ), attributes[ "public_gists" ]
            self._public_gists = attributes[ "public_gists" ]
        if "public_repos" in attributes: # pragma no branch
            assert attributes[ "public_repos" ] is None or isinstance( attributes[ "public_repos" ], int ), attributes[ "public_repos" ]
            self._public_repos = attributes[ "public_repos" ]
        if "total_private_repos" in attributes: # pragma no branch
            assert attributes[ "total_private_repos" ] is None or isinstance( attributes[ "total_private_repos" ], int ), attributes[ "total_private_repos" ]
            self._total_private_repos = attributes[ "total_private_repos" ]
        if "type" in attributes: # pragma no branch
            assert attributes[ "type" ] is None or isinstance( attributes[ "type" ], ( str, unicode ) ), attributes[ "type" ]
            self._type = attributes[ "type" ]
        if "url" in attributes: # pragma no branch
            assert attributes[ "url" ] is None or isinstance( attributes[ "url" ], ( str, unicode ) ), attributes[ "url" ]
            self._url = attributes[ "url" ]