def get_renderers(self, request, context=None, template_name=None,
accept_header=None, formats=None, default_format=None, fallback_formats=None):
"""
Returns a list of renderer functions in the order they should be tried.
Tries the format override parameter first, then the Accept header. If
neither is present, attempt to fall back to self._default_format. If
a fallback format has been specified, we try that last.
"""
if formats:
renderers, seen_formats = [], set()
for format in formats:
if format in self.renderers_by_format and format not in seen_formats:
renderers.extend(self.renderers_by_format[format])
seen_formats.add(format)
elif accept_header:
accepts = MediaType.parse_accept_header(accept_header)
renderers = MediaType.resolve(accepts, self.renderers)
elif default_format:
renderers = self.renderers_by_format[default_format]
else:
renderers = []
fallback_formats = fallback_formats if isinstance(fallback_formats, (list, tuple)) else (fallback_formats,)
for format in fallback_formats:
renderers.extend(self.renderers_by_format[format])
if context is not None and template_name:
renderers = [r for r in renderers if r.test(request, context, template_name)]
return renderers
def get_renderers(self, request):
"""
Returns a list of renderer functions in the order they should be tried.
Tries the format override parameter first, then the Accept header. If
neither is present, attempt to fall back to self._default_format. If
a fallback format has been specified, we try that last.
"""
if self._format_override_parameter in request.REQUEST:
formats = request.REQUEST[self._format_override_parameter].split(
',')
renderers, seen_formats = [], set()
for format in formats:
if format in self._renderers_by_format and format not in seen_formats:
renderers.extend(self._renderers_by_format[format])
elif request.META.get('HTTP_ACCEPT'):
accepts = self.parse_accept_header(request.META['HTTP_ACCEPT'])
renderers = MediaType.resolve(accepts, self._renderers)
elif self._default_format:
renderers = self._renderers_by_format[self._default_format]
else:
renderers = []
if self._force_fallback_format:
renderers.extend(
self._renderers_by_format[self._force_fallback_format])
return renderers
def parse_accept_header(cls, accept):
media_types = []
for media_type in accept.split(','):
try:
media_types.append(MediaType(media_type))
except ValueError:
pass
return media_types
def get_renderers(self, request, context=None, template_name=None,
accept_header=None, formats=None, default_format=None, fallback_formats=None,
early=False):
"""
Returns a list of renderer functions in the order they should be tried.
Tries the format override parameter first, then the Accept header. If
neither is present, attempt to fall back to self._default_format. If
a fallback format has been specified, we try that last.
If early is true, don't test renderers to see whether they can handle
a serialization. This is useful if we're trying to find all relevant
serializers before we've built a context which they will accept.
"""
if formats:
renderers, seen_formats = [], set()
for format in formats:
if format in self.renderers_by_format and format not in seen_formats:
renderers.extend(self.renderers_by_format[format])
seen_formats.add(format)
elif accept_header:
accepts = MediaType.parse_accept_header(accept_header)
renderers = MediaType.resolve(accepts, self.renderers)
elif default_format:
renderers = self.renderers_by_format[default_format]
else:
renderers = []
fallback_formats = fallback_formats if isinstance(fallback_formats, (list, tuple)) else (fallback_formats,)
for format in fallback_formats:
for renderer in self.renderers_by_format[format]:
if renderer not in renderers:
renderers.append(renderer)
if not early and context is not None and template_name:
renderers = [r for r in renderers if r.test(request, context, template_name)]
return renderers
def error_406(self, request, exception, *args, **kwargs):
accept_header_parsed = MediaType.parse_accept_header(request.META.get('HTTP_ACCEPT', ''))
accept_header_parsed.sort(reverse=True)
accept_header_parsed = map(unicode, accept_header_parsed)
context = {'error': {'status_code': httplib.NOT_ACCEPTABLE,
'tried_mimetypes': exception.tried_mimetypes,
'available_renderers': [self.renderer_for_context(request, r) for r in self.conneg.renderers],
'format_parameter_name': self._format_override_parameter,
'format_parameter': request.REQUEST.get(self._format_override_parameter),
'format_parameter_parsed': request.REQUEST.get(self._format_override_parameter, '').split(','),
'accept_header': request.META.get('HTTP_ACCEPT'),
'accept_header_parsed': accept_header_parsed}}
return self.error_view(request, context,
self.error_template_names[httplib.NOT_ACCEPTABLE])
def get_renderers(self, request):
renderers = []
if request.META.get('HTTP_NEGOTIATE'):
negotiate = self.parse_negotiate_header(request.META['HTTP_NEGOTIATE'])
if 'format' in request.REQUEST:
formats = request.REQUEST[self._format_override_parameter].split(',')
renderers, seen_formats = [], set()
for format in formats:
if format in self._renderers_by_format and format not in seen_formats:
renderers.extend(self._renderers_by_format[format])
elif request.META.get('HTTP_ACCEPT'):
accepts = self.parse_accept_header(request.META['HTTP_ACCEPT'])
renderers = MediaType.resolve(accepts, tuple(self._renderers))
elif self._default_format:
renderers = self._renderers_by_format[self._default_format]
if self._force_fallback_format:
renderers.extend(self._renderers_by_format[self._force_fallback_format])
return tuple(renderers)
def is_agent_a_robot(self, request):
if request.META.get('HTTP_ORIGIN'):
# A CORS request (from JavaScript)
return True
if request.META.get('HTTP_X_REQUESTED_WITH'):
# An AJAX request (from JavaScript)
return True
accept = sorted(MediaType.parse_accept_header(request.META.get('HTTP_ACCEPT', '')), reverse=True)
if accept and accept[0].type in (('text', 'html', None), ('application', 'xml', 'xhtml')):
# Agents whose first preference is for HTML are presumably trying
# to show it to a human.
return False
if 'MSIE' in request.META.get('HTTP_USER_AGENT', ''):
# We'll assume that IE (which doesn't set a proper Accept header)
# is making a request on behalf of a human. It does seem to set an
# Origin header when using XDomainRequest, and can set
# X-Requested-With if the request is being made from JavaScript.
return False
return True
def override_redirect(self, request, description_url, mimetypes):
url = urlparse.urlparse(description_url)
if 'django_hosts' in settings.INSTALLED_APPS:
host, _ = self.hosts_middleware.get_host(url.netloc)
urlconf = host.urlconf
else:
urlconf = None
try:
view, _, _ = resolve(url.path, urlconf)
except Resolver404:
return False
should_redirect = lambda: True
renderer = decorators.renderer(None, mimetypes, float('inf'), None)(should_redirect)
accepts = self.parse_accept_header(request.META.get('HTTP_ACCEPT', ''))
renderers = MediaType.resolve(accepts, (renderer,) + view.conneg.renderers)
return renderers and renderers[0] is should_redirect
def render(self, request, context, template_name):
results = context.get('results') \
or context.get('graph') \
or context.get('bindings') \
or context.get('boolean')
if isinstance(results, types.FunctionType):
results = results()
try:
data = iter(serializer_class(results))
media_type = MediaType(mimetype)
# JSONP, for JSON-derived media types
if media_type.type[:2] == ('application',
'json') and 'callback' in request.GET:
actual_mimetype = 'text/javascript'
data = itertools.chain([request.GET['callback'], '('], data,
[');\n'])
else:
actual_mimetype = mimetype
return HttpResponse(data, mimetype=actual_mimetype)
except TypeError:
return NotImplemented
def override_redirect(self, request, description_url, mimetypes):
url = urlparse.urlparse(description_url)
if 'django_hosts' in settings.INSTALLED_APPS:
host, _ = self.hosts_middleware.get_host(url.netloc)
urlconf = host.urlconf
else:
urlconf = None
try:
view, _, _ = resolve(url.path, urlconf)
except Resolver404:
return False
should_redirect = lambda: True
renderer = decorators.renderer(None, mimetypes, float('inf'),
None)(should_redirect)
accepts = self.parse_accept_header(request.META.get('HTTP_ACCEPT', ''))
renderers = MediaType.resolve(accepts,
(renderer, ) + view.conneg.renderers)
return renderers and renderers[0] is should_redirect
def get_renderers(self, request):
"""
Returns a list of renderer functions in the order they should be tried.
Tries the format override parameter first, then the Accept header. If
neither is present, attempt to fall back to self._default_format. If
a fallback format has been specified, we try that last.
"""
if self._format_override_parameter in request.REQUEST:
formats = request.REQUEST[self._format_override_parameter].split(',')
renderers, seen_formats = [], set()
for format in formats:
if format in self._renderers_by_format and format not in seen_formats:
renderers.extend(self._renderers_by_format[format])
elif request.META.get('HTTP_ACCEPT'):
accepts = self.parse_accept_header(request.META['HTTP_ACCEPT'])
renderers = MediaType.resolve(accepts, self._renderers)
elif self._default_format:
renderers = self._renderers_by_format[self._default_format]
else:
renderers = []
if self._force_fallback_format:
renderers.extend(self._renderers_by_format[self._force_fallback_format])
return renderers
def parse_accept_header(cls, accept):
warnings.warn("The parse_accept_header method has moved to django_conneg.http.MediaType")
return MediaType.parse_accept_header(accept)
