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)