Reset project

26 files changed, 0 insertions, 2476 deletions

diff --git a/github3/__init__.py b/github3/__init__.py
deleted file mode 100644
index 40a96af..0000000
--- a/github3/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# -*- coding: utf-8 -*-
diff --git a/github3/api.py b/github3/api.py
deleted file mode 100644
index e1d1fbe..0000000
--- a/github3/api.py
+++ /dev/null
@@ -1,159 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-import requests
-import json
-from errors import GithubError
-from handlers import users, gists
-
-RESOURCES_PER_PAGE = 100
-
-
-#TODO: refactor: loads json in request editing Response object
-class GithubCore(object):
-    """
-    Wrapper to github api requests
-
-    Methods: get, head, post, patch, put, delete
-    """
-
-    requests_remaining = None
-    base_url = 'https://api.github.com/'
-
-    def __init__(self):
-        """
-        Init `requests.session`
-        Init JSON parser
-        """
-        self.session = requests.session()
-        self.session.params = {'per_page': RESOURCES_PER_PAGE}
-        self._parser = json
-
-    def get(self, request, paginate=False, **kwargs):
-        """
-        GET request
-
-        :param paginate: Boolean to return link header to paginate
-        """
-        response = self._request('GET', request, **kwargs)
-        content = self._parser.loads(response.content)
-        if paginate:
-            return response.headers.get('link'), content
-        else:
-            return content
-
-    def head(self, request, **kwargs):
-        """ HEAD request """
-        return self._request('HEAD', request, **kwargs)
-
-    def post(self, request, data=None, **kwargs):
-        """
-        POST request
-
-        :param data: raw python object to send
-        """
-        kwargs['data'] = self._parser.dumps(data)
-        response = self._request('POST', request, **kwargs)
-        assert response.status_code == 201
-        return self._parser.loads(response.content)
-
-    def patch(self, request, data=None, **kwargs):
-        """
-        PATCH request
-
-        :param data: raw python object to send
-        """
-        kwargs['data'] = self._parser.dumps(data)
-        response = self._request('PATCH', request, **kwargs)
-        assert response.status_code == 200
-        return self._parser.loads(response.content)
-
-    def put(self, request, **kwargs):
-        """ PUT request """
-
-        response = self._request('PUT', request,
-                                 headers={'Content-length': '0'}, **kwargs)
-        assert response.status_code == 204
-        return response
-
-    def delete(self, request, **kwargs):
-        """ DELETE request """
-
-        data = kwargs.get('data')
-        if data:
-            kwargs['data'] = self._parser.dumps(data)
-        response = self._request('DELETE', request, **kwargs)
-        assert response.status_code == 204
-        return response
-
-    def _parse_args(self, request_args):
-        """
-        Arg's parser to `_request` method
-
-        Put extra request_args in params
-        """
-        request_core = (
-            'params', 'data', 'headers', 'cookies', 'files', 'auth', 'tiemout',
-            'allow_redirects', 'proxies', 'return_response', 'config')
-        request_params = request_args.get('params')
-        extra_params = {}
-        for k, v in request_args.items():
-            if k in request_core:
-                continue
-            extra_params.update({k: v})
-            del request_args[k]
-        if request_params and getattr(request_params, 'update'):
-            request_args['params'].update(extra_params)
-        elif extra_params:
-            request_args['params'] = extra_params
-
-        return request_args
-
-    def _request(self, verb, request, **kwargs):
-        """
-        Http request wrapper
-
-        :param verb: Http method
-        :param request : Url query request
-        :param kwargs: Keyword args to request
-        """
-        request = self.base_url + request
-        self._parse_args(kwargs)
-        response = self.session.request(verb, request, **kwargs)
-        self.requests_remaining = response.headers.get(
-            'x-ratelimit-remaining', -1)
-        error = GithubError(response)
-        error.process()
-
-        return response
-
-        return response
-
-class Github(GithubCore):
-    """ Library enter """
-
-    def __init__(self, *args):
-        super(Github, self).__init__()
-        self.authenticated = False
-        auth = len(args)
-        if auth == 2:  # Basic auth
-            self.session.auth = tuple(map(str, args))
-            self.authenticated = True
-        elif auth == 1:  # Token oauth
-            raise NotImplementedError
-        elif auth > 2:
-            raise TypeError("user, password or token")
-
-    @property
-    def users(self):
-        if self.authenticated:
-            return users.AuthUser(self)
-        else:
-            return users.User(self)
-
-    @property
-    def gists(self):
-        if self.authenticated:
-            return gists.AuthGist(self)
-        else:
-            return gists.Gist(self)
diff --git a/github3/converters.py b/github3/converters.py
deleted file mode 100644
index 9f975be..0000000
--- a/github3/converters.py
+++ /dev/null
@@ -1,103 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from .core import Converter
-
-
-class Rawlizer(Converter):
-    """ Raw converter """
-
-    def inject(self, fake):
-        pass
-
-    def loads(self, raw_resource):
-        return raw_resource
-
-    def dumps(self):
-        pass
-
-
-class Json(Converter):
-    """ Json converter """
-
-    def __init__(self):
-        import json
-        self.parser = json
-
-    def inject(self, fake):
-        pass
-
-    def loads(self, raw_resource):
-        return self.parser.dumps(raw_resource)
-
-    def dumps(self):
-        pass
-
-
-class Modelizer(Converter):
-    """ Own model converter """
-
-    def __init__(self, model=None):
-        if model:
-            self.inject(model)
-
-    def _parse_date(self, string_date):
-        from datetime import datetime
-        try:
-            date = datetime.strptime(string_date, '%Y-%m-%dT%H:%M:%SZ')
-        except TypeError:
-            date = None
-
-        return date
-
-    def inject(self, model):
-        self.model = model
-
-    def _parse_map(self, model, raw_resource):
-        if hasattr(raw_resource, 'items'):
-            return Modelizer(model).loads(raw_resource)
-
-    def _parse_collection_map(self, model, raw_resources):
-        # Dict of resources (Ex: Gist file)
-        if hasattr(raw_resources, 'items'):
-            dict_map = {}
-            for key, raw_resource in raw_resources.items():
-                dict_map[key] = Modelizer(model).loads(raw_resource)
-            return dict_map
-        # list of resources
-        elif hasattr(raw_resources, '__iter__'):
-            return [Modelizer(model).loads(raw_resource)
-                    for raw_resource in raw_resources]
-
-    def loads(self, raw_resource):
-        attrs = {}
-        if not getattr(self, 'model', False):
-            raise NotImplementedError("%s needs model attr" %
-                self.__class__.__name__)
-        idl = self.model.idl()
-        attrs.update(
-            {attr: raw_resource[attr] for attr in idl.get('strs', ())
-             if attr in raw_resource})
-        attrs.update(
-            {attr: raw_resource[attr] for attr in idl.get('ints', ())
-             if attr in raw_resource})
-        attrs.update(
-            {attr: self._parse_date(raw_resource[attr])
-             for attr in idl.get('dates', ()) if attr in raw_resource})
-        attrs.update(
-            {attr: raw_resource[attr] for attr in idl.get('bools', ())
-             if attr in raw_resource})
-        attrs.update(
-            {attr: self._parse_map(model, raw_resource[attr])
-             for attr, model in idl.get('maps', {}).items()
-             if attr in raw_resource})
-        attrs.update(
-            {attr: self._parse_collection_map(model, raw_resource[attr])
-             for attr, model in idl.get('collection_maps', {}).items()
-             if attr in raw_resource})
-
-        return self.model(attrs)
-
-    def dumps(self, model):
-        # return JSON
-        pass
diff --git a/github3/core.py b/github3/core.py
deleted file mode 100644
index ab71943..0000000
--- a/github3/core.py
+++ /dev/null
@@ -1,72 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-
-class Paginate:
-    """ Paginate resource iterator
-
-    :param resource: URL resource
-    :param requester: Bound method to request. See `GithubCore.get`
-    :param kwargs: Args to request (params)
-    """
-
-    def __init__(self, resource, requester, **kwargs):
-        self.resource = resource
-        self.requester = requester
-        self.kwargs = kwargs
-        self.page = 1
-
-    def _last_page(self, link):
-        """ Get and cached last page from link header """
-        if not getattr(self, 'last', False):
-            from github3.packages.link_header import parse_link_value
-            from urlparse import urlparse, parse_qs
-            for link, rels in parse_link_value(link).items():
-                if rels.get('rel') == 'last':
-                    query = urlparse(link).query
-                    self.last = int(parse_qs(query).get('page').pop())
-
-        return self.last
-
-    def __iter__(self):
-        return self
-
-    def initial(self):
-        """
-        First request
-        Force requester to paginate returning link header
-        """
-        link, content = self.requester(self.resource, paginate=True,
-                                       page=1, **self.kwargs)
-        self.last = self._last_page(link) if link else 1
-        return content
-
-    def next(self):
-        if self.page == 1:
-            content = self.initial()
-            self.page += 1
-            return content
-        else:
-            if self.page > self.last:
-                raise StopIteration
-            else:
-                content = self.requester(self.resource, page=self.page,
-                                         **self.kwargs)
-                self.page += 1
-                return content
-
-
-class Converter(object):
-    """ Abstract converter class """
-
-    def loads(self):
-        raise NotImplementedError("%s needs define '%s' method" %
-            (self.__class__.__name__, 'loads'))
-
-    def dumps(self):
-        raise NotImplementedError("%s needs define '%s' method" %
-            (self.__class__.__name__, 'dumps'))
-
-    def inject(self):
-        raise NotImplementedError("%s needs define '%s' method" %
-            (self.__class__.__name__, 'inject'))
diff --git a/github3/errors.py b/github3/errors.py
deleted file mode 100644
index e96e2da..0000000
--- a/github3/errors.py
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-import json
-import github3.exceptions as exceptions
-
-
-class GithubError(object):
-    """ Handler for API errors """
-
-    def __init__(self, response):
-        self._parser = json
-        self.status_code = response.status_code
-        try:
-            self.debug = self._parser.loads(response.content)
-        except (ValueError, TypeError):
-            self.debug = {'message': response.content}
-
-    def error_400(self):
-        return exceptions.BadRequest("400 - %s" % self.debug.get('message'))
-
-    def error_401(self):
-        return exceptions.Unauthorized("401 - %s" % self.debug.get('message'))
-
-    def error_404(self):
-        return exceptions.NotFound("404 - %s" % self.debug.get('message'))
-
-    def error_422(self):
-        errors = self.debug.get('errors')
-        if errors:
-            errors = ['{resource}: {code} => {field}'.format(**error)
-                      for error in errors]
-        return exceptions.UnprocessableEntity(
-            '422 - %s %s' % (self.debug.get('message'), errors))
-
-    def process(self):
-        raise_error = getattr(self, 'error_%s' % self.status_code, False)
-        if raise_error:
-            raise raise_error()
diff --git a/github3/exceptions.py b/github3/exceptions.py
deleted file mode 100644
index b9070d7..0000000
--- a/github3/exceptions.py
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-class BadRequest(Exception):
-    pass
-class UnprocessableEntity(Exception):
-    pass
-class NotFound(Exception):
-    pass
-class Unauthorized(Exception):
-    pass
-class UserIsAnonymous(Exception):
-    pass
diff --git a/github3/handlers/__init__.py b/github3/handlers/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/github3/handlers/__init__.py
+++ /dev/null
diff --git a/github3/handlers/base.py b/github3/handlers/base.py
deleted file mode 100644
index 565978f..0000000
--- a/github3/handlers/base.py
+++ /dev/null
@@ -1,125 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from github3.core import Paginate
-from github3.converters import Modelizer
-
-
-class MimeTypeMixin(object):
-
-    VERSION = 'beta'
-
-    def __init__(self):
-        self.mimetypes = set()
-
-    def _parse_mime_type(self, type):
-        return 'application/vnd.github.%s.%s+json' % (
-            self.VERSION, type)
-
-    def add_raw(self):
-        self.mimetypes.add(self._parse_mime_type('raw'))
-        return self
-
-    def add_text(self):
-        self.mimetypes.add(self._parse_mime_type('text'))
-        return self
-
-    def add_html(self):
-        self.mimetypes.add(self._parse_mime_type('html'))
-        return self
-
-    def add_full(self):
-        self.mimetypes.add(self._parse_mime_type('full'))
-        return self
-
-    def mime_header(self):
-        if self.mimetypes:
-            return {'Accept': ', '.join(self.mimetypes)}
-        return None
-
-
-class Handler(object):
-    """ Handler base. Requests to API and modelize responses """
-
-    def __init__(self, gh):
-        self._gh = gh
-        super(Handler, self).__init__()
-
-    def _inject_handler(self, handler, prefix=''):
-        import inspect
-        for method, callback in inspect.getmembers(handler):
-            if method.startswith(prefix) and inspect.ismethod(callback):
-                setattr(self, method, callback)
-
-    def _prefix_resource(self, resource):
-        prefix = getattr(self, 'prefix', '')
-        return '/'.join((prefix, str(resource))).strip('/')
-
-    def _get_converter(self, kwargs={}):
-        converter = kwargs.pop(
-            'converter',  # 1. in kwargs
-            getattr(self, 'converter',  # 2. in handler
-            Modelizer))  # 3. Default
-
-        return converter()
-
-    def _put(self, resource, **kwargs):
-        """ Put proxy request"""
-
-        return self._bool(resource, method='put', **kwargs)
-
-    def _delete(self, resource, **kwargs):
-        """ Delete proxy request"""
-
-        return self._bool(resource, method='delete', **kwargs)
-
-    def _bool(self, resource, **kwargs):
-        """ Handler request to boolean response """
-
-        from github3.exceptions import NotFound
-        resource = self._prefix_resource(resource)
-        try:
-            callback = getattr(self._gh, kwargs.get('method', ''),
-                               self._gh.head)
-            response = callback(resource, **kwargs)
-        except NotFound:
-            return False
-        assert response.status_code == 204
-        return True
-
-    def _get_resources(self, resource, model=None, limit=None, **kwargs):
-        """ Hander request to multiple resources """
-
-        if limit:
-            limit = abs(limit)
-        resource = self._prefix_resource(resource)
-        converter = self._get_converter(kwargs)
-        counter = 1
-        for page in Paginate(resource, self._gh.get, **kwargs):
-            for raw_resource in page:
-                counter += 1
-                converter.inject(model)
-                yield converter.loads(raw_resource)
-                if limit and counter > limit:
-                    break
-            else:
-                continue
-            break
-
-    def _get_resource(self, resource, model=None, **kwargs):
-        """ Handler request to single resource """
-
-        resource = self._prefix_resource(resource)
-        converter = self._get_converter(kwargs)
-        raw_resource = self._gh.get(resource, **kwargs)
-        converter.inject(model)
-        return converter.loads(raw_resource)
-
-    def _post_resource(self, resource, data, model=None, **kwargs):
-        """ Handler request to create a resource """
-
-        resource = self._prefix_resource(resource)
-        raw_resource = self._gh.post(resource, data=data)
-        converter = self._get_converter(kwargs)
-        converter.inject(model)
-        return converter.loads(raw_resource)
diff --git a/github3/handlers/gists.py b/github3/handlers/gists.py
deleted file mode 100644
index ed03c31..0000000
--- a/github3/handlers/gists.py
+++ /dev/null
@@ -1,145 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from .base import Handler, MimeTypeMixin
-from github3 import models
-
-
-class Gist(Handler, MimeTypeMixin):
-    """ Gist handler with public access """
-
-    prefix = 'gists'
-
-    def __repr__(self):
-        return '<Gist handler>'
-
-    def all_gists(self, limit=None):
-        """ Return all public gists
-
-        NOTE: It returns all gists in github environment. Maybe you
-        want to use `limit` parameter
-        """
-
-        return self._get_resources('', model=models.Gist, limit=limit)
-
-    def get(self, gist_id):
-        """ Return gist
-
-        param `gist_id`: Gist id
-        """
-
-        return self._get_resource(gist_id, model=models.Gist)
-
-    def get_comments(self, gist_id, limit=None):
-        """ Return gist's comments
-
-        param `gist_id`: Gist id
-        param `limit`: Number of comments
-        """
-
-        return self._get_resources('%s/comments' % gist_id,
-            model=models.GistComment, limit=limit,
-            headers=self.mime_header())
-
-    def get_comment(self, comment_id):
-        """ Return gist's comment
-
-        param `comment_id`: Comment id
-        """
-
-        return self._get_resource('comments/%s' % comment_id,
-            model=models.GistComment, headers=self.mime_header())
-
-
-class AuthGist(Gist):
-
-    def all_gists(self, limit=None):
-        """ Return all public gists
-
-        NOTE: It returns all gists in github environment. Maybe you
-        want to use `limit` parameter
-        """
-
-        return self._get_resources('public', model=models.Gist, limit=limit)
-
-    def my_gists(self, limit=None):
-        """ Return authenticated user's gists
-
-        param `limit`: Number of gists
-        """
-
-        return self._get_resources('', model=models.Gist, limit=limit)
-
-    def my_starred_gists(self, limit=None):
-        """ Return authenticated user's starred gists
-
-        param `limit`: Number of gists
-        """
-
-        return self._get_resources('starred', model=models.Gist, limit=limit)
-
-    def create_gist(self, is_public, files, desc=None):
-        """ Create and return a gist """
-
-        data = {
-            'public': bool(is_public),
-            'files': files,  # TODO: Issue #1
-            'desc': desc or '',
-        }
-        return self._post_resource('', data=data, model=models.Gist)
-
-    def star_gist(self, gist_id):
-        """ Star a gist
-
-        param `gist_id`: Gist id to star
-        """
-
-        return self._put('%s/star' % gist_id)
-
-    def unstar_gist(self, gist_id):
-        """ Unstar a gist
-
-        param `gist_id`: Gist id to unstar
-        """
-
-        return self._delete('%s/star' % gist_id)
-
-    def is_starred(self, gist_id):
-        """ True if gist is starred
-
-        param `gist_id`: Gist id
-        """
-
-        return self._bool('%s/star' % gist_id)
-
-    def fork_gist(self, gist_id):
-        """ Return forked gist from id
-
-        param `gist_id`: Gist id to be forked...
-        """
-
-        return self._post_resource('%s/fork' % gist_id, data=None,
-                                   model=models.Gist)
-
-    def delete_gist(self, gist_id):
-        """ Delete the gist
-
-        param `gist_id`: Gist id
-        """
-
-        return self._delete(str(gist_id))
-
-    def create_comment(self, gist_id, comment):
-        """ Create comment into gist """
-
-        data = {'body': comment}
-        return self._post_resource('%s/comments' % gist_id, data=data,
-                            model=models.GistComment)
-
-    def delete_comment(self, comment_id):
-        """ Delete comment
-
-        param `comment_id`: Comment id
-        """
-
-        return self._delete('comments/%s' % comment_id)
diff --git a/github3/handlers/user.py b/github3/handlers/user.py
deleted file mode 100644
index fb893b4..0000000
--- a/github3/handlers/user.py
+++ /dev/null
@@ -1,205 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-#
-# author: David Medina
-
-from .base import Handler
-import github3.models as models
-from github3.converters import Rawlizer
-
-class User(Handler):
-    """ User handler with public access """
-
-    prefix = 'users'
-
-    def __repr__(self):
-        return '<User handler> %s>' % getattr(self, 'username', 'without user')
-
-    def set_username(self, user):
-        """
-        Set username to query public handler
-
-        :param `user`: User model or username string
-        """
-
-        parse_user = str(getattr(user, 'login', user))
-        self.username = parse_user
-        self.prefix = '/'.join((self.prefix, parse_user))
-
-    def get(self):
-        """ Return user """
-
-        return self._get_resource('', model=models.User)
-
-    def get_followers(self):
-        """ Return user's followers """
-
-        return self._get_resources('followers', model=models.User)
-
-    def get_following(self):
-        """ Return users that follow """
-
-        return self._get_resources('following', model=models.User)
-
-    def get_repos(self):
-        """ Return user's public repositories """
-
-        return self._get_resources('repos', model=models.Repo)
-
-    def get_watched(self):
-        """ Return repositories that user whatch """
-
-        return self._get_resources('watched', model=models.Repo)
-
-    def get_orgs(self):
-        """ Return user's public organizations """
-
-        return self._get_resources('orgs', model=models.Org)
-
-    def get_gists(self):
-        """ Return user's gists """
-
-        return self._get_resources('gists', model=models.Gist)
-
-class AuthUser(User):
-    """ User handler with public and private access """
-
-    prefix = 'user'
-
-    def __repr__(self):
-        return '<AuthUser handler> %s>' % self._gh.session.auth[0]
-
-    def get(self):
-        return self._get_resource('', model=models.AuthUser)
-
-    def get_emails(self):
-        """ Return list of emails """
-
-        # Ignore converter, it must be Rawlizer
-        emails = self._get_resource('emails', converter=Rawlizer())
-        return emails
-
-    def create_emails(self, *args):
-        """
-        Add emails
-
-        :param args: Collection of emails
-            create_emails(*('test1@example.com', 'test2@example.cm'))
-        """
-        parsed_emails = map(str, args)
-        all_mails = self._post_resource(
-            'emails', data=parsed_emails, converter=Rawlizer())
-        return all_mails
-
-    def delete_emails(self, *args):
-        """
-        Delete emails
-
-        :param args: Collection of emails
-            create_emails(*('test1@example.com', 'test2@example.cm'))
-        """
-        parsed_emails = map(str, args)
-        return self._delete('emails', data=parsed_emails)
-
-    def is_following(self, user):
-        """
-        Return true if you are following the user
-
-        :param `user`: User model or username string
-        """
-
-        parse_user = str(getattr(user, 'login', user))
-        return self._bool('following/%s' % parse_user)
-
-    def follow(self, user):
-        """
-        Follow user
-
-        :param `user`: User model or username string
-        """
-
-        parse_user = str(getattr(user, 'login', user))
-        return self._put('following/%s' % parse_user)
-
-    def unfollow(self, user):
-        """
-        Unfollow user
-
-        :param `user`: User model or username string
-        """
-
-        parse_user = str(getattr(user, 'login', user))
-        return self._delete('following/%s' % parse_user)
-
-    def get_keys(self):
-        """ Get public keys """
-
-        return self._get_resources('keys', model=models.Key)
-
-    def get_key(self, key_id):
-        """ Get public key by id """
-
-        return self._get_resource('keys/%s' % key_id, model=models.Key)
-
-    def create_key(self, **kwargs):
-        """
-        Create public key
-
-        :param title
-        :param key: Key string
-        """
-
-        #TODO: render key.pub file
-        key = {
-            'title': kwargs.get('title',''),
-            'key': kwargs.get('key','')
-        }
-        return self._post_resource('keys', data=key, model=models.Key)
-
-    def delete_key(self, key_id):
-        """ Delete public key """
-
-        return self._delete('keys/%s' % key_id)
-
-    def get_repos(self, filter='all'):
-        """
-        Return user's public repositories
-
-        param: filter: 'all', 'public', 'private' or 'member'
-        """
-
-        return self._get_resources('repos', model=models.Repo,
-                                   type=str(filter))
-
-    def is_watching_repo(self, owner, repo):
-        """
-        Return true if you are watching the user repository
-
-        :param owner: username
-        :param repo: repository name
-            is_watching_repo('copitux', 'python-github3')
-        """
-
-        owner = getattr(owner, 'login', owner)
-        repo = getattr(repo, 'name', repo)
-        return self._bool('watched/%s/%s' % (owner, repo))
-
-    def watch_repo(self, owner, repo):
-        """
-        Watch the repository
-
-        :param owner: username
-        :param repo: repository name
-        """
-
-        return self._put('watched/%s/%s' % (owner, repo))
-
-    def unwatch_repo(self, owner, repo):
-        """
-        Unwatch the repository
-
-        :param owner: username
-        :param repo: repository name
-        """
-
-        return self._delete('watched/%s/%s' % (owner, repo))
diff --git a/github3/handlers/users.py b/github3/handlers/users.py
deleted file mode 100644
index 2f12184..0000000
--- a/github3/handlers/users.py
+++ /dev/null
@@ -1,299 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from .base import Handler
-from github3 import models
-from github3.converters import Rawlizer
-from github3.exceptions import UserIsAnonymous
-
-
-class User(Handler):
-    """ User handler with public access """
-
-    prefix = 'users'
-
-    def __repr__(self):
-        return '<User handler> %s>' % getattr(self, 'username', 'without user')
-
-    def _parse_user(self, user):
-        """ Parse user, and if it fails then try with username in handler
-
-        :param user: It can be a `models.User` or alphanumeric user string
-
-        """
-        username = getattr(user, 'login', user)
-        if not username or not str(username).isalpha():
-            username = getattr(self, 'username', False)
-        if not username:
-            raise UserIsAnonymous('%s user is not valid' % username)
-        return str(username)
-
-    def set_username(self, user):
-        """ Set username to query public handler
-        Helper to less writing
-
-        :param user: It can be a `models.User` or alphanumeric user string
-
-        """
-        self.username = self._parse_user(user)
-        return self
-
-    def get(self, user=None):
-        """ Return user
-
-        :param `user`: User model or username string
-
-        """
-        user = self._parse_user(user)
-        return self._get_resource(user, model=models.User)
-
-    def get_followers(self, user=None, limit=None):
-        """ Return user's followers
-
-        :param `user`: User model or username string
-
-        """
-        user = self._parse_user(user)
-        return self._get_resources('%s/followers' % user, model=models.User,
-                                   limit=limit)
-
-    def get_following(self, user=None, limit=None):
-        """ Return users that follow
-
-        :param `user`: User model or username string
-
-        """
-        user = self._parse_user(user)
-        return self._get_resources('%s/following' % user, model=models.User,
-                                   limit=limit)
-
-    def get_repos(self, user=None, limit=None):
-        """ Return user's public repositories
-
-        :param `user`: User model or username string
-
-        """
-        user = self._parse_user(user)
-        return self._get_resources('%s/repos' % user, model=models.Repo,
-                                   limit=limit)
-
-    def get_watched(self, user=None, limit=None):
-        """ Return repositories that user watch
-
-        :param `user`: User model or username string
-
-        """
-        user = self._parse_user(user)
-        return self._get_resources('%s/watched' % user, model=models.Repo,
-                                   limit=limit)
-
-    def get_orgs(self, user=None, limit=None):
-        """ Return user's public organizations
-
-        :param `user`: User model or username string
-
-        """
-        user = self._parse_user(user)
-        return self._get_resources('%s/orgs' % user, model=models.Org,
-                                   limit=limit)
-
-    def get_gists(self, user=None, limit=None):
-        """ Return user's gists
-
-        :param `user`: User model or username string
-
-        """
-        user = self._parse_user(user)
-        return self._get_resources('%s/gists' % user, model=models.Gist,
-                                   limit=limit)
-
-
-class AuthUser(Handler):
-    """ User handler with public and private access """
-
-    prefix = 'user'
-
-    def __init__(self, gh):
-        super(AuthUser, self).__init__(gh)
-        self._inject_handler(User(gh), prefix='get')
-
-    def __repr__(self):
-        return '<AuthUser handler> %s>' % self._gh.session.auth[0]
-
-    def me(self):
-        """ Return authenticated user """
-
-        return self._get_resource('', model=models.AuthUser)
-
-    def my_followers(self, limit=None):
-        """ Return authenticated user followers """
-
-        return self._get_resources('followers', model=models.User,
-                                   limit=limit)
-
-    def my_following(self, limit=None):
-        """ Return authenticated user following """
-
-        return self._get_resources('following', model=models.User,
-                                   limit=limit)
-
-    def get_emails(self):
-        """ Return list of emails """
-
-        # Ignore converter, it must be Rawlizer
-        emails = self._get_resource('emails', converter=Rawlizer)
-        return emails
-
-    def create_emails(self, *args):
-        """
-        Add emails
-
-        :param args: Collection of emails
-            create_emails(*('test1@example.com', 'test2@example.cm'))
-        """
-        parsed_emails = map(str, args)
-        all_mails = self._post_resource(
-            'emails', data=parsed_emails, converter=Rawlizer)
-        return all_mails
-
-    def delete_emails(self, *args):
-        """
-        Delete emails
-
-        :param args: Collection of emails
-            create_emails(*('test1@example.com', 'test2@example.cm'))
-        """
-        parsed_emails = map(str, args)
-        return self._delete('emails', data=parsed_emails)
-
-    def is_following(self, user):
-        """
-        Return true if you are following the user
-
-        :param `user`: User model or username string
-        """
-
-        parse_user = getattr(user, 'login', user)
-        return self._bool('following/%s' % parse_user)
-
-    def follow(self, user):
-        """
-        Follow user
-
-        :param `user`: User model or username string
-
-        """
-
-        parse_user = getattr(user, 'login', user)
-        return self._put('following/%s' % parse_user)
-
-    def unfollow(self, user):
-        """
-        Unfollow user
-
-        :param `user`: User model or username string
-        """
-
-        parse_user = getattr(user, 'login', user)
-        return self._delete('following/%s' % parse_user)
-
-    def get_keys(self, limit=None):
-        """ Get public keys """
-
-        return self._get_resources('keys', model=models.Key,
-                                   limit=limit)
-
-    def get_key(self, key):
-        """ Get public key
-
-        :param `key`: Key model or key id
-
-        """
-
-        parse_key_id = getattr(key, 'id', key)
-        return self._get_resource('keys/%s' % parse_key_id, model=models.Key)
-
-    def create_key(self, **kwargs):
-        """
-        Create public key
-
-        :param title
-        :param key: Key string (It must starts with 'ssh-rsa')
-        """
-
-        #TODO: render key.pub file
-        key = {
-            'title': kwargs.get('title', ''),
-            'key': kwargs.get('key', '')
-        }
-        return self._post_resource('keys', data=key, model=models.Key)
-
-    def delete_key(self, key):
-        """ Delete public key
-
-        :param `key`: Key model or key id
-
-        """
-
-        parse_key_id = getattr(key, 'id', key)
-        return self._delete('keys/%s' % parse_key_id)
-
-    def my_repos(self, filter='all', limit=None):
-        """
-        Return user's public repositories
-
-        param: filter: 'all', 'owner', 'public', 'private' or 'member'
-        """
-
-        return self._get_resources('repos', model=models.Repo,
-                                   limit=limit, type=str(filter))
-
-    def my_watched(self, limit=None):
-        """ Return authenticated user repos that he watch """
-
-        return self._get_resources('watched', model=models.Repo,
-                                   limit=limit)
-
-    def is_watching_repo(self, owner, repo):
-        """
-        Return true if you are watching the user repository
-
-        :param owner: Model user or username string
-        :param repo: Model repo or repo name string
-            is_watching_repo('copitux', 'python-github3')
-        """
-
-        owner = getattr(owner, 'login', owner)
-        repo = getattr(repo, 'name', repo)
-        return self._bool('watched/%s/%s' % (owner, repo))
-
-    def watch_repo(self, owner, repo):
-        """
-        Watch the repository
-
-        :param owner: Model user or username string
-        :param repo: Model repo or repo name string
-        """
-
-        owner = getattr(owner, 'login', owner)
-        repo = getattr(repo, 'name', repo)
-        return self._put('watched/%s/%s' % (owner, repo))
-
-    def unwatch_repo(self, owner, repo):
-        """
-        Unwatch the repository
-
-        :param owner: Model user or username string
-        :param repo: Model repo or repo name string
-        """
-
-        owner = getattr(owner, 'login', owner)
-        repo = getattr(repo, 'name', repo)
-        return self._delete('watched/%s/%s' % (owner, repo))
-
-    def my_orgs(self, limit=None):
-        """ List public and private organizations
-        for the authenticated user
-        """
-
-        return self._get_resources('orgs', model=models.Org, limit=limit)
diff --git a/github3/models/__init__.py b/github3/models/__init__.py
deleted file mode 100644
index 0471393..0000000
--- a/github3/models/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from .user import AuthUser, User, Key
-from .repos import Repo
-from .orgs import Org
-from .gists import Gist, GistComment
diff --git a/github3/models/base.py b/github3/models/base.py
deleted file mode 100644
index 5295d07..0000000
--- a/github3/models/base.py
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-class BaseResource(object):
-    """A BaseResource object."""
-
-    def __init__(self, attrs=None):
-        if attrs:
-            for attr, value in attrs.items():
-                setattr(self, attr, value)
-        super(BaseResource, self).__init__()
-
-    def __len__(self):
-        return len(self.__dict__)
-
-    @classmethod
-    def idl(self):
-        raise NotImplementedError('Each model need subcass that method')
diff --git a/github3/models/gists.py b/github3/models/gists.py
deleted file mode 100644
index 8979dbb..0000000
--- a/github3/models/gists.py
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from .base import BaseResource
-from .user import User
-
-
-class GistComment(BaseResource):
-    """ Gist comment """
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['url', 'body', 'body_text', 'body_html'],
-            'ints': ['id'],
-            'maps': {'user': User},
-            'dates': ['created_at'],
-        }
-
-    def __repr__(self):
-        return '<GistComment %s>' % self.user.login
-
-
-class File(BaseResource):
-    """ File model """
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['filename', 'raw_url', 'content', 'language', 'type'],
-            'ints': ['size'],
-        }
-
-    def __repr__(self):
-        return '<File gist> %s' % self.filename
-
-
-class GistFork(BaseResource):
-    """ GistFork model """
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['url'],
-            'dates': ['created_at'],
-            'maps': {'user': User}
-        }
-
-    def __repr__(self):
-        return '<Gist fork> %s>' % self.user.login
-
-
-class ChangeStatus(BaseResource):
-    """ ChangeStatus model """
-
-    @classmethod
-    def idl(self):
-        return {
-            'ints': ['deletions', 'additions', 'total'],
-        }
-
-    def __repr__(self):
-        return '<Gist history> change_status>'
-
-
-class GistHistory(BaseResource):
-    """ """
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['url', 'version'],
-            'maps': {'user': User, 'change_status': ChangeStatus},
-            'dates': ['committed_at'],
-        }
-
-    def __repr__(self):
-        return '<GistHistory %s/%s>' % (self.user, self.committed_at)
-
-
-class Gist(BaseResource):
-    """ """
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['url', 'description', 'html_url', 'git_pull_url',
-                     'git_push_url'],
-            'ints': ['id', 'comments'],
-            'bools': ['public'],
-            'dates': ['created_at'],
-            'maps': {'user': User},
-            'collection_maps': {'files': File, 'forks': GistFork,
-                                'history': GistHistory},
-        }
-
-    def __repr__(self):
-        return '<Gist %s/%s>' % (self.user, self.description)
diff --git a/github3/models/orgs.py b/github3/models/orgs.py
deleted file mode 100644
index b2dacbd..0000000
--- a/github3/models/orgs.py
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from .base import BaseResource
-from .user import Plan
-
-class Org(BaseResource):
-    """Github Organization object model."""
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['login', 'url', 'avatar_url', 'name', 'company', 'blog',
-                     'location', 'email', 'html_url', 'type', 'billing_email'],
-            'ints': ['id', 'public_repos', 'public_gists', 'followers',
-                     'following', 'total_private_repos', 'owned_private_repos',
-                     'private_gists', 'disk_usage', 'collaborators'],
-            'dates': ['created_at'],
-            'maps': {'plan': Plan}
-        }
-
-    def __repr__(self):
-        return '<Org %s>' % self.login
diff --git a/github3/models/repos.py b/github3/models/repos.py
deleted file mode 100644
index 882fb37..0000000
--- a/github3/models/repos.py
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from .base import BaseResource
-from .user import User
-from .orgs import Org
-
-class Repo(BaseResource):
-    """ Repo model """
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': [
-                'url', 'html_url', 'clone_url', 'git_url', 'ssh_url', 'svn_url',
-                'name', 'description', 'homepage', 'language', 'master_branch'],
-            'ints': ['forks', 'watchers', 'size', 'open_issues'],
-            'dates': ['created_at', 'pushed_at'],
-            'bools': ['private', 'fork', 'has_issues', 'has_wiki', 'has_downloads'],
-            'maps': {
-                'owner': User,
-                'organization': Org,
-                'parent': self.__class__,
-                'source': self.__class__,
-            }
-        }
-
-    def __repr__(self):
-        return '<Repo %s/%s>' % (self.owner.login, self.name)
diff --git a/github3/models/user.py b/github3/models/user.py
deleted file mode 100644
index aed6f09..0000000
--- a/github3/models/user.py
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from .base import BaseResource
-
-
-class Plan(BaseResource):
-    """Github Plan object model."""
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['name'],
-            'ints': ['space', 'collaborators', 'private_repos'],
-        }
-
-    def __repr__(self):
-        return '<Plan %s>' % self.name
-
-
-class Key(BaseResource):
-    """Github Key object model."""
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['url', 'title', 'key'],
-            'ints': ['id'],
-        }
-
-    def __repr__(self):
-        return '<Key %s>' % self.title
-
-
-class User(BaseResource):
-    """Github User object model."""
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': [
-                'login', 'avatar_url', 'gravatar_id', 'url', 'name',
-                'company', 'blog', 'location', 'email', 'bio', 'html_url',
-                'type'],
-            'ints': [
-                'id', 'public_repos', 'public_gists', 'followers', 'following',
-                'total_private_repos', 'owned_private_repos', 'private_gists',
-                'disk_usage', 'collaborators'],
-            'maps': {'plan': Plan},
-            'dates': ['created_at', ],
-            'bools': ['hireable', ],
-        }
-
-    def __repr__(self):
-        return '<User %s>' % getattr(self, 'login', 'without user')
-
-    #def handler(self):
-    #    return self._gh.users
-
-
-class AuthUser(User):
-    """Github Authenticated User object model."""
-
-    def __repr__(self):
-        return '<AuthUser %s>' % self.login
-
-    #def handler(self):
-    #    return self._gh.users
-
diff --git a/github3/packages/__init__.py b/github3/packages/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/github3/packages/__init__.py
+++ /dev/null
diff --git a/github3/packages/link_header.py b/github3/packages/link_header.py
deleted file mode 100644
index 5ad20f1..0000000
--- a/github3/packages/link_header.py
+++ /dev/null
@@ -1,90 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-"""
-HTTP Link Header Parsing
-
-Simple routines to parse and manipulate Link headers.
-"""
-
-__license__ = """
-Copyright (c) 2009 Mark Nottingham
- 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
- 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
- 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-"""
-
-import re
-
-TOKEN = r'(?:[^\(\)<>@,;:\\"/\[\]\?={} \t]+?)'
-QUOTED_STRING = r'(?:"(?:\\"|[^"])*")'
-PARAMETER = r'(?:%(TOKEN)s(?:=(?:%(TOKEN)s|%(QUOTED_STRING)s))?)' % locals()
-LINK = r'<[^>]*>\s*(?:;\s*%(PARAMETER)s?\s*)*' % locals()
-COMMA = r'(?:\s*(?:,\s*)+)'
-LINK_SPLIT = r'%s(?=%s|\s*$)' % (LINK, COMMA)
-
-def _unquotestring(instr):
-    if instr[0] == instr[-1] == '"':
-        instr = instr[1:-1]
-        instr = re.sub(r'\\(.)', r'\1', instr)
-    return instr
-def _splitstring(instr, item, split):
-    if not instr: 
-        return []
-    return [ h.strip() for h in re.findall(r'%s(?=%s|\s*$)' % (item, split), instr)]
-
-link_splitter = re.compile(LINK_SPLIT)
-
-def parse_link_value(instr):
-	"""
-	Given a link-value (i.e., after separating the header-value on commas), 
-	return a dictionary whose keys are link URLs and values are dictionaries
-	of the parameters for their associated links.
-	
-	Note that internationalised parameters (e.g., title*) are 
-	NOT percent-decoded.
-	
-	Also, only the last instance of a given parameter will be included.
-	
-	For example, 
-	
-	>>> parse_link_value('</foo>; rel="self"; title*=utf-8\'de\'letztes%20Kapitel')
-	{'/foo': {'title*': "utf-8'de'letztes%20Kapitel", 'rel': 'self'}}
-	
-	"""
-	out = {}
-	if not instr: 
-		return out
-	for link in [h.strip() for h in link_splitter.findall(instr)]:
-		url, params = link.split(">", 1)
-		url = url[1:]
-		param_dict = {}
-		for param in _splitstring(params, PARAMETER, "\s*;\s*"):
-			try:
-				a, v = param.split("=", 1)
-				param_dict[a.lower()] = _unquotestring(v)
-			except ValueError:
-				param_dict[param.lower()] = None
-		out[url] = param_dict
-	return out
-	
-	
-if __name__ == '__main__':
-	import sys
-	if len(sys.argv) > 1:
-		print parse_link_value(sys.argv[1])
diff --git a/github3/tests/api_test.py b/github3/tests/api_test.py
deleted file mode 100644
index 3ae75ee..0000000
--- a/github3/tests/api_test.py
+++ /dev/null
@@ -1,124 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from mock import Mock, patch
-from unittest import TestCase
-from github3 import api
-from github3.exceptions import *
-import json
-import requests
-
-
-@patch.object(requests.sessions.Session, 'request')
-class TestGithubCore(TestCase):
-
-    def setUp(self):
-        self.gh = api.GithubCore()
-        self.assertEquals(self.gh.base_url, 'https://api.github.com/')
-        self.assertEquals(self.gh._parser, json)
-        self.base_url = self.gh.base_url
-        self.parser = self.gh._parser
-
-    def test_parse_args(self, request_method):
-        args = {
-            'data': {'some': 'data'},
-            'params': {'arg0': 'some'},
-            'headers': 'out',
-            'auth': 'out',
-            'arg1': 'some',
-            'arg2': 'some',
-            'arg3': {'some': 'data', 'are': {'nested': 'true'}},
-        }
-        self.gh._parse_args(args)
-        self.assertEquals(args, {
-            'data': {'some': 'data'},
-            'params': {'arg0': 'some', 'arg1': 'some', 'arg2': 'some',
-                       'arg3': {'some': 'data', 'are': {'nested': 'true'}}},
-            'headers': 'out',
-            'auth': 'out',
-        })
-
-    def test_raise_errors(self, request_method):
-        real_request = (self.gh._request, 'GET', 'test')
-        request_method.return_value.status_code = 404
-        self.assertRaises(NotFound, *real_request)
-
-        request_method.return_value.status_code = 400
-        self.assertRaises(BadRequest, *real_request)
-
-        request_method.return_value.status_code = 422
-        self.assertRaises(UnprocessableEntity, *real_request)
-
-        request_method.return_value.status_code = 401
-        self.assertRaises(Unauthorized, *real_request)
-
-    def test_get(self, request_method):
-        response = request_method.return_value
-        response.content = self.parser.dumps({'test': 'test'})
-        content = self.gh.get('core')
-        request_method.assert_called_with('GET', self.base_url + 'core')
-        self.assertEquals(content, {'test': 'test'})
-
-        response = request_method.return_value
-        response.headers = {'link': 'url_with_links'}
-        response.content = self.parser.dumps({'test': 'test'})
-        header, content = self.gh.get('core', paginate=True)
-        request_method.assert_called_with('GET', self.base_url + 'core')
-        self.assertEquals(header, 'url_with_links')
-        self.assertEquals(content, {'test': 'test'})
-
-    def test_head(self, request_method):
-        pass  # It has no sense using mocks
-
-    def test_post_and_patch(self, request_method):
-        data = {'login': 'test', 'bio': 'test'}
-        response = request_method.return_value
-        response.status_code = 201
-        response.content = self.parser.dumps({'post': 'done'})
-
-        content = self.gh.post('core', data=data)
-        request_method.assert_called_with(
-            'POST', self.base_url + 'core',
-            data=self.parser.dumps(data))
-        self.assertEquals(content, {'post': 'done'})
-
-        content = self.gh.post('core')
-        request_method.assert_called_with(
-            'POST', self.base_url + 'core',
-            data=self.parser.dumps(None))
-        self.assertEquals(content, {'post': 'done'})
-
-        response.status_code = 200
-        content = self.gh.patch('core', data=data)
-        request_method.assert_called_with(
-            'PATCH', self.base_url + 'core',
-            data=self.parser.dumps(data))
-        self.assertEquals(content, {'post': 'done'})
-
-        content = self.gh.patch('core')
-        request_method.assert_called_with(
-            'PATCH', self.base_url + 'core',
-            data=self.parser.dumps(None))
-        self.assertEquals(content, {'post': 'done'})
-
-    def test_delete(self, request_method):
-        data = {'test': 'test'}
-        response = request_method.return_value
-        response.status_code = 204
-        response.content = self.parser.dumps({'delete': 'done'})
-        delete = self.gh.delete('core', data=data)
-        request_method.assert_called_with(
-            'DELETE', self.base_url + 'core',
-            data=self.parser.dumps(data))
-        delete = self.gh.delete('core')
-        request_method.assert_called_with(
-            'DELETE', self.base_url + 'core')
-
-    def test_put(self, request_method):
-        response = request_method.return_value
-        response.status_code = 204
-        response.content = ''
-        put = self.gh.put('core')
-        request_method.assert_called_with(
-            'PUT', self.base_url + 'core',
-            headers={'Content-length': '0'})
diff --git a/github3/tests/converters_test.py b/github3/tests/converters_test.py
deleted file mode 100644
index 66eedc3..0000000
--- a/github3/tests/converters_test.py
+++ /dev/null
@@ -1,96 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from github3.converters import *
-from github3.models.base import BaseResource
-from unittest import TestCase
-from datetime import datetime
-
-API_STUB = {
-    'test_str': 'string',
-    'test_int': 1,
-    'test_date': '2008-01-14T04:33:35Z',
-    'test_bool': True,
-    'map': {'test_str': 'string'},
-    'dict_map': {
-        'map1': {
-            'test_str': 'string',
-            'test_int': 1
-        },
-        'map2': {
-            'test_str': 'string',
-            'test_int': 2
-        },
-    },
-    'list_map': [
-        {'test_str': 'string', 'test_int': 1},
-        {'test_str': 'string', 'test_int': 2},
-    ],
-    'fake_map': 9,
-}
-
-
-class Model(BaseResource):
-
-    @classmethod
-    def idl(self):
-        return {
-            'strs': ['test_str'],
-            'ints': ['test_int'],
-            'dates': ['test_date'],
-            'bools': ['test_bool'],
-            'maps': {'map': Model, 'fake_map': Model},
-            'collection_maps': {
-                'dict_map': Model,
-                'list_map': Model,
-                'fake_map': Model,
-            },
-        }
-
-
-class TestModelizer(TestCase):
-
-    def setUp(self):
-        model = Model
-        self.modelizer = Modelizer()
-        self.modelizer.inject(model)
-
-    def test_loads(self):
-        parsed_model = self.modelizer.loads(API_STUB)
-        self.assertEquals(len(parsed_model), len(API_STUB))
-        self.assertEquals(parsed_model.test_str, 'string')
-        self.assertEquals(parsed_model.test_int, 1)
-        self.assertEquals(
-            parsed_model.test_date,
-            datetime(2008, 1, 14, 4, 33, 35))
-        self.assertTrue(parsed_model.test_bool)
-        self.assertTrue(isinstance(parsed_model.map, Model))
-        self.assertEquals(parsed_model.map.test_str, 'string')
-        self.assertTrue(isinstance(parsed_model.dict_map, dict))
-        map1 = parsed_model.dict_map['map1']
-        map2 = parsed_model.dict_map['map2']
-        self.assertTrue(isinstance(map1, Model))
-        self.assertTrue(isinstance(map2, Model))
-        self.assertEquals(map1.test_str, 'string')
-        self.assertEquals(map1.test_int, 1)
-        self.assertEquals(map2.test_str, 'string')
-        self.assertEquals(map2.test_int, 2)
-
-        list_map = parsed_model.list_map
-        self.assertTrue(isinstance(list_map, list))
-        self.assertEquals(list_map[0].test_str, 'string')
-        self.assertEquals(list_map[0].test_int, 1)
-        self.assertEquals(list_map[1].test_str, 'string')
-        self.assertEquals(list_map[1].test_int, 2)
-
-
-class TestRawlizer(TestCase):
-
-    def setUp(self):
-        model = Model
-        self.rawlizer = Rawlizer()
-
-    #  Trivial, I know it
-    def test_loads(self):
-        raw = self.rawlizer.loads(API_STUB)
-        self.assertEquals(raw, API_STUB)
diff --git a/github3/tests/fixtures.py b/github3/tests/fixtures.py
deleted file mode 100644
index ff5179c..0000000
--- a/github3/tests/fixtures.py
+++ /dev/null
@@ -1,164 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-GET_USER = {
-    "login": "octocat",
-    "id": 1,
-    "avatar_url": "https://github.com/images/error/octocat_happy.gif",
-    "gravatar_id": "somehexcode",
-    "url": "https://api.github.com/users/octocat",
-    "name": "monalisa octocat",
-    "company": "GitHub",
-    "blog": "https://github.com/blog",
-    "location": "San Francisco",
-    "email": "octocat@github.com",
-    "hireable": False,
-    "bio": "There once was...",
-    "public_repos": 2,
-    "public_gists": 1,
-    "followers": 20,
-    "following": 0,
-    "html_url": "https://github.com/octocat",
-    "created_at": "2008-01-14T04:33:35Z",
-    "type": "User"
-}
-
-GET_LINK = '<https://api.github.com/it_doesnt_matter?page=2>; rel="next", \
-<https://api.github.com/it_doesnt_matter?page=5>; rel="last"'
-
-GET_RESOURCES = [
-    {'login': 'octocat'},
-    {'login': 'octocat'}
-]
-
-GET_SHORT_USERS = [
-    {
-        "login": "octocat",
-        "id": 1,
-        "avatar_url": "https://github.com/images/error/octocat_happy.gif",
-        "gravatar_id": "somehexcode",
-        "url": "https://api.github.com/users/octocat"
-    },
-    {
-        "login": "octocat",
-        "id": 1,
-        "avatar_url": "https://github.com/images/error/octocat_happy.gif",
-        "gravatar_id": "somehexcode",
-        "url": "https://api.github.com/users/octocat"
-    },
-]
-
-GET_SHORT_ORGS = [
-    {
-        "login": "github",
-        "id": 1,
-        "url": "https://api.github.com/orgs/1",
-        "avatar_url": "https://github.com/images/error/octocat_happy.gif"
-    }
-]
-
-GET_SHORT_REPOS = [
-    {
-        "url": "https://api.github.com/repos/octocat/Hello-World",
-        "html_url": "https://github.com/octocat/Hello-World",
-        "clone_url": "https://github.com/octocat/Hello-World.git",
-        "git_url": "git://github.com/octocat/Hello-World.git",
-        "ssh_url": "git@github.com:octocat/Hello-World.git",
-        "svn_url": "https://svn.github.com/octocat/Hello-World",
-        "owner": {
-            "login": "octocat",
-            "id": 1,
-            "avatar_url": "https://github.com/images/error/octocat_happy.gif",
-            "gravatar_id": "somehexcode",
-            "url": "https://api.github.com/users/octocat"
-        },
-        "name": "Hello-World",
-        "description": "This your first repo!",
-        "homepage": "https://github.com",
-        "language": None,
-        "private": False,
-        "fork": False,
-        "forks": 9,
-        "watchers": 80,
-        "size": 108,
-        "master_branch": "master",
-        "open_issues": 0,
-        "pushed_at": "2011-01-26T19:06:43Z",
-        "created_at": "2011-01-26T19:01:12Z"
-    }
-]
-
-GET_SHORT_GISTS = [
-    {
-        "url": "https://api.github.com/gists/1",
-        "id": "1",
-        "description": "description of gist",
-        "public": True,
-        "user": {
-            "login": "octocat",
-            "id": 1,
-            "avatar_url": "https://github.com/images/error/octocat_happy.gif",
-            "gravatar_id": "somehexcode",
-            "url": "https://api.github.com/users/octocat"
-        },
-        "files": {
-            "ring.erl": {
-                "size": 932,
-                "filename": "ring.erl",
-                "raw_url": "https://gist.github.com/raw/365370/8c4d2d43d178df\
-                    44f4c03a7f2ac0ff512853564e/ring.erl",
-                "content": "contents of gist"
-            }
-        },
-        "comments": 0,
-        "html_url": "https://gist.github.com/1",
-        "git_pull_url": "git://gist.github.com/1.git",
-        "git_push_url": "git@gist.github.com:1.git",
-        "created_at": "2010-04-14T02:15:15Z"
-    }
-]
-GET_FULL_USER = {
-    "login": "octocat",
-    "id": 1,
-    "avatar_url": "https://github.com/images/error/octocat_happy.gif",
-    "gravatar_id": "somehexcode",
-    "url": "https://api.github.com/users/octocat",
-    "name": "monalisa octocat",
-    "company": "GitHub",
-    "blog": "https://github.com/blog",
-    "location": "San Francisco",
-    "email": "octocat@github.com",
-    "hireable": False,
-    "bio": "There once was...",
-    "public_repos": 2,
-    "public_gists": 1,
-    "followers": 20,
-    "following": 0,
-    "html_url": "https://github.com/octocat",
-    "created_at": "2008-01-14T04:33:35Z",
-    "type": "User",
-    "total_private_repos": 100,
-    "owned_private_repos": 100,
-    "private_gists": 81,
-    "disk_usage": 10000,
-    "collaborators": 8,
-    "plan": {
-        "name": "Medium",
-        "space": 400,
-        "collaborators": 10,
-        "private_repos": 20
-    }
-}
-GET_USER_EMAILS = [
-  "octocat@github.com",
-  "support@github.com"
-]
-
-GET_USER_KEYS = [
-    {
-        "url": "https://api.github.com/user/keys/1",
-        "id": 1,
-        "title": "octocat@octomac",
-        "key": "ssh-rsa AAA..."
-    }
-]
diff --git a/github3/tests/get_handlers_test.py b/github3/tests/get_handlers_test.py
deleted file mode 100644
index 0d88670..0000000
--- a/github3/tests/get_handlers_test.py
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from unittest import TestCase
-from github3 import api
-from github3 import handlers
-
-
-class TestGetHandlers(TestCase):
-
-    def setUp(self):
-        self.anom_gh = api.Github()
-        self.auth_gh = api.Github('test', 'password')
-
-    def test_get_user(self):
-        anom_user = self.anom_gh.users
-        auth_user = self.auth_gh.users
-
-        self.assertIsInstance(anom_user, handlers.users.User)
-        self.assertEquals(anom_user.prefix, 'users')
-        self.assertIsInstance(auth_user, handlers.users.AuthUser)
-        self.assertEquals(auth_user.prefix, 'user')
-
-    def test_get_gists(self):
-        anom_gists = self.anom_gh.gists
-        auth_gists = self.auth_gh.gists
-
-        self.assertIsInstance(anom_gists, handlers.gists.Gist)
-        self.assertEquals(anom_gists.prefix, 'gists')
-        self.assertIsInstance(auth_gists, handlers.gists.AuthGist)
-        self.assertEquals(anom_gists.prefix, 'gists')
diff --git a/github3/tests/gists_handler_test.py b/github3/tests/gists_handler_test.py
deleted file mode 100644
index ecadcfb..0000000
--- a/github3/tests/gists_handler_test.py
+++ /dev/null
@@ -1,110 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from unittest import TestCase
-from mock import Mock, patch
-from github3 import api
-from github3.models import Gist, GistComment
-from github3.handlers.base import Handler
-
-
-class TestGistHandler(TestCase):
-
-    def setUp(self):
-        self.gh = api.Github()
-        self.handler = self.gh.gists
-
-    @patch.object(Handler, '_get_resources')
-    def test_get_gists(self, get):
-        gists = self.handler.all_gists()
-        get.assert_called_with('', model=Gist, limit=None)
-
-    @patch.object(Handler, '_get_resource')
-    def test_get(self, get):
-        gist = self.handler.get(1)
-        get.assert_called_with(1, model=Gist)
-
-    @patch.object(Handler, '_get_resources')
-    def test_get_comments(self, get):
-        comments = self.handler.get_comments(1)
-        get.assert_called_with('1/comments', model=GistComment, limit=None,
-            headers=None)
-
-    @patch.object(Handler, '_get_resource')
-    def test_get_comment(self, get):
-        comment = self.handler.get_comment(1)
-        get.assert_called_with('comments/1', model=GistComment, headers=None)
-
-
-class TestAuthGistHandler(TestCase):
-
-    def setUp(self):
-        self.gh = api.Github('test', 'pass')
-        self.handler = self.gh.gists
-
-    def test_inherit(self):
-        self.assertTrue(hasattr(self.handler, 'get'))
-        self.assertTrue(hasattr(self.handler, 'get_comments'))
-        self.assertTrue(hasattr(self.handler, 'get_comment'))
-
-    @patch.object(Handler, '_get_resources')
-    def test_all_gists(self, get):
-        gists = self.handler.all_gists()
-        get.assert_called_with('public', model=Gist, limit=None)
-
-    @patch.object(Handler, '_get_resources')
-    def test_my_gists(self, get):
-        gists = self.handler.my_gists()
-        get.assert_called_with('', model=Gist, limit=None)
-
-    @patch.object(Handler, '_get_resources')
-    def test_my_starred_gists(self, get):
-        gists = self.handler.my_starred_gists()
-        get.assert_called_with('starred', model=Gist, limit=None)
-
-    @patch.object(Handler, '_post_resource')
-    def test_create_gist(self, post):
-        data = {
-            'public': False,
-            'files': {'file': {'contents': 'file_data'}},
-            'desc': 'some'
-        }
-        gist = self.handler.create_gist(data['public'], data['files'],
-                                        data['desc'])
-        post.assert_called_with('', data=data, model=Gist)
-
-    @patch.object(Handler, '_put')
-    def test_star_gist(self, put):
-        boolean = self.handler.star_gist(1)
-        put.assert_called_with('1/star')
-
-    @patch.object(Handler, '_delete')
-    def test_unstar_gist(self, delete):
-        boolean = self.handler.unstar_gist(1)
-        delete.assert_callted_with('1/star')
-
-    @patch.object(Handler, '_bool')
-    def test_is_starred(self, bool):
-        boolean = self.handler.is_starred(1)
-        bool.assert_called_with('1/star')
-
-    @patch.object(Handler, '_post_resource')
-    def test_fork_gist(self, post):
-        gist = self.handler.fork_gist(1)
-        post.assert_called_with('1/fork', data=None, model=Gist)
-
-    @patch.object(Handler, '_delete')
-    def test_delete_gist(self, delete):
-        boolean = self.handler.delete_gist(1)
-        delete.assert_called_with('1')
-
-    @patch.object(Handler, '_post_resource')
-    def test_create_comment(self, post):
-        gist_comment = self.handler.create_comment(1, 'comment')
-        post.assert_called_with('1/comments', data={'body': 'comment'},
-            model=GistComment)
-
-    @patch.object(Handler, '_delete')
-    def test_delete_comment(self, delete):
-        boolean = self.handler.delete_comment(1)
-        delete.assert_called_with('comments/1')
diff --git a/github3/tests/handler_test.py b/github3/tests/handler_test.py
deleted file mode 100644
index 83c89ef..0000000
--- a/github3/tests/handler_test.py
+++ /dev/null
@@ -1,133 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from mock import Mock, patch
-from unittest import TestCase
-from github3 import api
-from github3.handlers.base import Handler, MimeTypeMixin
-from github3.exceptions import *
-from github3.converters import *
-from github3.models.user import User
-from fixtures import *
-import json
-import requests
-
-
-class TestMimeTypeMixin(TestCase):
-
-    def setUp(self):
-        self.mixin = MimeTypeMixin()
-
-    def _parse_mime_type(self, type):
-        return 'application/vnd.github.%s.%s+json' % (
-            MimeTypeMixin.VERSION, type)
-
-    def test_header(self):
-        self.assertEquals(self.mixin.mime_header(), None)
-
-    def test_add_mimetypes(self):
-        self.mixin.add_raw()
-        self.mixin.add_text()
-        self.mixin.add_html()
-        self.mixin.add_full()
-        self.assertEquals(sorted(self.mixin.mime_header()), sorted({
-            'Accept': '%s, %s, %s, %s' % (
-            self._parse_mime_type('raw'),
-            self._parse_mime_type('text'),
-            self._parse_mime_type('html'),
-            self._parse_mime_type('full'))}))
-
-
-class TestHandler(TestCase):
-
-    def setUp(self):
-        self.gh = api.Github()
-        self.handler = Handler(self.gh)
-
-    def test_get_converter(self):
-        self.assertIsInstance(self.handler._get_converter(), Modelizer)
-        kwargs = {'converter': Rawlizer}
-        self.assertIsInstance(self.handler._get_converter(kwargs),
-                              Rawlizer)
-        self.assertEquals(kwargs, {})
-        self.handler.converter = Modelizer
-        self.assertIsInstance(self.handler._get_converter(), Modelizer)
-
-    def test_bool(self):
-        with patch.object(api.Github, 'head') as head:
-            response = head.return_value
-            response.status_code = 204
-            bool1 = self.handler._bool('test')
-            head.side_effect = NotFound()
-            bool2 = self.handler._bool('test')
-        head.assert_called_with('test')
-        self.assertTrue(bool1)
-        self.assertFalse(bool2)
-
-        with patch.object(api.Github, 'put') as put:
-            response = put.return_value
-            response.status_code = 204
-            booll = self.handler._put('test')
-        put.assert_called_with('test', method='put')
-        self.assertTrue(booll)
-
-        with patch.object(api.Github, 'delete') as delete:
-            response = delete.return_value
-            response.content = self.gh._parser.dumps({'data': 'test'})
-            response.status_code = 204
-            bool1 = self.handler._bool('test', method='delete')
-            bool2 = self.handler._bool('test', method='delete',
-                                       data={'some': 'data'})
-        self.assertTrue(bool1)
-        self.assertTrue(bool2)
-
-    @patch.object(api.Github, '_request')
-    def test_get_resources(self, request):
-        #  Simulating per_page=2 with STUB (it returns two resources)
-        response = request.return_value
-        response.status_code = 200
-        response.headers = {'link': GET_LINK}
-        response.content = self.gh._parser.dumps(GET_RESOURCES)
-        resources = self.handler._get_resources('users', model=User)
-        self.assertFalse(request.called)
-        resources = list(resources)
-        self.assertTrue(request.call_count, 5)
-        request_args = ('GET', 'users')
-        self.assertEquals(request.call_args_list, [
-            (request_args, {'page': 1}),
-            (request_args, {'page': 2}),
-            (request_args, {'page': 3}),
-            (request_args, {'page': 4}),
-            (request_args, {'page': 5})])
-        self.assertEquals(len(resources), 10)
-        self.assertEquals(resources[0].login, 'octocat')
-
-        request.reset_mock()
-        resources = self.handler._get_resources('users', model=User, limit=5)
-        resources = list(resources)
-        self.assertEquals(request.call_count, 3)
-        self.assertEquals(len(resources), 5)
-        request.reset_mock()
-        resources = self.handler._get_resources('users', model=User, limit=4)
-        resources = list(resources)
-        self.assertEquals(request.call_count, 2)
-        self.assertEquals(len(resources), 4)
-        request.reset_mock()
-        resources = self.handler._get_resources('users', model=User, limit=-5)
-        resources = list(resources)
-        self.assertEquals(request.call_count, 3)
-        self.assertEquals(len(resources), 5)
-
-    @patch.object(api.Github, 'get')
-    def test_get_resource(self, get):
-        #  Converter test + api(get) test. Half trivial
-        get.return_value = {'login': 'octocat'}
-        model = self.handler._get_resource('test', model=User)
-        self.assertEquals(model.login, 'octocat')
-
-    @patch.object(api.Github, 'post')
-    def test_post_resource(self, post):
-        post.return_value = {'data': 'posted'}
-        data = {'data': 'to_post'}
-        user_new = self.handler._post_resource('test', data=data, model=User)
-        post.assert_called_with('test', data=data)
diff --git a/github3/tests/user_handler_test.py b/github3/tests/user_handler_test.py
deleted file mode 100644
index 33658d2..0000000
--- a/github3/tests/user_handler_test.py
+++ /dev/null
@@ -1,326 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-
-from unittest import TestCase
-from mock import Mock, patch
-from github3 import api
-from fixtures import *
-from github3.models import User, AuthUser, Repo, Gist, Org, Key
-from github3.exceptions import *
-from github3 import handlers
-
-
-class TestAuthUserHandler(TestCase):
-    """ Test private api about user logged """
-
-    def setUp(self):
-        self.gh = api.Github('test', 'pass')
-        self.handler = self.gh.users
-        self.user_mock = Mock()
-        self.user_mock.login = 'user_model'
-
-    def test_inject_user_handler(self):
-        self.assertEquals(self.handler.get.im_class, handlers.users.User)
-        self.assertEquals(self.handler.get_followers.im_class,
-            handlers.users.User)
-        self.assertEquals(self.handler.get_following.im_class,
-            handlers.users.User)
-        self.assertEquals(self.handler.get_repos.im_class,
-            handlers.users.User)
-        self.assertEquals(self.handler.get_watched.im_class,
-            handlers.users.User)
-        self.assertEquals(self.handler.get_orgs.im_class,
-            handlers.users.User)
-        self.assertEquals(self.handler.get_gists.im_class,
-            handlers.users.User)
-
-    @patch.object(api.Github, 'get')
-    def test_me(self, get):
-        get.return_value = GET_FULL_USER
-        user = self.handler.me()
-        self.assertIsInstance(user, AuthUser)
-        get.assert_called_with('user')
-        self.assertEquals(len(user), len(GET_FULL_USER))
-
-    @patch.object(handlers.base.Handler, '_get_resource')
-    def test_get(self, get):
-        user = self.handler.get('test')
-        get.assert_called_with('test', model=User)
-
-    @patch.object(handlers.base.Handler, '_get_resources')
-    def test_get_my_followers(self, get):
-        followers = self.handler.my_followers()
-        get.assert_called_with('followers', model=User, limit=None)
-
-    @patch.object(handlers.base.Handler, '_get_resources')
-    def test_get_my_following(self, get):
-        following = self.handler.my_following()
-        get.assert_called_with('following', model=User, limit=None)
-
-    @patch.object(handlers.base.Handler, '_get_resources')
-    def test_get_my_watched(self, get):
-        following = self.handler.my_watched()
-        get.assert_called_with('watched', model=Repo, limit=None)
-
-    @patch.object(handlers.base.Handler, '_get_resources')
-    def test_get_my_orgs(self, get):
-        following = self.handler.my_orgs()
-        get.assert_called_with('orgs', model=Org, limit=None)
-
-    @patch.object(api.Github, 'get')
-    def test_get_emails(self, get):
-        get.return_value = GET_USER_EMAILS
-        emails = self.handler.get_emails()
-        get.assert_called_with('user/emails')
-        self.assertEquals(emails, GET_USER_EMAILS)
-
-    @patch.object(api.Github, 'post')
-    def test_create_emails(self, post):
-        post.return_value = GET_USER_EMAILS
-        emails = self.handler.create_emails(*GET_USER_EMAILS)
-        post.assert_called_with('user/emails', data=GET_USER_EMAILS)
-        self.assertEquals(emails, GET_USER_EMAILS)
-
-    @patch.object(api.Github, 'delete')
-    def test_delete_emails(self, delete):
-        response = delete.return_value
-        response.return_value = ''
-        response.status_code = 204
-        emails = self.handler.delete_emails(*GET_USER_EMAILS)
-        delete.assert_called_with('user/emails', data=GET_USER_EMAILS,
-                                  method='delete')
-        self.assertTrue(emails)
-
-    @patch.object(api.Github, 'head')
-    def test_is_following(self, head):
-        response = head.return_value
-        response.status_code = 204
-        self.assertTrue(self.handler.is_following('test'))
-        head.assert_called_with('user/following/test')
-        self.handler.is_following(self.user_mock)
-        head.assert_called_with('user/following/user_model')
-
-    @patch.object(api.Github, 'put')
-    def test_follow(self, put):
-        response = put.return_value
-        response.status_code = 204
-        self.assertTrue(self.handler.follow('test'))
-        put.assert_called_with('user/following/test', method='put')
-
-    @patch.object(api.Github, 'delete')
-    def test_unfollow(self, delete):
-        response = delete.return_value
-        response.status_code = 204
-        self.assertTrue(self.handler.unfollow('test'))
-        delete.assert_called_with('user/following/test', method='delete')
-
-    @patch.object(api.Github, '_request')
-    def test_get_keys(self, request):
-        response = request.return_value
-        response.status_code = 200
-        response.content = self.gh._parser.dumps(GET_USER_KEYS)
-        response.headers = {'link': GET_LINK}  # 1 per page
-        keys = list(self.handler.get_keys())
-        self.assertEquals(len(keys), 5)
-        self.assertIsInstance(keys[0], Key)
-        request.assert_called_with('GET', 'user/keys', page=5)
-        keys = list(self.handler.get_keys(limit=2))
-        self.assertEquals(len(keys), 2)
-
-    @patch.object(api.Github, 'get')
-    def test_get_key(self, get):
-        get.return_value = GET_USER_KEYS[0]
-        key = self.handler.get_key(1)
-        self.assertIsInstance(key, Key)
-        get.assert_called_with('user/keys/1')
-        model_key = Mock()
-        model_key.id = 1
-        key = self.handler.get_key(model_key)
-        get.assert_called_with('user/keys/1')
-
-    @patch.object(api.Github, 'post')
-    def test_create_key(self, post):
-        post.return_value = GET_USER_KEYS[0]
-        key_data = {'title': 'some', 'key': 'ssh-rsa AAA'}
-        created_key = self.handler.create_key(**key_data)
-        self.assertIsInstance(created_key, Key)
-        post.assert_called_with('user/keys', data=key_data)
-
-    @patch.object(api.Github, 'delete')
-    def test_delete_key(self, delete):
-        response = delete.return_value
-        response.status_code = 204
-        self.assertTrue(self.handler.delete_key(1))
-        delete.assert_called_with('user/keys/1', method='delete')
-        model_key = Mock()
-        model_key.id = 1
-        key = self.handler.delete_key(model_key)
-        delete.assert_called_with('user/keys/1', method='delete')
-
-    @patch.object(api.Github, '_request')
-    def test_my_repos(self, request):
-        response = request.return_value
-        response.status_code = 200
-        response.content = self.gh._parser.dumps(GET_SHORT_REPOS)
-        response.headers = {'link': GET_LINK}  # 1 per page
-        repos = list(self.handler.my_repos(filter='public'))
-        self.assertEquals(len(repos), 5)
-        self.assertIsInstance(repos[0], Repo)
-        request.assert_called_with('GET', 'user/repos',
-                                   page=5, type='public')
-        repos = list(self.handler.my_repos(limit=2))
-        self.assertEquals(len(repos), 2)
-
-    @patch.object(api.Github, 'head')
-    def test_is_watching_repo(self, head):
-        response = head.return_value
-        response.status_code = 204
-        self.assertTrue(self.handler.is_watching_repo('user', 'repo'))
-        head.assert_called_with('user/watched/user/repo')
-        model_user, model_repo = Mock(), Mock()
-        model_user.login = 'user'
-        model_repo.name = 'repo'
-        self.assertTrue(self.handler.is_watching_repo('user', 'repo'))
-        head.assert_called_with('user/watched/user/repo')
-
-    @patch.object(api.Github, 'put')
-    def test_watch_repo(self, put):
-        response = put.return_value
-        response.status_code = 204
-        self.assertTrue(self.handler.watch_repo('user', 'repo'))
-        put.assert_called_with('user/watched/user/repo', method='put')
-        model_user, model_repo = Mock(), Mock()
-        model_user.login = 'user'
-        model_repo.name = 'repo'
-        self.assertTrue(self.handler.watch_repo('user', 'repo'))
-        put.assert_called_with('user/watched/user/repo', method='put')
-
-    @patch.object(api.Github, 'delete')
-    def test_unwatch_repo(self, delete):
-        response = delete.return_value
-        response.status_code = 204
-        self.assertTrue(self.handler.unwatch_repo('user', 'repo'))
-        delete.assert_called_with('user/watched/user/repo', method='delete')
-        model_user, model_repo = Mock(), Mock()
-        model_user.login = 'user'
-        model_repo.name = 'repo'
-        self.assertTrue(self.handler.unwatch_repo('user', 'repo'))
-        delete.assert_called_with('user/watched/user/repo', method='delete')
-
-
-class TestUserHandler(TestCase):
-    """ Test public api about users """
-
-    def setUp(self):
-        self.gh = api.Github()
-        self.handler = self.gh.users
-
-    def test_set_username(self):
-        handler = self.handler.set_username('test')
-        self.assertEquals(id(handler), id(self.handler))
-        self.assertEquals(handler.username, 'test')
-        model_user = Mock()
-        model_user.login = 'test'
-        handler = self.handler.set_username(model_user)
-        self.assertEquals(handler.username, 'test')
-
-    def test_parse_user(self):
-        model_user = Mock()
-        model_user.login = 'test'
-        self.assertRaises(UserIsAnonymous, self.handler._parse_user, None)
-        user = self.handler._parse_user(model_user)
-        self.assertEquals(user, 'test')
-        user = self.handler._parse_user('test')
-        self.assertEquals(user, 'test')
-        self.assertRaises(UserIsAnonymous, self.handler._parse_user, Mock())
-        self.handler.set_username('octocat')
-        self.assertEquals('octocat', self.handler._parse_user(None))
-        self.assertEquals('octocat', self.handler._parse_user(Mock()))
-        self.assertEquals('test', self.handler._parse_user('test'))
-        self.assertEquals('test', self.handler._parse_user(model_user))
-
-    @patch.object(api.Github, 'get')
-    def test_get(self, get):
-        get.return_value = GET_USER
-        self.assertRaises(UserIsAnonymous, self.handler.get)
-        user = self.handler.get('octocat')
-        self.assertIsInstance(user, User)
-        get.assert_called_with('users/octocat')
-
-    @patch.object(api.Github, '_request')
-    def test_get_followers(self, request):
-        response = request.return_value
-        response.headers = {'link': GET_LINK}
-        response.content = self.gh._parser.dumps(GET_SHORT_USERS)  # 2 users
-        followers = list(self.handler.get_followers('test'))
-        request.assert_called_with('GET', 'users/test/followers', page=5)
-        self.assertIsInstance(followers[0], User)
-        self.assertEquals(len(followers), 10)
-        followers = list(self.handler.get_followers('test', limit=2))
-        self.assertEquals(len(followers), 2)
-        self.assertEquals(followers[0].login, 'octocat')
-
-    @patch.object(api.Github, '_request')
-    def test_get_following(self, request):
-        response = request.return_value
-        response.headers = {'link': GET_LINK}
-        response.content = self.gh._parser.dumps(GET_SHORT_USERS)  # 2 users
-        following = list(self.handler.get_following('test'))
-        request.assert_called_with('GET', 'users/test/following', page=5)
-        self.assertIsInstance(following[0], User)
-        self.assertEquals(len(following), 10)
-        following = list(self.handler.get_following('test', limit=2))
-        self.assertEquals(len(following), 2)
-
-    @patch.object(api.Github, '_request')
-    def test_get_repos(self, request):
-        response = request.return_value
-        response.headers = {'link': GET_LINK}
-        response.content = self.gh._parser.dumps(GET_SHORT_REPOS)  # 1 repo
-        repos = list(self.handler.get_repos('test'))
-        request.assert_called_with('GET', 'users/test/repos', page=5)
-        self.assertIsInstance(repos[0], Repo)
-        self.assertEquals(len(repos), 5)
-        repos = list(self.handler.get_repos('test', limit=2))
-        self.assertEquals(len(repos), 2)
-        self.assertIsInstance(repos[0].owner, User)
-
-    @patch.object(api.Github, '_request')
-    def test_get_watched(self, request):
-        response = request.return_value
-        response.headers = {'link': GET_LINK}
-        response.content = self.gh._parser.dumps(GET_SHORT_REPOS)  # 1 repo
-        watched = list(self.handler.get_watched('test'))
-        request.assert_called_with('GET', 'users/test/watched', page=5)
-        self.assertIsInstance(watched[0], Repo)
-        self.assertEquals(len(watched), 5)
-        watched = list(self.handler.get_watched('test', limit=2))
-        self.assertEquals(len(watched), 2)
-
-    @patch.object(api.Github, '_request')
-    def test_get_orgs(self, request):
-        response = request.return_value
-        response.headers = {'link': GET_LINK}
-        response.content = self.gh._parser.dumps(GET_SHORT_ORGS)  # 1 repo
-        orgs = list(self.handler.get_orgs('test'))
-        request.assert_called_with('GET', 'users/test/orgs', page=5)
-        self.assertIsInstance(orgs[0], Org)
-        self.assertEquals(len(orgs), 5)
-        orgs = list(self.handler.get_orgs('test', limit=2))
-        self.assertEquals(len(orgs), 2)
-        self.assertEquals(orgs[0].login, 'github')
-
-    @patch.object(api.Github, '_request')
-    def test_get_gists(self, request):
-        response = request.return_value
-        response.headers = {'link': GET_LINK}
-        response.content = self.gh._parser.dumps(GET_SHORT_GISTS)  # 1 repo
-        gists = list(self.handler.get_gists('test'))
-        request.assert_called_with('GET', 'users/test/gists', page=5)
-        self.assertIsInstance(gists[0], Gist)
-        self.assertEquals(len(gists), 5)
-        gists = list(self.handler.get_gists('test', limit=2))
-        self.assertEquals(len(gists), 2)
-        self.assertIsInstance(gists[0].files, dict)
-        from github3.models.gists import File
-        self.assertIsInstance(gists[0].files['ring.erl'], File)