Python api.Api类代码示例

def get_urls(version=1):
    api = Api(api_name='auth')

    if version == 1:
        api.register(User())

    return api.urls

    def test_top_level_include_schema_content(self):
        api = Api()

        note_resource = NoteResource()
        user_resource = UserResource()

        api.register(note_resource)
        api.register(user_resource)

        request = HttpRequest()
        request.GET = {'fullschema': 'true'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)

        content = json.loads(resp.content.decode('utf-8'))

        content['notes']['schema'] = adjust_schema(content['notes']['schema'])
        content['users']['schema'] = adjust_schema(content['users']['schema'])

        dummy_request = HttpRequest()
        dummy_request.method = 'GET'

        notes_schema = adjust_schema(json.loads(note_resource.get_schema(dummy_request).content.decode('utf-8')))
        user_schema = adjust_schema(json.loads(user_resource.get_schema(dummy_request).content.decode('utf-8')))

        self.assertEqual(content['notes']['list_endpoint'], '/api/v1/notes/')
        self.assertEqual(content['notes']['schema'], notes_schema)

        self.assertEqual(content['users']['list_endpoint'], '/api/v1/users/')
        self.assertEqual(content['users']['schema'], user_schema)

    def test_custom_api_serializer(self):
        """Confirm that an Api can use a custom serializer"""

        # Origin: https://github.com/django-tastypie/django-tastypie/pull/817

        class JSONSerializer(Serializer):
            formats = ('json', )

        api = Api(serializer_class=JSONSerializer)
        api.register(NoteResource())

        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'text/javascript'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['content-type'], 'application/json',
                         msg="Expected application/json response but received %s" % resp['content-type'])

        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'application/xml'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['content-type'], 'application/json',
                         msg="Expected application/json response but received %s" % resp['content-type'])

    def test_top_level_jsonp(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()
        request.META = {"HTTP_ACCEPT": "text/javascript"}
        request.GET = {"callback": "foo"}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp["content-type"].split(";")[0], "text/javascript")
        self.assertEqual(
            resp.content.decode("utf-8"),
            'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})',
        )

        request = HttpRequest()
        request.META = {"HTTP_ACCEPT": "text/javascript"}
        request.GET = {"callback": ""}

        try:
            resp = api.top_level(request)
            self.fail("Broken callback didn't fail!")
        except BadRequest:
            # Regression: We expect this, which is fine, but this used to
            #             be an import error.
            pass

def get_api():
	# create the naespaces for the applications
	api = Api(api_name='simpleapp')
	api.register(TypeResource())
	api.register(ProductResource())
	
	base_path_regex = r'^api/v1/'
	return base_path_regex,api

def named_api(api_name):
    """ api_name is the version part of the api path
    """
    new_api = Api(api_name=api_name)

    for resource in resources.__all__:
        new_api.register(getattr(resources, resource)())
    return new_api

 def test_top_level(self):
     api = Api()
     api.register(NoteResource())
     api.register(UserResource())
     request = HttpRequest()
     
     resp = api.top_level(request)
     self.assertEqual(resp.status_code, 200)
     self.assertEqual(resp.content, '{"notes": "/api/v1/notes/", "users": "/api/v1/users/"}')

    def test_top_level(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.content.decode('utf-8'), '{"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}}')

def build_api_urls():
    v1_api = Api(api_name='v1')
    v1_api.register(VideoResource())
    v1_api.register(CategoryResource())

    return patterns(
        'richard.videos.views',

        (r'^api/', include(v1_api.urls)),
        )

def resouce_autodiscover(api_name="v1", api_module_name="api"):
    api = Api(api_name=api_name)
    for app in settings.INSTALLED_APPS:
        try:
            resorce_api = import_module('%s.%s' % (app, api_module_name))
            for resource_klass_name in resorce_api.__all__:
                resource_klass = getattr(resorce_api, resource_klass_name)
                api.register(resource_klass())
        except:
            continue
    return api

    def test_jsonp_not_on_by_default(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'text/javascript'}
        request.GET = {'callback': 'foo'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['content-type'].split(';')[0], 'application/json')
        self.assertFalse("foo" in resp.content.decode('utf-8'))

def resouce_autodiscover():
    from django.conf import settings
    from django.utils.importlib import import_module
    v1_api = Api(api_name='v1')
    for app in settings.INSTALLED_APPS:
        try:
            resorce_api = import_module('%s.api' % app)
            for resource_klass_name in resorce_api.__all__:
                resource_klass = getattr(resorce_api, resource_klass_name)
                v1_api.register(resource_klass())
        except:
            continue
    return v1_api

    def test_top_level_jsonp(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()
        request.META = {"HTTP_ACCEPT": "text/javascript"}
        request.GET = {"callback": "foo"}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp["content-type"].split(";")[0], "text/javascript")
        self.assertEqual(
            resp.content,
            'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})',
        )

def api_factory():
    API_VERSION = 'v1'
    pootle_api = Api(api_name=API_VERSION)
    pootle_api.register(LanguageResource())
    pootle_api.register(ProjectResource())
    pootle_api.register(TranslationProjectResource())
    return pootle_api

    def __init__(self, resources):
        self.tastypieApi = TastypieApi(api_name='resources')
        self.dummy_resources = []
        self.resources = {}

        for resource_class in resources:
            resource = resource_class()
            self.resources[resource._meta.resource_name] = resource
            self.tastypieApi.register(resource)