$ easy_install apiwrapper

$ mkvirtualenv apiwrapper
$ pip install apiwrapper

from apiwrapper import APIWrapper

my_api = APIWrapper()
url = 'https://api.github.com/users/ardydedase/repos'
resp = my_api.make_request(url, method='get', headers=None, data=None, callback=None).parsed
print(resp)

class GithubAPI(APIWrapper):
    def get_repos(self, username):
        """
        Uses 'make_request' method
        """
        url = "https://api.github.com/users/{username}/repos".format(username=username)
        return self.make_request(url, method='get', headers=None, data=None, callback=None).parsed

def make_request(self, url, method='get', headers=None, data=None,
                 callback=None, errors=STRICT, verify=False, **params):
    """
    Reusable method for performing requests.
    :param url - URL to request
    :param method - request method, default is 'get'
    :param headers - request headers
    :param data - post data
    :param callback - callback to be applied to response,
                      default callback will parse response as json object.
    :param errors - specifies communication errors handling mode, possible
                    values are:
                     * strict (default) - throw an error as soon as one
                        occurred
                     * graceful - ignore certain errors, e.g. EmptyResponse
                     * ignore - ignore all errors and return a result in
                                any case.
                                NOTE that it DOES NOT mean that no
                                exceptions can be
                                raised from this method, it mostly ignores
                                communication
                                related errors.
                     * None or empty string equals to default
    :param verify - whether or not to verify SSL cert, default to False
    :param timeout - the timeout of the request in second, default to None
    :param params - additional query parameters for request
    """

from apiwrapper import (
    APIWrapper,
    STRICT,
    GRACEFUL,
    IGNORE)

class Flights(APIWrapper):
    """
    Skyscanner Flights Live Pricing
    http://business.skyscanner.net/
    portal/en-GB/Documentation/FlightsLivePricingList
    """
    API_HOST = 'http://partners.api.skyscanner.net'
    PRICING_SESSION_URL = '{api_host}/apiservices/pricing/v1.0'.format(
        api_host=API_HOST)

    def __init__(self, api_key):
        self.api_key = api_key
        super(Flights, self).__init__(response_format='json')

def make_request(self, url, method='get', headers=None,
                 data=None, callback=None, errors=STRICT,
                 verify=False, **params):
    """
    Call the `make_request` method from apiwrapper.
    So we can inject the apikey when it is not available.
    """
    if 'apikey' not in url.lower():
        params.update({
            'apiKey': self.api_key
        })
    return super(Flights, self).make_request(url, method, headers,
                                             data, callback, errors,
                                             verify, **params)

def create_session(self, **params):
    """
    Create the session
    date format: YYYY-mm-dd
    location: ISO code.
    After creating the session,
    this method will return the poll_url.
    """
    service_url = self.PRICING_SESSION_URL
    return self.make_request(service_url,
                             method='post',
                             headers=self._headers(),
                             callback=lambda resp: resp.headers[
                                 'location'],
                             data=params)

def _is_poll_complete_callback(self, poll_resp):
    """
    Checks the condition in poll response to determine if it is complete
    and no subsequent poll requests should be done.
    """
    if poll_resp.parsed is None:
        return False
    success_list = ['UpdatesComplete', True, 'COMPLETE']
    status = None
    if self.response_format == 'xml':
        status = poll_resp.parsed.find('./Status').text
    elif self.response_format == 'json':
        status = poll_resp.parsed.get(
            'Status', poll_resp.parsed.get('status'))
    if status is None:
        raise RuntimeError('Unable to get poll response status.')
    return status in success_list

def get_result(self, errors=STRICT, **params):
    """
    Get all results, no filtering,
    etc. by creating and polling the session.
    """
    service_url = self.create_session(**params)
    return self.poll(service_url, errors=errors, is_poll_complete_callback=self._is_poll_complete_callback)

def poll(self, url, initial_delay=2, delay=1, tries=20, errors=STRICT, is_complete_callback=None, **params):
    """
    Poll the URL
    :param url - URL to poll, should be returned by 'create_session' call
    :param initial_delay - specifies how many seconds to wait before the first poll
    :param delay - specifies how many seconds to wait between the polls
    :param tries - number of polls to perform
    :param errors - errors handling mode, see corresponding parameter in 'make_request' method
    :param params - additional query params for each poll request
    """

class GithubAPI(APIWrapper):
    def _my_callback(self, resp):
        """
        'resp' is a Response object returned from `requests` library
        """
        return resp.json()


    def get_repos(self, username):
        """
        Uses 'make_request' method
        """
        url = "https://api.github.com/users/{username}/repos".format(username=username)
        return self.make_request(url, method='get', headers=None, data=None, callback=self._my_callback)

$ python -m unittest tests.test_apiwrapper