From e5e6329a222def3b0745f90fc55ee36de95ada83 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 29 Aug 2014 11:29:26 +0100
Subject: Remove `pk_url_field`, `slug_url_field`, `slug_field`.

Closes #1773.
---
 rest_framework/relations.py | 117 ++------------------------------------------
 1 file changed, 4 insertions(+), 113 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 1acbdce2..56870b40 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -16,7 +16,6 @@ from rest_framework.fields import Field, WritableField, get_component, is_simple
 from rest_framework.reverse import reverse
 from rest_framework.compat import urlparse
 from rest_framework.compat import smart_text
-import warnings
 
 
 # Relational fields
@@ -320,11 +319,6 @@ class HyperlinkedRelatedField(RelatedField):
         'incorrect_type': _('Incorrect type.  Expected url string, received %s.'),
     }
 
-    # These are all deprecated
-    pk_url_kwarg = 'pk'
-    slug_field = 'slug'
-    slug_url_kwarg = None  # Defaults to same as `slug_field` unless overridden
-
     def __init__(self, *args, **kwargs):
         try:
             self.view_name = kwargs.pop('view_name')
@@ -334,22 +328,6 @@ class HyperlinkedRelatedField(RelatedField):
         self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
         self.format = kwargs.pop('format', None)
 
-        # These are deprecated
-        if 'pk_url_kwarg' in kwargs:
-            msg = 'pk_url_kwarg is deprecated. Use lookup_field instead.'
-            warnings.warn(msg, DeprecationWarning, stacklevel=2)
-        if 'slug_url_kwarg' in kwargs:
-            msg = 'slug_url_kwarg is deprecated. Use lookup_field instead.'
-            warnings.warn(msg, DeprecationWarning, stacklevel=2)
-        if 'slug_field' in kwargs:
-            msg = 'slug_field is deprecated. Use lookup_field instead.'
-            warnings.warn(msg, DeprecationWarning, stacklevel=2)
-
-        self.pk_url_kwarg = kwargs.pop('pk_url_kwarg', self.pk_url_kwarg)
-        self.slug_field = kwargs.pop('slug_field', self.slug_field)
-        default_slug_kwarg = self.slug_url_kwarg or self.slug_field
-        self.slug_url_kwarg = kwargs.pop('slug_url_kwarg', default_slug_kwarg)
-
         super(HyperlinkedRelatedField, self).__init__(*args, **kwargs)
 
     def get_url(self, obj, view_name, request, format):
@@ -361,39 +339,7 @@ class HyperlinkedRelatedField(RelatedField):
         """
         lookup_field = getattr(obj, self.lookup_field)
         kwargs = {self.lookup_field: lookup_field}
-        try:
-            return reverse(view_name, kwargs=kwargs, request=request, format=format)
-        except NoReverseMatch:
-            pass
-
-        if self.pk_url_kwarg != 'pk':
-            # 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
-
-        slug = getattr(obj, self.slug_field, None)
-        if slug is not None:
-            # Only try slug if it corresponds to an attribute on the object.
-            kwargs = {self.slug_url_kwarg: slug}
-            try:
-                ret = reverse(view_name, kwargs=kwargs, request=request, format=format)
-                if self.slug_field == 'slug' and self.slug_url_kwarg == 'slug':
-                    # 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 deprecated.' \
-                          'You should set `lookup_field=slug` on the HyperlinkedRelatedField.'
-                    warnings.warn(msg, DeprecationWarning, stacklevel=2)
-                return ret
-            except NoReverseMatch:
-                pass
-
-        raise NoReverseMatch()
+        return reverse(view_name, kwargs=kwargs, request=request, format=format)
 
     def get_object(self, queryset, view_name, view_args, view_kwargs):
         """
