renderers.py

"""
Renderers
"""
importcopy
fromcollectionsimportOrderedDict

importinflection
fromdjango.db.modelsimportManager, QuerySet
fromdjango.utilsimportsix, encoding
fromrest_frameworkimportrelations
fromrest_frameworkimportrenderers
fromrest_framework.serializersimportBaseSerializer, Serializer, ListSerializer
fromrest_framework.settingsimportapi_settings

from . importutils


classJSONRenderer(renderers.JSONRenderer):
"""
 Render a JSON response per the JSON API spec:
 {
 "data": [{
 "type": "companies",
 "id": 1,
 "attributes": {
 "name": "Mozilla",
 "slug": "mozilla",
 "date-created": "2014-03-13 16:33:37"
 }
 }, {
 "type": "companies",
 "id": 2,
 ...
 }]
 }
 """

media_type='application/vnd.api+json'
format='vnd.api+json'

@classmethod
defextract_attributes(cls, fields, resource):
data=OrderedDict()
forfield_name, fieldinsix.iteritems(fields):
# ID is always provided in the root of JSON API so remove it from attributes
iffield_name=='id':
continue
# don't output a key for write only fields
iffields[field_name].write_only:
continue
# Skip fields with relations
ifisinstance(field, (relations.RelatedField, relations.ManyRelatedField, BaseSerializer)):
continue

# Skip read_only attribute fields when `resource` is an empty
# serializer. Prevents the "Raw Data" form of the browsable API
# from rendering `"foo": null` for read only fields
try:
resource[field_name]
exceptKeyError:
iffields[field_name].read_only:
continue

data.update({
field_name: resource.get(field_name)
 })

returnutils.format_keys(data)

@classmethod
defextract_relationships(cls, fields, resource, resource_instance):
# Avoid circular deps
fromrest_framework_json_api.relationsimportResourceRelatedField

data=OrderedDict()

# Don't try to extract relationships from a non-existent resource
ifresource_instanceisNone:
return

forfield_name, fieldinsix.iteritems(fields):
# Skip URL field
iffield_name==api_settings.URL_FIELD_NAME:
continue

# Skip fields without relations
ifnotisinstance(field, (relations.RelatedField, relations.ManyRelatedField, BaseSerializer)):
continue

source=field.source
relation_type=utils.get_related_resource_type(field)

ifisinstance(field, relations.HyperlinkedIdentityField):
resolved, relation_instance=utils.get_relation_instance(resource_instance, source, field.parent)
ifnotresolved:
continue
# special case for HyperlinkedIdentityField
relation_data=list()

# Don't try to query an empty relation
relation_queryset=relation_instance \
ifrelation_instanceisnotNoneelselist()

forrelated_objectinrelation_queryset:
relation_data.append(
OrderedDict([('type', relation_type), ('id', encoding.force_text(related_object.pk))])
 )

data.update({field_name: {
'links': {
"related": resource.get(field_name)},
'data': relation_data,
'meta': {
'count': len(relation_data)
 }
 }})
continue

ifisinstance(field, ResourceRelatedField):
resolved, relation_instance=utils.get_relation_instance(resource_instance, source, field.parent)
ifnotresolved:
continue

# special case for ResourceRelatedField
relation_data= {
'data': resource.get(field_name)
 }

field_links=field.get_links(resource_instance)
relation_data.update(
 {'links': field_links}
iffield_linkselsedict()
 )
data.update({field_name: relation_data})
continue

ifisinstance(field, (relations.PrimaryKeyRelatedField, relations.HyperlinkedRelatedField)):
resolved, relation=utils.get_relation_instance(resource_instance, '%s_id'%source, field.parent)
ifnotresolved:
continue
relation_id=relationifresource.get(field_name) elseNone
relation_data= {
'data': (
OrderedDict([('type', relation_type), ('id', encoding.force_text(relation_id))])
ifrelation_idisnotNoneelseNone)
 }

