def _api_name_from_headers(self, request): self._accept_range = request.META.get('HTTP_ACCEPT', '*/*') # Accepts header can look like: # text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 # So we need to split it apart for use with parse_media_range. ranges = self._accept_range.split(',') try: ranges = [mimeparse.parse_media_range(m) for m in ranges] except ValueError: raise BadRequest('Incorrect accept header') # Then sort the accepted types by their quality, best first. ranges.sort( lambda x, y: cmp(float(y[2].get('q')), float(x[2].get('q')))) for range in ranges: subtype = range[1] for api_name in self._registry.keys(): # We enforce the vnd.api.<api_name>+<type> convention to keep # things simple. E.g. vnd.api.myapi-v2+json or # vnd.api.djangoappv3+xml api_subtype = '{}+'.format( self.api_subtype.format(api_name=api_name)) if subtype.startswith(api_subtype): # This is our match. # Rewrite the Accepts header, removing our # vendor-specific api name so that the rest of our logic # works the same way. request.META['HTTP_ACCEPT'] = self._accept_range.replace( api_subtype, '') return api_name return self._default_api_name
def _api_name_from_headers(self, request): self._accept_range = request.META.get("HTTP_ACCEPT", "*/*") # Accepts header can look like: # text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 # So we need to split it apart for use with parse_media_range. ranges = self._accept_range.split(",") try: ranges = [mimeparse.parse_media_range(m) for m in ranges] except ValueError: raise BadRequest("Incorrect accept header") # Then sort the accepted types by their quality, best first. ranges.sort(lambda x, y: cmp(float(y[2].get("q")), float(x[2].get("q")))) for range in ranges: subtype = range[1] for api_name in self._registry.keys(): # We enforce the vnd.api.<api_name>+<type> convention to keep # things simple. E.g. vnd.api.myapi-v2+json or # vnd.api.djangoappv3+xml api_subtype = "{}+".format(self.api_subtype.format(api_name=api_name)) if subtype.startswith(api_subtype): # This is our match. # Rewrite the Accepts header, removing our # vendor-specific api name so that the rest of our logic # works the same way. request.META["HTTP_ACCEPT"] = self._accept_range.replace(api_subtype, "") return api_name return self._default_api_name
def quality_and_fitness_parsed( mime_type: str, parsed_ranges: List[MimeTypeComponents]) -> QFParsed: """Find the best match for a mime-type amongst parsed media-ranges. Find the best match for a given mime-type against a list of media_ranges that have already been parsed by parse_media_range(). Returns a tuple of the fitness value and the value of the 'q' quality parameter of the best match, or (-1, 0) if no match was found. Just as for quality_parsed(), 'parsed_ranges' must be a list of parsed media ranges. Cherry-picked from python-mimeparse and improved. """ best_fitness = -1 best_fit_q = 0 (target_type, target_subtype, target_params) = parse_media_range(mime_type) best_matched = None for (type, subtype, params) in parsed_ranges: # check if the type and the subtype match type_match = (type in (target_type, '*') or target_type == '*') subtype_match = (subtype in (target_subtype, '*') or target_subtype == '*') # if they do, assess the "fitness" of this mime_type if type_match and subtype_match: # 100 points if the type matches w/o a wildcard fitness = type == target_type and 100 or 0 # 10 points if the subtype matches w/o a wildcard fitness += subtype == target_subtype and 10 or 0 # 1 bonus point for each matching param besides "q" param_matches = sum([ 1 for (key, value) in target_params.items() if key != 'q' and key in params and value == params[key] ]) fitness += param_matches # finally, add the target's "q" param (between 0 and 1) fitness += float(target_params.get('q', 1)) if fitness > best_fitness: best_fitness = fitness best_fit_q = params['q'] best_matched = (type, subtype, params) return (float(best_fit_q), best_fitness), best_matched
def quality(self, accept=None, accept_charset=None, accept_language=None): """ :param accept: string in the same format as an http `Accept` header :param accept_language: string in the same format as an http `Accept-Language` header :param accept_charset: string in the same format as an http `Accept-Charset` header :return: a number or tuple of tuples representing the quality of the match. By convention outer tuples should be in content type, language, charset order. Raises `NotAcceptable If the binding does not match the request. """ if self.content_type is None: # TODO return 5, self.qs if accept is None: return 0, self.qs accept = [ mimeparse.parse_media_range(media_range) for media_range in accept.split(',') ] fitness, quality = mimeparse.fitness_and_quality_parsed( self.content_type, accept ) if fitness == -1: raise NotAcceptable() return fitness, quality * self.qs
def best_match(supported: IterableType[str], header: str) -> Tuple[str, Optional[MimeTypeComponents]]: """Return mime-type with the highest quality ('q') from list of candidates. Takes a list of supported mime-types and finds the best match for all the media-ranges listed in header. The value of header must be a string that conforms to the format of the HTTP Accept: header. The value of 'supported' is a list of mime-types. The list of supported mime-types should be sorted in order of increasing desirability, in case of a situation where there is a tie. Cherry-picked from python-mimeparse and improved. >>> best_match(['application/xbel+xml', 'text/xml'], 'text/*;q=0.5,*/*; q=0.1') ('text/xml', ('text', '*', {'q': '0.5'})) """ split_header = _filter_blank(header.split(',')) parsed_header = [parse_media_range(r) for r in split_header] weighted_matches = {} for i, mime_type in enumerate(supported): weight, match = quality_and_fitness_parsed(mime_type, parsed_header) weighted_matches[(weight, i)] = (mime_type, match) best = max(weighted_matches.keys()) return best[0][0] and weighted_matches[best] or ('', None)
def _test_parse_media_range(self, args, expected): expected = tuple(expected) result = mimeparse.parse_media_range(args) message = "Expected: '%s' but got %s" % (expected, result) self.assertEqual(expected, result, message)
def test_parse_media_range(args, expected): expected = tuple(expected) result = mimeparse.parse_media_range(args) message = "Expected: '%s' but got %s" % (expected, result) assert expected == result, message
import logging import re from collections import namedtuple from enum import Enum, Flag, auto from mimeparse import parse_media_range #: Logger instance logger = logging.getLogger('aiohttp-json-api') #: Key of JSON API stuff in aiohttp.web.Application JSONAPI = 'jsonapi' #: JSON API Content-Type by specification JSONAPI_CONTENT_TYPE = 'application/vnd.api+json' JSONAPI_CONTENT_TYPE_PARSED = parse_media_range(JSONAPI_CONTENT_TYPE) #: Regular expression rule for check allowed fields and types names ALLOWED_MEMBER_NAME_RULE = \ r'[a-zA-Z0-9]([a-zA-Z0-9\-_]+[a-zA-Z0-9]|[a-zA-Z0-9]?)' #: Compiled regexp of rule ALLOWED_MEMBER_NAME_REGEX = re.compile('^' + ALLOWED_MEMBER_NAME_RULE + '$') #: Filter rule FilterRule = namedtuple('FilterRule', ('name', 'value')) #: JSON API resource identifier ResourceID = collections.namedtuple('ResourceID', ['type', 'id'])