@@ -402,19 +348,8 @@ class HyperlinkedRelatedField(RelatedField):
         Takes the matched URL conf arguments, and the queryset, and should
         return an object instance, or raise an `ObjectDoesNotExist` exception.
         """
-        lookup = view_kwargs.get(self.lookup_field, None)
-        pk = view_kwargs.get(self.pk_url_kwarg, None)
-        slug = view_kwargs.get(self.slug_url_kwarg, None)
-
-        if lookup is not None:
-            filter_kwargs = {self.lookup_field: lookup}
-        elif pk is not None:
-            filter_kwargs = {'pk': pk}
-        elif slug is not None:
-            filter_kwargs = {self.slug_field: slug}
-        else:
-            raise ObjectDoesNotExist()
-
+        lookup_value = view_kwargs[self.lookup_field]
+        filter_kwargs = {self.lookup_field: lookup_value}
         return queryset.get(**filter_kwargs)
 
     def to_native(self, obj):
@@ -486,11 +421,6 @@ class HyperlinkedIdentityField(Field):
     lookup_field = 'pk'
     read_only = True
 
-    # These are all deprecated
-    pk_url_kwarg = 'pk'
-    slug_field = 'slug'
-    slug_url_kwarg = None  # Defaults to same as `slug_field` unless overridden
-
     def __init__(self, *args, **kwargs):
         try:
             self.view_name = kwargs.pop('view_name')
@@ -502,22 +432,6 @@ class HyperlinkedIdentityField(Field):
         lookup_field = kwargs.pop('lookup_field', None)
         self.lookup_field = lookup_field or self.lookup_field
 
-        # These are deprecated
-        if 'pk_url_kwarg' in kwargs:
-            msg = 'pk_url_kwarg is deprecated. Use lookup_field instead.'
-            warnings.warn(msg, DeprecationWarning, stacklevel=2)
-        if 'slug_url_kwarg' in kwargs:
-            msg = 'slug_url_kwarg is deprecated. Use lookup_field instead.'
-            warnings.warn(msg, DeprecationWarning, stacklevel=2)
-        if 'slug_field' in kwargs:
-            msg = 'slug_field is deprecated. Use lookup_field instead.'
-            warnings.warn(msg, DeprecationWarning, stacklevel=2)
-
-        self.slug_field = kwargs.pop('slug_field', self.slug_field)
-        default_slug_kwarg = self.slug_url_kwarg or self.slug_field
-        self.pk_url_kwarg = kwargs.pop('pk_url_kwarg', self.pk_url_kwarg)
-        self.slug_url_kwarg = kwargs.pop('slug_url_kwarg', default_slug_kwarg)
-
         super(HyperlinkedIdentityField, self).__init__(*args, **kwargs)
 
     def field_to_native(self, obj, field_name):
@@ -569,27 +483,4 @@ class HyperlinkedIdentityField(Field):
         if lookup_field is None:
             return None
 
-        try:
-            return reverse(view_name, kwargs=kwargs, request=request, format=format)
-        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()
+        return reverse(view_name, kwargs=kwargs, request=request, format=format)
-- 
cgit v1.2.3


From 4ac4676a40b121d27cfd1173ff548d96b8d3de2f Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 29 Aug 2014 16:46:26 +0100
Subject: First pass

---
 rest_framework/relations.py | 486 --------------------------------------------
 1 file changed, 486 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 56870b40..e69de29b 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -1,486 +0,0 @@
-"""
-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.
-"""
-from __future__ import unicode_literals
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
-from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch
-from django import forms
-from django.db.models.fields import BLANK_CHOICE_DASH
-from django.forms import widgets
-from django.forms.models import ModelChoiceIterator
-from django.utils.translation import ugettext_lazy as _
-from rest_framework.fields import Field, WritableField, get_component, is_simple_callable
-from rest_framework.reverse import reverse
-from rest_framework.compat import urlparse
-from rest_framework.compat import smart_text
-
-
-# Relational fields
-
-# Not actually Writable, but subclasses may need to be.
-class RelatedField(WritableField):
-    """
-    Base class for related model fields.
-
-    This represents a relationship using the unicode representation of the target.
-    """
-    widget = widgets.Select
-    many_widget = widgets.SelectMultiple
-    form_field_class = forms.ChoiceField
-    many_form_field_class = forms.MultipleChoiceField
-    null_values = (None, '', 'None')
-
-    cache_choices = False
-    empty_label = None
-    read_only = True
-    many = False
-
-    def __init__(self, *args, **kwargs):
-        queryset = kwargs.pop('queryset', None)
-        self.many = kwargs.pop('many', self.many)
-        if self.many:
-            self.widget = self.many_widget
-            self.form_field_class = self.many_form_field_class
-
-        kwargs['read_only'] = kwargs.pop('read_only', self.read_only)
-        super(RelatedField, self).__init__(*args, **kwargs)
-
-        if not self.required:
-            # Accessed in ModelChoiceIterator django/forms/models.py:1034
-            # If set adds empty choice.
-            self.empty_label = BLANK_CHOICE_DASH[0][1]
-
-        self.queryset = queryset
-
-    def initialize(self, parent, field_name):
-        super(RelatedField, self).initialize(parent, field_name)
-        if self.queryset is None and not self.read_only:
-            manager = getattr(self.parent.opts.model, self.source or field_name)
-            if hasattr(manager, 'related'):  # Forward
-                self.queryset = manager.related.model._default_manager.all()
-            else:  # Reverse
-                self.queryset = manager.field.rel.to._default_manager.all()
-
-    # We need this stuff to make form choices work...
-
-    def prepare_value(self, obj):
-        return self.to_native(obj)
-
-    def label_from_instance(self, 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)
-
-    def _get_queryset(self):
-        return self._queryset
-
-    def _set_queryset(self, queryset):
-        self._queryset = queryset
-        self.widget.choices = self.choices
-
-    queryset = property(_get_queryset, _set_queryset)
-
-    def _get_choices(self):
-        # If self._choices is set, then somebody must have manually set
-        # the property self.choices. In this case, just return self._choices.
-        if hasattr(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.
-        return ModelChoiceIterator(self)
-
-    def _set_choices(self, value):
-        # 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)
-
-    choices = property(_get_choices, _set_choices)
-
-    # Default value handling
-
-    def get_default_value(self):
-        default = super(RelatedField, self).get_default_value()
-        if self.many and default is None:
-            return []
-        return default
-
-    # Regular serializer stuff...
-
-    def field_to_native(self, obj, field_name):
-        try:
-            if self.source == '*':
-                return self.to_native(obj)
-
-            source = self.source or field_name
-            value = obj
-
-            for component in source.split('.'):
-                if value is None:
-                    break
-                value = get_component(value, component)
-        except ObjectDoesNotExist:
-            return None
-
-        if value is None:
-            return None
-
-        if self.many:
-            if is_simple_callable(getattr(value, 'all', None)):
-                return [self.to_native(item) for item in value.all()]
-            else:
-                # Also support non-queryset iterables.
-                # This allows us to also support plain lists of related items.
-                return [self.to_native(item) for item in value]
-        return self.to_native(value)
-
-    def field_from_native(self, data, files, field_name, into):
-        if self.read_only:
-            return
-
-        try:
-            if self.many:
-                try:
-                    # Form data
-                    value = data.getlist(field_name)
-                    if value == [''] or value == []:
-                        raise KeyError
-                except AttributeError:
-                    # Non-form data
-                    value = data[field_name]
-            else:
-                value = data[field_name]
-        except KeyError:
-            if self.partial:
-                return
-            value = self.get_default_value()
-
-        if value in self.null_values:
-            if self.required:
-                raise ValidationError(self.error_messages['required'])
-            into[(self.source or field_name)] = None
-        elif self.many:
-            into[(self.source or field_name)] = [self.from_native(item) for item in value]
-        else:
-            into[(self.source or field_name)] = self.from_native(value)
-
-
-# PrimaryKey relationships
-
-class PrimaryKeyRelatedField(RelatedField):
-    """
-    Represents a relationship as a pk value.
-    """
-    read_only = False
-
-    default_error_messages = {
-        'does_not_exist': _("Invalid pk '%s' - object does not exist."),
-        'incorrect_type': _('Incorrect type.  Expected pk value, received %s.'),
-    }
-
-    # TODO: Remove these field hacks...
-    def prepare_value(self, obj):
-        return self.to_native(obj.pk)
-
-    def label_from_instance(self, obj):
-        """
-        Return a readable representation for use with eg. select widgets.
-        """
-        desc = smart_text(obj)
-        ident = smart_text(self.to_native(obj.pk))
-        if desc == ident:
-            return desc
-        return "%s - %s" % (desc, ident)
-
-    # TODO: Possibly change this to just take `obj`, through prob less performant
-    def to_native(self, pk):
-        return pk
-
-    def from_native(self, data):
-        if self.queryset is None:
-            raise Exception('Writable related fields must include a `queryset` argument')
-
-        try:
-            return self.queryset.get(pk=data)
-        except ObjectDoesNotExist:
-            msg = self.error_messages['does_not_exist'] % smart_text(data)
-            raise ValidationError(msg)
-        except (TypeError, ValueError):
-            received = type(data).__name__
-            msg = self.error_messages['incorrect_type'] % received
-            raise ValidationError(msg)
-
-    def field_to_native(self, obj, field_name):
-        if self.many:
-            # To-many relationship
-
-            queryset = None
-            if not self.source:
-                # Prefer obj.serializable_value for performance reasons
-                try:
-                    queryset = obj.serializable_value(field_name)
-                except AttributeError:
-                    pass
-            if queryset is None:
-                # RelatedManager (reverse relationship)
-                source = self.source or field_name
-                queryset = obj
-                for component in source.split('.'):
-                    if queryset is None:
-                        return []
-                    queryset = get_component(queryset, component)
-
-            # Forward relationship
-            if is_simple_callable(getattr(queryset, 'all', None)):
-                return [self.to_native(item.pk) for item in queryset.all()]
-            else:
-                # Also support non-queryset iterables.
-                # This allows us to also support plain lists of related items.
-                return [self.to_native(item.pk) for item in queryset]
-
-        # To-one relationship
-        try:
-            # Prefer obj.serializable_value for performance reasons
-            pk = obj.serializable_value(self.source or field_name)
-        except AttributeError:
-            # RelatedObject (reverse relationship)
-            try:
-                pk = getattr(obj, self.source or field_name).pk
-            except (ObjectDoesNotExist, AttributeError):
-                return None
-
-        # Forward relationship
-        return self.to_native(pk)
-
-
-# Slug relationships
-
-class SlugRelatedField(RelatedField):
-    """
-    Represents a relationship using a unique field on the target.
-    """
-    read_only = False
-
-    default_error_messages = {
-        'does_not_exist': _("Object with %s=%s does not exist."),
-        'invalid': _('Invalid value.'),
-    }
-
-    def __init__(self, *args, **kwargs):
-        self.slug_field = kwargs.pop('slug_field', None)
-        assert self.slug_field, 'slug_field is required'
-        super(SlugRelatedField, self).__init__(*args, **kwargs)
-
-    def to_native(self, obj):
-        return getattr(obj, self.slug_field)
-
-    def from_native(self, data):
-        if self.queryset is None:
-            raise Exception('Writable related fields must include a `queryset` argument')
-
-        try:
-            return self.queryset.get(**{self.slug_field: data})
-        except ObjectDoesNotExist:
-            raise ValidationError(self.error_messages['does_not_exist'] %
-                                  (self.slug_field, smart_text(data)))
-        except (TypeError, ValueError):
-            msg = self.error_messages['invalid']
-            raise ValidationError(msg)
-
-
-# Hyperlinked relationships
-
-class HyperlinkedRelatedField(RelatedField):
-    """
-    Represents a relationship using hyperlinking.
-    """
-    read_only = False
-    lookup_field = 'pk'
-
-    default_error_messages = {
-        '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.'),
-    }
-
-    def __init__(self, *args, **kwargs):
-        try:
-            self.view_name = kwargs.pop('view_name')
-        except KeyError:
-            raise ValueError("Hyperlinked field requires 'view_name' kwarg")
-
-        self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
-        self.format = kwargs.pop('format', None)
-
-        super(HyperlinkedRelatedField, self).__init__(*args, **kwargs)
-
-    def get_url(self, obj, view_name, request, format):
-        """
-        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.
-        """
-        lookup_field = getattr(obj, self.lookup_field)
-        kwargs = {self.lookup_field: lookup_field}
-        return reverse(view_name, kwargs=kwargs, request=request, format=format)
-
-    def get_object(self, queryset, view_name, view_args, view_kwargs):
-        """
-        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.
-        """
-        lookup_value = view_kwargs[self.lookup_field]
-        filter_kwargs = {self.lookup_field: lookup_value}
-        return queryset.get(**filter_kwargs)
-
-    def to_native(self, obj):
-        view_name = self.view_name
-        request = self.context.get('request', None)
-        format = self.format or self.context.get('format', None)
-
-        assert request is not None, (
-            "`HyperlinkedRelatedField` requires the request in the serializer "
-            "context. Add `context={'request': request}` when instantiating "
-            "the serializer."
-        )
-
-        # If the object has not yet been saved then we cannot hyperlink to it.
-        if getattr(obj, 'pk', None) is None:
-            return
-
-        # Return the hyperlink, or error if incorrectly configured.
-        try:
-            return self.get_url(obj, view_name, request, format)
-        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)
-
-    def from_native(self, value):
-        # Convert URL -> model instance pk
-        # TODO: Use values_list
-        queryset = self.queryset
-        if queryset is None:
-            raise Exception('Writable related fields must include a `queryset` argument')
-
-        try:
-            http_prefix = value.startswith(('http:', 'https:'))
-        except AttributeError:
-            msg = self.error_messages['incorrect_type']
-            raise ValidationError(msg % type(value).__name__)
-
-        if http_prefix:
-            # If needed convert absolute URLs to relative path
-            value = urlparse.urlparse(value).path
-            prefix = get_script_prefix()
-            if value.startswith(prefix):
-                value = '/' + value[len(prefix):]
-
-        try:
-            match = resolve(value)
-        except Exception:
-            raise ValidationError(self.error_messages['no_match'])
-
-        if match.view_name != self.view_name:
-            raise ValidationError(self.error_messages['incorrect_match'])
-
-        try:
-            return self.get_object(queryset, match.view_name,
-                                   match.args, match.kwargs)
-        except (ObjectDoesNotExist, TypeError, ValueError):
-            raise ValidationError(self.error_messages['does_not_exist'])
-
-
-class HyperlinkedIdentityField(Field):
-    """
-    Represents the instance, or a property on the instance, using hyperlinking.
-    """
-    lookup_field = 'pk'
-    read_only = True
-
-    def __init__(self, *args, **kwargs):
-        try:
-            self.view_name = kwargs.pop('view_name')
-        except KeyError:
-            msg = "HyperlinkedIdentityField requires 'view_name' argument"
-            raise ValueError(msg)
-
-        self.format = kwargs.pop('format', None)
-        lookup_field = kwargs.pop('lookup_field', None)
-        self.lookup_field = lookup_field or self.lookup_field
-
-        super(HyperlinkedIdentityField, self).__init__(*args, **kwargs)
-
-    def field_to_native(self, obj, field_name):
-        request = self.context.get('request', None)
-        format = self.context.get('format', None)
-        view_name = self.view_name
-
-        assert request is not None, (
-            "`HyperlinkedIdentityField` requires the request in the serializer"
-            " context. Add `context={'request': request}` when instantiating "
-            "the serializer."
-        )
-
-        # 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'
-        if format and self.format and self.format != format:
-            format = self.format
-
-        # Return the hyperlink, or error if incorrectly configured.
-        try:
-            return self.get_url(obj, view_name, request, format)
-        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)
-
-    def get_url(self, obj, view_name, request, format):
-        """
-        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.
-        """
-        lookup_field = getattr(obj, self.lookup_field, None)
-        kwargs = {self.lookup_field: lookup_field}
-
-        # Handle unsaved object case
-        if lookup_field is None:
-            return None
-
-        return reverse(view_name, kwargs=kwargs, request=request, format=format)
-- 
cgit v1.2.3


From ec096a1caceff6a4f5c75a152dd1c7bea9ed281d Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 2 Sep 2014 15:07:56 +0100
Subject: Add relations and get tests running

---
 rest_framework/relations.py | 111 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 111 insertions(+)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index e69de29b..42d2c121 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -0,0 +1,111 @@
+from rest_framework.fields import Field
+from django.core.exceptions import ObjectDoesNotExist
+from django.core.urlresolvers import resolve, get_script_prefix
+from rest_framework.compat import urlparse
+
+
+def get_default_queryset(serializer_class, field_name):
+    manager = getattr(serializer_class.opts.model, field_name)
+    if hasattr(manager, 'related'):
+        # Forward relationships
+        return manager.related.model._default_manager.all()
+    # Reverse relationships
+    return manager.field.rel.to._default_manager.all()
+
+
+class RelatedField(Field):
+    def __init__(self, **kwargs):
+        self.queryset = kwargs.pop('queryset', None)
+        self.many = kwargs.pop('many', False)
+        super(RelatedField, self).__init__(**kwargs)
+
+    def bind(self, field_name, parent, root):
+        super(RelatedField, self).bind(field_name, parent, root)
+        if self.queryset is None and not self.read_only:
+            self.queryset = get_default_queryset(parent, self.source)
+
+
+class PrimaryKeyRelatedField(RelatedField):
+    MESSAGES = {
+        'required': 'This field is required.',
+        'does_not_exist': "Invalid pk '{pk_value}' - object does not exist.",
+        'incorrect_type': 'Incorrect type.  Expected pk value, received {data_type}.',
+    }
+
+    def from_native(self, data):
+        try:
+            return self.queryset.get(pk=data)
+        except ObjectDoesNotExist:
+            self.fail('does_not_exist', pk_value=data)
+        except (TypeError, ValueError):
+            self.fail('incorrect_type', data_type=type(data).__name__)
+
+
+class HyperlinkedRelatedField(RelatedField):
+    lookup_field = 'pk'
+
+    MESSAGES = {
+        'required': 'This field is required.',
+        'no_match': 'Invalid hyperlink - No URL match',
+        'incorrect_match': 'Invalid hyperlink - Incorrect URL match.',
+        'does_not_exist': "Invalid hyperlink - Object does not exist.",
+        'incorrect_type': 'Incorrect type.  Expected URL string, received {data_type}.',
+    }
+
+    def __init__(self, **kwargs):
+        self.view_name = kwargs.pop('view_name')
+        self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
+        self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
+        super(HyperlinkedRelatedField, self).__init__(**kwargs)
+
+    def get_object(self, view_name, view_args, view_kwargs):
+        """
+        Return the object corresponding to a matched URL.
+
+        Takes the matched URL conf arguments, and should return an
+        object instance, or raise an `ObjectDoesNotExist` exception.
+        """
+        lookup_value = view_kwargs[self.lookup_url_kwarg]
+        lookup_kwargs = {self.lookup_field: lookup_value}
+        return self.queryset.get(**lookup_kwargs)
+
+    def from_native(self, value):
+        try:
+            http_prefix = value.startswith(('http:', 'https:'))
+        except AttributeError:
+            self.fail('incorrect_type', type(value).__name__)
+
+        if http_prefix:
+            # If needed convert absolute URLs to relative path
+            value = urlparse.urlparse(value).path
+            prefix = get_script_prefix()
+            if value.startswith(prefix):
+                value = '/' + value[len(prefix):]
+
+        try:
+            match = resolve(value)
+        except Exception:
+            self.fail('no_match')
+
+        if match.view_name != self.view_name:
+            self.fail('incorrect_match')
+
+        try:
+            return self.get_object(match.view_name, match.args, match.kwargs)
+        except (ObjectDoesNotExist, TypeError, ValueError):
+            self.fail('does_not_exist')
+
+
+class HyperlinkedIdentityField(RelatedField):
+    lookup_field = 'pk'
+
+    def __init__(self, **kwargs):
+        self.view_name = kwargs.pop('view_name')
+        self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
+        self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
+        super(HyperlinkedIdentityField, self).__init__(**kwargs)
+
+
+class SlugRelatedField(RelatedField):
+    def __init__(self, **kwargs):
+        self.slug_field = kwargs.pop('slug_field', None)
-- 
cgit v1.2.3


From f2852811f93863f2eed04d51eeb7ef27716b2409 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 2 Sep 2014 17:41:23 +0100
Subject: Getting tests passing

---
 rest_framework/relations.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 42d2c121..0b01394a 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -73,7 +73,7 @@ class HyperlinkedRelatedField(RelatedField):
         try:
             http_prefix = value.startswith(('http:', 'https:'))
         except AttributeError:
-            self.fail('incorrect_type', type(value).__name__)
+            self.fail('incorrect_type', data_type=type(value).__name__)
 
         if http_prefix:
             # If needed convert absolute URLs to relative path
-- 
cgit v1.2.3


From c1036c17533a3091401ff90f825571f0e6125eca Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 3 Sep 2014 16:34:09 +0100
Subject: More test passing

---
 rest_framework/relations.py | 56 ++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 0b01394a..661a1249 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -1,6 +1,7 @@
 from rest_framework.fields import Field
+from rest_framework.reverse import reverse
 from django.core.exceptions import ObjectDoesNotExist
-from django.core.urlresolvers import resolve, get_script_prefix
+from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch
 from rest_framework.compat import urlparse
 
 
@@ -100,11 +101,64 @@ class HyperlinkedIdentityField(RelatedField):
     lookup_field = 'pk'
 
     def __init__(self, **kwargs):
+        kwargs['read_only'] = True
         self.view_name = kwargs.pop('view_name')
         self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
         self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
         super(HyperlinkedIdentityField, self).__init__(**kwargs)
 
+    def get_attribute(self, instance):
+        return instance
+
+    def to_primative(self, value):
+        request = self.context.get('request', None)
+        format = self.context.get('format', None)
+
+        assert request is not None, (
+            "`HyperlinkedIdentityField` requires the request in the serializer"
+            " context. Add `context={'request': request}` when instantiating "
+            "the serializer."
+        )
+
+        # 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'
+        if format and self.format and self.format != format:
+            format = self.format
+
+        # Return the hyperlink, or error if incorrectly configured.
+        try:
+            return self.get_url(value, self.view_name, request, format)
+        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 % self.view_name)
+
+    def get_url(self, obj, view_name, request, format):
+        """
+        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.
+        """
+        # Unsaved objects will not yet have a valid URL.
+        if obj.pk is None:
+            return None
+
+        lookup_value = getattr(obj, self.lookup_field)
+        kwargs = {self.lookup_url_kwarg: lookup_value}
+        return reverse(view_name, kwargs=kwargs, request=request, format=format)
+
 
 class SlugRelatedField(RelatedField):
     def __init__(self, **kwargs):
-- 
cgit v1.2.3


From 0d354e8f92c7daaf8dac3b80f0fd64f983f21e0b Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 12 Sep 2014 09:49:35 +0100
Subject: to_internal_value() and to_representation()

---
 rest_framework/relations.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 661a1249..30a252db 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -110,7 +110,7 @@ class HyperlinkedIdentityField(RelatedField):
     def get_attribute(self, instance):
         return instance
 
-    def to_primative(self, value):
+    def to_representation(self, value):
         request = self.context.get('request', None)
         format = self.context.get('format', None)
 
-- 
cgit v1.2.3


From 250755def707e1397876614fa0c08130d9fcc449 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 12 Sep 2014 10:59:51 +0100
Subject: Clean up relational fields queryset usage

---
 rest_framework/relations.py | 73 ++++++++++++++++++++++++---------------------
 1 file changed, 39 insertions(+), 34 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 30a252db..e23a4152 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -2,28 +2,35 @@ from rest_framework.fields import Field
 from rest_framework.reverse import reverse
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch
+from django.db.models.query import QuerySet
 from rest_framework.compat import urlparse
 
 
-def get_default_queryset(serializer_class, field_name):
-    manager = getattr(serializer_class.opts.model, field_name)
-    if hasattr(manager, 'related'):
-        # Forward relationships
-        return manager.related.model._default_manager.all()
-    # Reverse relationships
-    return manager.field.rel.to._default_manager.all()
-
-
 class RelatedField(Field):
     def __init__(self, **kwargs):
         self.queryset = kwargs.pop('queryset', None)
         self.many = kwargs.pop('many', False)
+        assert self.queryset is not None or kwargs.get('read_only', False), (
+            'Relational field must provide a `queryset` argument, '
+            'or set read_only=`True`.'
+        )
         super(RelatedField, self).__init__(**kwargs)
 
-    def bind(self, field_name, parent, root):
-        super(RelatedField, self).bind(field_name, parent, root)
-        if self.queryset is None and not self.read_only:
-            self.queryset = get_default_queryset(parent, self.source)
+    def get_queryset(self):
+        queryset = self.queryset
+        if isinstance(queryset, QuerySet):
+            # Ensure queryset is re-evaluated whenever used.
+            queryset = queryset.all()
+        return queryset
+
+
+class StringRelatedField(Field):
+    def __init__(self, **kwargs):
+        kwargs['read_only'] = True
+        super(StringRelatedField, self).__init__(**kwargs)
+
+    def to_representation(self, value):
+        return str(value)
 
 
 class PrimaryKeyRelatedField(RelatedField):
@@ -33,9 +40,9 @@ class PrimaryKeyRelatedField(RelatedField):
         'incorrect_type': 'Incorrect type.  Expected pk value, received {data_type}.',
     }
 
-    def from_native(self, data):
+    def to_internal_value(self, data):
         try:
-            return self.queryset.get(pk=data)
+            return self.get_queryset().get(pk=data)
         except ObjectDoesNotExist:
             self.fail('does_not_exist', pk_value=data)
         except (TypeError, ValueError):
@@ -68,9 +75,9 @@ class HyperlinkedRelatedField(RelatedField):
         """
         lookup_value = view_kwargs[self.lookup_url_kwarg]
         lookup_kwargs = {self.lookup_field: lookup_value}