relation_data.update(
 {'links': {'related': resource.get(field_name)}}
ifisinstance(field, relations.HyperlinkedRelatedField) andresource.get(field_name) elsedict()
 )
data.update({field_name: relation_data})
continue

ifisinstance(field, relations.ManyRelatedField):
resolved, relation_instance=utils.get_relation_instance(resource_instance, source, field.parent)
ifnotresolved:
continue

ifisinstance(field.child_relation, ResourceRelatedField):
# special case for ResourceRelatedField
relation_data= {
'data': resource.get(field_name)
 }

field_links=field.child_relation.get_links(resource_instance)
relation_data.update(
 {'links': field_links}
iffield_linkselsedict()
 )
relation_data.update(
 {
'meta': {
'count': len(resource.get(field_name))
 }
 }
 )
data.update({field_name: relation_data})
continue

relation_data=list()
fornested_resource_instanceinrelation_instance:
nested_resource_instance_type= (
relation_typeor
utils.get_resource_type_from_instance(nested_resource_instance)
 )

relation_data.append(OrderedDict([
 ('type', nested_resource_instance_type),
 ('id', encoding.force_text(nested_resource_instance.pk))
 ]))
data.update({
field_name: {
'data': relation_data,
'meta': {
'count': len(relation_data)
 }
 }
 })
continue

ifisinstance(field, ListSerializer):
resolved, relation_instance=utils.get_relation_instance(resource_instance, source, field.parent)
ifnotresolved:
continue

relation_data=list()

serializer_data=resource.get(field_name)
resource_instance_queryset=list(relation_instance)
ifisinstance(serializer_data, list):
forpositioninrange(len(serializer_data)):
nested_resource_instance=resource_instance_queryset[position]
nested_resource_instance_type= (
relation_typeor
utils.get_resource_type_from_instance(nested_resource_instance)
 )

relation_data.append(OrderedDict([
 ('type', nested_resource_instance_type),
 ('id', encoding.force_text(nested_resource_instance.pk))
 ]))

data.update({field_name: {'data': relation_data}})
continue

ifisinstance(field, Serializer):
resolved, relation_instance=utils.get_relation_instance(resource_instance, source, field.parent)
ifnotresolved:
continue

data.update({
field_name: {
'data': (
OrderedDict([
 ('type', relation_type),
 ('id', encoding.force_text(relation_instance.pk))
 ]) ifresource.get(field_name) elseNone)
 }
 })
continue

returnutils.format_keys(data)

@classmethod
defextract_included(cls, fields, resource, resource_instance, included_resources):
# this function may be called with an empty record (example: Browsable Interface)
ifnotresource_instance:
return

included_data=list()
current_serializer=fields.serializer
context=current_serializer.context
included_serializers=utils.get_included_serializers(current_serializer)
included_resources=copy.copy(included_resources)
included_resources= [inflection.underscore(value) forvalueinincluded_resources]

forfield_name, fieldinsix.iteritems(fields):
# Skip URL field
iffield_name==api_settings.URL_FIELD_NAME:
continue

# Skip fields without relations or serialized data
ifnotisinstance(field, (relations.RelatedField, relations.ManyRelatedField, BaseSerializer)):
continue

try:
included_resources.remove(field_name)
exceptValueError:
# Skip fields not in requested included resources
# If no child field, directly continue with the next field
iffield_namenotin [node.split('.')[0] fornodeinincluded_resources]:
continue

try:
relation_instance=getattr(resource_instance, field_name)
exceptAttributeError:
try:
# For ManyRelatedFields if `related_name` is not set we need to access `foo_set` from `source`
relation_instance=getattr(resource_instance, field.child_relation.source)
exceptAttributeError:
ifnothasattr(current_serializer, field.source):
continue
serializer_method=getattr(current_serializer, field.source)
relation_instance=serializer_method(resource_instance)

