Coverage report: + 89% +
+
+
+
+
+
+
+ 
+ Hot-keys on this page
++ n + s + m + x + + c change column sorting +
+| Module | +statements | +missing | +excluded | + +coverage | +
|---|---|---|---|---|
| Total | +3621 | +406 | +0 | + +89% | +
| rest_framework/__init__ | +4 | +0 | +0 | + +100% | +
| rest_framework/authentication | +169 | +33 | +0 | + +80% | +
| rest_framework/authtoken/__init__ | +0 | +0 | +0 | + +100% | +
| rest_framework/authtoken/models | +21 | +1 | +0 | + +95% | +
| rest_framework/authtoken/serializers | +17 | +2 | +0 | + +88% | +
| rest_framework/authtoken/views | +21 | +0 | +0 | + +100% | +
| rest_framework/decorators | +60 | +0 | +0 | + +100% | +
| rest_framework/exceptions | +51 | +2 | +0 | + +96% | +
| rest_framework/fields | +594 | +80 | +0 | + +87% | +
| rest_framework/filters | +77 | +6 | +0 | + +92% | +
| rest_framework/generics | +196 | +34 | +0 | + +83% | +
| rest_framework/mixins | +97 | +7 | +0 | + +93% | +
| rest_framework/models | +0 | +0 | +0 | + +100% | +
| rest_framework/negotiation | +41 | +4 | +0 | + +90% | +
| rest_framework/pagination | +43 | +0 | +0 | + +100% | +
| rest_framework/parsers | +153 | +13 | +0 | + +92% | +
| rest_framework/permissions | +63 | +12 | +0 | + +81% | +
| rest_framework/relations | +365 | +88 | +0 | + +76% | +
| rest_framework/renderers | +282 | +23 | +0 | + +92% | +
| rest_framework/request | +161 | +8 | +0 | + +95% | +
| rest_framework/response | +42 | +1 | +0 | + +98% | +
| rest_framework/reverse | +12 | +3 | +0 | + +75% | +
| rest_framework/routers | +108 | +7 | +0 | + +94% | +
| rest_framework/serializers | +464 | +27 | +0 | + +94% | +
| rest_framework/settings | +44 | +2 | +0 | + +95% | +
| rest_framework/status | +46 | +0 | +0 | + +100% | +
| rest_framework/throttling | +90 | +17 | +0 | + +81% | +
| rest_framework/urlpatterns | +31 | +4 | +0 | + +87% | +
| rest_framework/urls | +4 | +0 | +0 | + +100% | +
| rest_framework/utils/__init__ | +0 | +0 | +0 | + +100% | +
| rest_framework/utils/breadcrumbs | +27 | +0 | +0 | + +100% | +
| rest_framework/utils/encoders | +70 | +19 | +0 | + +73% | +
| rest_framework/utils/formatting | +39 | +1 | +0 | + +97% | +
| rest_framework/utils/mediatypes | +44 | +10 | +0 | + +77% | +
| rest_framework/views | +146 | +0 | +0 | + +100% | +
| rest_framework/viewsets | +39 | +2 | +0 | + +95% | +
| t |
| + + + + + + + + + + + | +
+
+ + + + # Header encoding (see RFC5987) + ++ # Default datetime input and output formats + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Provides various authentication policies. +""" + + + ++ + + + + + + + + + + """ +Return request's 'Authorization:' header, as a bytestring. ++ Hide some test client ickyness where the header can be unicode. +""" + + +# Work around django test client oddness + + ++ + + """ +All authentication classes should extend BaseAuthentication. +""" ++ + """ +Authenticate the request and return a two-tuple of (user, token). +""" +raise NotImplementedError(".authenticate() must be overridden.") ++ + """ +Return a string to be used as the value of the `WWW-Authenticate` +header in a `401 Unauthenticated` response, or `None` if the +authentication scheme should return `403 Permission Denied` responses. +""" + ++ + + """ +HTTP Basic authentication against username/password. +""" + ++ + """ +Returns a `User` if a correct username and password have been supplied +using HTTP Basic authentication. Otherwise returns `None`. +""" + ++ + + + + msg = 'Invalid basic header. No credentials provided.' +raise exceptions.AuthenticationFailed(msg) + +msg = 'Invalid basic header. Credentials string should not contain spaces.' +raise exceptions.AuthenticationFailed(msg) ++ + + except (TypeError, UnicodeDecodeError): +msg = 'Invalid basic header. Credentials not correctly base64 encoded' +raise exceptions.AuthenticationFailed(msg) ++ + + + + """ +Authenticate the userid and password against username and password. +""" + + +raise exceptions.AuthenticationFailed('Invalid username/password') + ++ + + + + + """ +Use Django's session framework for authentication. +""" ++ + """ +Returns a `User` if the request session currently has a logged in user. +Otherwise returns `None`. +""" ++ # Get the underlying HttpRequest object + + ++ # Unauthenticated, CSRF validation not required + + ++ # Enforce CSRF validation for session based authentication. + + +# Return the failure reason instead of an HttpResponse + ++ + + # CSRF failed, bail with explicit error message + ++ # CSRF passed with authenticated user + ++ + + """ +Simple token based authentication. ++ Clients should authenticate by passing the token key in the "Authorization" +HTTP header, prepended with the string "Token ". For example: ++ Authorization: Token 401f7ac837da42b97f613d789819ff93537bee6a +""" ++ + """ +A custom token model may be used, but must have the following properties. ++ * key -- The string identifying the token +* user -- The user to which the token belongs +""" ++ + + + + + + + msg = 'Invalid token header. No credentials provided.' +raise exceptions.AuthenticationFailed(msg) + +msg = 'Invalid token header. Token string should not contain spaces.' +raise exceptions.AuthenticationFailed(msg) ++ + + + + + except self.model.DoesNotExist: +raise exceptions.AuthenticationFailed('Invalid token') ++ + raise exceptions.AuthenticationFailed('User inactive or deleted') ++ + + + + + + + """ +OAuth 1.0a authentication backend using `django-oauth-plus` and `oauth2`. ++ Note: The `oauth2` package actually provides oauth1.0a support. Urg. +We import it from the `compat` module as `oauth`. +""" + ++ + + + + raise ImproperlyConfigured( +"The 'oauth2' package could not be imported." +"It is required for use with the 'OAuthAuthentication' class.") ++ + raise ImproperlyConfigured( +"The 'django-oauth-plus' package could not be imported." +"It is required for use with the 'OAuthAuthentication' class.") ++ + """ +Returns two-tuple of (user, token) if authentication succeeds, +or None otherwise. +""" + + +except oauth.Error as err: +raise exceptions.AuthenticationFailed(err.message) ++ + return None ++ + + + + + + # OAuth authentication was not attempted. +return None ++ + # OAuth was attempted but missing parameters. +msg = 'Missing parameters: %s' % (', '.join(missing)) +raise exceptions.AuthenticationFailed(msg) ++ + + + + + + + + + + + + + + + + + + + + + + + + except oauth.Error as err: +raise exceptions.AuthenticationFailed(err.message) ++ + + + msg = 'User inactive or deleted: %s' % user.username +raise exceptions.AuthenticationFailed(msg) ++ + + + """ +If permission is denied, return a '401 Unauthorized' response, +with an appropraite 'WWW-Authenticate' header. +""" + ++ + """ +Check the token and raise an `oauth.Error` exception if invalid. +""" + + ++ + """ +Checks nonce of request, and return True if valid. +""" + ++ + + """ +OAuth 2 authentication backend using `django-oauth2-provider` +""" + ++ + + + + raise ImproperlyConfigured( +"The 'django-oauth2-provider' package could not be imported. " +"It is required for use with the 'OAuth2Authentication' class.") ++ + """ +Returns two-tuple of (user, token) if authentication succeeds, +or None otherwise. +""" ++ + + + + + + msg = 'Invalid bearer header. No credentials provided.' +raise exceptions.AuthenticationFailed(msg) + + + ++ + + + """ +Authenticate the request, given the access token. +""" ++ + + # TODO: Change to timezone aware datetime when oauth2_provider add +# support to it. + + + ++ + + + msg = 'User inactive or deleted: %s' % user.username +raise exceptions.AuthenticationFailed(msg) ++ + + + """ +Bearer is the only finalized type currently ++ Check details on the `OAuth2Authentication.authenticate` method +""" + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + | ++ + | +
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+
+
+
+
+
+
+ + + + """ +The default authorization token model. +""" + + + ++ + # Work around for a bug in Django: +# https://code.djangoproject.com/ticket/19422 +# +# Also see corresponding ticket: +# https://github.com/tomchristie/django-rest-framework/issues/705 + ++ + + + + + + + + + + return self.key + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+
+
+ + + + + + + + + + + + + + + + raise serializers.ValidationError('User account is disabled.') + + +else: + +else: +raise serializers.ValidationError('Must include "username" and "password"') + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+
+
+
+
+
+
+
+ + + + + + + + + + + + + + + + + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +The most important decorator in this module is `@api_view`, which is used +for writing function-based views with REST framework. ++ There are also various decorators for setting the API policies on function +based views, as well as the `@action` and `@link` decorators, which are +used to annotate methods on viewsets that should be included by routers. +""" + + + + ++ + + + """ +Decorator that converts a function-based view into an APIView subclass. +Takes a list of allowed methods for the view as an argument. +""" ++ + + + six.PY3 and 'WrappedAPIView' or b'WrappedAPIView', +(APIView,), +{'__doc__': func.__doc__} +) ++ # Note, the above allows us to set the docstring. +# It is the equivalent of: +# +# class WrappedAPIView(APIView): +# pass +# WrappedAPIView.__doc__ = func.doc <--- Not possible to do this ++ # api_view applied without (method_names) + +'@api_view missing list of allowed HTTP methods' ++ # api_view applied with eg. string instead of list of strings + +'@api_view expected a list of strings, received %s' % type(http_method_names).__name__ ++ + + + + + + + + + + + + APIView.renderer_classes) ++ + APIView.parser_classes) ++ + APIView.authentication_classes) ++ + APIView.throttle_classes) ++ + APIView.permission_classes) ++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + """ +Used to mark a method on a ViewSet that should be routed for GET requests. +""" + + + + + ++ + + """ +Used to mark a method on a ViewSet that should be routed for POST requests. +""" + + + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Handled exceptions raised by REST framework. ++ In addition Django's built in 403 and 404 exceptions are handled. +(`django.http.Http404` and `django.core.exceptions.PermissionDenied`) +""" + + ++ + + """ +Base class for REST framework exceptions. +Subclasses should provide `.status_code` and `.detail` properties. +""" + ++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + self.detail = (detail or self.default_detail) % media_type ++ + + + + + + + + + + + + else: +self.detail = detail or self.default_detail + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Serializer fields perform validation on incoming data. ++ They are very similar to Django's form fields. +""" + ++ + + + + + + + + + + + + + + + + + timezone, parse_date, parse_datetime, parse_time, BytesIO, six, smart_text, +force_text, is_non_str_iterable +) + ++ + + """ +True if the object is a callable that takes no arguments. +""" + + ++ + + + + + + + + + + """ +Given an object, and an attribute name, +return that attribute on the object. +""" + + +else: + ++ + + + + + + + 'YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HHMM|-HHMM|Z]') + ++ + + + + + + + + + + + + # Note that we're missing some of the locale specific mappings that +# don't really make sense. + +"%Y": "YYYY", +"%y": "YY", +"%m": "MM", +"%b": "[Jan-Dec]", +"%B": "[January-December]", +"%d": "DD", +"%H": "hh", +"%I": "hh", # Requires '%p' to differentiate from '%H'. +"%M": "mm", +"%S": "ss", +"%f": "uuuuuu", +"%a": "[Mon-Sun]", +"%A": "[Monday-Sunday]", +"%p": "[AM|PM]", +"%z": "[+HHMM|-HHMM]" +} + + + ++ + + + + + + + + + + + + + + + + + + + + + + + + + + """ +Called to set up a field prior to field_to_native or field_from_native. ++ parent - The parent serializer. +model_field - The model field this field corresponds to, if one exists. +""" + + + + + + ++ + """ +Given a dictionary and a field name, updates the dictionary `into`, +with the field and it's deserialized value. +""" + ++ + """ +Given and object and a field name, returns the value that should be +serialized for that field. +""" + + ++ + + + + + + + + + + + + + + """ +Converts the field's value into it's simple representation. +""" + +value = value() ++ + + + not isinstance(value, (dict, six.string_types))): + + +# Make sure we preserve field ordering, if it exists + + + + + ++ + """ +Returns a dictionary of attributes to be used when serializing to xml. +""" +if self.type_name: +return {'type': self.type_name} +return {} ++ + + + + + 'min_length', 'max_length'] + + + + + ++ + + """ +Base for read/write fields. +""" + + +'required': _('This field is required.'), +'invalid': _('Invalid value.'), +} + + ++ + read_only=False, required=None, +validators=[], error_messages=None, widget=None, +default=None, blank=None): ++ # 'blank' is to be deprecated in favor of 'required' + +warnings.warn('The `blank` keyword argument is deprecated. ' +'Use the `required` keyword argument instead.', +DeprecationWarning, stacklevel=2) +required = not(blank) ++ + + + + + else: + + ++ + + + + + + + + + # Widgets are ony used for HTML forms. + + + + ++ + + + + + + + + + + + + + + + + + + + + + + + else: + + + ++ + """ +Given a dictionary and a field name, updates the dictionary `into`, +with the field and it's deserialized value. +""" + + ++ + + + + else: + + + +# Note: partial updates shouldn't set defaults + + +else: + +else: + + + ++ + + if value: +into.update(value) +else: + + + ++ + """ +Reverts a simple representation back to the field's value. +""" + ++ + + """ +A generic field that can be used against an arbitrary model field. +""" + + + +except KeyError: +raise ValueError("ModelField requires 'model_field' kwarg") ++ + getattr(self.model_field, 'min_length', None)) + +getattr(self.model_field, 'max_length', None)) + +getattr(self.model_field, 'min_value', None)) + +getattr(self.model_field, 'max_value', None)) ++ + + + self.validators.append(validators.MinLengthValidator(self.min_length)) + + + + + +self.validators.append(validators.MaxValueValidator(self.max_value)) ++ + + + return rel.to._meta.get_field(rel.field_name).to_python(value) +else: + ++ + + + + return self.model_field.value_to_string(obj) ++ + return { +"type": self.model_field.get_internal_type() +} ++ + ##### Typed Fields ##### ++ + + + + + + 'invalid': _("'%s' value must be either True or False."), +} + ++ # Note: we set default to `False` in order to fill in missing value not +# supplied by html form. TODO: Fix so that only html form input gets +# this behavior. + ++ + + return True + +return False + ++ + + + + + + + + + + self.validators.append(validators.MinLengthValidator(min_length)) + + ++ + + + return smart_text(value) ++ + + + + + + + + + + + + + + + + 'invalid': _("Enter a valid 'slug' consisting of letters, numbers," +" underscores or hyphens."), +} + ++ + + + + + + + + + + 'invalid_choice': _('Select a valid choice. %(value)s is not one of ' +'the available choices.'), +} ++ + + + + + + + + + + # Setting choices also sets the choices on the widget. +# choices can be any iterable, but we call list() on it because +# it will be consumed more than once. + ++ + + + """ +Validates that the input is in self.choices. +""" + + +raise ValidationError(self.error_messages['invalid_choice'] % {'value': value}) ++ + """ +Check to see if the provided value is a valid choice. +""" + + +# This is an optgroup, so look inside the group for options +for k2, v2 in v: +if value == smart_text(k2): +return True +else: + + +return False ++ + + + + + + + 'invalid': _('Enter a valid e-mail address.'), +} + ++ + + + return None + ++ + + + + + + + + + + + return self._regex ++ + + + + + self.validators.remove(self._regex_validator) + + ++ + + + + + + + + + + 'invalid': _("Date has wrong format. Use one of these formats instead: %s"), +} + + + ++ + + + + + + + + + + if timezone and settings.USE_TZ and timezone.is_aware(value): +# Convert aware datetimes to the default time zone +# before casting them to dates (#17742). +default_timezone = timezone.get_default_timezone() +value = timezone.make_naive(value, default_timezone) +return value.date() + + ++ + + + + + + else: + + +else: + + + + +else: + ++ + + + + + + + + value = value.date() ++ + + + + + + + + + + + + 'invalid': _("Datetime has wrong format. Use one of these formats instead: %s"), +} + + + ++ + + + + + + + + + + + + value = datetime.datetime(value.year, value.month, value.day) +if settings.USE_TZ: +# For backwards compatibility, interpret naive datetimes in +# local time. This won't work during DST change, but we can't +# do much about it, so we let the exceptions percolate up the +# call stack. +warnings.warn("DateTimeField received a naive datetime (%s)" +" while time zone support is active." % value, +RuntimeWarning) +default_timezone = timezone.get_default_timezone() +value = timezone.make_aware(value, default_timezone) +return value ++ + + + + + + else: + + +else: + + + + +else: + ++ + + + + + + + + + + ret = ret[:-6] + 'Z' + + ++ + + + + + + + + 'invalid': _("Time has wrong format. Use one of these formats instead: %s"), +} + + + ++ + + + + + + + + + + + + + + + + + + else: + + +else: + + + + +else: + ++ + + + + + + + + value = value.time() ++ + + + + + + + + + + + 'invalid': _('Enter a whole number.'), +'max_value': _('Ensure this value is less than or equal to %(limit_value)s.'), +'min_value': _('Ensure this value is greater than or equal to %(limit_value)s.'), +} ++ + + + + + self.validators.append(validators.MaxValueValidator(max_value)) + + ++ + + return None ++ + + + + + + + + + + + + + 'invalid': _("'%s' value must be a float."), +} ++ + if value in validators.EMPTY_VALUES: +return None ++ try: +return float(value) +except (TypeError, ValueError): +msg = self.error_messages['invalid'] % value +raise ValidationError(msg) ++ + + + + + + + 'invalid': _('Enter a number.'), +'max_value': _('Ensure this value is less than or equal to %(limit_value)s.'), +'min_value': _('Ensure this value is greater than or equal to %(limit_value)s.'), +'max_digits': _('Ensure that there are no more than %s digits in total.'), +'max_decimal_places': _('Ensure that there are no more than %s decimal places.'), +'max_whole_digits': _('Ensure that there are no more than %s digits before the decimal point.') +} ++ + + + + + + + + + + + """ +Validates that the input is a decimal number. Returns a Decimal +instance. Returns None for empty values. Ensures that there are no more +than max_digits in the number, and no more than decimal_places digits +after the decimal point. +""" + + + + + + + + ++ + + + return +# Check for NaN, Inf and -Inf values. We can't compare directly for NaN, +# since it is never equal to itself. However, NaN is the only value that +# isn't equal to itself, so we can use this to identify NaN + +raise ValidationError(self.error_messages['invalid']) + + +# digittuple doesn't include any leading zeros. + + +# We have leading zeros up to or past the decimal point. Count +# everything past the decimal point as a digit. We do not count +# 0 before the decimal point as a digit since that would mean +# we would not allow max_digits = decimal_places. +digits = decimals + ++ + + + + + raise ValidationError(self.error_messages['max_whole_digits'] % (self.max_digits - self.decimal_places)) + ++ + + + + + + + + + 'invalid': _("No file was submitted. Check the encoding type on the form."), +'missing': _("No file was submitted."), +'empty': _("The submitted file is empty."), +'max_length': _('Ensure this filename has at most %(max)d characters (it has %(length)d).'), +'contradiction': _('Please either submit a file or check the clear checkbox, not both.') +} ++ + + + + + + + return None ++ # UploadedFile objects should have name and size attributes. + + + +except AttributeError: +raise ValidationError(self.error_messages['invalid']) ++ + error_values = {'max': self.max_length, 'length': len(file_name)} +raise ValidationError(self.error_messages['max_length'] % error_values) + +raise ValidationError(self.error_messages['invalid']) + +raise ValidationError(self.error_messages['empty']) ++ + + + return value.name ++ + + + + + + + + 'invalid_image': _("Upload a valid image. The file you uploaded was " +"either not an image or a corrupted image."), +} ++ + """ +Checks that the file-upload field data contains a valid image (GIF, JPG, +PNG, possibly others -- whatever the Python Imaging Library supports). +""" +f = super(ImageField, self).from_native(data) +if f is None: +return None ++ from compat import Image +assert Image is not None, 'PIL must be installed for ImageField support' ++ # We need to get a file object for PIL. We might have a path or we might +# have to read the data into memory. +if hasattr(data, 'temporary_file_path'): +file = data.temporary_file_path() +else: +if hasattr(data, 'read'): +file = BytesIO(data.read()) +else: +file = BytesIO(data['content']) ++ try: +# load() could spot a truncated JPEG, but it loads the entire +# image in memory, which is a DoS vector. See #3848 and #18520. +# verify() must be called immediately after the constructor. +Image.open(file).verify() +except ImportError: +# Under PyPy, it is possible to import PIL. However, the underlying +# _imaging C module isn't available, so an ImportError will be +# raised. Catch and re-raise. +raise +except Exception: # Python Imaging Library doesn't recognize it as an image +raise ValidationError(self.error_messages['invalid_image']) +if hasattr(f, 'seek') and callable(f.seek): +f.seek(0) +return f ++ + + """ +A field that gets its value by calling a method on the serializer it's attached to. +""" ++ + + + + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Provides generic filtering backends that can be used to filter the results +returned by list views. +""" + + + + + ++ + + + + """ +A base class from which all filter backend classes should inherit. +""" ++ + """ +Return a filtered queryset. +""" +raise NotImplementedError(".filter_queryset() must be overridden.") ++ + + """ +A filter backend that uses django-filter. +""" + ++ + + + + """ +Return the django-filters `FilterSet` used to filter the queryset. +""" + + ++ + + + + 'FilterSet model %s does not match queryset model %s' % \ +(filter_model, queryset.model) ++ + + + + + + + + + return None ++ + + + + + + return queryset ++ + + + + + """ +Search terms are set by a ?search=... query parameter, +and may be comma and/or whitespace delimited. +""" + + ++ + + + + + + return "%s__search" % field_name[1:] +else: + ++ + + + + return queryset ++ + for search_field in search_fields] ++ + + for orm_lookup in orm_lookups] + ++ + + + + + + + """ +Search terms are set by a ?search=... query parameter, +and may be comma and/or whitespace delimited. +""" + + + ++ + + + + + + + + + + + + + + # Skip any incorrect parameters + ++ + # Use 'ordering' attribtue by default + ++ + + + return queryset + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Generic views that provide commonly needed behaviour. +""" + ++ + + + + + + + + + + + + """ +Same as Django's standard shortcut, but make sure to raise 404 +if the filter_kwargs don't match the required types. +""" + + + + ++ + + """ +Base class for all other generic views. +""" ++ # You'll need to either set these attributes, +# or override `get_queryset()`/`get_serializer_class()`. + + ++ # This shortcut may be used instead of setting either or both +# of the `queryset`/`serializer_class` attributes, although using +# the explicit style is generally preferred. + ++ # If you want to use object lookups other than pk, set this attribute. +# For more complex lookup requirements override `get_object()`. + ++ # Pagination settings + + + + ++ # The filter backend classes to use for queryset filtering + ++ # The following attributes may be subject to change, +# and should be considered private API. + + ++ ###################################### +# These are pending deprecation... ++ + + + + + + + """ +Extra context provided to the serializer class. +""" + +'request': self.request, +'format': self.format_kwarg, +'view': self +} ++ + files=None, many=False, partial=False): +""" +Return the serializer instance that should be used for validating and +deserializing input, and for serializing output. +""" + + + +many=many, partial=partial, context=context) ++ + """ +Return a serializer instance to use with paginated data. +""" + + + ++ + + + + + """ +Paginate a queryset if required, either returning a page object, +or `None` if pagination is not configured for this view. +""" + + +warnings.warn('The `page_size` parameter to `paginate_queryset()` ' +'is due to be deprecated. ' +'Note that the return style of this method is also ' +'changed, and will simply return a page object ' +'when called without a `page_size` argument.', +PendingDeprecationWarning, stacklevel=2) +deprecated_style = True +else: +# Determine the required page size. +# If pagination is not configured, simply return None. + + + ++ + warnings.warn( +'The `allow_empty` parameter is due to be deprecated. ' +'To use `allow_empty=False` style behavior, You should override ' +'`get_queryset()` and explicitly raise a 404 on empty querysets.', +PendingDeprecationWarning, stacklevel=2 +) ++ + allow_empty_first_page=self.allow_empty) + + + + + +except ValueError: +if page == 'last': +page_number = paginator.num_pages +else: +raise Http404(_("Page is not 'last', nor can it be converted to an int.")) + + +except InvalidPage as e: +raise Http404(_('Invalid page (%(page_number)s): %(message)s') % { +'page_number': page_number, +'message': str(e) +}) ++ + return (paginator, page, page.object_list, page.has_other_pages()) + ++ + """ +Given a queryset, filter it with whichever filter backend is in use. ++ You are unlikely to want to override this method, although you may need +to call it either from a list view, or from a custom `get_object` +method if you want to apply the configured filtering backend to the +default queryset. +""" + + +warnings.warn( +'The `filter_backend` attribute and `FILTER_BACKEND` setting ' +'are due to be deprecated in favor of a `filter_backends` ' +'attribute and `DEFAULT_FILTER_BACKENDS` setting, that take ' +'a *list* of filter backend classes.', +PendingDeprecationWarning, stacklevel=2 +) +filter_backends = [self.filter_backend] ++ + + + + ######################## +### The following methods provide default implementations +### that you may want to override for more complex cases. ++ + """ +Return the size of pages to use with pagination. ++ If `PAGINATE_BY_PARAM` is set it will attempt to get the page size +from a named query parameter in the url, eg. ?page_size=100 ++ Otherwise defaults to using `self.paginate_by`. +""" + +warnings.warn('The `queryset` parameter to `get_paginate_by()` ' +'is due to be deprecated.', +PendingDeprecationWarning, stacklevel=2) ++ + + + + + + + + + + """ +Return the class to use for the serializer. +Defaults to using `self.serializer_class`. ++ You may want to override this if you need to provide different +serializations depending on the incoming request. ++ (Eg. admins get full serialization, others get basic serialization) +""" + + + ++ + "'%s' should either include a 'serializer_class' attribute, " \ +"or use the 'model' attribute as a shortcut for " \ +"automatically generating a serializer class." \ +% self.__class__.__name__ ++ + + + + + + """ +Get the list of items for this view. +This must be an iterable, and may be a queryset. +Defaults to using `self.queryset`. ++ You may want to override this if you need to provide different +querysets depending on the incoming request. ++ (Eg. return a list of items that is specific to the user) +""" + + ++ + + + raise ImproperlyConfigured("'%s' must define 'queryset' or 'model'" +% self.__class__.__name__) ++ + """ +Returns the object the view is displaying. ++ You may want to override this if you need to provide non-standard +queryset lookups. Eg if objects are referenced using multiple +keyword arguments in the url conf. +""" +# Determine the base queryset to use. + + +else: +pass # Deprecation warning ++ # Perform the lookup filtering. + + + ++ + + elif pk is not None and self.lookup_field == 'pk': +warnings.warn( +'The `pk_url_kwarg` attribute is due to be deprecated. ' +'Use the `lookup_field` attribute instead', +PendingDeprecationWarning +) +filter_kwargs = {'pk': pk} +elif slug is not None and self.lookup_field == 'pk': +warnings.warn( +'The `slug_url_kwarg` attribute is due to be deprecated. ' +'Use the `lookup_field` attribute instead', +PendingDeprecationWarning +) +filter_kwargs = {self.slug_field: slug} +else: +raise ImproperlyConfigured( +'Expected view %s to be called with a URL keyword argument ' +'named "%s". Fix your URL conf, or set the `.lookup_field` ' +'attribute on the view correctly.' % +(self.__class__.__name__, self.lookup_field) +) ++ + + # May raise a permission denied + ++ + + ######################## +### The following are placeholder methods, +### and are intended to be overridden. +### +### The are not called by GenericAPIView directly, +### but are used by the mixin methods. ++ + """ +Placeholder method for calling before saving an object. ++ May be used to set attributes on the object that are implicit +in either the request, or the url. +""" + ++ + """ +Placeholder method for calling after saving an object. +""" + ++ + """ +Return a dictionary of metadata about the view. +Used to return responses for OPTIONS requests. ++ We override the default behavior, and add some extra information +about the required request body for POST and PUT operations. +""" + ++ + + + + + + + # Test global permissions + +# Test object permissions + + + + +else: +# If user has appropriate permissions for the view, include +# appropriate metadata about the fields that should be supplied. + + ++ + + + + + + ########################################################## +### Concrete view classes that provide method handlers ### +### by composing the mixin classes with the base view. ### +########################################################## ++ + GenericAPIView): ++ """ +Concrete view for creating a model instance. +""" + +return self.create(request, *args, **kwargs) ++ + + GenericAPIView): +""" +Concrete view for listing a queryset. +""" + + ++ + + GenericAPIView): +""" +Concrete view for retrieving a model instance. +""" + + ++ + + GenericAPIView): ++ """ +Concrete view for deleting a model instance. +""" + +return self.destroy(request, *args, **kwargs) ++ + + GenericAPIView): ++ """ +Concrete view for updating a model instance. +""" + +return self.update(request, *args, **kwargs) ++ + return self.partial_update(request, *args, **kwargs) ++ + + mixins.CreateModelMixin, +GenericAPIView): +""" +Concrete view for listing a queryset or creating a model instance. +""" + + ++ + + + + + mixins.UpdateModelMixin, +GenericAPIView): +""" +Concrete view for retrieving, updating a model instance. +""" + +return self.retrieve(request, *args, **kwargs) ++ + return self.update(request, *args, **kwargs) ++ + return self.partial_update(request, *args, **kwargs) ++ + + mixins.DestroyModelMixin, +GenericAPIView): +""" +Concrete view for retrieving or deleting a model instance. +""" + +return self.retrieve(request, *args, **kwargs) ++ + return self.destroy(request, *args, **kwargs) ++ + + mixins.UpdateModelMixin, +mixins.DestroyModelMixin, +GenericAPIView): +""" +Concrete view for retrieving, updating or deleting a model instance. +""" + + ++ + + + + + + + + + + ########################## +### Deprecated classes ### +########################## ++ + + warnings.warn( +'Subclassing `MultipleObjectAPIView` is due to be deprecated. ' +'You should simply subclass `GenericAPIView` instead.', +PendingDeprecationWarning, stacklevel=2 +) +super(MultipleObjectAPIView, self).__init__(*args, **kwargs) ++ + + + warnings.warn( +'Subclassing `SingleObjectAPIView` is due to be deprecated. ' +'You should simply subclass `GenericAPIView` instead.', +PendingDeprecationWarning, stacklevel=2 +) +super(SingleObjectAPIView, self).__init__(*args, **kwargs) + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Basic building blocks for generic class based views. ++ We don't bind behaviour to http method handlers yet, +which allows mixin classes to be composed in interesting ways. +""" + ++ + + + + + + + + """ +Given a model instance, and an optional pk and slug field, +return the full list of all other field names on that model. ++ For use when performing full_clean on a model instance, +so we only clean the required fields. +""" + ++ + # Pending deprecation + + +pk_field = pk_field.rel.to._meta.pk + ++ + # Pending deprecation + ++ + + + + + + + """ +Create a model instance. +""" + + ++ + + + + + + headers=headers) ++ return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) ++ + + + + + + + + """ +List a queryset. +""" + ++ + + + # Default is to allow empty querysets. This can be altered by setting +# `.allow_empty = False`, to raise 404 errors on empty querysets. + +warnings.warn( +'The `allow_empty` parameter is due to be deprecated. ' +'To use `allow_empty=False` style behavior, You should override ' +'`get_queryset()` and explicitly raise a 404 on empty querysets.', +PendingDeprecationWarning +) +class_name = self.__class__.__name__ +error_msg = self.empty_error % {'class_name': class_name} +raise Http404(error_msg) ++ # Switch between paginated or standard style responses + + + +else: + ++ + + + + """ +Retrieve a model instance. +""" + + + + ++ + + """ +Update a model instance. +""" + + + ++ + + + + else: + + + ++ + files=request.FILES, partial=partial) ++ + + + + + + return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) ++ + + + + + + + + # If this is a PUT-as-create operation, we need to ensure that +# we have relevant permissions, as if this was a POST request. +# This will either raise a PermissionDenied exception, +# or simply return None + ++ + """ +Set any attributes on the object that are implicit in the request. +""" +# pk and/or slug attributes are implicit in the URL. + + + + ++ + + + + + + + + + # Ensure we clean the attributes so that we don't eg return integer +# pk using a string representation, as provided by the url conf kwarg. + + + ++ + + """ +Destroy a model instance. +""" + + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + | +
+ # Just to keep things like ./manage.py test happy + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Content negotiation deals with selecting an appropriate renderer given the +incoming request. Typically this will be based on the request's Accept header. +""" + + + + + + ++ + + + raise NotImplementedError('.select_parser() must be implemented') ++ + raise NotImplementedError('.select_renderer() must be implemented') ++ + + + + + """ +Given a list of parsers and a media type, return the appropriate +parser to handle the incoming request. +""" + + + +return None ++ + """ +Given a request and a list of renderers, return a two-tuple of: +(renderer, media type). +""" +# Allow URL style format override. eg. "?format=json + + ++ + + + + + # 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) + + + + +# Return the most specific media type as accepted. + +_MediaType(media_type).precedence): +# Eg client requests '*/*' +# Accepted media type is 'application/json' + +else: +# Eg client requests 'application/json; indent=8' +# Accepted media type is 'application/json; indent=8' + ++ + + + """ +If there is a '.json' style format suffix, filter the renderers +so that we only negotiation against those that accept that format. +""" + +if renderer.format == format] + +raise Http404 + ++ + """ +Given the incoming request, return a tokenised list of media +type strings. ++ Allows URL style accept override. eg. "?accept=application/json" +""" + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Pagination serializers determine the structure of the output that should +be used for paginated responses. +""" + + + ++ + + """ +Field that returns a link to the next page in paginated results. +""" + ++ + + + + + + + + + + """ +Field that returns a link to the previous page in paginated results. +""" + ++ + + + + + + + + + + """ +If no object serializer is specified, then this serializer will be applied +as the default. +""" ++ + # Note: Swallow context kwarg - only required for eg. ModelSerializer. + ++ + + """ +An object that stores the options that may be provided to a +pagination serializer by using the inner `Meta` class. ++ Accessible on the instance as `serializer.opts`. +""" + + + +DefaultObjectSerializer) ++ + + """ +A base class for pagination serializers to inherit from, +to make implementing custom serializers more easy. +""" + + ++ + """ +Override init to add in the object serializer field on-the-fly. +""" + + + ++ + + else: + ++ + + + + """ +A default implementation of a pagination serializer. +""" + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Parsers are used to parse the content of incoming HTTP requests. ++ They give us a generic way of being able to handle various media types +on the request, such as form content or json encoded data. +""" + + + + + + + + + + + + ++ + + + + + + + + """ +All parsers should extend `BaseParser`, specifying a `media_type` +attribute, and overriding the `.parse()` method. +""" ++ + + + """ +Given a stream to read from, return the parsed representation. +Should return parsed data, or a `DataAndFiles` object consisting of the +parsed data and files. +""" +raise NotImplementedError(".parse() must be overridden.") ++ + + """ +Parses JSON-serialized data. +""" ++ + + + """ +Returns a 2-tuple of `(data, files)`. ++ `data` will be an object which is the parsed content of the response. +`files` will always be `None`. +""" + + ++ + + + + + + + + """ +Parses YAML-serialized data. +""" ++ + + + """ +Returns a 2-tuple of `(data, files)`. ++ `data` will be an object which is the parsed content of the response. +`files` will always be `None`. +""" + ++ + + + + + + except (ValueError, yaml.parser.ParserError) as exc: +raise ParseError('YAML parse error - %s' % six.u(exc)) ++ + + """ +Parser for form data. +""" ++ + + + """ +Returns a 2-tuple of `(data, files)`. ++ `data` will be a :class:`QueryDict` containing all the form parameters. +`files` will always be :const:`None`. +""" + + + + ++ + + """ +Parser for multipart form data, which may include file data. +""" ++ + + + """ +Returns a DataAndFiles object. ++ `.data` will be a `QueryDict` containing all the form parameters. +`.files` will be a `QueryDict` containing all the form files. +""" + + + + + ++ + + + + except MultiPartParserError as exc: +raise ParseError('Multipart form parse error - %s' % six.u(exc)) ++ + + """ +XML parser. +""" ++ + + + + + + + + + + except (etree.ParseError, ValueError) as exc: +raise ParseError('XML parse error - %s' % six.u(exc)) + ++ + + + """ +convert the xml `element` into the corresponding python object +""" ++ + + + + else: +# if the fist child tag is list-item means all children are list-item + + + + +else: + + + ++ + + + """ +Converts the value returned by the XMl parse into the equivalent +Python type +""" + + ++ + + + + + + + + + + + + + + + + + + + """ +Parser for file upload data. +""" + ++ + """ +Returns a DataAndFiles object. ++ `.data` will be None (we expect request body to be a file content). +`.files` will be a `QueryDict` containing one 'file' element. +""" ++ + + + + + + + # Note that this code is extracted from Django's handling of +# file uploads in MultiPartParser. + +meta.get('CONTENT_TYPE', '')) + + +meta.get('CONTENT_LENGTH', 0))) +except (ValueError, TypeError): +content_length = None ++ # See if the handler will want to take care of the parsing. + + +meta, +content_length, +None, +encoding) + +return DataAndFiles(None, {'file': result[1]}) ++ # This is the standard case. + + + + ++ + + + content_length, encoding) + + ++ + + + + + + + + + + + + raise ParseError("FileUpload parse error - " +"none of upload handlers can handle the stream") ++ + """ +Detects the uploaded file name. First searches a 'filename' url kwarg. +Then tries to parse Content-Disposition header. +""" + + + + ++ + + + + except (AttributeError, KeyError): +pass + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Provides a set of pluggable permission policies. +""" + + + ++ + + + + + + """ +A base class from which all permission classes should inherit. +""" ++ + """ +Return `True` if permission is granted, `False` otherwise. +""" + ++ + """ +Return `True` if permission is granted, `False` otherwise. +""" + +warnings.warn( +'The `obj` argument in `has_permission` is deprecated. ' +'Use `has_object_permission()` instead for object permissions.', +DeprecationWarning, stacklevel=2 +) +return self.has_permission(request, view, obj) + ++ + + """ +Allow any access. +This isn't strictly required, since you could use an empty +permission_classes list, but it's useful because it makes the intention +more explicit. +""" + + ++ + + """ +Allows access only to authenticated users. +""" ++ + + + + + + + """ +Allows access only to admin users. +""" ++ + if request.user and request.user.is_staff: +return True +return False ++ + + """ +The request is authenticated as a user, or is a read-only request. +""" ++ + if (request.method in SAFE_METHODS or +request.user and +request.user.is_authenticated()): +return True +return False ++ + + """ +The request is authenticated using `django.contrib.auth` permissions. +See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions ++ It ensures that the user is authenticated, and has the appropriate +`add`/`change`/`delete` permissions on the model. ++ This permission can only be applied against view classes that +provide a `.model` or `.queryset` attribute. +""" ++ # Map methods into required permission codes. +# Override this if you need to also provide 'view' permissions, +# or if you want to provide custom permission codes. + +'GET': [], +'OPTIONS': [], +'HEAD': [], +'POST': ['%(app_label)s.add_%(model_name)s'], +'PUT': ['%(app_label)s.change_%(model_name)s'], +'PATCH': ['%(app_label)s.change_%(model_name)s'], +'DELETE': ['%(app_label)s.delete_%(model_name)s'], +} ++ + + + """ +Given a model and an HTTP method, return the list of permission +codes that the user is required to have. +""" + +'app_label': model_cls._meta.app_label, +'model_name': model_cls._meta.module_name +} + ++ + + + + + model_cls = queryset.model ++ # Workaround to ensure DjangoModelPermissions are not applied +# to the root view when using DefaultRouter. + +return True ++ + ' does not have `.model` or `.queryset` property.') ++ + + + (request.user.is_authenticated() or not self.authenticated_users_only) and +request.user.has_perms(perms)): + + ++ + + """ +Similar to DjangoModelPermissions, except that anonymous users are +allowed read-only access. +""" + ++ + + """ +The request is authenticated as a user and the token used has the right scope +""" ++ + + + + + return False ++ + + + + + + assert False, ('TokenHasReadWriteScope requires either the' +'`OAuthAuthentication` or `OAuth2Authentication` authentication ' +'class to be used.') + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Serializer fields that deal with relationships. ++ These fields allow you to specify the style that should be used to represent +model relationships, including hyperlinks, primary keys, or slugs. +""" + + + + + + + + + + + + + ++ + ##### Relational fields ##### ++ + # Not actually Writable, but subclasses may need to be. + +""" +Base class for related model fields. ++ This represents a relationship using the unicode representation of the target. +""" + + + + ++ + + + + + + + # 'null' is to be deprecated in favor of 'required' + +warnings.warn('The `null` keyword argument is deprecated. ' +'Use the `required` keyword argument instead.', +DeprecationWarning, stacklevel=2) +kwargs['required'] = not kwargs.pop('null') ++ + + + + + + + + + + + + + + + + + + + + + else: # Reverse + +except Exception: +msg = ('Serializer related fields must include a `queryset`' + +' argument or set `read_only=True') +raise Exception(msg) ++ ### We need this stuff to make form choices work... ++ + return self.to_native(obj) ++ + """ +Return a readable representation for use with eg. select widgets. +""" +desc = smart_text(obj) +ident = smart_text(self.to_native(obj)) +if desc == ident: +return desc +return "%s - %s" % (desc, ident) ++ + + + + + + + + + + # If self._choices is set, then somebody must have manually set +# the property self.choices. In this case, just return self._choices. + +return self._choices ++ # Otherwise, execute the QuerySet in self.queryset to determine the +# choices dynamically. Return a fresh ModelChoiceIterator that has not been +# consumed. Note that we're instantiating a new ModelChoiceIterator *each* +# time _get_choices() is called (and, thus, each time self.choices is +# accessed) so that we can ensure the QuerySet has not been consumed. This +# construct might look complicated but it allows for lazy evaluation of +# the queryset. + ++ + # Setting choices also sets the choices on the widget. +# choices can be any iterable, but we call list() on it because +# it will be consumed more than once. +self._choices = self.widget.choices = list(value) ++ + + ### Regular serializer stuff... ++ + + + return self.to_native(obj) ++ + + + + + + + + + + + + + + + + else: +# Also support non-queryset iterables. +# This allows us to also support plain lists of related items. + + ++ + + + + + + + # Form data + + + + +# Non-form data + +else: + + + + + ++ + + + + + + else: + ++ + ### PrimaryKey relationships ++ + """ +Represents a relationship as a pk value. +""" + ++ + 'does_not_exist': _("Invalid pk '%s' - object does not exist."), +'incorrect_type': _('Incorrect type. Expected pk value, received %s.'), +} ++ # TODO: Remove these field hacks... + + ++ + """ +Return a readable representation for use with eg. select widgets. +""" + + + +return desc + ++ # TODO: Possibly change this to just take `obj`, through prob less performant + + ++ + + raise Exception('Writable related fields must include a `queryset` argument') ++ + + + msg = self.error_messages['does_not_exist'] % smart_text(data) +raise ValidationError(msg) + + + + ++ + + # To-many relationship ++ + + # Prefer obj.serializable_value for performance reasons + + + + + +# RelatedManager (reverse relationship) + + + + ++ # Forward relationship + + +else: +# Also support non-queryset iterables. +# This allows us to also support plain lists of related items. + ++ # To-one relationship + +# Prefer obj.serializable_value for performance reasons + + +# RelatedObject (reverse relationship) + + + + ++ # Forward relationship + ++ + ### Slug relationships ++ + + """ +Represents a relationship using a unique field on the target. +""" + ++ + 'does_not_exist': _("Object with %s=%s does not exist."), +'invalid': _('Invalid value.'), +} ++ + + + + + + + + + + raise Exception('Writable related fields must include a `queryset` argument') ++ + + + + (self.slug_field, smart_text(data))) + + + ++ + ### Hyperlinked relationships ++ + """ +Represents a relationship using hyperlinking. +""" + + ++ + 'no_match': _('Invalid hyperlink - No URL match'), +'incorrect_match': _('Invalid hyperlink - Incorrect URL match'), +'configuration_error': _('Invalid hyperlink due to configuration error'), +'does_not_exist': _("Invalid hyperlink - object does not exist."), +'incorrect_type': _('Incorrect type. Expected url string, received %s.'), +} ++ # These are all pending deprecation + + + ++ + + + except KeyError: +raise ValueError("Hyperlinked field requires 'view_name' kwarg") ++ + + + # These are pending deprecation + +msg = 'pk_url_kwarg is pending deprecation. Use lookup_field instead.' +warnings.warn(msg, PendingDeprecationWarning, stacklevel=2) + + + + + + ++ + + + + + + + + """ +Given an object, return the URL that hyperlinks to the object. ++ May raise a `NoReverseMatch` if the `view_name` and `lookup_field` +attributes are not configured to correctly match the URL conf. +""" + + + + + + ++ + # Only try pk if it has been explicitly set. +# Otherwise, the default `lookup_field = 'pk'` has us covered. +pk = obj.pk +kwargs = {self.pk_url_kwarg: pk} +try: +return reverse(view_name, kwargs=kwargs, request=request, format=format) +except NoReverseMatch: +pass ++ + + # Only try slug if it corresponds to an attribute on the object. + + + + +# If the lookup succeeds using the default slug params, +# then `slug_field` is being used implicitly, and we +# we need to warn about the pending deprecation. +msg = 'Implicit slug field hyperlinked fields are pending deprecation.' \ +'You should set `lookup_field=slug` on the HyperlinkedRelatedField.' +warnings.warn(msg, PendingDeprecationWarning, stacklevel=2) + +except NoReverseMatch: +pass ++ raise NoReverseMatch() ++ + """ +Return the object corresponding to a matched URL. ++ Takes the matched URL conf arguments, and the queryset, and should +return an object instance, or raise an `ObjectDoesNotExist` exception. +""" + + + ++ + + + filter_kwargs = {'pk': pk} + + +else: +raise ObjectDoesNotExist() ++ + + + + + + + + msg = ( +"Using `HyperlinkedRelatedField` without including the request " +"in the serializer context is deprecated. " +"Add `context={'request': request}` when instantiating " +"the serializer." +) +warnings.warn(msg, DeprecationWarning, stacklevel=4) ++ # If the object has not yet been saved then we cannot hyperlink to it. + +return ++ # Return the hyperlink, or error if incorrectly configured. + + +except NoReverseMatch: +msg = ( +'Could not resolve URL for hyperlinked relationship using ' +'view name "%s". You may have failed to include the related ' +'model in your API, or incorrectly configured the ' +'`lookup_field` attribute on this field.' +) +raise Exception(msg % view_name) ++ + # Convert URL -> model instance pk +# TODO: Use values_list + + +raise Exception('Writable related fields must include a `queryset` argument') ++ + + + + + + + # If needed convert absolute URLs to relative path + + + + ++ + + + + + + raise ValidationError(self.error_messages['incorrect_match']) ++ + + match.args, match.kwargs) +except (ObjectDoesNotExist, TypeError, ValueError): +raise ValidationError(self.error_messages['does_not_exist']) ++ + + """ +Represents the instance, or a property on the instance, using hyperlinking. +""" + + ++ # These are all pending deprecation + + + ++ + + + except KeyError: +msg = "HyperlinkedIdentityField requires 'view_name' argument" +raise ValueError(msg) ++ + + + + # These are pending deprecation + +msg = 'pk_url_kwarg is pending deprecation. Use lookup_field instead.' +warnings.warn(msg, PendingDeprecationWarning, stacklevel=2) + +msg = 'slug_url_kwarg is pending deprecation. Use lookup_field instead.' +warnings.warn(msg, PendingDeprecationWarning, stacklevel=2) + +msg = 'slug_field is pending deprecation. Use lookup_field instead.' +warnings.warn(msg, PendingDeprecationWarning, stacklevel=2) ++ + + + + + + + + + + + + + warnings.warn("Using `HyperlinkedIdentityField` without including the " +"request in the serializer context is deprecated. " +"Add `context={'request': request}` when instantiating the serializer.", +DeprecationWarning, stacklevel=4) ++ # By default use whatever format is given for the current context +# unless the target is a different type to the source. +# +# Eg. Consider a HyperlinkedIdentityField pointing from a json +# representation to an html property of that representation... +# +# '/snippets/1/' should link to '/snippets/1/highlight/' +# ...but... +# '/snippets/1/.json' should link to '/snippets/1/highlight/.html' + +format = self.format ++ # Return the hyperlink, or error if incorrectly configured. + + +except NoReverseMatch: +msg = ( +'Could not resolve URL for hyperlinked relationship using ' +'view name "%s". You may have failed to include the related ' +'model in your API, or incorrectly configured the ' +'`lookup_field` attribute on this field.' +) +raise Exception(msg % view_name) ++ + """ +Given an object, return the URL that hyperlinks to the object. ++ May raise a `NoReverseMatch` if the `view_name` and `lookup_field` +attributes are not configured to correctly match the URL conf. +""" + + + + +except NoReverseMatch: +pass ++ if self.pk_url_kwarg != 'pk': +# Only try pk lookup if it has been explicitly set. +# Otherwise, the default `lookup_field = 'pk'` has us covered. +kwargs = {self.pk_url_kwarg: obj.pk} +try: +return reverse(view_name, kwargs=kwargs, request=request, format=format) +except NoReverseMatch: +pass ++ slug = getattr(obj, self.slug_field, None) +if slug: +# Only use slug lookup if a slug field exists on the model +kwargs = {self.slug_url_kwarg: slug} +try: +return reverse(view_name, kwargs=kwargs, request=request, format=format) +except NoReverseMatch: +pass ++ raise NoReverseMatch() ++ + ### Old-style many classes for backwards compat ++ + + warnings.warn('`ManyRelatedField()` is deprecated. ' +'Use `RelatedField(many=True)` instead.', +DeprecationWarning, stacklevel=2) +kwargs['many'] = True +super(ManyRelatedField, self).__init__(*args, **kwargs) ++ + + + warnings.warn('`ManyPrimaryKeyRelatedField()` is deprecated. ' +'Use `PrimaryKeyRelatedField(many=True)` instead.', +DeprecationWarning, stacklevel=2) +kwargs['many'] = True +super(ManyPrimaryKeyRelatedField, self).__init__(*args, **kwargs) ++ + + + warnings.warn('`ManySlugRelatedField()` is deprecated. ' +'Use `SlugRelatedField(many=True)` instead.', +DeprecationWarning, stacklevel=2) +kwargs['many'] = True +super(ManySlugRelatedField, self).__init__(*args, **kwargs) ++ + + + warnings.warn('`ManyHyperlinkedRelatedField()` is deprecated. ' +'Use `HyperlinkedRelatedField(many=True)` instead.', +DeprecationWarning, stacklevel=2) +kwargs['many'] = True +super(ManyHyperlinkedRelatedField, self).__init__(*args, **kwargs) + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Renderers are used to serialize a response into specific media types. ++ They give us a generic way of being able to handle various media types +on the response, such as JSON encoded data or HTML output. ++ REST framework also provides an HTML renderer the renders the browsable API. +""" + ++ + + + + + + + + + + + + + + + + + + + + """ +All renderers should extend this class, setting the `media_type` +and `format` attributes, and override the `.render()` method. +""" ++ + + + + + raise NotImplemented('Renderer class requires .render() to be implemented') ++ + + """ +Renderer which serializes to JSON. +Applies JSON's backslash-u character escaping for non-ascii characters. +""" ++ + + + + + # Note that JSON encodings must be utf-8, utf-16 or utf-32. +# See: http://www.ietf.org/rfc/rfc4627.txt ++ + """ +Render `data` into JSON. +""" + + ++ # If 'indent' is provided in the context, then pretty print the result. +# E.g. If we're being called by the BrowsableAPIRenderer. + + ++ + # If the media type looks like 'application/json; indent=4', +# then pretty print the result. + + + + + + ++ + indent=indent, ensure_ascii=self.ensure_ascii) ++ # On python 2.x json.dumps() returns bytestrings if ensure_ascii=True, +# but if ensure_ascii=False, the return type is underspecified, +# and may (or may not) be unicode. +# On python 3.x json.dumps() returns unicode strings. + + + ++ + + + + + Renderer which serializes to JSON. +Does *not* apply JSON's character escaping for non-ascii characters. +""" ++ + + """ +Renderer which serializes to json, +wrapping the json output in a callback function. +""" ++ + + + + + + """ +Determine the name of the callback to wrap around the json output. +""" + + + ++ + """ +Renders into jsonp, wrapping the json output in a callback function. ++ Clients may set the callback function name using a query parameter +on the URL, for example: ?callback=exampleCallbackName +""" + + + +renderer_context) + ++ + + """ +Renderer which serializes to XML. +""" ++ + + + + + """ +Renders *obj* into serialized XML. +""" + +return '' ++ + + + + + + + + + + + + + + + + + + + + + + + + + + # Don't output any value + ++ else: + ++ + + """ +Renderer which serializes to YAML. +""" ++ + + + + + + """ +Renders *obj* into serialized YAML. +""" + ++ + return '' ++ + + + + """ +An HTML renderer for use with templates. ++ The data supplied to the Response object should be a dictionary that will +be used as context for the template. ++ The template name is determined by (in order of preference): ++ 1. An explicit `.template_name` attribute set on the response. +2. An explicit `.template_name` attribute set on this class. +3. The return result of calling `view.get_template_names()`. ++ For example: +data = {'users': User.objects.all()} +return Response(data, template_name='users.html') ++ For pre-rendered HTML, see StaticHTMLRenderer. +""" ++ + + + + '%(status_code)s.html', +'api_exception.html' +] + ++ + """ +Renders data to HTML, using Django's standard template rendering. ++ The template name is determined by (in order of preference): ++ 1. An explicit .template_name set on the response. +2. An explicit .template_name set on this class. +3. The return result of calling view.get_template_names(). +""" + + + + ++ + + else: + + ++ + + + + + + + + + + + + + + elif self.template_name: +return [self.template_name] +elif hasattr(view, 'get_template_names'): +return view.get_template_names() +raise ImproperlyConfigured('Returned a template response with no template_name') ++ + + for name in self.exception_template_names] ++ + # Try to find an appropriate error template + + +# Fall back to using eg '404 Not Found' + +response.status_text.title())) ++ + # Note, subclass TemplateHTMLRenderer simply for the exception behavior + +""" +An HTML renderer class that simply returns pre-rendered HTML. ++ The data supplied to the Response object should be a string representing +the pre-rendered HTML content. ++ For example: +data = '<html><body>example</body></html>' +return Response(data) ++ For template rendered HTML, see TemplateHTMLRenderer. +""" + + + ++ + renderer_context = renderer_context or {} +response = renderer_context['response'] ++ if response and response.exception: +request = renderer_context['request'] +template = self.get_exception_template(response) +context = self.resolve_context(data, request, response) +return template.render(context) ++ return data ++ + + """ +HTML renderer used to self-document the API. +""" + + + + ++ + """ +Return an instance of the first valid renderer. +(Don't use another documenting renderer.) +""" + +if not issubclass(renderer, BrowsableAPIRenderer)] + + + ++ + accepted_media_type, renderer_context): +""" +Get the content as if it had been rendered by the default +non-documenting renderer. +""" + + ++ + + + + return '[%d bytes of binary content]' % len(content) ++ + + + """ +Returns True if a form should be shown for this method. +""" + + ++ + return # Cannot use form overloading ++ + + + view.check_object_permissions(request, obj) + + + ++ + + + + + + + + + #if getattr(v, 'queryset', None): +# kwargs['queryset'] = v.queryset ++ + + + + kwargs['regex'] = v.regex ++ + + + + + kwargs['initial'] = v.default ++ + + + + + + + + + + + # We need to impersonate a request with the correct method, +# so that eg. any dynamic get_serializer_class methods return the +# correct form for each method. + + + + + +finally: + ++ + # We need to impersonate a request with the correct method, +# so that eg. any dynamic get_serializer_class methods return the +# correct form for each method. + + + + + +finally: + ++ + """ +Get a form, possibly bound to either the input or output data. +In the absence on of the Resource having an associated form then +provide a form that can be used to submit arbitrary content. +""" + + + ++ + + + + + + + + + # Creating an on the fly form see: +# http://stackoverflow.com/questions/3915024/dynamically-creating-classes-python + + + + ++ + """ +Returns a form that allows for arbitrary content types to be tunneled +via standard HTML forms. +(Which are typically application/x-www-form-urlencoded) +""" ++ # If we're not using content overloading there's no point in supplying a generic form, +# as the view won't treat the form's value as the content of the request. + +and api_settings.FORM_CONTENTTYPE_OVERRIDE): +return None ++ # Check permissions + + + ++ + + + + + # NB. http://jacobian.org/writing/dynamic-form-generation/ + + + ++ + label='Media type', +choices=choices, +initial=initial +) + +label='Content', +widget=forms.Textarea +) ++ + + + + + + + + + + + + """ +Render the HTML for the browsable API representation. +""" + + ++ + + + + + + + + + + + + + + + + + + + + + + + + + 'content': content, +'view': view, +'request': request, +'response': response, +'description': description, +'name': name, +'version': VERSION, +'breadcrumblist': breadcrumb_list, +'allowed_methods': view.allowed_methods, +'available_formats': [renderer.format for renderer in view.renderer_classes], ++ 'put_form': put_form, +'post_form': post_form, +'patch_form': patch_form, +'delete_form': delete_form, +'options_form': options_form, ++ 'raw_data_put_form': raw_data_put_form, +'raw_data_post_form': raw_data_post_form, +'raw_data_patch_form': raw_data_patch_form, +'raw_data_put_or_patch_form': raw_data_put_or_patch_form, ++ 'api_settings': api_settings +}) ++ + + # Munge DELETE Response code to allow us to return content +# (Do this *after* we've rendered the template so that we include +# the normal deletion response code in the output) + +response.status_code = status.HTTP_200_OK ++ + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +The Request class is used as a wrapper around the standard request object. ++ The wrapped request then offers a richer API, in particular : ++ - content automatically parsed according to `Content-Type` header, +and available as `request.DATA` +- full support of PUT method, including support for file uploads +- form overloading of HTTP method, content type and content +""" + + + + + + + + + ++ + + """ +Return True if the media type is a valid form media type. +""" + + +base_media_type == 'multipart/form-data') ++ + + """ +Placeholder for unset attributes. +Cannot use `None`, as that may be a valid value. +""" + ++ + + + + + + """ +Internal helper method to clone a request, replacing with a different +HTTP method. Used for checking permissions against other methods. +""" + +parsers=request.parsers, +authenticators=request.authenticators, +negotiator=request.negotiator, +parser_context=request.parser_context) + + + + + + + + + + + + ++ + + """ +Wrapper allowing to enhance a standard `HttpRequest` instance. ++ Kwargs: +- request(HttpRequest). The original request instance. +- parsers_classes(list/tuple). The parsers to use for parsing the +request content. +- authentication_classes(list/tuple). The authentications used to try +authenticating the request's user. +""" ++ + + + + + negotiator=None, parser_context=None): + + + + + + + + + + ++ + + + + + + + + + def method(self): +""" +Returns the HTTP method. ++ This allows the `method` to be overridden by using a hidden `form` +field on a form POST request. +""" + + + ++ + def content_type(self): +""" +Returns the content type header. ++ This should be used instead of `request.META.get('HTTP_CONTENT_TYPE')`, +as it allows the content type to be overridden by using a hidden form +field on a form POST request. +""" + +self._load_method_and_content_type() + ++ + def stream(self): +""" +Returns an object that may be used to stream the request content. +""" + + + ++ + def QUERY_PARAMS(self): +""" +More semantically correct name for request.GET. +""" + ++ + def DATA(self): +""" +Parses the request body and returns the data. ++ Similar to usual behaviour of `request.POST`, except that it handles +arbitrary parsers, and also works on methods other than POST (eg PUT). +""" + + + ++ + def FILES(self): +""" +Parses the request body and returns any files uploaded in the request. ++ Similar to usual behaviour of `request.FILES`, except that it handles +arbitrary parsers, and also works on methods other than POST (eg PUT). +""" + +self._load_data_and_files() + ++ + def user(self): +""" +Returns the user associated with the current request, as authenticated +by the authentication classes provided to the request. +""" + + + ++ + def user(self, value): +""" +Sets the user on the current request. This is necessary to maintain +compatilbility with django.contrib.auth where the user proprety is +set in the login and logout functions. +""" + ++ + def auth(self): +""" +Returns any non-user authentication information associated with the +request, such as an authentication token. +""" + +self._authenticate() + ++ + def auth(self, value): +""" +Sets any non-user authentication information associated with the +request, such as an authentication token. +""" + ++ + def successful_authenticator(self): +""" +Return the instance of the authentication instance class that was used +to authenticate the request, or `None`. +""" + +self._authenticate() + ++ + """ +Parses the request content into self.DATA and self.FILES. +""" + + ++ + + + + """ +Sets the method and content_type, and then check if they've +been overridden. +""" + +self.META.get('CONTENT_TYPE', '')) ++ + + + + + + # Allow X-HTTP-METHOD-OVERRIDE header + +self._method) ++ + """ +Return the content body of the request, as a stream. +""" + + +self.META.get('HTTP_CONTENT_LENGTH'))) + + ++ + + + + else: +self._stream = BytesIO(self.raw_post_data) ++ + """ +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. +""" ++ + self._METHOD_PARAM or +(self._CONTENT_PARAM and self._CONTENTTYPE_PARAM) +) ++ # We only need to use form overloading on form POST requests. + +or self._request.method != 'POST' +or not is_form_media_type(self._content_type)): + ++ # At this point we're committed to parsing the request as form data. + + ++ # Method overloading - change the method and remove the param from the content. + +self._METHOD_PARAM in self._data): + ++ # Content overloading - modify the content type, and force re-parse. + +self._CONTENTTYPE_PARAM and +self._CONTENT_PARAM in self._data and +self._CONTENTTYPE_PARAM in self._data): + + + ++ + """ +Parse the request content, returning a two-tuple of (data, files) ++ May raise an `UnsupportedMediaType`, or `ParseError` exception. +""" + + ++ + + + + + + + + raise exceptions.UnsupportedMediaType(media_type) ++ + + # Parser classes may return the raw data, or a +# DataAndFiles object. Unpack the result as required. + + + + + ++ + """ +Attempt to authenticate the request using each authentication instance +in turn. +Returns a three-tuple of (authenticator, user, authtoken). +""" + + + + + + ++ + + + + + + + + """ +Return a three-tuple of (authenticator, user, authtoken), representing +an unauthenticated request. ++ By default this will be (None, AnonymousUser, None). +""" + ++ + + else: +self._user = None ++ + self._auth = api_settings.UNAUTHENTICATED_TOKEN() +else: + ++ + """ +Proxy other attributes to the underlying HttpRequest object. +""" + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +The Response class in REST framework is similar to HTTPResponse, except that +it is initialized with unrendered data, instead of a pre-rendered string. ++ The appropriate renderer is called during Django's template response rendering. +""" + + + + ++ + + """ +An HttpResponse that allows its data to be rendered into +arbitrary media types. +""" ++ + template_name=None, headers=None, +exception=False, content_type=None): +""" +Alters the init arguments slightly. +For example, drop 'template_name', and instead use 'data'. ++ Setting 'renderer' and 'media_type' will typically be deferred, +For example being set automatically by the `APIView`. +""" + + + + + ++ + + + + + def rendered_content(self): + + + ++ + + + + + + + + + + + content_type = media_type + ++ + + + 'a charset value.' + + ++ + def status_text(self): +""" +Returns reason text corresponding to our HTTP response status code. +Provided for convenience. +""" +# TODO: Deprecate and use a template tag instead +# TODO: Status code text for RFC 6585 status codes + ++ + """ +Remove attributes from the response that shouldn't be cached +""" + + + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Provide reverse functions that return fully qualified URLs +""" + + + ++ + + """ +Same as `django.core.urlresolvers.reverse`, but optionally takes a request +and returns a fully qualified URL, using the request to get the base URL. +""" + +kwargs = kwargs or {} +kwargs['format'] = format + + + +return url ++ + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Routers provide a convenient and consistent way of automatically +determining the URL conf for your API. ++ They are used by simply instantiating a Router class, and then registering +all the required ViewSets with that router. ++ For example, you might have a `urls.py` that looks something like this: ++ router = routers.DefaultRouter() +router.register('users', UserViewSet, 'user') +router.register('accounts', AccountViewSet, 'account') ++ urlpatterns = router.urls +""" + ++ + + + + + + + + + + + + """ +Partially format a format_string, swapping out any +'{methodname}' or '{methodnamehyphen}' components. +""" + + + + + ++ + + + + + + + + + + + """ +If `base_name` is not specified, attempt to automatically determine +it from the viewset. +""" +raise NotImplemented('get_default_base_name must be overridden') ++ + """ +Return a list of URL patterns, given the registered viewsets. +""" +raise NotImplemented('get_urls must be overridden') ++ + def urls(self): + + + ++ + + + # List route. +Route( +url=r'^{prefix}{trailing_slash}$', +mapping={ +'get': 'list', +'post': 'create' +}, +name='{basename}-list', +initkwargs={'suffix': 'List'} +), +# Detail route. +Route( +url=r'^{prefix}/{lookup}{trailing_slash}$', +mapping={ +'get': 'retrieve', +'put': 'update', +'patch': 'partial_update', +'delete': 'destroy' +}, +name='{basename}-detail', +initkwargs={'suffix': 'Instance'} +), +# Dynamically generated routes. +# Generated using @action or @link decorators on methods of the viewset. +Route( +url=r'^{prefix}/{lookup}/{methodname}{trailing_slash}$', +mapping={ +'{httpmethod}': '{methodname}', +}, +name='{basename}-{methodnamehyphen}', +initkwargs={} +), +] ++ + + + + + """ +If `base_name` is not specified, attempt to automatically determine +it from the viewset. +""" + + + + ++ + 'not automatically determine the name from the viewset, as ' \ +'it does not have a `.model` or `.queryset` attribute.' ++ + + + """ +Augment `self.routes` with any dynamically generated routes. ++ Returns a list of the Route namedtuple. +""" ++ # Determine any `@action` or `@link` decorated methods on the viewset + + + + + + ++ + + + # Dynamic routes (@link or @action decorator) + + + + +url=replace_methodname(route.url, methodname), +mapping=dict((httpmethod, methodname) for httpmethod in httpmethods), +name=replace_methodname(route.name, methodname), +initkwargs=initkwargs, +)) +else: +# Standard route + ++ + + + """ +Given a viewset, and a mapping of http methods to actions, +return a new mapping which only includes any mappings that +are actually implemented by the viewset. +""" + + + + + ++ + """ +Given a viewset, return the portion of URL regex that is used +to match against a single instance. +""" + + + ++ + """ +Use the registered viewsets to generate a list of URL patterns. +""" + ++ + + + + + + # Only actions which actually exist on the viewset will be bound + + +continue ++ # Build the url pattern + +prefix=prefix, +lookup=lookup, +trailing_slash=self.trailing_slash +) + + + ++ + + + + """ +The default router extends the SimpleRouter, but also adds in a default +API root view, and adds format suffix patterns to the URLs. +""" + + + ++ + """ +Return a view to use as the API root. +""" + + + + ++ + + + + ret = {} +for key, url_name in api_root_dict.items(): +ret[key] = reverse(url_name, request=request, format=format) +return Response(ret) ++ + + + """ +Generate the list of URL patterns, including a default root view +for the API, and appending `.json` style format suffixes. +""" + ++ + + + + + + + + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Serializers and ModelSerializers are similar to Forms and ModelForms. +Unlike forms, they are not constrained to dealing with HTML output, and +form encoded input. ++ Serialization in REST framework is a two-phase process: ++ 1. Serializers marshal between complex types like model instances, and +python primatives. +2. The process of marshalling between python primatives and request and +response content is handled by parsers and renderers. +""" + + + + + + + + + + ++ # Note: We do the following so that users of the framework can use this style: +# +# example_field = serializers.CharField(...) +# +# This helps keep the separation between model fields, form fields, and +# serializer fields more explicit. ++ + + + + + """ +The default ValidationError behavior is to stringify each item in the list +if the messages are a list of error messages. ++ In the case of nested serializers, where the parent has many children, +then the child's `serializer.errors` will be a list of dicts. In the case +of a single child, the `serializer.errors` will be a dict. ++ We need to override the default behavior to get properly nested error dicts. +""" ++ + + self.messages = [message] +else: + ++ + + """ +A dict-like object, that can have additional properties attached. +""" + +""" +Used by pickle (e.g., caching). +Overridden to remove the metadata from the dict, since it shouldn't be +pickled and may in some instances be unpickleable. +""" + ++ + + """ +A sorted dict-like object, that can have additional properties attached. +""" + +""" +Used by pickle (e.g., caching). +Overriden to remove the metadata from the dict, since it shouldn't be +pickle and may in some instances be unpickleable. +""" + ++ + + """ +True if the object is a native datatype that does not need to +be serialized further. +""" +return isinstance(obj, ( +types.NoneType, +int, long, +datetime.datetime, datetime.date, datetime.time, +float, Decimal, +basestring) +) ++ + + """ +Create a list of serializer field instances from the passed in 'attrs', +plus any fields on the base classes (in 'bases'). ++ Note that all fields from the base classes are used. +""" + +for field_name, obj in list(six.iteritems(attrs)) +if isinstance(obj, Field)] + ++ # If this class is subclassing another Serializer, add that Serializer's +# fields. Note that we loop over the bases in *reverse*. This is necessary +# in order to maintain the correct order of fields. + + + ++ + + + + + + + + + + """ +Meta class options for Serializer +""" + + + + ++ + + """ +This is the Serializer implementation. +We need to implement it as `BaseSerializer` due to metaclass magicks. +""" + + ++ + + + + context=None, partial=False, many=None, +allow_add_remove=False, **kwargs): + + + + + + + ++ + + + + + + + + + + + + + raise ValueError('instance should be a queryset or other iterable with many=True') ++ + raise ValueError('allow_add_remove should only be used for bulk updates, but you have not set many=True') ++ ##### +# Methods to determine which fields to use when (de)serializing objects. ++ + """ +Return the complete set of default fields for the object, as a dict. +""" + ++ + """ +Returns the complete set of fields for the object as a dict. ++ This will be the set of any explicitly declared fields, +plus the set of fields returned by get_default_fields(). +""" + ++ # Get the explicitly declared fields + + + ++ # Add in the default fields + + + + ++ # If 'fields' is specified, use those fields, in that order. + + + + + + ++ # Remove anything in 'exclude' + + + + ++ + + + + + ##### +# Methods to convert or revert from objects <--> primitive representations. ++ + """ +Return the key that should be used for a given field. +""" + ++ + """ +Core of deserialization, together with `restore_object`. +Converts a dictionary of data into a dictionary of deserialized fields. +""" + ++ + + + + + + + + + + + + + + """ +Run `validate_<fieldname>()` and `validate()` methods on the serializer +""" + + + + + + + + + + ++ # If there are already errors, we don't run .validate() because +# field-validation failed and thus `attrs` may not be complete. +# which in turn can cause inconsistent validation errors. + + + + + +for field_name, error_messages in err.message_dict.items(): +self._errors[field_name] = self._errors.get(field_name, []) + list(error_messages) + + ++ + + + """ +Stub method, to be overridden in Serializer subclasses +""" + ++ + """ +Deserialize a dictionary of attributes into an object instance. +You should override this method to control how deserialized objects +are instantiated. +""" + +instance.update(attrs) +return instance + ++ + """ +Serialize objects -> primitives. +""" + + ++ + + + + + + + + + """ +Deserialize primitives -> objects. +""" + + + + + +else: +self._errors['non_field_errors'] = ['No input provided'] ++ + + + + """ +Override default so that the serializer can be used as a nested field +across relationships. +""" + + ++ + + + + + + + + + + + + + + + + + + + else: + ++ + + + + + """ +Override default so that the serializer can be used as a writable +nested field across relationships. +""" + +return ++ + + + + # Note: partial updates shouldn't set defaults +value = copy.deepcopy(self.default) +else: + +raise ValidationError(self.error_messages['required']) + ++ # Set the serializer object if it exists + ++ + + + else: + +into[(self.source or field_name)] = None +else: + +'instance': obj, +'data': value, +'context': self.context, +'partial': self.partial, +'many': self.many +} + ++ + + else: +# Propagate errors up to our parent + ++ + """ +This hook is required for bulk update. +It is used to determine the canonical identity of a given object. ++ Note that the data has not been validated at this point, so we need +to make sure that we catch any cases of incorrect datatypes being +passed to this method. +""" + + +except AttributeError: +return None ++ + def errors(self): +""" +Run deserialization and return error data, +setting self.object if no errors occurred. +""" + + ++ + + else: + + +warnings.warn('Implict list/queryset serialization is deprecated. ' +'Use the `many=True` flag when instantiating the serializer.', +DeprecationWarning, stacklevel=3) ++ + + + + + + # If this is a bulk update we need to map all the objects +# to a canonical identity so we can determine which +# individual object is being updated for each item in the +# incoming data + + + ++ + + + # Determine which object we're updating + + + + + + ++ + + + + + + + else: + +else: + ++ + + + + + + + + + def data(self): +""" +Returns the serialized data on the serializer. +""" + + ++ + + else: + + +warnings.warn('Implict list/queryset serialization is deprecated. ' +'Use the `many=True` flag when instantiating the serializer.', +DeprecationWarning, stacklevel=2) ++ + + else: + ++ + + + + + + + + + """ +Save the deserialized object and return it. +""" + + +else: + ++ + + + + + + """ +Return a dictionary of metadata about the fields on the serializer. +Useful for things like responding to OPTIONS requests, or generating +API schemas for auto-documentation. +""" + +[(field_name, field.metadata()) +for field_name, field in six.iteritems(self.fields)] +) ++ + + + + + + """ +Meta class options for ModelSerializer +""" + + + + ++ + + """ +A serializer that deals with model instances and querysets. +""" + ++ + models.AutoField: IntegerField, +models.FloatField: FloatField, +models.IntegerField: IntegerField, +models.PositiveIntegerField: IntegerField, +models.SmallIntegerField: IntegerField, +models.PositiveSmallIntegerField: IntegerField, +models.DateTimeField: DateTimeField, +models.DateField: DateField, +models.TimeField: TimeField, +models.DecimalField: DecimalField, +models.EmailField: EmailField, +models.CharField: CharField, +models.URLField: URLField, +models.SlugField: SlugField, +models.TextField: CharField, +models.CommaSeparatedIntegerField: CharField, +models.BooleanField: BooleanField, +models.FileField: FileField, +models.ImageField: ImageField, +} ++ + """ +Return all the fields that should be serialized for the model. +""" ++ + + "Serializer class '%s' is missing 'model' Meta option" % self.__class__.__name__ + + + ++ # Deal with adding the primary key field + + +# If model is a child via multitable inheritance, use parent's pk + ++ + + + + # Deal with forward relationships + + ++ + + + + + models.fields.related.ManyToManyField) + ++ + + + + + warnings.warn( +'The `get_nested_field(model_field)` call signature ' +'is due to be deprecated. ' +'Use `get_nested_field(model_field, related_model, ' +'to_many) instead', +PendingDeprecationWarning +) +field = self.get_nested_field(model_field) +else: + + + +warnings.warn( +'The `get_related_field(model_field, to_many)` call ' +'signature is due to be deprecated. ' +'Use `get_related_field(model_field, related_model, ' +'to_many) instead', +PendingDeprecationWarning +) +field = self.get_related_field(model_field, to_many=to_many) +else: + +else: + ++ + + + + + + # Deal with reverse relationships + + +else: +# Reverse relationships are only included if they are explicitly +# present in the `fields` option on the serializer + + ++ + + + + + + + + models.fields.related.ManyToManyField) ++ + + + + + else: + ++ + + + + + + # Add the `read_only` flag to any fields that have bee specified +# in the `read_only_fields` option + + +"field '%s' on serializer '%s' specfied in " \ +"`read_only_fields`, but also added " \ +"as an explict field. Remove it from `read_only_fields`." % \ +(field_name, self.__class__.__name__) + +"Noexistant field '%s' specified in `read_only_fields` " \ +"on serializer '%s'." % \ +(self.__class__.__name__, field_name) + ++ + + + """ +Returns a default instance of the pk field. +""" + ++ + """ +Creates a default instance of a nested relational field. ++ Note that model_field will be `None` for reverse relationships. +""" + + + + ++ + + + """ +Creates a default instance of a flat relational field. ++ Note that model_field will be `None` for reverse relationships. +""" +# TODO: filter queryset using: +# .using(db).complex_filter(self.rel.limit_choices_to) ++ + 'queryset': related_model._default_manager, +'many': to_many +} ++ + + + + + + """ +Creates a default instance of a basic non-relational field. +""" + ++ + + + + + + + + + + + + + + + + + + # TODO: TypedChoiceField? + + + ++ # put this below the ChoiceField because min_value isn't a valid initializer + +issubclass(model_field.__class__, models.PositiveSmallIntegerField): + ++ + models.CharField: ['max_length'], +models.CommaSeparatedIntegerField: ['max_length'], +models.DecimalField: ['max_digits', 'decimal_places'], +models.EmailField: ['max_length'], +models.FileField: ['max_length'], +models.ImageField: ['max_length'], +models.SlugField: ['max_length'], +models.URLField: ['max_length'], +} ++ + + + + + + + + + + + """ +Return a list of field names to exclude from model validation. +""" + + + + + + + + ++ + """ +Perform Django's full_clean, and populate the `errors` dictionary +if any validation errors occur. ++ Note that we don't perform this inside the `.restore_object()` method, +so that subclasses can override `.restore_object()`, and still get +the full_clean validation checking. +""" + + + + + + ++ + """ +Restore the model instance. +""" + + + ++ # Reverse fk or one-to-one relations + + + + ++ # Reverse m2m relations + + + + ++ # Forward m2m relations + + + ++ # Update an existing instance... + + + ++ # ...or create a new instance +else: + ++ # Any relations that cannot be set until we've +# saved the model get hidden away on these +# private attributes, so we can deal with them +# at the point of save. + + ++ + + + """ +Override the default method to also include model field validation. +""" + + + ++ + """ +Save the deserialized object and return it. +""" + ++ + + + + + + + + + + + + """ +Options for HyperlinkedModelSerializer +""" + + + + ++ + + """ +A subclass of ModelSerializer that uses hyperlinked relationships, +instead of primary key relationships. +""" + + + ++ + + + + + + + + view_name=self.opts.view_name, +lookup_field=self.opts.lookup_field +) + ++ + + + + return self.get_field(model_field) ++ + """ +Creates a default instance of a flat relational field. +""" +# TODO: filter queryset using: +# .using(db).complex_filter(self.rel.limit_choices_to) + +'queryset': related_model._default_manager, +'view_name': self._get_default_view_name(related_model), +'many': to_many +} ++ + + + + kwargs['lookup_field'] = self.opts.lookup_field ++ + + + """ +This hook is required for bulk update. +We need to override the default, to use the url as the identity. +""" +try: +return data.get('url', None) +except AttributeError: +return None ++ + """ +Return the view name to use if 'view_name' is not specified in 'Meta' +""" + + +'app_label': model_meta.app_label, +'model_name': model_meta.object_name.lower() +} + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Settings for REST framework are all namespaced in the REST_FRAMEWORK setting. +For example your project's `settings.py` file might look like this: ++ REST_FRAMEWORK = { +'DEFAULT_RENDERER_CLASSES': ( +'rest_framework.renderers.JSONRenderer', +'rest_framework.renderers.YAMLRenderer', +) +'DEFAULT_PARSER_CLASSES': ( +'rest_framework.parsers.JSONParser', +'rest_framework.parsers.YAMLParser', +) +} ++ This module provides the `api_setting` object, that is used to access +REST framework settings, checking for user settings first, then falling +back to the defaults. +""" + ++ + + + + + + + + + + # Base API policies +'DEFAULT_RENDERER_CLASSES': ( +'rest_framework.renderers.JSONRenderer', +'rest_framework.renderers.BrowsableAPIRenderer', +), +'DEFAULT_PARSER_CLASSES': ( +'rest_framework.parsers.JSONParser', +'rest_framework.parsers.FormParser', +'rest_framework.parsers.MultiPartParser' +), +'DEFAULT_AUTHENTICATION_CLASSES': ( +'rest_framework.authentication.SessionAuthentication', +'rest_framework.authentication.BasicAuthentication' +), +'DEFAULT_PERMISSION_CLASSES': ( +'rest_framework.permissions.AllowAny', +), +'DEFAULT_THROTTLE_CLASSES': ( +), ++ 'DEFAULT_CONTENT_NEGOTIATION_CLASS': +'rest_framework.negotiation.DefaultContentNegotiation', ++ # Genric view behavior +'DEFAULT_MODEL_SERIALIZER_CLASS': +'rest_framework.serializers.ModelSerializer', +'DEFAULT_PAGINATION_SERIALIZER_CLASS': +'rest_framework.pagination.PaginationSerializer', +'DEFAULT_FILTER_BACKENDS': (), ++ # Throttling +'DEFAULT_THROTTLE_RATES': { +'user': None, +'anon': None, +}, ++ # Pagination +'PAGINATE_BY': None, +'PAGINATE_BY_PARAM': None, ++ # Authentication +'UNAUTHENTICATED_USER': 'django.contrib.auth.models.AnonymousUser', +'UNAUTHENTICATED_TOKEN': None, ++ # Browser enhancements +'FORM_METHOD_OVERRIDE': '_method', +'FORM_CONTENT_OVERRIDE': '_content', +'FORM_CONTENTTYPE_OVERRIDE': '_content_type', +'URL_ACCEPT_OVERRIDE': 'accept', +'URL_FORMAT_OVERRIDE': 'format', ++ 'FORMAT_SUFFIX_KWARG': 'format', ++ # Input and output formats +'DATE_INPUT_FORMATS': ( +ISO_8601, +), +'DATE_FORMAT': None, ++ 'DATETIME_INPUT_FORMATS': ( +ISO_8601, +), +'DATETIME_FORMAT': None, ++ 'TIME_INPUT_FORMATS': ( +ISO_8601, +), +'TIME_FORMAT': None, ++ # Pending deprecation +'FILTER_BACKEND': None, +} ++ + # List of settings that may be in string import notation. + +'DEFAULT_RENDERER_CLASSES', +'DEFAULT_PARSER_CLASSES', +'DEFAULT_AUTHENTICATION_CLASSES', +'DEFAULT_PERMISSION_CLASSES', +'DEFAULT_THROTTLE_CLASSES', +'DEFAULT_CONTENT_NEGOTIATION_CLASS', +'DEFAULT_MODEL_SERIALIZER_CLASS', +'DEFAULT_PAGINATION_SERIALIZER_CLASS', +'DEFAULT_FILTER_BACKENDS', +'FILTER_BACKEND', +'UNAUTHENTICATED_USER', +'UNAUTHENTICATED_TOKEN', +) ++ + + """ +If the given setting is a string import notation, +then perform the necessary import or imports. +""" + + + + +return val ++ + + """ +Attempt to import a class from a string representation. +""" + +# Nod to tastypie's use of importlib. + + + + + + + ++ + + """ +A settings object, that allows API settings to be accessed as properties. +For example: ++ from rest_framework.settings import api_settings +print api_settings.DEFAULT_RENDERER_CLASSES ++ Any setting with string import paths will be automatically resolved +and return the class, rather than the string literal. +""" + + + + ++ + + + + + # Check if present in user settings + + +# Fall back to defaults + ++ # Coerce import strings into classes + + ++ + + # Cache the result + + ++ + + # Make sure we can initialize the class +val() ++ + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Descriptive HTTP status codes, for code readability. ++ See RFC 2616 - http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html +And RFC 6585 - http://tools.ietf.org/html/rfc6585 +""" + ++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Provides various throttling policies. +""" + + + + + ++ + + """ +Rate throttling of requests. +""" + +""" +Return `True` if the request should be allowed, `False` otherwise. +""" +raise NotImplementedError('.allow_request() must be overridden') ++ + """ +Optionally, return a recommended number of seconds to wait before +the next request. +""" +return None ++ + + """ +A simple cache implementation, that only requires `.get_cache_key()` +to be overridden. ++ The rate (requests / seconds) is set by a `throttle` attribute on the View +class. The attribute is a string of the form 'number_of_requests/period'. ++ Period should be one of: ('s', 'sec', 'm', 'min', 'h', 'hour', 'd', 'day') ++ Previous request information used for throttling is stored in the cache. +""" ++ + + + + + + + self.rate = self.get_rate() + ++ + """ +Should return a unique cache-key which can be used for throttling. +Must be overridden. ++ May return `None` if the request should not be throttled. +""" +raise NotImplementedError('.get_cache_key() must be overridden') ++ + """ +Determine the string representation of the allowed request rate. +""" + +msg = ("You must set either `.scope` or `.rate` for '%s' throttle" % +self.__class__.__name__) +raise ImproperlyConfigured(msg) ++ + + except KeyError: +msg = "No default throttle rate set for '%s' scope" % self.scope +raise ImproperlyConfigured(msg) ++ + """ +Given the request rate string, return a two tuple of: +<allowed number of requests>, <period of time in seconds> +""" + +return (None, None) + + + + ++ + """ +Implement the check to see if the request should be throttled. ++ On success calls `throttle_success`. +On failure calls `throttle_failure`. +""" + +return True ++ + + + + # Drop any requests from the history which have now passed the +# throttle duration + + + + + ++ + """ +Inserts the current request's timestamp along with the key +into the cache. +""" + + + ++ + """ +Called when a request to the API has failed due to throttling. +""" + ++ + """ +Returns the recommended next request time in seconds. +""" + + +else: +remaining_duration = self.duration ++ + + + + + + """ +Limits the rate of API calls that may be made by a anonymous users. ++ The IP address of the request will be used as the unique cache key. +""" + ++ + if request.user.is_authenticated(): +return None # Only throttle unauthenticated requests. ++ ident = request.META.get('REMOTE_ADDR', None) ++ return self.cache_format % { +'scope': self.scope, +'ident': ident +} ++ + + """ +Limits the rate of API calls that may be made by a given user. ++ The user id will be used as a unique cache key if the user is +authenticated. For anonymous requests, the IP address of the request will +be used. +""" + ++ + + + else: + ++ + 'scope': self.scope, +'ident': ident +} ++ + + """ +Limits the rate of API calls by different amounts for various parts of +the API. Any view that has the `throttle_scope` property set will be +throttled. The unique cache key will be generated by concatenating the +user id of the request, and the scope of the view being accessed. +""" + ++ + # Override the usual SimpleRateThrottle, because we can't determine +# the rate until called by the view. + ++ + # We can only determine the scope once we're called by the view. + ++ # If a view does not have a `throttle_scope` always allow the request + + ++ # Determine the allowed request rate as we normally would during +# the `__init__` call. + + ++ # We can now proceed as normal. + ++ + """ +If `view.throttle_scope` is not set, don't apply this throttle. ++ Otherwise generate the unique cache key by concatenating the user id +with the '.throttle_scope` property of the view. +""" + +ident = request.user.id +else: + ++ + 'scope': self.scope, +'ident': ident +} + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+
+
+
+
+ + + + + + + # Set of included URL patterns + + + + +# Add in the included patterns, after applying the suffixes + +suffix_pattern, +suffix_required) + ++ else: +# Regular URL pattern + + + + +# Add in both the existing and the new urlpattern + + + ++ + + + + """ +Supplement existing urlpatterns with corresponding patterns that also +include a '.format' suffix. Retains urlpattern ordering. ++ urlpatterns: +A list of URL patterns. ++ suffix_required: +If `True`, only suffixed URLs will be generated, and non-suffixed +URLs will not be used. Defaults to `False`. ++ allowed: +An optional tuple/list of allowed suffixes. eg ['json', 'api'] +Defaults to `None`, which allows any suffix. +""" + + +if len(allowed) == 1: +allowed_pattern = allowed[0] +else: +allowed_pattern = '(%s)' % '|'.join(allowed) +suffix_pattern = r'\.(?P<%s>%s)$' % (suffix_kwarg, allowed_pattern) +else: + ++ + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Login and logout views for the browsable API. ++ Add these to your root URLconf if you're using the browsable API and +your API requires authentication. ++ The urls must be namespaced as 'rest_framework', and you should make sure +your authentication settings include `SessionAuthentication`. ++ urlpatterns = patterns('', +... +url(r'^auth', include('rest_framework.urls', namespace='rest_framework')) +) +""" + + ++ + + + + url(r'^login/$', 'login', template_name, name='login'), +url(r'^logout/$', 'logout', template_name, name='logout'), +) + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + | ++ + | +
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+
+
+
+ + + + """ +Given a url returns a list of breadcrumbs, which are each a +tuple of (name, url). +""" ++ + + + """ +Add tuples of (name, url) to the breadcrumbs list, +progressively chomping off parts of the url. +""" ++ + + + + else: +# Check if this is a REST framework view, +# and if so add it to the breadcrumbs + + +# Don't list the same view twice in a row. +# Probably an optional trailing slash. + + + + + ++ + # All done + ++ + # Drop trailing slash off the end and continue to try to +# resolve more breadcrumbs + + ++ # Drop trailing non-slash off the end and continue to try to +# resolve more breadcrumbs + + ++ + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Helper classes for parsers. +""" + + + + + + + + + ++ + + """ +JSONEncoder subclass that knows how to encode date/time/timedelta, +decimal types, and generators. +""" + +# For Date Time string spec, see ECMA 262 +# http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.15 + + + +r = o.isoformat() +if o.microsecond: +r = r[:23] + r[26:] +if r.endswith('+00:00'): +r = r[:-6] + 'Z' +return r + + + +if timezone and timezone.is_aware(o): +raise ValueError("JSON can't represent timezone-aware times.") +r = o.isoformat() +if o.microsecond: +r = r[:12] +return r + +return str(o.total_seconds()) + + + + +return super(JSONEncoder, self).default(o) ++ + + + except ImportError: +SafeDumper = None +else: +# Adapted from http://pyyaml.org/attachment/ticket/161/use_ordered_dict.py + +""" +Handles decimals as strings. +Handles SortedDicts as usual dicts, but preserves field order, rather +than the usual behaviour of sorting the keys. +""" + +return self.represent_scalar('tag:yaml.org,2002:str', str(data)) ++ + + + + + + + + + + + + + + best_style = False + + + + + +node.flow_style = self.default_flow_style +else: + + ++ + yaml.representer.SafeRepresenter.represent_dict) + +yaml.representer.SafeRepresenter.represent_dict) + +yaml.representer.SafeRepresenter.represent_dict) + +yaml.representer.SafeRepresenter.represent_list) + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Utility functions to return a formatted name and description for a given view. +""" + ++ + + + + + + + """ +Strip trailing component `trailing` from `content` if it exists. +Used when generating names from view classes. +""" + + + ++ + + """ +Remove leading indent from a block of text. +Used when generating descriptions from docstrings. +""" + +for line in content.splitlines()[1:] if line.lstrip()] ++ # unindent the content if needed + + + + + ++ + + """ +Translate 'CamelCaseNames' to 'Camel Case Names'. +Used when generating names from view classes. +""" + + + ++ + + """ +Return a formatted name for an `APIView` class or `@api_view` function. +""" + + + + + + + ++ + + """ +Return a description for an `APIView` class or `@api_view` function. +""" + + + + + ++ + + """ +Apply HTML markup to the given description. +""" + + +else: +description = escape(description).replace('\n', '<br />') + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Handling of media types, as found in HTTP Content-Type and Accept headers. ++ See http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7 +""" + + + ++ + + """ +Returns ``True`` if the media type in the first argument <= the +media type in the second argument. The media types are strings +as described by the HTTP spec. ++ Valid media type strings include: ++ 'application/json; indent=4' +'application/json' +'text/*' +'*/*' +""" + + + ++ + + """ +Returns a list of sets of media type strings, ordered by precedence. +Precedence is determined by how specific a media type is: ++ 3. 'type/subtype; param=val' +2. 'type/subtype' +1. 'type/*' +0. '*/*' +""" + + + + + ++ + + + + media_type_str = '' + + + ++ + """Return true if this MediaType satisfies the given MediaType.""" + +if key != 'q' and other.params.get(key, None) != self.params.get(key, None): +return False ++ + + + + return False ++ + + + def precedence(self): +""" +Return a precedence level from 0-3 for the media type given how specific it is. +""" + + + +return 1 + + + ++ + return unicode(self).encode('utf-8') ++ + ret = "%s/%s" % (self.main_type, self.sub_type) +for key, val in self.params.items(): +ret += "; %s=%s" % (key, val) +return ret + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +Provides an APIView class that is the base of all views in REST framework. +""" + ++ + + + + + + + + + + + + + + + + + + + + + + + def as_view(cls, **initkwargs): +""" +Store the original class on the view function. ++ This allows us to discover information about the view when we do URL +reverse lookups. Used for breadcrumb generation. +""" + + + ++ + def allowed_methods(self): +""" +Wrap Django's private `_allowed_methods` interface in a public property. +""" + ++ + def default_response_headers(self): +# TODO: deprecate? +# TODO: Only vary by accept if multiple renderers + +'Allow': ', '.join(self.allowed_methods), +'Vary': 'Accept' +} ++ + """ +If `request.method` does not correspond to a handler method, +determine what kind of exception to raise. +""" + ++ + """ +If request is not permitted, determine what kind of exception to raise. +""" + + + ++ + """ +If request is throttled, determine what kind of exception to raise. +""" + ++ + """ +If a request is unauthenticated, determine the WWW-Authenticate +header to use for 401 responses, if any. +""" + + + ++ + """ +Returns a dict that is passed through to Parser.parse(), +as the `parser_context` keyword argument. +""" +# Note: Additionally `request` will also be added to the context +# by the Request object. + +'view': self, +'args': getattr(self, 'args', ()), +'kwargs': getattr(self, 'kwargs', {}) +} ++ + """ +Returns a dict that is passed through to Renderer.render(), +as the `renderer_context` keyword argument. +""" +# Note: Additionally 'response' will also be added to the context, +# by the Response object. + +'view': self, +'args': getattr(self, 'args', ()), +'kwargs': getattr(self, 'kwargs', {}), +'request': getattr(self, 'request', None) +} ++ # API policy instantiation methods ++ + """ +Determine if the request includes a '.json' style format suffix +""" + + ++ + """ +Instantiates and returns the list of renderers that this view can use. +""" + ++ + """ +Instantiates and returns the list of parsers that this view can use. +""" + ++ + """ +Instantiates and returns the list of authenticators that this view can use. +""" + ++ + """ +Instantiates and returns the list of permissions that this view requires. +""" + ++ + """ +Instantiates and returns the list of throttles that this view uses. +""" + ++ + """ +Instantiate and return the content negotiation class to use. +""" + + + ++ # API policy implementation methods ++ + """ +Determine which renderer and media type to use render the response. +""" + + ++ + + + + + + + + """ +Perform authentication on the incoming request. ++ Note that if you override this and simply 'pass', then authentication +will instead be performed lazily, the first time either +`request.user` or `request.auth` is accessed. +""" + ++ + """ +Check if the request should be permitted. +Raises an appropriate exception if the request is not permitted. +""" + + + ++ + """ +Check if the request should be permitted for a given object. +Raises an appropriate exception if the request is not permitted. +""" + + + ++ + """ +Check if request should be throttled. +Raises an appropriate exception if the request is throttled. +""" + + + ++ # Dispatch methods ++ + """ +Returns the initial request object. +""" + ++ + parsers=self.get_parsers(), +authenticators=self.get_authenticators(), +negotiator=self.get_content_negotiator(), +parser_context=parser_context) ++ + """ +Runs anything that needs to occur prior to calling the method handler. +""" + ++ # Ensure that the incoming request is permitted + + + ++ # Perform content negotiation and store the accepted info on the request + + ++ + """ +Returns the final response object. +""" +# Make the error obvious if a proper response is not returned + +'Expected a `Response` to be returned from the view, ' +'but received a `%s`' % type(response) +) ++ + + + + + + + + + + + + + + + """ +Handle any exception that occurs, by returning an appropriate response, +or re-raising the error. +""" + +# Throttle wait header + ++ + exceptions.AuthenticationFailed)): +# WWW-Authenticate header for 401 responses, else coerce to 403 + ++ + + else: + ++ + + status=exc.status_code, +exception=True) + + +status=status.HTTP_404_NOT_FOUND, +exception=True) + + +status=status.HTTP_403_FORBIDDEN, +exception=True) + ++ # Note: session based authentication is explicitly CSRF validated, +# all other authentication is CSRF exempt. + +def dispatch(self, request, *args, **kwargs): +""" +`.dispatch()` is pretty much the same as Django's regular dispatch, +but with extra hooks for startup, finalize, and exception handling. +""" + + + + + ++ + + + # Get the appropriate handler method + + +self.http_method_not_allowed) +else: + ++ + + + + + + + + + """ +Handler method for HTTP 'OPTIONS' request. +We may as well implement this as Django will otherwise provide +a less useful default implementation. +""" + ++ + """ +Return a dictionary of metadata about the view. +Used to return responses for OPTIONS requests. +""" ++ # This is used by ViewSets to disambiguate instance vs list views + ++ # By default we can't provide any form-like information, however the +# generic views override this implementation and add additional +# information for POST and PUT methods, based on the serializer. + + + + + + + + |
+
+
+Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | +
+ """ +ViewSets are essentially just a type of class based view, that doesn't provide +any method handlers, such as `get()`, `post()`, etc... but instead has actions, +such as `list()`, `retrieve()`, `create()`, etc... ++ Actions are only bound to methods at the point of instantiating the views. ++ user_list = UserViewSet.as_view({'get': 'list'}) +user_detail = UserViewSet.as_view({'get': 'retrieve'}) ++ Typically, rather than instantiate views from viewsets directly, you'll +regsiter the viewset with a router and let the URL conf be determined +automatically. ++ router = DefaultRouter() +router.register(r'users', UserViewSet, 'user') +urlpatterns = router.urls +""" + ++ + + + + + + """ +This is the magic. ++ Overrides `.as_view()` so that it takes an `actions` keyword that performs +the binding of HTTP methods to actions on the Resource. ++ For example, to create a concrete view binding the 'GET' and 'POST' methods +to the 'list' and 'create' actions... ++ view = MyViewSet.as_view({'get': 'list', 'post': 'create'}) +""" ++ + + """ +Because of the way class based views create a closure around the +instantiated view, we need to totally reimplement `.as_view`, +and slightly modify the view function that is created and returned. +""" +# The suffix initkwarg is reserved for identifing the viewset type +# eg. 'List' or 'Instance'. + ++ # sanitize keyword arguments + + +raise TypeError("You tried to pass in the %s method name as a " +"keyword argument to %s(). Don't do that." +% (key, cls.__name__)) + +raise TypeError("%s() received an invalid keyword %r" % ( +cls.__name__, key)) ++ + + # We also store the mapping of request methods to actions, +# so that we can later set the action attribute. +# eg. `self.action = 'list'` on an incoming GET request. + ++ # Bind methods to actions +# This is the bit that's different to a standard view + + + ++ # Patch this in as it's otherwise only present from 1.5 onwards + + ++ # And continue as usual + ++ # take name and docstring from class + ++ # and possible attributes set by decorators +# like csrf_exempt from dispatch + ++ # We need to set these on the view function, so that breadcrumb +# generation can pick out these bits of information from a +# resolved URL. + + + ++ + """ +Set the `.action` attribute on the view, +depending on the request method. +""" + + + ++ + + """ +The base ViewSet class does not provide any actions by default. +""" + ++ + + """ +The GenericViewSet class does not provide any actions by default, +but does include the base set of generic view behavior, such as +the `get_object` and `get_queryset` methods. +""" + ++ + + mixins.ListModelMixin, +GenericViewSet): +""" +A viewset that provides default `list()` and `retrieve()` actions. +""" + ++ + + mixins.RetrieveModelMixin, +mixins.UpdateModelMixin, +mixins.DestroyModelMixin, +mixins.ListModelMixin, +GenericViewSet): +""" +A viewset that provides default `create()`, `retrieve()`, `update()`, +`partial_update()`, `destroy()` and `list()` actions. +""" + + + |
+