-        return self.queryset.get(**lookup_kwargs)
+        return self.get_queryset().get(**lookup_kwargs)
 
-    def from_native(self, value):
+    def to_internal_value(self, value):
         try:
             http_prefix = value.startswith(('http:', 'https:'))
         except AttributeError:
@@ -102,13 +109,26 @@ class HyperlinkedIdentityField(RelatedField):
 
     def __init__(self, **kwargs):
         kwargs['read_only'] = True
+        kwargs['source'] = '*'
         self.view_name = kwargs.pop('view_name')
         self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
         self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
         super(HyperlinkedIdentityField, self).__init__(**kwargs)
 
-    def get_attribute(self, instance):
-        return instance
+    def get_url(self, obj, view_name, request, format):
+        """
+        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.
+        """
+        # Unsaved objects will not yet have a valid URL.
+        if obj.pk is None:
+            return None
+
+        lookup_value = getattr(obj, self.lookup_field)
+        kwargs = {self.lookup_url_kwarg: lookup_value}
+        return reverse(view_name, kwargs=kwargs, request=request, format=format)
 
     def to_representation(self, value):
         request = self.context.get('request', None)
@@ -144,21 +164,6 @@ class HyperlinkedIdentityField(RelatedField):
             )
             raise Exception(msg % self.view_name)
 