ifisinstance(relation_instance, Manager):
relation_instance=relation_instance.all()

new_included_resources= [key.replace('%s.'%field_name, '', 1)
forkeyinincluded_resources
iffield_name==key.split('.')[0]]
serializer_data=resource.get(field_name)

ifisinstance(field, relations.ManyRelatedField):
serializer_class=included_serializers[field_name]
field=serializer_class(relation_instance, many=True, context=context)
serializer_data=field.data

ifisinstance(field, relations.RelatedField):
ifrelation_instanceisNone:
continue

many=field._kwargs.get('child_relation', None) isnotNone
serializer_class=included_serializers[field_name]
field=serializer_class(relation_instance, many=many, context=context)
serializer_data=field.data

ifisinstance(field, ListSerializer):
serializer=field.child
relation_type=utils.get_resource_type_from_serializer(serializer)
relation_queryset=list(relation_instance)

ifserializer_data:
forpositioninrange(len(serializer_data)):
serializer_resource=serializer_data[position]
nested_resource_instance=relation_queryset[position]
resource_type= (
relation_typeor
utils.get_resource_type_from_instance(nested_resource_instance)
 )
serializer_fields=utils.get_serializer_fields(serializer.__class__(nested_resource_instance, context=serializer.context))
included_data.append(
cls.build_json_resource_obj(
serializer_fields, serializer_resource, nested_resource_instance, resource_type
 )
 )
included_data.extend(
cls.extract_included(
serializer_fields, serializer_resource, nested_resource_instance, new_included_resources
 )
 )

ifisinstance(field, Serializer):

relation_type=utils.get_resource_type_from_serializer(field)

# Get the serializer fields
serializer_fields=utils.get_serializer_fields(field)
ifserializer_data:
included_data.append(
cls.build_json_resource_obj(
serializer_fields, serializer_data,
relation_instance, relation_type)
 )
included_data.extend(
cls.extract_included(
serializer_fields, serializer_data, relation_instance, new_included_resources
 )
 )

returnutils.format_keys(included_data)

@classmethod
defextract_meta(cls, serializer, resource):
ifhasattr(serializer, 'child'):
meta=getattr(serializer.child, 'Meta', None)
else:
meta=getattr(serializer, 'Meta', None)
meta_fields=getattr(meta, 'meta_fields', [])
data=OrderedDict()
forfield_nameinmeta_fields:
data.update({
field_name: resource.get(field_name)
 })
returndata

@classmethod
defextract_root_meta(cls, serializer, resource):
many=False
ifhasattr(serializer, 'child'):
many=True
serializer=serializer.child

data= {}
ifgetattr(serializer, 'get_root_meta', None):
json_api_meta=serializer.get_root_meta(resource, many)
assertisinstance(json_api_meta, dict), 'get_root_meta must return a dict'
data.update(json_api_meta)
returndata

@classmethod
defbuild_json_resource_obj(cls, fields, resource, resource_instance, resource_name):
# Determine type from the instance if the underlying model is polymorphic
ifisinstance(resource_instance, utils.POLYMORPHIC_ANCESTORS):
resource_name=utils.get_resource_type_from_instance(resource_instance)
resource_data= [
 ('type', resource_name),
 ('id', encoding.force_text(resource_instance.pk) ifresource_instanceelseNone),
 ('attributes', cls.extract_attributes(fields, resource)),
 ]
relationships=cls.extract_relationships(fields, resource, resource_instance)
ifrelationships:
resource_data.append(('relationships', relationships))
# Add 'self' link if field is present and valid
ifapi_settings.URL_FIELD_NAMEinresourceand \
isinstance(fields[api_settings.URL_FIELD_NAME], relations.RelatedField):
resource_data.append(('links', {'self': resource[api_settings.URL_FIELD_NAME]}))
returnOrderedDict(resource_data)

