included_serializers may be specified with strings

in the included_serializers class attribute, classes may be specified as a
string containing the absolute python path for the desired class. Thus, the
values in included_serializers may be a class, a string with the python path
of the desired class, or 'self' to specify the class of the current serializer.

for example:

```python
from rest_framework_json_api import serializers
from rest_framework_json_api.relations import ResourceRelatedField

from myapp.models import Thing
from anotherapp.serializers import CategorySerializer

class ThingSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Thing
        serializer_related_field = ResourceRelatedField

    included_serializers = {
        'category': CategorySerializer,
        'accessories': 'myapp.serializers.AccessorySerializer',
        'related_things': 'self'  # ThingSerializer
    }
```

Author: Leifur Halldor Asgeirsson

example/serializers.py

@@ -1,5 +1,5 @@
 from rest_framework import serializers
-from example.models import Blog, Entry, Author
+from example.models import Blog, Entry, Author, Comment
 
 
 class BlogSerializer(serializers.ModelSerializer):
@@ -21,3 +21,10 @@ class AuthorSerializer(serializers.ModelSerializer):
     class Meta:
         model = Author
         fields = ('name', 'email',)
+
+
+class CommentSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Comment
+        fields = ('entry', 'body', 'author',)

example/tests/test_utils.py

@@ -1,4 +1,5 @@
 import pytest
+from django.utils import six
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from rest_framework import serializers
@@ -7,6 +8,10 @@
 
 from rest_framework_json_api import utils
 
+from example.serializers import (EntrySerializer, BlogSerializer,
+                                 AuthorSerializer, CommentSerializer)
+from rest_framework_json_api.utils import get_included_serializers
+
 pytestmark = pytest.mark.django_db
 
 class ResourceView(APIView):
@@ -100,3 +105,43 @@ def test_build_json_resource_obj():
     assert utils.build_json_resource_obj(
             serializer.fields, resource, resource_instance, 'user') == output
 
+
+class SerializerWithIncludedSerializers(EntrySerializer):
+    included_serializers = {
+        'blog': BlogSerializer,
+        'authors': 'example.serializers.AuthorSerializer',
+        'comments': 'example.serializers.CommentSerializer',
+        'self': 'self'  # this wouldn't make sense in practice (and would be prohibited by
+                        # IncludedResourcesValidationMixin) but it's useful for the test
+    }
+
+
+def test_get_included_serializers_against_class():
+    klass = SerializerWithIncludedSerializers
+    included_serializers = get_included_serializers(klass)
+    expected_included_serializers = {
+        'blog': BlogSerializer,
+        'authors': AuthorSerializer,
+        'comments': CommentSerializer,
+        'self': klass
+    }
+    assert (six.viewkeys(included_serializers) == six.viewkeys(klass.included_serializers),
+            'the keys must be preserved')
+
+    assert included_serializers == expected_included_serializers
+
+
+def test_get_included_serializers_against_instance():
+    klass = SerializerWithIncludedSerializers
+    instance = klass()
+    included_serializers = get_included_serializers(instance)
+    expected_included_serializers = {
+        'blog': BlogSerializer,
+        'authors': AuthorSerializer,
+        'comments': CommentSerializer,
+        'self': klass
+    }
+    assert (six.viewkeys(included_serializers) == six.viewkeys(klass.included_serializers),
+            'the keys must be preserved')
+
+    assert included_serializers == expected_included_serializers

rest_framework_json_api/serializers.py

@@ -3,7 +3,7 @@
 from rest_framework.serializers import *
 
 from rest_framework_json_api.utils import format_relation_name, get_resource_type_from_instance, \
-    get_resource_type_from_serializer
+    get_resource_type_from_serializer, get_included_serializers
 
 
 class ResourceIdentifierObjectSerializer(BaseSerializer):
@@ -67,11 +67,8 @@ def __init__(self, *args, **kwargs):
         request = context.get('request') if context else None
         view = context.get('view') if context else None
 
-        def validate_path(serializer_class, field_path, serializers, path):
-            serializers = {
-                key: serializer_class if serializer == 'self' else serializer
-                for key, serializer in serializers.items()
-                } if serializers else dict()
+        def validate_path(serializer_class, field_path, path):
+            serializers = get_included_serializers(serializer_class)
             if serializers is None:
                 raise ParseError('This endpoint does not support the include parameter')
             this_field_name = field_path[0]
@@ -94,9 +91,8 @@ def validate_path(serializer_class, field_path, serializers, path):
                 for included_field_name in included_resources:
                     included_field_path = included_field_name.split('.')
                     this_serializer_class = view.serializer_class
-                    included_serializers = getattr(this_serializer_class, 'included_serializers', None)
                     # lets validate the current path
-                    validate_path(this_serializer_class, included_field_path, included_serializers, included_field_name)
+                    validate_path(this_serializer_class, included_field_path, included_field_name)
 
         super(IncludedResourcesValidationMixin, self).__init__(*args, **kwargs)
 

rest_framework_json_api/utils.py

@@ -1,10 +1,12 @@
 """
 Utils.
 """
+import copy
 import inflection
 from django.conf import settings
 from django.utils import six, encoding
 from django.utils.translation import ugettext_lazy as _
+from django.utils.module_loading import import_string
 from rest_framework.compat import OrderedDict
 from rest_framework.serializers import BaseSerializer, ListSerializer, ModelSerializer
 from rest_framework.relations import RelatedField, HyperlinkedRelatedField, PrimaryKeyRelatedField, \
@@ -395,12 +397,7 @@ def extract_included(fields, resource, resource_instance, included_resources):
 
     current_serializer = fields.serializer
     context = current_serializer.context
-    included_serializers = getattr(fields.serializer, 'included_serializers', None)
-
-    included_serializers = {
-        key: current_serializer.__class__ if serializer == 'self' else serializer
-        for key, serializer in included_serializers.items()
-        } if included_serializers else dict()
+    included_serializers = get_included_serializers(current_serializer)
 
     for field_name, field in six.iteritems(fields):
         # Skip URL field
@@ -473,6 +470,19 @@ def extract_included(fields, resource, resource_instance, included_resources):
     return format_keys(included_data)
 
 
+def get_included_serializers(serializer):
+    included_serializers = copy.copy(getattr(serializer, 'included_serializers', dict()))
+
+    for name, value in six.iteritems(included_serializers):
+        if not isinstance(value, type):
+            if value == 'self':
+                included_serializers[name] = serializer if isinstance(serializer, type) else serializer.__class__
+            else:
+                included_serializers[name] = import_string(value)
+
+    return included_serializers
+
+
 class Hyperlink(six.text_type):
     """
     A string like object that additionally has an associated name.