-    def get_url(self, obj, view_name, request, format):
-        """
-        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.
-        """
-        # Unsaved objects will not yet have a valid URL.
-        if obj.pk is None:
-            return None
-
-        lookup_value = getattr(obj, self.lookup_field)
-        kwargs = {self.lookup_url_kwarg: lookup_value}
-        return reverse(view_name, kwargs=kwargs, request=request, format=format)
-
 
 class SlugRelatedField(RelatedField):
     def __init__(self, **kwargs):
-- 
cgit v1.2.3


From b73a205cc021983d9a508b447f30e144a1ce4129 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 12 Sep 2014 17:03:42 +0100
Subject: Tests for relational fields (not including many=True)

---
 rest_framework/relations.py | 143 +++++++++++++++++++++++++++++---------------
 1 file changed, 94 insertions(+), 49 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index e23a4152..75ec89a8 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -1,19 +1,24 @@
+from rest_framework.compat import smart_text, urlparse
 from rest_framework.fields import Field
 from rest_framework.reverse import reverse
-from django.core.exceptions import ObjectDoesNotExist
+from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
 from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch
 from django.db.models.query import QuerySet
-from rest_framework.compat import urlparse
+from django.utils.translation import ugettext_lazy as _
 
 
 class RelatedField(Field):
     def __init__(self, **kwargs):
         self.queryset = kwargs.pop('queryset', None)
         self.many = kwargs.pop('many', False)