defrender_relationship_view(self, data, accepted_media_type=None, renderer_context=None):
# Special case for RelationshipView
view=renderer_context.get("view", None)
render_data=OrderedDict([
 ('data', data)
 ])
links=view.get_links()
iflinks:
render_data.update({'links': links}),
returnsuper(JSONRenderer, self).render(
render_data, accepted_media_type, renderer_context
 )

defrender_errors(self, data, accepted_media_type=None, renderer_context=None):
returnsuper(JSONRenderer, self).render(
utils.format_errors(data), accepted_media_type, renderer_context
 )

defrender(self, data, accepted_media_type=None, renderer_context=None):

view=renderer_context.get("view", None)
request=renderer_context.get("request", None)

# Get the resource name.
resource_name=utils.get_resource_name(renderer_context)

# If this is an error response, skip the rest.
ifresource_name=='errors':
returnself.render_errors(data, accepted_media_type, renderer_context)

fromrest_framework_json_api.viewsimportRelationshipView
ifisinstance(view, RelationshipView):
returnself.render_relationship_view(data, accepted_media_type, renderer_context)

# If `resource_name` is set to None then render default as the dev
# wants to build the output format manually.
ifresource_nameisNoneorresource_nameisFalse:
returnsuper(JSONRenderer, self).render(
data, accepted_media_type, renderer_context
 )

json_api_data=data
json_api_included=list()
# initialize json_api_meta with pagination meta or an empty dict
json_api_meta=data.get('meta', {}) ifisinstance(data, dict) else {}

ifdataand'results'indata:
serializer_data=data["results"]
else:
serializer_data=data

serializer=getattr(serializer_data, 'serializer', None)

included_resources=utils.get_included_resources(request, serializer)

ifserializerisnotNone:

# Get the serializer fields
fields=utils.get_serializer_fields(serializer)

# Extract root meta for any type of serializer
json_api_meta.update(self.extract_root_meta(serializer, serializer_data))

ifgetattr(serializer, 'many', False):
json_api_data=list()

forpositioninrange(len(serializer_data)):
resource=serializer_data[position] # Get current resource
resource_instance=serializer.instance[position] # Get current instance

json_resource_obj=self.build_json_resource_obj(fields, resource, resource_instance, resource_name)
meta=self.extract_meta(serializer, resource)
ifmeta:
json_resource_obj.update({'meta': utils.format_keys(meta)})
json_api_data.append(json_resource_obj)

included=self.extract_included(fields, resource, resource_instance, included_resources)
ifincluded:
json_api_included.extend(included)
else:
resource_instance=serializer.instance
json_api_data=self.build_json_resource_obj(fields, serializer_data, resource_instance, resource_name)

meta=self.extract_meta(serializer, serializer_data)
ifmeta:
json_api_data.update({'meta': utils.format_keys(meta)})

included=self.extract_included(fields, serializer_data, resource_instance, included_resources)
ifincluded:
json_api_included.extend(included)

# Make sure we render data in a specific order
render_data=OrderedDict()

ifisinstance(data, dict) anddata.get('links'):
render_data['links'] =data.get('links')

# format the api root link list
ifview.__class__andview.__class__.__name__=='APIRoot':
render_data['data'] =None
render_data['links'] =json_api_data
else:
render_data['data'] =json_api_data

iflen(json_api_included) >0:
# Iterate through compound documents to remove duplicates
seen=set()
unique_compound_documents=list()
forincluded_dictinjson_api_included:
type_tuple=tuple((included_dict['type'], included_dict['id']))
iftype_tuplenotinseen:
seen.add(type_tuple)
unique_compound_documents.append(included_dict)

# Sort the items by type then by id
render_data['included'] =sorted(unique_compound_documents, key=lambdaitem: (item['type'], item['id']))

ifjson_api_meta:
render_data['meta'] =utils.format_keys(json_api_meta)

returnsuper(JSONRenderer, self).render(
render_data, accepted_media_type, renderer_context
 )