From f84fd47825a7921c9d0dbdf7aba05f49df428c9b Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 14 Dec 2011 14:48:22 +0000 Subject: [PATCH] Cleanups - line lengths, whitespace etc. --- djangorestframework/authentication.py | 71 +++--- djangorestframework/mixins.py | 302 +++++++++++++------------ djangorestframework/tests/renderers.py | 59 +++-- djangorestframework/utils/__init__.py | 18 +- djangorestframework/views.py | 30 +-- 5 files changed, 256 insertions(+), 224 deletions(-) diff --git a/djangorestframework/authentication.py b/djangorestframework/authentication.py index be22103e6..d342e7a0f 100644 --- a/djangorestframework/authentication.py +++ b/djangorestframework/authentication.py @@ -1,15 +1,17 @@ """ -The :mod:`authentication` module provides a set of pluggable authentication classes. +The :mod:`authentication` module provides a set of pluggable authentication +classes. -Authentication behavior is provided by mixing the :class:`mixins.AuthMixin` class into a :class:`View` class. +Authentication behavior is provided by mixing the :class:`mixins.AuthMixin` +class into a :class:`View` class. -The set of authentication methods which are used is then specified by setting the -:attr:`authentication` attribute on the :class:`View` class, and listing a set of :class:`authentication` classes. +The set of authentication methods which are used is then specified by setting +the :attr:`authentication` attribute on the :class:`View` class, and listing a +set of :class:`authentication` classes. """ from django.contrib.auth import authenticate from django.middleware.csrf import CsrfViewMiddleware -from djangorestframework.utils import as_tuple import base64 __all__ = ( @@ -26,23 +28,25 @@ class BaseAuthentication(object): def __init__(self, view): """ - :class:`Authentication` classes are always passed the current view on creation. + :class:`Authentication` classes are always passed the current view on + creation. """ self.view = view def authenticate(self, request): """ - Authenticate the :obj:`request` and return a :obj:`User` or :const:`None`. [*]_ - + Authenticate the :obj:`request` and return a :obj:`User` or + :const:`None`. [*]_ + .. [*] The authentication context *will* typically be a :obj:`User`, but it need not be. It can be any user-like object so long as the - permissions classes (see the :mod:`permissions` module) on the view can - handle the object and use it to determine if the request has the required - permissions or not. - - This can be an important distinction if you're implementing some token - based authentication mechanism, where the authentication context - may be more involved than simply mapping to a :obj:`User`. + permissions classes (see the :mod:`permissions` module) on the view + can handle the object and use it to determine if the request has + the required permissions or not. + + This can be an important distinction if you're implementing some + token based authentication mechanism, where the authentication + context may be more involved than simply mapping to a :obj:`User`. """ return None @@ -51,14 +55,20 @@ class BasicAuthentication(BaseAuthentication): """ Use HTTP Basic authentication. """ + def _authenticate_user(self, username, password): + user = authenticate(username=username, password=password) + if user and user.is_active: + return user + return None def authenticate(self, request): """ - Returns a :obj:`User` if a correct username and password have been supplied - using HTTP Basic authentication. Otherwise returns :const:`None`. + Returns a :obj:`User` if a correct username and password have been + supplied using HTTP Basic authentication. + Otherwise returns :const:`None`. """ - from django.utils.encoding import smart_unicode, DjangoUnicodeDecodeError - + from django.utils import encoding + if 'HTTP_AUTHORIZATION' in request.META: auth = request.META['HTTP_AUTHORIZATION'].split() if len(auth) == 2 and auth[0].lower() == "basic": @@ -66,17 +76,19 @@ class BasicAuthentication(BaseAuthentication): auth_parts = base64.b64decode(auth[1]).partition(':') except TypeError: return None - + try: - uname, passwd = smart_unicode(auth_parts[0]), smart_unicode(auth_parts[2]) - except DjangoUnicodeDecodeError: + username = encoding.smart_unicode(auth_parts[0]) + password = encoding.smart_unicode(auth_parts[2]) + except encoding.DjangoUnicodeDecodeError: return None - - user = authenticate(username=uname, password=passwd) - if user is not None and user.is_active: + + user = self._authenticate_user(username, password) + if user: return user + return None - + class UserLoggedInAuthentication(BaseAuthentication): """ @@ -85,10 +97,11 @@ class UserLoggedInAuthentication(BaseAuthentication): def authenticate(self, request): """ - Returns a :obj:`User` if the request session currently has a logged in user. - Otherwise returns :const:`None`. + Returns a :obj:`User` if the request session currently has a logged in + user. Otherwise returns :const:`None`. """ - # TODO: Switch this back to request.POST, and let FormParser/MultiPartParser deal with the consequences. + # TODO: Switch this back to request.POST, and let + # FormParser/MultiPartParser deal with the consequences. if getattr(request, 'user', None) and request.user.is_active: # If this is a POST request we enforce CSRF validation. if request.method.upper() == 'POST': diff --git a/djangorestframework/mixins.py b/djangorestframework/mixins.py index 350af5cb1..69e03f696 100644 --- a/djangorestframework/mixins.py +++ b/djangorestframework/mixins.py @@ -5,13 +5,12 @@ classes that can be added to a `View`. from django.contrib.auth.models import AnonymousUser from django.core.paginator import Paginator -from django.db.models.fields.related import ForeignKey from django.http import HttpResponse from djangorestframework import status +from djangorestframework.renderers import BaseRenderer from djangorestframework.resources import Resource, FormResource, ModelResource -from djangorestframework.response import ErrorResponse -from djangorestframework.utils import as_tuple, MSIE_USER_AGENT_REGEX +from djangorestframework.response import Response, ErrorResponse from djangorestframework.utils import MSIE_USER_AGENT_REGEX from djangorestframework.utils.mediatypes import is_form_media_type, order_by_precedence @@ -55,14 +54,14 @@ class RequestMixin(object): """ Returns the HTTP method. - This should be used instead of just reading :const:`request.method`, as it allows the `method` - to be overridden by using a hidden `form` field on a form POST request. + This should be used instead of just reading :const:`request.method`, as + it allows the `method` to be overridden by using a hidden `form` field + on a form POST request. """ if not hasattr(self, '_method'): self._load_method_and_content_type() return self._method - @property def content_type(self): """ @@ -76,7 +75,6 @@ class RequestMixin(object): self._load_method_and_content_type() return self._content_type - @property def DATA(self): """ @@ -89,7 +87,6 @@ class RequestMixin(object): self._load_data_and_files() return self._data - @property def FILES(self): """ @@ -101,7 +98,6 @@ class RequestMixin(object): self._load_data_and_files() return self._files - def _load_data_and_files(self): """ Parse the request content into self.DATA and self.FILES. @@ -110,18 +106,19 @@ class RequestMixin(object): self._load_method_and_content_type() if not hasattr(self, '_data'): - (self._data, self._files) = self._parse(self._get_stream(), self._content_type) - + (self._data, self._files) = self._parse(self._get_stream(), + self._content_type) def _load_method_and_content_type(self): """ - Set the method and content_type, and then check if they've been overridden. + Set the method and content_type, and then check if they've been + overridden. """ self._method = self.request.method - self._content_type = self.request.META.get('HTTP_CONTENT_TYPE', self.request.META.get('CONTENT_TYPE', '')) + self._content_type = self.request.META.get('HTTP_CONTENT_TYPE', + self.request.META.get('CONTENT_TYPE', '')) self._perform_form_overloading() - def _get_stream(self): """ Returns an object that may be used to stream the request content. @@ -129,7 +126,8 @@ class RequestMixin(object): request = self.request try: - content_length = int(request.META.get('CONTENT_LENGTH', request.META.get('HTTP_CONTENT_LENGTH'))) + content_length = int(request.META.get('CONTENT_LENGTH', + request.META.get('HTTP_CONTENT_LENGTH'))) except (ValueError, TypeError): content_length = 0 @@ -138,18 +136,20 @@ class RequestMixin(object): if content_length == 0: return None elif hasattr(request, 'read'): - return request + return request return StringIO(request.raw_post_data) - def _perform_form_overloading(self): """ - If this is a form POST request, then we need to check if the method and content/content_type have been - overridden by setting them in hidden form fields or not. + If this is a form POST request, then we need to check if the method and + content/content_type have been overridden by setting them in hidden + form fields or not. """ # We only need to use form overloading on form POST requests. - if not self._USE_FORM_OVERLOADING or self._method != 'POST' or not is_form_media_type(self._content_type): + if (not self._USE_FORM_OVERLOADING + or self._method != 'POST' + or not is_form_media_type(self._content_type)): return # At this point we're committed to parsing the request as form data. @@ -167,26 +167,24 @@ class RequestMixin(object): stream = StringIO(self._data.pop(self._CONTENT_PARAM)[0]) (self._data, self._files) = self._parse(stream, self._content_type) - def _parse(self, stream, content_type): """ Parse the request content. - May raise a 415 ErrorResponse (Unsupported Media Type), or a 400 ErrorResponse (Bad Request). + May raise a 415 ErrorResponse (Unsupported Media Type), or a 400 + ErrorResponse (Bad Request). """ if stream is None or content_type is None: return (None, None) - parsers = as_tuple(self.parsers) for parser_cls in self.parsers: parser = parser_cls(self) if parser.can_handle_request(content_type): return parser.parse(stream) - raise ErrorResponse(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, - {'error': 'Unsupported media type in request \'%s\'.' % - content_type}) - + error = {'error': + "Unsupported media type in request '%s'." % content_type} + raise ErrorResponse(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, error) @property def _parsed_media_types(self): @@ -195,7 +193,6 @@ class RequestMixin(object): """ return [parser.media_type for parser in self.parsers] - @property def _default_parser(self): """ @@ -204,29 +201,34 @@ class RequestMixin(object): return self.parsers[0] - ########## ResponseMixin ########## + class ResponseMixin(object): """ Adds behavior for pluggable `Renderers` to a :class:`views.View` class. Default behavior is to use standard HTTP Accept header content negotiation. - Also supports overriding the content type by specifying an ``_accept=`` parameter in the URL. - Ignores Accept headers from Internet Explorer user agents and uses a sensible browser Accept header instead. + + Also supports overriding the content type by specifying an ``_accept=`` + parameter in the URL. + + Ignores Accept headers from Internet Explorer user agents and uses a + sensible browser Accept header instead. """ - _ACCEPT_QUERY_PARAM = '_accept' # Allow override of Accept header in URL query params + # Allow override of Accept header in URL query params + _ACCEPT_QUERY_PARAM = '_accept' _IGNORE_IE_ACCEPT_HEADER = True """ The set of response renderers that the view can handle. - Should be a tuple/list of classes as described in the :mod:`renderers` module. + Should be a tuple/list of classes as described in the :mod:`renderers` + module. """ renderers = () - # TODO: wrap this behavior around dispatch(), ensuring it works # out of the box with existing Django classes that use render_to_response. def render(self, response): @@ -253,13 +255,13 @@ class ResponseMixin(object): content = renderer.render() # Build the HTTP Response - resp = HttpResponse(content, mimetype=response.media_type, status=response.status) + resp = HttpResponse(content, mimetype=response.media_type, + status=response.status) for (key, val) in response.headers.items(): resp[key] = val return resp - def _determine_renderer(self, request): """ Determines the appropriate renderer for the output, given the client's @@ -283,10 +285,10 @@ class ResponseMixin(object): # instead. accept_list = ['text/html', '*/*'] - elif 'HTTP_USER_AGENT' in request.META: + elif 'HTTP_ACCEPT' in request.META: # Use standard HTTP Accept negotiation accept_list = [token.strip() for token in - request.META["HTTP_ACCEPT"].split(',')] + request.META['HTTP_ACCEPT'].split(',')] else: # No accept header specified @@ -295,7 +297,7 @@ class ResponseMixin(object): # Check the acceptable media types against each renderer, # attempting more specific media types first # NB. The inner loop here isn't as bad as it first looks :) - # Worst case is we're looping over len(accept_list) * len(self.renderers) + # Worst case is: len(accept_list) * len(self.renderers) renderers = [renderer_cls(self) for renderer_cls in self.renderers] for accepted_media_type_lst in order_by_precedence(accept_list): @@ -305,10 +307,9 @@ class ResponseMixin(object): return renderer, accepted_media_type # No acceptable renderers were found - raise ErrorResponse(status.HTTP_406_NOT_ACCEPTABLE, - {'detail': 'Could not satisfy the client\'s Accept header', - 'available_types': self._rendered_media_types}) - + error = {'detail': "Could not satisfy the client's Accept header", + 'available_types': self._rendered_media_types} + raise ErrorResponse(status.HTTP_406_NOT_ACCEPTABLE, error) @property def _rendered_media_types(self): @@ -336,39 +337,40 @@ class ResponseMixin(object): class AuthMixin(object): """ - Simple :class:`mixin` class to add authentication and permission checking to a :class:`View` class. + Simple :class:`mixin` class to add authentication and permission checking + to a :class:`View` class. """ """ The set of authentication types that this view can handle. - Should be a tuple/list of classes as described in the :mod:`authentication` module. + Should be a tuple/list of classes as described in the :mod:`authentication` + module. """ authentication = () """ The set of permissions that will be enforced on this view. - Should be a tuple/list of classes as described in the :mod:`permissions` module. + Should be a tuple/list of classes as described in the :mod:`permissions` + module. """ permissions = () - @property def user(self): """ - Returns the :obj:`user` for the current request, as determined by the set of - :class:`authentication` classes applied to the :class:`View`. + Returns the :obj:`user` for the current request, as determined by the + set of :class:`authentication` classes applied to the :class:`View`. """ if not hasattr(self, '_user'): self._user = self._authenticate() return self._user - def _authenticate(self): """ - Attempt to authenticate the request using each authentication class in turn. - Returns a ``User`` object, which may be ``AnonymousUser``. + Attempt to authenticate the request using each authentication class in + turn. Returns a ``User`` object, which may be ``AnonymousUser``. """ for authentication_cls in self.authentication: authentication = authentication_cls(self) @@ -377,7 +379,6 @@ class AuthMixin(object): return user return AnonymousUser() - # TODO: wrap this behavior around dispatch() def _check_permissions(self): """ @@ -397,10 +398,12 @@ class ResourceMixin(object): Should be a class as described in the :mod:`resources` module. - The :obj:`resource` is an object that maps a view onto it's representation on the server. + The :obj:`resource` is an object that maps a view onto it's representation + on the server. It provides validation on the content of incoming requests, - and filters the object representation into a serializable object for the response. + and filters the object representation into a serializable object for the + response. """ resource = None @@ -409,7 +412,8 @@ class ResourceMixin(object): """ Returns the cleaned, validated request content. - May raise an :class:`response.ErrorResponse` with status code 400 (Bad Request). + May raise an :class:`response.ErrorResponse` with status code 400 + (Bad Request). """ if not hasattr(self, '_content'): self._content = self.validate_request(self.DATA, self.FILES) @@ -420,7 +424,8 @@ class ResourceMixin(object): """ Returns the cleaned, validated query parameters. - May raise an :class:`response.ErrorResponse` with status code 400 (Bad Request). + May raise an :class:`response.ErrorResponse` with status code 400 + (Bad Request). """ return self.validate_request(self.request.GET) @@ -438,8 +443,10 @@ class ResourceMixin(object): def validate_request(self, data, files=None): """ - Given the request *data* and optional *files*, return the cleaned, validated content. - May raise an :class:`response.ErrorResponse` with status code 400 (Bad Request) on failure. + Given the request *data* and optional *files*, return the cleaned, + validated content. + May raise an :class:`response.ErrorResponse` with status code 400 + (Bad Request) on failure. """ return self._resource.validate_request(data, files) @@ -456,26 +463,28 @@ class ResourceMixin(object): return None - ########## + class InstanceMixin(object): """ - `Mixin` class that is used to identify a `View` class as being the canonical identifier - for the resources it is mapped to. + `Mixin` class that is used to identify a `View` class as being the + canonical identifier for the resources it is mapped to. """ @classmethod def as_view(cls, **initkwargs): """ - Store the callable object on the resource class that has been associated with this view. + Store the callable object on the resource class that has been + associated with this view. """ view = super(InstanceMixin, cls).as_view(**initkwargs) resource = getattr(cls(**initkwargs), 'resource', None) if resource: # We do a little dance when we store the view callable... - # we need to store it wrapped in a 1-tuple, so that inspect will treat it - # as a function when we later look it up (rather than turning it into a method). + # we need to store it wrapped in a 1-tuple, so that inspect will + # treat it as a function when we later look it up (rather than + # turning it into a method). # This makes sure our URL reversing works ok. resource.view_callable = (view,) return view @@ -483,6 +492,7 @@ class InstanceMixin(object): ########## Model Mixins ########## + class ModelMixin(object): def get_model(self): """ @@ -497,7 +507,7 @@ class ModelMixin(object): """ return getattr(self, 'queryset', getattr(self.resource, 'queryset', - self._get_model().objects.all())) + self.get_model().objects.all())) def get_ordering(self): """ @@ -507,73 +517,32 @@ class ModelMixin(object): getattr(self.resource, 'ordering', None)) + # Underlying instance API... + def get_instance(self, *args, **kwargs): """ Return a model instance or None. """ model = self.get_model() queryset = self.get_queryset() - kwargs = self._filter_kwargs(kwargs) try: - # If we have any positional args then assume the last - # represents the primary key. Otherwise assume the named kwargs - # uniquely identify the instance. - if args: - return queryset.get(pk=args[-1], **kwargs) - else: - return queryset.get(**kwargs) + return queryset.get(**kwargs) except model.DoesNotExist: return None - def read(self, request, *args, **kwargs): - instance = self.get_instance(*args, **kwargs) - return instance + def create_instance(self, *args, **kwargs): + model = self.get_model() - def update(self, request, *args, **kwargs): - """ - Return a model instance. - """ - instance = self.get_instance(*args, **kwargs) - - if instance: - for (key, val) in self.CONTENT.items(): - setattr(instance, key, val) - else: - instance = self.get_model()(**self.CONTENT) - - instance.save() - return instance - - def create(self, request, *args, **kwargs): - """ - Return a model instance. - """ - model = self._get_model() - - # Copy the dict to keep self.CONTENT intact - content = dict(self.CONTENT) m2m_data = {} - - for field in model._meta.fields: - if isinstance(field, ForeignKey) and field.name in kwargs: - # translate 'related_field' kwargs into 'related_field_id' - kwargs[field.name + '_id'] = kwargs[field.name] + for field in model._meta.many_to_many: + if field.name in kwargs: + m2m_data[field.name] = ( + field.m2m_reverse_field_name(), kwargs[field.name] + ) del kwargs[field.name] - for field in model._meta.many_to_many: - if field.name in content: - m2m_data[field.name] = ( - field.m2m_reverse_field_name(), content[field.name] - ) - del content[field.name] - - all_kw_args = dict(content.items() + kwargs.items()) - - if args: - instance = model(pk=args[-1], **all_kw_args) - else: - instance = model(**all_kw_args) + instance = model(**kwargs) instance.save() for fieldname in m2m_data: @@ -591,31 +560,81 @@ class ModelMixin(object): return instance - - def destroy(self, request, *args, **kwargs): - """ - Return a model instance or None. - """ - instance = self.get_instance(*args, **kwargs) - - if instance: - instance.delete() - + def update_instance(self, instance, *args, **kwargs): + for (key, val) in kwargs.items(): + setattr(instance, key, val) + instance.save() return instance + def delete_instance(self, instance, *args, **kwargs): + instance.delete() + return instance - def list(self, request, *args, **kwargs): - """ - Return a list of instances. - """ + def list_instances(self, *args, **kwargs): queryset = self.get_queryset() ordering = self.get_ordering() if ordering: - assert(hasattr(ordering, '__iter__')) - queryset = queryset.order_by(*args) + queryset = queryset.order_by(ordering) return queryset.filter(**kwargs) + # Request/Response layer... + + def _get_url_kwargs(self, kwargs): + format_arg = BaseRenderer._FORMAT_QUERY_PARAM + if format_arg in kwargs: + kwargs = kwargs.copy() + del kwargs[format_arg] + return kwargs + + def _get_content_kwargs(self, kwargs): + return dict(self._get_url_kwargs(kwargs).items() + + self.CONTENT.items()) + + def read(self, request, *args, **kwargs): + kwargs = self._get_url_kwargs(kwargs) + instance = self.get_instance(**kwargs) + + if instance is None: + raise ErrorResponse(status.HTTP_404_NOT_FOUND, None, {}) + + return instance + + def update(self, request, *args, **kwargs): + kwargs = self._get_url_kwargs(kwargs) + instance = self.get_instance(**kwargs) + + kwargs = self._get_content_kwargs(kwargs) + if instance: + instance = self.update_instance(instance, **kwargs) + else: + instance = self.create_instance(**kwargs) + + return instance + + def create(self, request, *args, **kwargs): + kwargs = self._get_content_kwargs(kwargs) + instance = self.create_instance(**kwargs) + + headers = {} + try: + headers['Location'] = self.resource(self).url(instance) + except: # TODO: _SkipField should not really happen. + pass + + return Response(status.HTTP_201_CREATED, instance, headers) + + def destroy(self, request, *args, **kwargs): + kwargs = self._get_url_kwargs(kwargs) + instance = self.delete_instance(**kwargs) + if not instance: + raise ErrorResponse(status.HTTP_404_NOT_FOUND, None, {}) + + return instance + + def list(self, request, *args, **kwargs): + return self.list_instances(**kwargs) + ########## Pagination Mixins ########## @@ -638,7 +657,7 @@ class PaginatorMixin(object): return self.limit def url_with_page_number(self, page_number): - """ Constructs a url used for getting the next/previous urls """ + """Constructs a url used for getting the next/previous urls.""" url = "%s?page=%d" % (self.request.path, page_number) limit = self.get_limit() @@ -648,21 +667,21 @@ class PaginatorMixin(object): return url def next(self, page): - """ Returns a url to the next page of results (if any) """ + """Returns a url to the next page of results. (If any exists.)""" if not page.has_next(): return None return self.url_with_page_number(page.next_page_number()) def previous(self, page): - """ Returns a url to the previous page of results (if any) """ + """Returns a url to the previous page of results. (If any exists.)""" if not page.has_previous(): return None return self.url_with_page_number(page.previous_page_number()) def serialize_page_info(self, page): - """ This is some useful information that is added to the response """ + """This is some useful information that is added to the response.""" return { 'next': self.next(page), 'page': page.number, @@ -676,14 +695,15 @@ class PaginatorMixin(object): """ Given the response content, paginate and then serialize. - The response is modified to include to useful data relating to the number - of objects, number of pages, next/previous urls etc. etc. + The response is modified to include to useful data relating to the + number of objects, number of pages, next/previous urls etc. etc. The serialised objects are put into `results` on this new, modified response """ - # We don't want to paginate responses for anything other than GET requests + # We don't want to paginate responses for anything other than GET + # requests if self.method.upper() != 'GET': return self._resource.filter_response(obj) diff --git a/djangorestframework/tests/renderers.py b/djangorestframework/tests/renderers.py index 997fd5103..023de54b9 100644 --- a/djangorestframework/tests/renderers.py +++ b/djangorestframework/tests/renderers.py @@ -1,15 +1,13 @@ from django.conf.urls.defaults import patterns, url -from django import http from django.test import TestCase from djangorestframework import status from djangorestframework.compat import View as DjangoView -from djangorestframework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer,\ - XMLRenderer +from djangorestframework.renderers import BaseRenderer, JSONRenderer, \ + YAMLRenderer, XMLRenderer from djangorestframework.parsers import JSONParser, YAMLParser from djangorestframework.mixins import ResponseMixin from djangorestframework.response import Response -from djangorestframework.utils.mediatypes import add_media_type_param from StringIO import StringIO import datetime @@ -21,27 +19,30 @@ DUMMYCONTENT = 'dummycontent' RENDERER_A_SERIALIZER = lambda x: 'Renderer A: %s' % x RENDERER_B_SERIALIZER = lambda x: 'Renderer B: %s' % x + class RendererA(BaseRenderer): media_type = 'mock/renderera' - format="formata" + format = "formata" def render(self, obj=None, media_type=None): return RENDERER_A_SERIALIZER(obj) + class RendererB(BaseRenderer): media_type = 'mock/rendererb' - format="formatb" + format = "formatb" def render(self, obj=None, media_type=None): return RENDERER_B_SERIALIZER(obj) + class MockView(ResponseMixin, DjangoView): renderers = (RendererA, RendererB) def get(self, request, **kwargs): response = Response(DUMMYSTATUS, DUMMYCONTENT) return self.render(response) - + urlpatterns = patterns('', url(r'^.*\.(?P.+)$', MockView.as_view(renderers=[RendererA, RendererB])), @@ -92,7 +93,7 @@ class RendererIntegrationTests(TestCase): self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEquals(resp.status_code, DUMMYSTATUS) - + def test_specified_renderer_serializes_content_on_accept_query(self): """The '_accept' query string should behave in the same way as the Accept header.""" resp = self.client.get('/?_accept=%s' % RendererB.media_type) @@ -148,12 +149,7 @@ class RendererIntegrationTests(TestCase): _flat_repr = '{"foo": ["bar", "baz"]}' -_indented_repr = """{ - "foo": [ - "bar", - "baz" - ] -}""" +_indented_repr = '{\n "foo": [\n "bar", \n "baz"\n ]\n}' class JSONRendererTests(TestCase): @@ -165,45 +161,44 @@ class JSONRendererTests(TestCase): """ Test basic JSON rendering. """ - obj = {'foo':['bar','baz']} + obj = {'foo': ['bar', 'baz']} renderer = JSONRenderer(None) content = renderer.render(obj, 'application/json') self.assertEquals(content, _flat_repr) def test_with_content_type_args(self): """ - Test JSON rendering with additional content type arguments supplied. + Test JSON rendering with additional content type arguments supplied. """ - obj = {'foo':['bar','baz']} + obj = {'foo': ['bar', 'baz']} renderer = JSONRenderer(None) - content = renderer.render(obj, 'application/json; indent=2') + content = renderer.render(obj, 'application/json; indent=4') self.assertEquals(content, _indented_repr) - + def test_render_and_parse(self): """ Test rendering and then parsing returns the original object. IE obj -> render -> parse -> obj. """ - obj = {'foo':['bar','baz']} + obj = {'foo': ['bar', 'baz']} renderer = JSONRenderer(None) parser = JSONParser(None) content = renderer.render(obj, 'application/json') (data, files) = parser.parse(StringIO(content)) - self.assertEquals(obj, data) - + self.assertEquals(obj, data) if YAMLRenderer: _yaml_repr = 'foo: [bar, baz]\n' - - + + class YAMLRendererTests(TestCase): """ Tests specific to the JSON Renderer """ - + def test_render(self): """ Test basic YAML rendering. @@ -212,24 +207,24 @@ if YAMLRenderer: renderer = YAMLRenderer(None) content = renderer.render(obj, 'application/yaml') self.assertEquals(content, _yaml_repr) - - + + def test_render_and_parse(self): """ Test rendering and then parsing returns the original object. IE obj -> render -> parse -> obj. """ obj = {'foo':['bar','baz']} - + renderer = YAMLRenderer(None) parser = YAMLParser(None) - + content = renderer.render(obj, 'application/yaml') (data, files) = parser.parse(StringIO(content)) - self.assertEquals(obj, data) + self.assertEquals(obj, data) + - class XMLRendererTestCase(TestCase): """ Tests specific to the XML Renderer @@ -289,4 +284,4 @@ class XMLRendererTestCase(TestCase): def assertXMLContains(self, xml, string): self.assertTrue(xml.startswith('\n')) self.assertTrue(xml.endswith('')) - self.assertTrue(string in xml, '%r not in %r' % (string, xml)) + self.assertTrue(string in xml, '%r not in %r' % (string, xml)) diff --git a/djangorestframework/utils/__init__.py b/djangorestframework/utils/__init__.py index 7d693cc44..86fa4a295 100644 --- a/djangorestframework/utils/__init__.py +++ b/djangorestframework/utils/__init__.py @@ -32,7 +32,7 @@ def url_resolves(url): # From http://www.koders.com/python/fidB6E125C586A6F49EAC38992CF3AFDAAE35651975.aspx?s=mdef:xml #class object_dict(dict): -# """object view of dict, you can +# """object view of dict, you can # >>> a = object_dict() # >>> a.fish = 'fish' # >>> a['fish'] @@ -85,8 +85,8 @@ class XML2Dict(object): old = node_tree[tag] if not isinstance(old, list): node_tree.pop(tag) - node_tree[tag] = [old] # multi times, so change old dict to a list - node_tree[tag].append(tree) # add the new one + node_tree[tag] = [old] # multi times, so change old dict to a list + node_tree[tag].append(tree) # add the new one return node_tree @@ -99,13 +99,13 @@ class XML2Dict(object): """ result = re.compile("\{(.*)\}(.*)").search(tag) if result: - value.namespace, tag = result.groups() + value.namespace, tag = result.groups() return (tag, value) def parse(self, file): """parse a xml file to a dict""" f = open(file, 'r') - return self.fromstring(f.read()) + return self.fromstring(f.read()) def fromstring(self, s): """parse a string""" @@ -132,16 +132,16 @@ class XMLRenderer(): xml.startElement(key, {}) self._to_xml(xml, value) xml.endElement(key) - + elif data is None: # Don't output any value - pass + pass else: xml.characters(smart_unicode(data)) def dict2xml(self, data): - stream = StringIO.StringIO() + stream = StringIO.StringIO() xml = SimplerXMLGenerator(stream, "utf-8") xml.startDocument() @@ -154,4 +154,4 @@ class XMLRenderer(): return stream.getvalue() def dict2xml(input): - return XMLRenderer().dict2xml(input) \ No newline at end of file + return XMLRenderer().dict2xml(input) diff --git a/djangorestframework/views.py b/djangorestframework/views.py index 4c472e2dc..d449636db 100644 --- a/djangorestframework/views.py +++ b/djangorestframework/views.py @@ -50,13 +50,13 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView): """ List of all authenticating methods to attempt. """ - authentication = ( authentication.UserLoggedInAuthentication, - authentication.BasicAuthentication ) + authentication = (authentication.UserLoggedInAuthentication, + authentication.BasicAuthentication) """ List of all permissions that must be checked. """ - permissions = ( permissions.FullAnonAccess, ) + permissions = (permissions.FullAnonAccess,) @classmethod def as_view(cls, **initkwargs): @@ -86,8 +86,8 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView): def initial(self, request, *args, **kargs): """ Hook for any code that needs to run prior to anything else. - Required if you want to do things like set `request.upload_handlers` before - the authentication and dispatch handling is run. + Required if you want to do things like set `request.upload_handlers` + before the authentication and dispatch handling is run. """ pass @@ -136,11 +136,13 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView): response = Response(status.HTTP_204_NO_CONTENT) if request.method == 'OPTIONS': - # do not filter the response for HTTP OPTIONS, else the response fields are lost, + # do not filter the response for HTTP OPTIONS, + # else the response fields are lost, # as they do not correspond with model fields response.cleaned_content = response.raw_content else: - # Pre-serialize filtering (eg filter complex objects into natively serializable types) + # Pre-serialize filtering (eg filter complex objects into + # natively serializable types) response.cleaned_content = self.filter_response(response.raw_content) except ErrorResponse, exc: @@ -148,8 +150,8 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView): # Always add these headers. # - # TODO - this isn't actually the correct way to set the vary header, - # also it's currently sub-optimal for HTTP caching - need to sort that out. + # TODO - this isn't really the correct way to set the Vary header, + # also it's currently sub-optimal for HTTP caching. response.headers['Allow'] = ', '.join(self.allowed_methods) response.headers['Vary'] = 'Authenticate, Accept' @@ -161,7 +163,7 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView): return self.render(response) def options(self, request, *args, **kwargs): - response_obj = { + ret = { 'name': get_name(self), 'description': get_description(self), 'renders': self._rendered_media_types, @@ -172,8 +174,8 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView): field_name_types = {} for name, field in form.fields.iteritems(): field_name_types[name] = field.__class__.__name__ - response_obj['fields'] = field_name_types - return response_obj + ret['fields'] = field_name_types + return ret class ModelView(ModelMixin, View): @@ -191,7 +193,9 @@ class ModelView(ModelMixin, View): class InstanceModelView(ModelView): """ - A view which provides default operations for read/update/delete against a model instance. + A view which provides default operations for read/update/delete against a + model instance. This view is also treated as the Canonical identifier + of the instances. """ _suffix = 'Instance'