-        assert self.queryset is not None or kwargs.get('read_only', False), (
+        assert self.queryset is not None or kwargs.get('read_only', None), (
             'Relational field must provide a `queryset` argument, '
             'or set read_only=`True`.'
         )
+        assert not (self.queryset is not None and kwargs.get('read_only', None)), (
+            'Relational fields should not provide a `queryset` argument, '
+            'when setting read_only=`True`.'
+        )
         super(RelatedField, self).__init__(**kwargs)
 
     def get_queryset(self):
@@ -25,6 +30,11 @@ class RelatedField(Field):
 
 
 class StringRelatedField(Field):
+    """
+    A read only field that represents its targets using their
+    plain string representation.
+    """
+
     def __init__(self, **kwargs):
         kwargs['read_only'] = True
         super(StringRelatedField, self).__init__(**kwargs)
@@ -34,10 +44,10 @@ class StringRelatedField(Field):
 
 
 class PrimaryKeyRelatedField(RelatedField):
-    MESSAGES = {
+    default_error_messages = {
         'required': 'This field is required.',
         'does_not_exist': "Invalid pk '{pk_value}' - object does not exist.",
-        'incorrect_type': 'Incorrect type.  Expected pk value, received {data_type}.',
+        'incorrect_type': 'Incorrect type. Expected pk value, received {data_type}.',
     }
 
     def to_internal_value(self, data):
@@ -48,22 +58,33 @@ class PrimaryKeyRelatedField(RelatedField):
         except (TypeError, ValueError):
             self.fail('incorrect_type', data_type=type(data).__name__)
 
+    def to_representation(self, value):
+        return value.pk
+
 
 class HyperlinkedRelatedField(RelatedField):
     lookup_field = 'pk'
 
-    MESSAGES = {
+    default_error_messages = {
         'required': 'This field is required.',
         'no_match': 'Invalid hyperlink - No URL match',
         'incorrect_match': 'Invalid hyperlink - Incorrect URL match.',
-        'does_not_exist': "Invalid hyperlink - Object does not exist.",
-        'incorrect_type': 'Incorrect type.  Expected URL string, received {data_type}.',
+        'does_not_exist': 'Invalid hyperlink - Object does not exist.',
+        'incorrect_type': 'Incorrect type. Expected URL string, received {data_type}.',
     }
 
-    def __init__(self, **kwargs):
-        self.view_name = kwargs.pop('view_name')
+    def __init__(self, view_name, **kwargs):
+        self.view_name = view_name
         self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
         self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
+        self.format = kwargs.pop('format', None)
+
+        # We include these simply for dependancy injection in tests.
+        # We can't add them as class attributes or they would expect an
+        # implict `self` argument to be passed.
+        self.reverse = reverse
+        self.resolve = resolve
+
         super(HyperlinkedRelatedField, self).__init__(**kwargs)
 
     def get_object(self, view_name, view_args, view_kwargs):
@@ -77,21 +98,36 @@ class HyperlinkedRelatedField(RelatedField):
         lookup_kwargs = {self.lookup_field: lookup_value}
         return self.get_queryset().get(**lookup_kwargs)
 
-    def to_internal_value(self, value):
+    def get_url(self, obj, view_name, request, format):
+        """
+        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.
+        """
+        # Unsaved objects will not yet have a valid URL.
+        if obj.pk is None:
+            return None
+
+        lookup_value = getattr(obj, self.lookup_field)
+        kwargs = {self.lookup_url_kwarg: lookup_value}
+        return self.reverse(view_name, kwargs=kwargs, request=request, format=format)
+
+    def to_internal_value(self, data):
         try:
-            http_prefix = value.startswith(('http:', 'https:'))
+            http_prefix = data.startswith(('http:', 'https:'))
         except AttributeError:
-            self.fail('incorrect_type', data_type=type(value).__name__)
+            self.fail('incorrect_type', data_type=type(data).__name__)
 
         if http_prefix:
             # If needed convert absolute URLs to relative path
-            value = urlparse.urlparse(value).path
+            data = urlparse.urlparse(data).path
             prefix = get_script_prefix()
-            if value.startswith(prefix):
-                value = '/' + value[len(prefix):]
+            if data.startswith(prefix):
+                data = '/' + data[len(prefix):]
 
         try:
-            match = resolve(value)
+            match = self.resolve(data)
         except Exception:
             self.fail('no_match')
 
@@ -103,41 +139,14 @@ class HyperlinkedRelatedField(RelatedField):
         except (ObjectDoesNotExist, TypeError, ValueError):
             self.fail('does_not_exist')
 
-
-class HyperlinkedIdentityField(RelatedField):
-    lookup_field = 'pk'
-
-    def __init__(self, **kwargs):
-        kwargs['read_only'] = True
-        kwargs['source'] = '*'
-        self.view_name = kwargs.pop('view_name')
-        self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
-        self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
-        super(HyperlinkedIdentityField, self).__init__(**kwargs)
-
-    def get_url(self, obj, view_name, request, format):
-        """
-        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.
-        """
-        # Unsaved objects will not yet have a valid URL.
-        if obj.pk is None:
-            return None
-
-        lookup_value = getattr(obj, self.lookup_field)
-        kwargs = {self.lookup_url_kwarg: lookup_value}
-        return reverse(view_name, kwargs=kwargs, request=request, format=format)
-
     def to_representation(self, value):
         request = self.context.get('request', None)
         format = self.context.get('format', None)
 
         assert request is not None, (
-            "`HyperlinkedIdentityField` requires the request in the serializer"
+            "`%s` requires the request in the serializer"
             " context. Add `context={'request': request}` when instantiating "
-            "the serializer."
+            "the serializer." % self.__class__.__name__
         )
 
         # By default use whatever format is given for the current context
@@ -162,9 +171,45 @@ class HyperlinkedIdentityField(RelatedField):
                 'model in your API, or incorrectly configured the '
                 '`lookup_field` attribute on this field.'
             )
-            raise Exception(msg % self.view_name)
+            raise ImproperlyConfigured(msg % self.view_name)
+
+
+class HyperlinkedIdentityField(HyperlinkedRelatedField):
+    """
+    A read-only field that represents the identity URL for an object, itself.
+
+    This is in contrast to `HyperlinkedRelatedField` which represents the
+    URL of relationships to other objects.
+    """
+
+    def __init__(self, view_name, **kwargs):
+        kwargs['read_only'] = True
+        kwargs['source'] = '*'
+        super(HyperlinkedIdentityField, self).__init__(view_name, **kwargs)
 
 
 class SlugRelatedField(RelatedField):
-    def __init__(self, **kwargs):
-        self.slug_field = kwargs.pop('slug_field', None)
+    """
+    A read-write field the represents the target of the relationship
+    by a unique 'slug' attribute.
+    """
+
+    default_error_messages = {
+        'does_not_exist': _("Object with {slug_name}={value} does not exist."),
+        'invalid': _('Invalid value.'),
+    }
+
+    def __init__(self, slug_field, **kwargs):
+        self.slug_field = slug_field
+        super(SlugRelatedField, self).__init__(**kwargs)
+
+    def to_internal_value(self, data):
+        try:
+            return self.get_queryset().get(**{self.slug_field: data})
+        except ObjectDoesNotExist:
+            self.fail('does_not_exist', slug_name=self.slug_field, value=smart_text(data))
+        except (TypeError, ValueError):
+            self.fail('invalid')
+
+    def to_representation(self, obj):
+        return getattr(obj, self.slug_field)
-- 
cgit v1.2.3


From 0ac52e0808288892717c017e57c57aa8ad81e6d3 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 12 Sep 2014 17:06:37 +0100
Subject: Use Resolver404 instead of base Exception

---
 rest_framework/relations.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 75ec89a8..46fe55ef 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -2,7 +2,7 @@ from rest_framework.compat import smart_text, urlparse
 from rest_framework.fields import Field
 from rest_framework.reverse import reverse
 from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
-from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch
+from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch, Resolver404
 from django.db.models.query import QuerySet
 from django.utils.translation import ugettext_lazy as _
 
@@ -128,7 +128,7 @@ class HyperlinkedRelatedField(RelatedField):
 
         try:
             match = self.resolve(data)
-        except Exception:
+        except Resolver404:
             self.fail('no_match')
 
         if match.view_name != self.view_name:
-- 
cgit v1.2.3


From 5b7e4af0d657a575cb15eea85a63a7100c636085 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 18 Sep 2014 11:20:56 +0100
Subject: get_base_field() refactor

---
 rest_framework/relations.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 46fe55ef..9f44ab63 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -73,7 +73,8 @@ class HyperlinkedRelatedField(RelatedField):
         'incorrect_type': 'Incorrect type. Expected URL string, received {data_type}.',
     }
 
-    def __init__(self, view_name, **kwargs):
+    def __init__(self, view_name=None, **kwargs):
+        assert view_name is not None, 'The `view_name` argument is required.'
         self.view_name = view_name
         self.lookup_field = kwargs.pop('lookup_field', self.lookup_field)
         self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
@@ -182,7 +183,8 @@ class HyperlinkedIdentityField(HyperlinkedRelatedField):
     URL of relationships to other objects.
     """
 
-    def __init__(self, view_name, **kwargs):
+    def __init__(self, view_name=None, **kwargs):
+        assert view_name is not None, 'The `view_name` argument is required.'
         kwargs['read_only'] = True
         kwargs['source'] = '*'
         super(HyperlinkedIdentityField, self).__init__(view_name, **kwargs)
@@ -199,7 +201,8 @@ class SlugRelatedField(RelatedField):
         'invalid': _('Invalid value.'),
     }
 
-    def __init__(self, slug_field, **kwargs):
+    def __init__(self, slug_field=None, **kwargs):
+        assert slug_field is not None, 'The `slug_field` argument is required.'
         self.slug_field = slug_field
         super(SlugRelatedField, self).__init__(**kwargs)
 
-- 
cgit v1.2.3


From 9fdb2280d11db126771686d626aa8a0247b8a46c Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 18 Sep 2014 14:23:00 +0100
Subject: First pass on ManyRelation

---
 rest_framework/relations.py | 42 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 41 insertions(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 9f44ab63..474d3e75 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -10,7 +10,6 @@ from django.utils.translation import ugettext_lazy as _
 class RelatedField(Field):
     def __init__(self, **kwargs):
         self.queryset = kwargs.pop('queryset', None)
-        self.many = kwargs.pop('many', False)
         assert self.queryset is not None or kwargs.get('read_only', None), (
             'Relational field must provide a `queryset` argument, '
             'or set read_only=`True`.'
@@ -21,6 +20,13 @@ class RelatedField(Field):
         )
         super(RelatedField, self).__init__(**kwargs)
 
+    def __new__(cls, *args, **kwargs):
+        # We override this method in order to automagically create
+        # `ManyRelation` classes instead when `many=True` is set.
+        if kwargs.pop('many', False):
+            return ManyRelation(child_relation=cls(*args, **kwargs))
+        return super(RelatedField, cls).__new__(cls, *args, **kwargs)
+
     def get_queryset(self):
         queryset = self.queryset
         if isinstance(queryset, QuerySet):
@@ -216,3 +222,37 @@ class SlugRelatedField(RelatedField):
 
     def to_representation(self, obj):
         return getattr(obj, self.slug_field)
+
+
+class ManyRelation(Field):
+    """
+    Relationships with `many=True` transparently get coerced into instead being
+    a ManyRelation with a child relationship.
+
+    The `ManyRelation` class is responsible for handling iterating through
+    the values and passing each one to the child relationship.
+
+    You shouldn't need to be using this class directly yourself.
+    """
+
+    def __init__(self, child_relation=None, *args, **kwargs):
+        self.child_relation = child_relation
+        assert child_relation is not None, '`child_relation` is a required argument.'
+        super(ManyRelation, self).__init__(*args, **kwargs)
+
+    def bind(self, field_name, parent, root):
+        # ManyRelation needs to provide the current context to the child relation.
+        super(ManyRelation, self).bind(field_name, parent, root)
+        self.child_relation.bind(field_name, parent, root)
+
+    def to_internal_value(self, data):
+        return [
+            self.child_relation.to_internal_value(item)
+            for item in data
+        ]
+
+    def to_representation(self, obj):
+        return [
+            self.child_relation.to_representation(value)
+            for value in obj.all()
+        ]
-- 
cgit v1.2.3


From 106362b437f45e04faaea759df57a66a8a2d7cfd Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 18 Sep 2014 14:58:08 +0100
Subject: ModelSerializer.create() to handle many to many by default

---
 rest_framework/relations.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 474d3e75..5aa1f8bd 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -24,7 +24,10 @@ class RelatedField(Field):
         # We override this method in order to automagically create
         # `ManyRelation` classes instead when `many=True` is set.
         if kwargs.pop('many', False):
-            return ManyRelation(child_relation=cls(*args, **kwargs))
+            return ManyRelation(
+                child_relation=cls(*args, **kwargs),
+                read_only=kwargs.get('read_only', False)
+            )
         return super(RelatedField, cls).__new__(cls, *args, **kwargs)
 
     def get_queryset(self):
-- 
cgit v1.2.3


From 64632da3718f501cb8174243385d38b547c2fefd Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 25 Sep 2014 11:40:32 +0100
Subject: Clean up bind - no longer needs to be called multiple times in nested
 fields

---
 rest_framework/relations.py | 5 -----
 1 file changed, 5 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 5aa1f8bd..b37a6fed 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -243,11 +243,6 @@ class ManyRelation(Field):
         assert child_relation is not None, '`child_relation` is a required argument.'
         super(ManyRelation, self).__init__(*args, **kwargs)
 
-    def bind(self, field_name, parent, root):
-        # ManyRelation needs to provide the current context to the child relation.
-        super(ManyRelation, self).bind(field_name, parent, root)
-        self.child_relation.bind(field_name, parent, root)
-
     def to_internal_value(self, data):
         return [
             self.child_relation.to_internal_value(item)
-- 
cgit v1.2.3


From 381771731f48c75e7d5951e353049cceec386512 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 1 Oct 2014 13:09:14 +0100
Subject: Use six.text_type instead of str everywhere

---
 rest_framework/relations.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index b37a6fed..b5effc6c 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -4,6 +4,7 @@ from rest_framework.reverse import reverse
 from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
 from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch, Resolver404
 from django.db.models.query import QuerySet
+from django.utils import six
 from django.utils.translation import ugettext_lazy as _
 
 
@@ -49,7 +50,7 @@ class StringRelatedField(Field):
         super(StringRelatedField, self).__init__(**kwargs)
 
     def to_representation(self, value):
-        return str(value)
+        return six.text_type(value)
 
 
 class PrimaryKeyRelatedField(RelatedField):
-- 
cgit v1.2.3


From ffc6aa3abcb0f823b43b63db1666913565e6f934 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 1 Oct 2014 21:35:27 +0100
Subject: More forms support

---
 rest_framework/relations.py | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index b5effc6c..8c135672 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -38,6 +38,16 @@ class RelatedField(Field):
             queryset = queryset.all()
         return queryset
 
+    @property
+    def choices(self):
+        return dict([
+            (
+                str(self.to_representation(item)),
+                str(item)
+            )
+            for item in self.queryset.all()
+        ])
+
 
 class StringRelatedField(Field):
     """
@@ -255,3 +265,13 @@ class ManyRelation(Field):
             self.child_relation.to_representation(value)
             for value in obj.all()
         ]
