A wrapper for GitHub HTTP Repo API

github_API

import requests


class GitHub:

    def __init__(self, access_token):
        self.authorization = 'token {}'.format(access_token)
        self.__full_repo_name = None  # ex: paxosglobal/pax-contracts
        self.__repo = None

    @staticmethod
    def validate_repo_name(repo_name):
        if repo_name.find('/') == -1 or repo_name.endswith('/'):
            raise Exception("Invalid repo name: {}".format(repo_name))

        return True

    def set_repo(self, repo_name_with_owner) -> dict:
        self.validate_repo_name(repo_name_with_owner)
        self.__full_repo_name = repo_name_with_owner
        self.__repo = self.get_repo_info(repo_name_with_owner)
        return self.__repo

    def repo(self, repo_name_with_owner) -> dict:
        self.validate_repo_name(repo_name_with_owner)
        self.__full_repo_name = repo_name_with_owner
        self.__repo = self.get_repo_info(repo_name_with_owner)
        return self

    def get_repo_name(self):
        if not self.__full_repo_name:
            raise Exception("Repo not set.")
        return self.__full_repo_name

    def get_repo(self):
        if not self.__repo:
            raise Exception("Repo not set.")
        return self.__repo

    def call_api(self, endpoint, media_type='application/vnd.github.v3+json'):
        github_api_url = "https://api.github.com"
        url = github_api_url + endpoint
        headers = {
          'Accept': media_type,
          'authorization': self.authorization
        }

        response = requests.get(url, headers=headers)
        return response.json()

    def get_repo_info(self, repo_name_with_owner):
        endpoint = "/repos/{}".format(repo_name_with_owner)
        repo = self.call_api(endpoint)
        return repo

    def get_stargazers(self, pages=1):  # NOTE: Use pages=0 to fetch all pages
        endpoint_template = "/repos/{0}/stargazers?page={1}&per_page=100"
        media_type = 'application/vnd.github.v3.star+json'

        stargazers_list = []
        page_count = 1

        while True:
            endpoint = endpoint_template.format(self.get_repo_name(), page_count)
            current_stargazers_list = self.call_api(endpoint, media_type)
            stargazers_list.extend(current_stargazers_list)

            if (pages and page_count >= pages) or len(current_stargazers_list) < 100:
                break
            page_count = page_count + 1

        return stargazers_list

    def get_stargazers_count(self):
        if not self.__repo:
            raise Exception("Repo not set.")

        return self.__repo['stargazers_count']

    def get_watchers(self, pages=1):
        endpoint_template = "/repos/{0}/watchers?page={1}&per_page=100"

        watchers_list = []
        page_count = 1

        while True:
            endpoint = endpoint_template.format(self.get_repo_name(), page_count)
            current_watchers_list = self.call_api(endpoint)
            watchers_list.extend(current_watchers_list)

            if (pages and page_count >= pages) or len(current_watchers_list) < 100:
                break
            page_count = page_count + 1

        return watchers_list

    def get_watchers_count(self):
        if not self.__repo:
            raise Exception("Repo not set.")

        return self.__repo['watchers_count']

    def get_forks(self, pages=1):
        endpoint_template = "/repos/{0}/forks?page={1}&per_page=100"

        forks_list = []
        page_count = 1

        while True:
            endpoint = endpoint_template.format(self.get_repo_name(), page_count)
            current_forks_list = self.call_api(endpoint)
            forks_list.extend(current_forks_list)

            if (pages and page_count >= pages) or len(current_forks_list) < 100:
                break
            page_count = page_count + 1

        return forks_list

    def get_forks_count(self):
        if not self.__repo:
            raise Exception("Repo not set.")

        return self.__repo['forks_count']

    def get_user(self, user_login):
        endpoint = "/users/{}".format(user_login)
        return self.call_api(endpoint)

    def get_organization(self):
        if not self.__repo:
            raise Exception("Repo not set.")

        if 'organization' in self.__repo:
            if 'login' in self.__repo['organization']:
                org_login = self.__repo['organization']['login']
                return self.get_user(org_login)
        return None

    def get_branches(self, pages=1):
        endpoint_template = "/repos/{0}/branches?page={1}&per_page=100"

        branches_list = []
        page_count = 1

        while True:
            endpoint = endpoint_template.format(self.get_repo_name(), page_count)
            current_branches_list = self.call_api(endpoint)
            branches_list.extend(current_branches_list)

            if (pages and page_count >= pages) or len(current_branches_list) < 100:
                break
            page_count = page_count + 1

        return branches_list

    def get_topics(self, pages=1):
        endpoint_template = "/repos/{0}/topics?page={1}&per_page=100"

        topics_list = []
        page_count = 1

        while True:
            endpoint = endpoint_template.format(self.get_repo_name(), page_count)
            current_topics_list = self.call_api(endpoint)
            topics_list.extend(current_topics_list)

            if (pages and page_count >= pages) or len(current_topics_list) < 100:
                break
            page_count = page_count + 1

        return topics_list

    def get_languages(self):
        endpoint = "/repos/{}/languages".format(self.get_repo_name())
        return self.call_api(endpoint)


g = GitHub('token')
# print(g.get_stargazers_count())
# print(len(g.get_stargazers(0)))
# g.get_repo_info('dogecoin/dogecoin.com')
g.set_repo('dogecoin/dogecoin.com')
print(g.get_repo())