def parse_proxy_response(self, response):
"""
Modified version of rest_framework.request.Request._parse(self)
"""
parsers = self.get_parsers()
stream = StringIO(response._content)
content_type = response.headers.get('content-type', None)
if stream is None or content_type is None:
return {}
parser = None
for item in parsers:
if media_type_matches(item.media_type, content_type):
parser = item
if not parser:
raise UnsupportedMediaType(content_type)
parsed = parser.parse(stream, content_type)
# Parser classes may return the raw data, or a
# DataAndFiles object. Return only data.
try:
return parsed.data
except AttributeError:
return parsed
def select_renderer(self, request, renderers, format_suffix=None):
"""
Given a request and a list of renderers, return a two-tuple of:
(renderer, media type).
"""
accepts = self.get_accept_list(request)
# Check the acceptable media types against each renderer,
# attempting more specific media types first
# NB. The inner loop here isn't as bad as it first looks :)
# Worst case is we're looping over len(accept_list) * len(self.renderers)
for media_type_set in order_by_precedence(accepts):
for renderer in renderers:
for media_type in media_type_set:
if media_type_matches(renderer.media_type, media_type):
# Return the most specific media type as accepted.
media_type_wrapper = _MediaType(media_type)
if (_MediaType(renderer.media_type).precedence >
media_type_wrapper.precedence):
# Eg client requests '*/*'
# Accepted media type is 'application/json'
full_media_type = ';'.join(
(renderer.media_type, ) +
tuple('{0}={1}'.format(
key, value.decode(HTTP_HEADER_ENCODING))
for key, value in
media_type_wrapper.params.items()))
return renderer, full_media_type
else:
# Eg client requests 'application/json; indent=8'
# Accepted media type is 'application/json; indent=8'
return renderer, media_type
raise exceptions.NotAcceptable(available_renderers=renderers)
def parse_proxy_response(self, response):
"""
Modified version of rest_framework.request.Request._parse(self)
"""
parsers = self.get_parsers()
stream = StringIO(response._content)
content_type = response.headers.get('content-type', None)
if stream is None or content_type is None:
return {}
parser = None
for item in parsers:
if media_type_matches(item.media_type, content_type):
parser = item
if not parser:
raise UnsupportedMediaType(content_type)
parsed = parser.parse(stream, content_type)
# Parser classes may return the raw data, or a
# DataAndFiles object. Return only data.
try:
return parsed.data
except AttributeError:
return parsed
def select_renderer(self, request, renderers, format_suffix=None):
"""
Given a request and a list of renderers, return a two-tuple of:
(renderer, media type).
"""
# Allow URL style format override. eg. "?format=json
format_query_param = self.settings.URL_FORMAT_OVERRIDE
format = format_suffix or request.query_params.get(format_query_param)
if format:
renderers = self.filter_renderers(renderers, format)
accepts = self.get_accept_list(request)
# Check the acceptable media types against each renderer,
# attempting more specific media types first
# NB. The inner loop here isn't as bad as it first looks :)
# Worst case is we're looping over len(accept_list) * len(self.renderers)
for media_type_set in order_by_precedence(accepts):
for renderer in renderers:
for media_type in media_type_set:
if media_type_matches(renderer.media_type, media_type):
# Return the most specific media type as accepted.
if _MediaType(renderer.media_type).precedence > _MediaType(media_type).precedence:
# Eg client requests '*/*'
# Accepted media type is 'application/json'
return renderer, renderer.media_type
else:
# Eg client requests 'application/json; indent=8'
# Accepted media type is 'application/json; indent=8'
return renderer, media_type
raise exceptions.NotAcceptable(available_renderers=renderers)
def select_renderer(self, request, renderers, format_suffix=None):
"""
Given a request and a list of renderers, return a two-tuple of:
(renderer, media type).
"""
# Allow URL style format override. eg. "?format=json
format_query_param = self.settings.URL_FORMAT_OVERRIDE
format = format_suffix or request.QUERY_PARAMS.get(format_query_param)
if format:
renderers = self.filter_renderers(renderers, format)
accepts = self.get_accept_list(request)
# Check the acceptable media types against each renderer,
# attempting more specific media types first
# NB. The inner loop here isn't as bad as it first looks :)
# Worst case is we're looping over len(accept_list) * len(self.renderers)
for media_type_set in order_by_precedence(accepts):
for renderer in renderers:
for media_type in media_type_set:
if media_type_matches(renderer.media_type, media_type):
# Return the most specific media type as accepted.
if (_MediaType(renderer.media_type).precedence >
_MediaType(media_type).precedence):
# Eg client requests '*/*'
# Accepted media type is 'application/json'
return renderer, renderer.media_type
else:
# Eg client requests 'application/json; indent=8'
# Accepted media type is 'application/json; indent=8'
return renderer, media_type
raise exceptions.NotAcceptable(available_renderers=renderers)
def select_parser(self, request, parsers):
"""
Given a list of parsers and a pictures type, return the appropriate
parser to handle the incoming request.
"""
for parser in parsers:
if media_type_matches(parser.media_type, request.content_type):
return parser
return None
def select_parser(self, request, parsers):
"""
Given a list of parsers and a media type, return the appropriate
parser to handle the incoming request.
"""
for parser in parsers:
if media_type_matches(parser.media_type, request.content_type):
return parser
return None
def select_parser(self, request, parsers):
"""
Select the first parser in the `.parser_classes` list.
"""
for parser in parsers:
if media_type_matches(parser.media_type, request.content_type):
return parser
return parsers[0]
def select_parser(self, request, parsers):
"""
Given a list of parsers and a media type, return the appropriate
parser to handle the incoming request.
"""
logging.info("select parser in negotiation")
logging.info(parsers)
for parser in parsers:
logging.info(parser.media_type)
logging.info(request.content_type)
if media_type_matches(parser.media_type, request.content_type):
return parser
return None
def get_serializer_class(self):
classes = getattr(self, "mediatype_serializer_classes", None)
serializer = None
if isinstance(classes, dict):
if self.request.method.lower() not in ("GET", "HEAD", "OPTIONS"):
serializer = classes.get(self.request.content_type, None)
else:
header = self.request.META.get("HTTP_ACCEPT", "*/*")
tokens = [token.strip() for token in header.split(",")]
for a in order_by_precedence(tokens):
serializer = next(
(c for (k, c) in classes if media_type_matches(k, a)),
None)
if serializer:
return serializer
return super(MediatypeNegotiationMixin, self).get_serializer_class()
def select_parser(self, request, parsers):
content_type = request.content_type
if not content_type or content_type == 'text/plain':
content_type = request.QUERY_PARAMS.get('_content_type',
content_type)
for parser in parsers:
if media_type_matches(parser.media_type, content_type):
# Create a parser that proxies to the matching one but with the
# overridden content type.
class ParserWrapper(object):
media_type = content_type
def parse(self, stream, media_type=None, parser_context=None):
return parser.parse(stream, content_type, parser_context)
return ParserWrapper()
return None
def select_renderer(self, request, renderers, format_suffix=None):
"""
Given a request and a list of renderers, return a two-tuple of:
(renderer, media type).
"""
# Allow URL style format override. eg. "?format=json
format_query_param = self.settings.URL_FORMAT_OVERRIDE
format = format_suffix or request.query_params.get(format_query_param)
if format:
renderers = self.filter_renderers(renderers, format)
accepts = self.get_accept_list(request)
# Check the acceptable media types against each renderer,
# attempting more specific media types first
# NB. The inner loop here isn't as bad as it first looks :)
# Worst case is we're looping over len(accept_list) * len(self.renderers)
for media_type_set in order_by_precedence(accepts):
for renderer in renderers:
for media_type in media_type_set:
if media_type_matches(renderer.media_type, media_type):
# Return the most specific media type as accepted.
media_type_wrapper = _MediaType(media_type)
if (
_MediaType(renderer.media_type).precedence >
media_type_wrapper.precedence
):
# Eg client requests '*/*'
# Accepted media type is 'application/json'
full_media_type = ';'.join(
(renderer.media_type,) +
tuple('{0}={1}'.format(
key, value.decode(HTTP_HEADER_ENCODING))
for key, value in media_type_wrapper.params.items()))
return renderer, full_media_type
else:
# Eg client requests 'application/json; indent=8'
# Accepted media type is 'application/json; indent=8'
return renderer, media_type
return (renderers[0], renderers[0].media_type)