+
+    @property
+    def choices(self):
+        return dict([
+            (
+                str(self.child_relation.to_representation(item)),
+                str(item)
+            )
+            for item in self.child_relation.queryset.all()
+        ])
-- 
cgit v1.2.3


From df7b6fcf58417fd95e49655eb140b387899b1ceb Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 2 Oct 2014 16:24:24 +0100
Subject: First pass on incorperating the form rendering into the browsable API

---
 rest_framework/relations.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 8c135672..988b9ede 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -127,7 +127,7 @@ class HyperlinkedRelatedField(RelatedField):
         attributes are not configured to correctly match the URL conf.
         """
         # Unsaved objects will not yet have a valid URL.
-        if obj.pk is None:
+        if obj.pk:
             return None
 
         lookup_value = getattr(obj, self.lookup_field)
@@ -248,11 +248,13 @@ class ManyRelation(Field):
 
     You shouldn't need to be using this class directly yourself.
     """
+    initial = []
 
     def __init__(self, child_relation=None, *args, **kwargs):
         self.child_relation = child_relation
         assert child_relation is not None, '`child_relation` is a required argument.'
         super(ManyRelation, self).__init__(*args, **kwargs)
+        self.child_relation.bind(field_name='', parent=self)
 
     def to_internal_value(self, data):
         return [
-- 
cgit v1.2.3


From fec7c4b45812d22423e73ec3ab801857a55d7340 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 2 Oct 2014 18:13:15 +0100
Subject: Browsable API tweaks

---
 rest_framework/relations.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 988b9ede..4f971917 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -249,6 +249,7 @@ class ManyRelation(Field):
     You shouldn't need to be using this class directly yourself.
     """
     initial = []
+    default_empty_html = []
 
     def __init__(self, child_relation=None, *args, **kwargs):
         self.child_relation = child_relation
-- 
cgit v1.2.3


From dfab9af294972720f59890967cd9ae1a6c0796b6 Mon Sep 17 00:00:00 2001
From: Craig de Stigter
Date: Fri, 3 Oct 2014 08:41:18 +1300
Subject: Minor: fix spelling and grammar, mostly in 3.0 announcement

---
 rest_framework/relations.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 8c135672..8141de13 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -100,7 +100,7 @@ class HyperlinkedRelatedField(RelatedField):
         self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field)
         self.format = kwargs.pop('format', None)
 
-        # We include these simply for dependancy injection in tests.
+        # We include these simply for dependency injection in tests.
         # We can't add them as class attributes or they would expect an
         # implict `self` argument to be passed.
         self.reverse = reverse
-- 
cgit v1.2.3


From 857a8486b1534f89bd482de86d39ff717b6618eb Mon Sep 17 00:00:00 2001
From: Craig de Stigter
Date: Fri, 3 Oct 2014 09:00:33 +1300
Subject: More spelling tweaks

---
 rest_framework/relations.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 8141de13..dc9781e7 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -102,7 +102,7 @@ class HyperlinkedRelatedField(RelatedField):
 
         # We include these simply for dependency injection in tests.
         # We can't add them as class attributes or they would expect an
-        # implict `self` argument to be passed.
+        # implicit `self` argument to be passed.
         self.reverse = reverse
         self.resolve = resolve
 
-- 
cgit v1.2.3


From 765b0b33bf1fa9b7c6b45d3877d10a05d4e9f6ea Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 3 Oct 2014 13:12:23 +0100
Subject: Revert accidental stupidity

---
 rest_framework/relations.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 4f971917..f9b5ff0d 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -127,7 +127,7 @@ class HyperlinkedRelatedField(RelatedField):
         attributes are not configured to correctly match the URL conf.
         """
         # Unsaved objects will not yet have a valid URL.
-        if obj.pk:
+        if obj.pk is None:
             return None
 
         lookup_value = getattr(obj, self.lookup_field)
-- 
cgit v1.2.3


From 6b09e5f2bba9167404ec329fa12c7f0215ca51ac Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 8 Oct 2014 11:22:10 +0100
Subject: Tests for generic relationships

---
 rest_framework/relations.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index e5bdf60c..df5025b8 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -49,7 +49,7 @@ class RelatedField(Field):
         ])
 
 
-class StringRelatedField(Field):
+class StringRelatedField(RelatedField):
     """
     A read only field that represents its targets using their
     plain string representation.
-- 
cgit v1.2.3


From 4c015df28cfb7dc7cf29f6dc4985c57e1f5cdc5d Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 8 Oct 2014 16:43:33 +0100
Subject: Tweaks

---
 rest_framework/relations.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index df5025b8..e9dd7dde 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -264,9 +264,10 @@ class ManyRelation(Field):
         ]
 
     def to_representation(self, obj):
+        iterable = obj.all() if (hasattr(obj, 'all')) else obj
         return [
             self.child_relation.to_representation(value)
-            for value in obj.all()
+            for value in iterable
         ]
 
     @property
-- 
cgit v1.2.3


From f7d43f530a94e686d2f93781471b9ac4e90d0f58 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 8 Oct 2014 17:03:14 +0100
Subject: Limit blank string -> None to just be on relational fields

---
 rest_framework/relations.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index e9dd7dde..c1e5aa18 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -1,5 +1,5 @@
 from rest_framework.compat import smart_text, urlparse
-from rest_framework.fields import Field
+from rest_framework.fields import empty, Field
 from rest_framework.reverse import reverse
 from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
 from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch, Resolver404
@@ -31,6 +31,12 @@ class RelatedField(Field):
             )
         return super(RelatedField, cls).__new__(cls, *args, **kwargs)
 
+    def run_validation(self, data=empty):
+        # We force empty strings to None values for relational fields.
+        if data == '':
+            data = None
+        return super(RelatedField, self).run_validation(data)
+
     def get_queryset(self):
         queryset = self.queryset
         if isinstance(queryset, QuerySet):
-- 
cgit v1.2.3


From 5d247a65c89594a7ab5ce2333612f23eadc6828d Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 9 Oct 2014 15:11:19 +0100
Subject: First pass on nested serializers in HTML

---
 rest_framework/relations.py | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index c1e5aa18..268b95cf 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -1,6 +1,7 @@
 from rest_framework.compat import smart_text, urlparse
 from rest_framework.fields import empty, Field
 from rest_framework.reverse import reverse
+from rest_framework.utils import html
 from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
 from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch, Resolver404
 from django.db.models.query import QuerySet
@@ -263,6 +264,13 @@ class ManyRelation(Field):
         super(ManyRelation, self).__init__(*args, **kwargs)
         self.child_relation.bind(field_name='', parent=self)
 
+    def get_value(self, dictionary):
+        # We override the default field access in order to support
+        # lists in HTML forms.
+        if html.is_html_input(dictionary):
+            return dictionary.getlist(self.field_name)
+        return dictionary.get(self.field_name, empty)
+
     def to_internal_value(self, data):
         return [
             self.child_relation.to_internal_value(item)
@@ -278,10 +286,16 @@ class ManyRelation(Field):
 
     @property
     def choices(self):
+        queryset = self.child_relation.queryset
+        iterable = queryset.all() if (hasattr(queryset, 'all')) else queryset
+        items_and_representations = [
+            (item, self.child_relation.to_representation(item))
+            for item in iterable
+        ]
         return dict([
             (
-                str(self.child_relation.to_representation(item)),
-                str(item)
+                str(item_representation),
+                str(item) + ' - ' + str(item_representation)
             )
-            for item in self.child_relation.queryset.all()
+            for item, item_representation in items_and_representations
         ])
-- 
cgit v1.2.3


From 3af5df19552103aaea3f4c6338acfb61f54c0d34 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 16 Oct 2014 20:47:34 +0100
Subject: Performance for PK fields

---
 rest_framework/relations.py | 42 +++++++++++++++++++++++++++++++++++++++---
 1 file changed, 39 insertions(+), 3 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 268b95cf..1665dd35 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -1,5 +1,5 @@
 from rest_framework.compat import smart_text, urlparse
-from rest_framework.fields import empty, Field
+from rest_framework.fields import get_attribute, empty, Field
 from rest_framework.reverse import reverse
 from rest_framework.utils import html
 from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
@@ -9,6 +9,11 @@ from django.utils import six
 from django.utils.translation import ugettext_lazy as _
 
 
+class PKOnlyObject(object):
+    def __init__(self, pk):
+        self.pk = pk
+
+
 class RelatedField(Field):
     def __init__(self, **kwargs):
         self.queryset = kwargs.pop('queryset', None)
@@ -45,6 +50,10 @@ class RelatedField(Field):
             queryset = queryset.all()
         return queryset
 
+    def get_iterable(self, instance, source):
+        relationship = get_attribute(instance, [source])
+        return relationship.all() if (hasattr(relationship, 'all')) else relationship
+
     @property
     def choices(self):
         return dict([
@@ -85,6 +94,31 @@ class PrimaryKeyRelatedField(RelatedField):
         except (TypeError, ValueError):
             self.fail('incorrect_type', data_type=type(data).__name__)
 
+    def get_attribute(self, instance):
+        # We customize `get_attribute` here for performance reasons.
+        # For relationships the instance will already have the pk of
+        # the related object. We return this directly instead of returning the
+        # object itself, which would require a database lookup.
+        try:
+            return PKOnlyObject(pk=instance.serializable_value(self.source))
+        except AttributeError:
+            return get_attribute(instance, [self.source])
+
+    def get_iterable(self, instance, source):
+        # For consistency with `get_attribute` we're using `serializable_value()`
+        # here. Typically there won't be any difference, but some custom field
+        # types might return a non-primative value for the pk otherwise.
+        #
+        # We could try to get smart with `values_list('pk', flat=True)`, which
+        # would be better in some case, but would actually end up with *more*
+        # queries if the developer is using `prefetch_related` across the
+        # relationship.
+        relationship = super(PrimaryKeyRelatedField, self).get_iterable(instance, source)
+        return [
+            PKOnlyObject(pk=item.serializable_value('pk'))
+            for item in relationship
+        ]
+
     def to_representation(self, value):
         return value.pk
 
@@ -277,8 +311,10 @@ class ManyRelation(Field):
             for item in data
         ]
 
-    def to_representation(self, obj):
-        iterable = obj.all() if (hasattr(obj, 'all')) else obj
+    def get_attribute(self, instance):
+        return self.child_relation.get_iterable(instance, self.source)
+
+    def to_representation(self, iterable):
         return [
             self.child_relation.to_representation(value)
             for value in iterable
-- 
cgit v1.2.3


From 49fae230005bba4607f425d90de77363d6b8659e Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 5 Nov 2014 15:23:13 +0000
Subject: Pass through kwargs to both Serializer and ListSerializer

---
 rest_framework/relations.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 1665dd35..f6ae30d0 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -13,6 +13,11 @@ class PKOnlyObject(object):
     def __init__(self, pk):
         self.pk = pk
 
+MANY_RELATION_KWARGS = (
+    'read_only', 'write_only', 'required', 'default', 'initial', 'source',
+    'label', 'help_text', 'style', 'error_messages'
+)
+
 
 class RelatedField(Field):
     def __init__(self, **kwargs):
@@ -31,10 +36,11 @@ class RelatedField(Field):
         # We override this method in order to automagically create
         # `ManyRelation` classes instead when `many=True` is set.
         if kwargs.pop('many', False):
-            return ManyRelation(
-                child_relation=cls(*args, **kwargs),
-                read_only=kwargs.get('read_only', False)
-            )
+            list_kwargs = {'child_relation': cls(*args, **kwargs)}
+            for key in kwargs.keys():
+                if key in MANY_RELATION_KWARGS:
+                    list_kwargs[key] = kwargs[key]
+            return ManyRelation(**list_kwargs)
         return super(RelatedField, cls).__new__(cls, *args, **kwargs)
 
     def run_validation(self, data=empty):
-- 
cgit v1.2.3


From 51d86a65055491df3fe0533f8e2e89237a51e379 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 7 Nov 2014 16:05:07 +0000
Subject: Support dotted source on relational fields

---
 rest_framework/relations.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index f6ae30d0..48ddf41e 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -56,8 +56,8 @@ class RelatedField(Field):
             queryset = queryset.all()
         return queryset
 
-    def get_iterable(self, instance, source):
-        relationship = get_attribute(instance, [source])
+    def get_iterable(self, instance, source_attrs):
+        relationship = get_attribute(instance, source_attrs)
         return relationship.all() if (hasattr(relationship, 'all')) else relationship
 
     @property
@@ -106,11 +106,12 @@ class PrimaryKeyRelatedField(RelatedField):
         # the related object. We return this directly instead of returning the
         # object itself, which would require a database lookup.
         try:
-            return PKOnlyObject(pk=instance.serializable_value(self.source))
+            instance = get_attribute(instance, self.source_attrs[:-1])
+            return PKOnlyObject(pk=instance.serializable_value(self.source_attrs[-1]))
         except AttributeError:
-            return get_attribute(instance, [self.source])
+            return get_attribute(instance, self.source_attrs)
 
-    def get_iterable(self, instance, source):
+    def get_iterable(self, instance, source_attrs):
         # For consistency with `get_attribute` we're using `serializable_value()`
         # here. Typically there won't be any difference, but some custom field
         # types might return a non-primative value for the pk otherwise.
@@ -119,7 +120,7 @@ class PrimaryKeyRelatedField(RelatedField):
         # would be better in some case, but would actually end up with *more*
         # queries if the developer is using `prefetch_related` across the
         # relationship.
-        relationship = super(PrimaryKeyRelatedField, self).get_iterable(instance, source)
+        relationship = super(PrimaryKeyRelatedField, self).get_iterable(instance, source_attrs)
         return [
             PKOnlyObject(pk=item.serializable_value('pk'))
             for item in relationship
@@ -318,7 +319,7 @@ class ManyRelation(Field):
         ]
 
     def get_attribute(self, instance):
-        return self.child_relation.get_iterable(instance, self.source)
+        return self.child_relation.get_iterable(instance, self.source_attrs)
 
     def to_representation(self, iterable):
         return [
-- 
cgit v1.2.3


From fd97d9bff82b96b9362930686b9008ba78326115 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 13 Nov 2014 19:35:03 +0000
Subject: Use select inputs for relationships. Closes #2058.

---
 rest_framework/relations.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 48ddf41e..6dc02a11 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -34,13 +34,13 @@ class RelatedField(Field):
 
     def __new__(cls, *args, **kwargs):
         # We override this method in order to automagically create
-        # `ManyRelation` classes instead when `many=True` is set.
+        # `ManyRelatedField` classes instead when `many=True` is set.
         if kwargs.pop('many', False):
             list_kwargs = {'child_relation': cls(*args, **kwargs)}
             for key in kwargs.keys():
                 if key in MANY_RELATION_KWARGS:
                     list_kwargs[key] = kwargs[key]
-            return ManyRelation(**list_kwargs)
+            return ManyRelatedField(**list_kwargs)
         return super(RelatedField, cls).__new__(cls, *args, **kwargs)
 
     def run_validation(self, data=empty):
@@ -286,12 +286,12 @@ class SlugRelatedField(RelatedField):
         return getattr(obj, self.slug_field)
 
 
-class ManyRelation(Field):
+class ManyRelatedField(Field):
     """
     Relationships with `many=True` transparently get coerced into instead being
-    a ManyRelation with a child relationship.
+    a ManyRelatedField with a child relationship.
 
-    The `ManyRelation` class is responsible for handling iterating through
+    The `ManyRelatedField` class is responsible for handling iterating through
     the values and passing each one to the child relationship.
 
     You shouldn't need to be using this class directly yourself.
@@ -302,7 +302,7 @@ class ManyRelation(Field):
     def __init__(self, child_relation=None, *args, **kwargs):
         self.child_relation = child_relation
         assert child_relation is not None, '`child_relation` is a required argument.'
-        super(ManyRelation, self).__init__(*args, **kwargs)
+        super(ManyRelatedField, self).__init__(*args, **kwargs)
         self.child_relation.bind(field_name='', parent=self)
 
     def get_value(self, dictionary):
-- 
cgit v1.2.3


From 992330055eeb5d787ddd7d62dfc9121a2256fd9b Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 13 Nov 2014 21:11:13 +0000
Subject: Refactor many

---
 rest_framework/relations.py | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

(limited to 'rest_framework/relations.py')

diff --git a/rest_framework/relations.py b/rest_framework/relations.py
index 6dc02a11..79c8057b 100644
--- a/rest_framework/relations.py
+++ b/rest_framework/relations.py
@@ -10,9 +10,17 @@ from django.utils.translation import ugettext_lazy as _
 
 
 class PKOnlyObject(object):
+    """
+    This is a mock object, used for when we only need the pk of the object
+    instance, but still want to return an object with a .pk attribute,
+    in order to keep the same interface as a regular model instance.
+    """
     def __init__(self, pk):
         self.pk = pk
 
+
+# We assume that 'validators' are intended for the child serializer,
+# rather than the parent serializer.
 MANY_RELATION_KWARGS = (
     'read_only', 'write_only', 'required', 'default', 'initial', 'source',
     'label', 'help_text', 'style', 'error_messages'
@@ -36,13 +44,17 @@ class RelatedField(Field):
         # We override this method in order to automagically create
         # `ManyRelatedField` classes instead when `many=True` is set.
         if kwargs.pop('many', False):
-            list_kwargs = {'child_relation': cls(*args, **kwargs)}
-            for key in kwargs.keys():
-                if key in MANY_RELATION_KWARGS:
-                    list_kwargs[key] = kwargs[key]
-            return ManyRelatedField(**list_kwargs)
+            return cls.many_init(*args, **kwargs)
         return super(RelatedField, cls).__new__(cls, *args, **kwargs)
 
+    @classmethod
+    def many_init(cls, *args, **kwargs):
+        list_kwargs = {'child_relation': cls(*args, **kwargs)}
+        for key in kwargs.keys():
+            if key in MANY_RELATION_KWARGS:
+                list_kwargs[key] = kwargs[key]
+        return ManyRelatedField(**list_kwargs)
+
     def run_validation(self, data=empty):
         # We force empty strings to None values for relational fields.
         if data == '':
-- 
cgit v1.2.3