17.12
This commit is contained in:
Mai Gillmann
@@ -0,0 +1,21 @@
|
||||
from django.http.cookie import SimpleCookie, parse_cookie
|
||||
from django.http.request import (
|
||||
HttpRequest, QueryDict, RawPostDataException, UnreadablePostError,
|
||||
)
|
||||
from django.http.response import (
|
||||
BadHeaderError, FileResponse, Http404, HttpResponse,
|
||||
HttpResponseBadRequest, HttpResponseForbidden, HttpResponseGone,
|
||||
HttpResponseNotAllowed, HttpResponseNotFound, HttpResponseNotModified,
|
||||
HttpResponsePermanentRedirect, HttpResponseRedirect,
|
||||
HttpResponseServerError, JsonResponse, StreamingHttpResponse,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
'SimpleCookie', 'parse_cookie', 'HttpRequest', 'QueryDict',
|
||||
'RawPostDataException', 'UnreadablePostError',
|
||||
'HttpResponse', 'StreamingHttpResponse', 'HttpResponseRedirect',
|
||||
'HttpResponsePermanentRedirect', 'HttpResponseNotModified',
|
||||
'HttpResponseBadRequest', 'HttpResponseForbidden', 'HttpResponseNotFound',
|
||||
'HttpResponseNotAllowed', 'HttpResponseGone', 'HttpResponseServerError',
|
||||
'Http404', 'BadHeaderError', 'JsonResponse', 'FileResponse',
|
||||
]
|
||||
@@ -0,0 +1,26 @@
|
||||
from http import cookies
|
||||
|
||||
# For backwards compatibility in Django 2.1.
|
||||
SimpleCookie = cookies.SimpleCookie
|
||||
|
||||
# Add support for the SameSite attribute (obsolete when PY37 is unsupported).
|
||||
cookies.Morsel._reserved.setdefault('samesite', 'SameSite')
|
||||
|
||||
|
||||
def parse_cookie(cookie):
|
||||
"""
|
||||
Return a dictionary parsed from a `Cookie:` header string.
|
||||
"""
|
||||
cookiedict = {}
|
||||
for chunk in cookie.split(';'):
|
||||
if '=' in chunk:
|
||||
key, val = chunk.split('=', 1)
|
||||
else:
|
||||
# Assume an empty name per
|
||||
# https://bugzilla.mozilla.org/show_bug.cgi?id=169091
|
||||
key, val = '', chunk
|
||||
key, val = key.strip(), val.strip()
|
||||
if key or val:
|
||||
# unquote using Python's algorithm.
|
||||
cookiedict[key] = cookies._unquote(val)
|
||||
return cookiedict
|
||||
@@ -0,0 +1,603 @@
|
||||
import copy
|
||||
import re
|
||||
import warnings
|
||||
from io import BytesIO
|
||||
from itertools import chain
|
||||
from urllib.parse import quote, urlencode, urljoin, urlsplit
|
||||
|
||||
from django.conf import settings
|
||||
from django.core import signing
|
||||
from django.core.exceptions import (
|
||||
DisallowedHost, ImproperlyConfigured, RequestDataTooBig,
|
||||
)
|
||||
from django.core.files import uploadhandler
|
||||
from django.http.multipartparser import MultiPartParser, MultiPartParserError
|
||||
from django.utils.datastructures import (
|
||||
CaseInsensitiveMapping, ImmutableList, MultiValueDict,
|
||||
)
|
||||
from django.utils.deprecation import RemovedInDjango30Warning
|
||||
from django.utils.encoding import escape_uri_path, iri_to_uri
|
||||
from django.utils.functional import cached_property
|
||||
from django.utils.http import is_same_domain, limited_parse_qsl
|
||||
|
||||
RAISE_ERROR = object()
|
||||
host_validation_re = re.compile(r"^([a-z0-9.-]+|\[[a-f0-9]*:[a-f0-9\.:]+\])(:\d+)?$")
|
||||
|
||||
|
||||
class UnreadablePostError(IOError):
|
||||
pass
|
||||
|
||||
|
||||
class RawPostDataException(Exception):
|
||||
"""
|
||||
You cannot access raw_post_data from a request that has
|
||||
multipart/* POST data if it has been accessed via POST,
|
||||
FILES, etc..
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class HttpRequest:
|
||||
"""A basic HTTP request."""
|
||||
|
||||
# The encoding used in GET/POST dicts. None means use default setting.
|
||||
_encoding = None
|
||||
_upload_handlers = []
|
||||
|
||||
def __init__(self):
|
||||
# WARNING: The `WSGIRequest` subclass doesn't call `super`.
|
||||
# Any variable assignment made here should also happen in
|
||||
# `WSGIRequest.__init__()`.
|
||||
|
||||
self.GET = QueryDict(mutable=True)
|
||||
self.POST = QueryDict(mutable=True)
|
||||
self.COOKIES = {}
|
||||
self.META = {}
|
||||
self.FILES = MultiValueDict()
|
||||
|
||||
self.path = ''
|
||||
self.path_info = ''
|
||||
self.method = None
|
||||
self.resolver_match = None
|
||||
self.content_type = None
|
||||
self.content_params = None
|
||||
|
||||
def __repr__(self):
|
||||
if self.method is None or not self.get_full_path():
|
||||
return '<%s>' % self.__class__.__name__
|
||||
return '<%s: %s %r>' % (self.__class__.__name__, self.method, self.get_full_path())
|
||||
|
||||
@cached_property
|
||||
def headers(self):
|
||||
return HttpHeaders(self.META)
|
||||
|
||||
def _get_raw_host(self):
|
||||
"""
|
||||
Return the HTTP host using the environment or request headers. Skip
|
||||
allowed hosts protection, so may return an insecure host.
|
||||
"""
|
||||
# We try three options, in order of decreasing preference.
|
||||
if settings.USE_X_FORWARDED_HOST and (
|
||||
'HTTP_X_FORWARDED_HOST' in self.META):
|
||||
host = self.META['HTTP_X_FORWARDED_HOST']
|
||||
elif 'HTTP_HOST' in self.META:
|
||||
host = self.META['HTTP_HOST']
|
||||
else:
|
||||
# Reconstruct the host using the algorithm from PEP 333.
|
||||
host = self.META['SERVER_NAME']
|
||||
server_port = self.get_port()
|
||||
if server_port != ('443' if self.is_secure() else '80'):
|
||||
host = '%s:%s' % (host, server_port)
|
||||
return host
|
||||
|
||||
def get_host(self):
|
||||
"""Return the HTTP host using the environment or request headers."""
|
||||
host = self._get_raw_host()
|
||||
|
||||
# Allow variants of localhost if ALLOWED_HOSTS is empty and DEBUG=True.
|
||||
allowed_hosts = settings.ALLOWED_HOSTS
|
||||
if settings.DEBUG and not allowed_hosts:
|
||||
allowed_hosts = ['localhost', '127.0.0.1', '[::1]']
|
||||
|
||||
domain, port = split_domain_port(host)
|
||||
if domain and validate_host(domain, allowed_hosts):
|
||||
return host
|
||||
else:
|
||||
msg = "Invalid HTTP_HOST header: %r." % host
|
||||
if domain:
|
||||
msg += " You may need to add %r to ALLOWED_HOSTS." % domain
|
||||
else:
|
||||
msg += " The domain name provided is not valid according to RFC 1034/1035."
|
||||
raise DisallowedHost(msg)
|
||||
|
||||
def get_port(self):
|
||||
"""Return the port number for the request as a string."""
|
||||
if settings.USE_X_FORWARDED_PORT and 'HTTP_X_FORWARDED_PORT' in self.META:
|
||||
port = self.META['HTTP_X_FORWARDED_PORT']
|
||||
else:
|
||||
port = self.META['SERVER_PORT']
|
||||
return str(port)
|
||||
|
||||
def get_full_path(self, force_append_slash=False):
|
||||
return self._get_full_path(self.path, force_append_slash)
|
||||
|
||||
def get_full_path_info(self, force_append_slash=False):
|
||||
return self._get_full_path(self.path_info, force_append_slash)
|
||||
|
||||
def _get_full_path(self, path, force_append_slash):
|
||||
# RFC 3986 requires query string arguments to be in the ASCII range.
|
||||
# Rather than crash if this doesn't happen, we encode defensively.
|
||||
return '%s%s%s' % (
|
||||
escape_uri_path(path),
|
||||
'/' if force_append_slash and not path.endswith('/') else '',
|
||||
('?' + iri_to_uri(self.META.get('QUERY_STRING', ''))) if self.META.get('QUERY_STRING', '') else ''
|
||||
)
|
||||
|
||||
def get_signed_cookie(self, key, default=RAISE_ERROR, salt='', max_age=None):
|
||||
"""
|
||||
Attempt to return a signed cookie. If the signature fails or the
|
||||
cookie has expired, raise an exception, unless the `default` argument
|
||||
is provided, in which case return that value.
|
||||
"""
|
||||
try:
|
||||
cookie_value = self.COOKIES[key]
|
||||
except KeyError:
|
||||
if default is not RAISE_ERROR:
|
||||
return default
|
||||
else:
|
||||
raise
|
||||
try:
|
||||
value = signing.get_cookie_signer(salt=key + salt).unsign(
|
||||
cookie_value, max_age=max_age)
|
||||
except signing.BadSignature:
|
||||
if default is not RAISE_ERROR:
|
||||
return default
|
||||
else:
|
||||
raise
|
||||
return value
|
||||
|
||||
def get_raw_uri(self):
|
||||
"""
|
||||
Return an absolute URI from variables available in this request. Skip
|
||||
allowed hosts protection, so may return insecure URI.
|
||||
"""
|
||||
return '{scheme}://{host}{path}'.format(
|
||||
scheme=self.scheme,
|
||||
host=self._get_raw_host(),
|
||||
path=self.get_full_path(),
|
||||
)
|
||||
|
||||
def build_absolute_uri(self, location=None):
|
||||
"""
|
||||
Build an absolute URI from the location and the variables available in
|
||||
this request. If no ``location`` is specified, build the absolute URI
|
||||
using request.get_full_path(). If the location is absolute, convert it
|
||||
to an RFC 3987 compliant URI and return it. If location is relative or
|
||||
is scheme-relative (i.e., ``//example.com/``), urljoin() it to a base
|
||||
URL constructed from the request variables.
|
||||
"""
|
||||
if location is None:
|
||||
# Make it an absolute url (but schemeless and domainless) for the
|
||||
# edge case that the path starts with '//'.
|
||||
location = '//%s' % self.get_full_path()
|
||||
bits = urlsplit(location)
|
||||
if not (bits.scheme and bits.netloc):
|
||||
# Handle the simple, most common case. If the location is absolute
|
||||
# and a scheme or host (netloc) isn't provided, skip an expensive
|
||||
# urljoin() as long as no path segments are '.' or '..'.
|
||||
if (bits.path.startswith('/') and not bits.scheme and not bits.netloc and
|
||||
'/./' not in bits.path and '/../' not in bits.path):
|
||||
# If location starts with '//' but has no netloc, reuse the
|
||||
# schema and netloc from the current request. Strip the double
|
||||
# slashes and continue as if it wasn't specified.
|
||||
if location.startswith('//'):
|
||||
location = location[2:]
|
||||
location = self._current_scheme_host + location
|
||||
else:
|
||||
# Join the constructed URL with the provided location, which
|
||||
# allows the provided location to apply query strings to the
|
||||
# base path.
|
||||
location = urljoin(self._current_scheme_host + self.path, location)
|
||||
return iri_to_uri(location)
|
||||
|
||||
@cached_property
|
||||
def _current_scheme_host(self):
|
||||
return '{}://{}'.format(self.scheme, self.get_host())
|
||||
|
||||
def _get_scheme(self):
|
||||
"""
|
||||
Hook for subclasses like WSGIRequest to implement. Return 'http' by
|
||||
default.
|
||||
"""
|
||||
return 'http'
|
||||
|
||||
@property
|
||||
def scheme(self):
|
||||
if settings.SECURE_PROXY_SSL_HEADER:
|
||||
try:
|
||||
header, secure_value = settings.SECURE_PROXY_SSL_HEADER
|
||||
except ValueError:
|
||||
raise ImproperlyConfigured(
|
||||
'The SECURE_PROXY_SSL_HEADER setting must be a tuple containing two values.'
|
||||
)
|
||||
header_value = self.META.get(header)
|
||||
if header_value is not None:
|
||||
return 'https' if header_value == secure_value else 'http'
|
||||
return self._get_scheme()
|
||||
|
||||
def is_secure(self):
|
||||
return self.scheme == 'https'
|
||||
|
||||
def is_ajax(self):
|
||||
return self.META.get('HTTP_X_REQUESTED_WITH') == 'XMLHttpRequest'
|
||||
|
||||
@property
|
||||
def encoding(self):
|
||||
return self._encoding
|
||||
|
||||
@encoding.setter
|
||||
def encoding(self, val):
|
||||
"""
|
||||
Set the encoding used for GET/POST accesses. If the GET or POST
|
||||
dictionary has already been created, remove and recreate it on the
|
||||
next access (so that it is decoded correctly).
|
||||
"""
|
||||
self._encoding = val
|
||||
if hasattr(self, 'GET'):
|
||||
del self.GET
|
||||
if hasattr(self, '_post'):
|
||||
del self._post
|
||||
|
||||
def _initialize_handlers(self):
|
||||
self._upload_handlers = [uploadhandler.load_handler(handler, self)
|
||||
for handler in settings.FILE_UPLOAD_HANDLERS]
|
||||
|
||||
@property
|
||||
def upload_handlers(self):
|
||||
if not self._upload_handlers:
|
||||
# If there are no upload handlers defined, initialize them from settings.
|
||||
self._initialize_handlers()
|
||||
return self._upload_handlers
|
||||
|
||||
@upload_handlers.setter
|
||||
def upload_handlers(self, upload_handlers):
|
||||
if hasattr(self, '_files'):
|
||||
raise AttributeError("You cannot set the upload handlers after the upload has been processed.")
|
||||
self._upload_handlers = upload_handlers
|
||||
|
||||
def parse_file_upload(self, META, post_data):
|
||||
"""Return a tuple of (POST QueryDict, FILES MultiValueDict)."""
|
||||
self.upload_handlers = ImmutableList(
|
||||
self.upload_handlers,
|
||||
warning="You cannot alter upload handlers after the upload has been processed."
|
||||
)
|
||||
parser = MultiPartParser(META, post_data, self.upload_handlers, self.encoding)
|
||||
return parser.parse()
|
||||
|
||||
@property
|
||||
def body(self):
|
||||
if not hasattr(self, '_body'):
|
||||
if self._read_started:
|
||||
raise RawPostDataException("You cannot access body after reading from request's data stream")
|
||||
|
||||
# Limit the maximum request data size that will be handled in-memory.
|
||||
if (settings.DATA_UPLOAD_MAX_MEMORY_SIZE is not None and
|
||||
int(self.META.get('CONTENT_LENGTH') or 0) > settings.DATA_UPLOAD_MAX_MEMORY_SIZE):
|
||||
raise RequestDataTooBig('Request body exceeded settings.DATA_UPLOAD_MAX_MEMORY_SIZE.')
|
||||
|
||||
try:
|
||||
self._body = self.read()
|
||||
except IOError as e:
|
||||
raise UnreadablePostError(*e.args) from e
|
||||
self._stream = BytesIO(self._body)
|
||||
return self._body
|
||||
|
||||
def _mark_post_parse_error(self):
|
||||
self._post = QueryDict()
|
||||
self._files = MultiValueDict()
|
||||
|
||||
def _load_post_and_files(self):
|
||||
"""Populate self._post and self._files if the content-type is a form type"""
|
||||
if self.method != 'POST':
|
||||
self._post, self._files = QueryDict(encoding=self._encoding), MultiValueDict()
|
||||
return
|
||||
if self._read_started and not hasattr(self, '_body'):
|
||||
self._mark_post_parse_error()
|
||||
return
|
||||
|
||||
if self.content_type == 'multipart/form-data':
|
||||
if hasattr(self, '_body'):
|
||||
# Use already read data
|
||||
data = BytesIO(self._body)
|
||||
else:
|
||||
data = self
|
||||
try:
|
||||
self._post, self._files = self.parse_file_upload(self.META, data)
|
||||
except MultiPartParserError:
|
||||
# An error occurred while parsing POST data. Since when
|
||||
# formatting the error the request handler might access
|
||||
# self.POST, set self._post and self._file to prevent
|
||||
# attempts to parse POST data again.
|
||||
self._mark_post_parse_error()
|
||||
raise
|
||||
elif self.content_type == 'application/x-www-form-urlencoded':
|
||||
self._post, self._files = QueryDict(self.body, encoding=self._encoding), MultiValueDict()
|
||||
else:
|
||||
self._post, self._files = QueryDict(encoding=self._encoding), MultiValueDict()
|
||||
|
||||
def close(self):
|
||||
if hasattr(self, '_files'):
|
||||
for f in chain.from_iterable(l[1] for l in self._files.lists()):
|
||||
f.close()
|
||||
|
||||
# File-like and iterator interface.
|
||||
#
|
||||
# Expects self._stream to be set to an appropriate source of bytes by
|
||||
# a corresponding request subclass (e.g. WSGIRequest).
|
||||
# Also when request data has already been read by request.POST or
|
||||
# request.body, self._stream points to a BytesIO instance
|
||||
# containing that data.
|
||||
|
||||
def read(self, *args, **kwargs):
|
||||
self._read_started = True
|
||||
try:
|
||||
return self._stream.read(*args, **kwargs)
|
||||
except IOError as e:
|
||||
raise UnreadablePostError(*e.args) from e
|
||||
|
||||
def readline(self, *args, **kwargs):
|
||||
self._read_started = True
|
||||
try:
|
||||
return self._stream.readline(*args, **kwargs)
|
||||
except IOError as e:
|
||||
raise UnreadablePostError(*e.args) from e
|
||||
|
||||
def __iter__(self):
|
||||
return iter(self.readline, b'')
|
||||
|
||||
def xreadlines(self):
|
||||
warnings.warn(
|
||||
'HttpRequest.xreadlines() is deprecated in favor of iterating the '
|
||||
'request.', RemovedInDjango30Warning, stacklevel=2,
|
||||
)
|
||||
yield from self
|
||||
|
||||
def readlines(self):
|
||||
return list(self)
|
||||
|
||||
|
||||
class HttpHeaders(CaseInsensitiveMapping):
|
||||
HTTP_PREFIX = 'HTTP_'
|
||||
# PEP 333 gives two headers which aren't prepended with HTTP_.
|
||||
UNPREFIXED_HEADERS = {'CONTENT_TYPE', 'CONTENT_LENGTH'}
|
||||
|
||||
def __init__(self, environ):
|
||||
headers = {}
|
||||
for header, value in environ.items():
|
||||
name = self.parse_header_name(header)
|
||||
if name:
|
||||
headers[name] = value
|
||||
super().__init__(headers)
|
||||
|
||||
@classmethod
|
||||
def parse_header_name(cls, header):
|
||||
if header.startswith(cls.HTTP_PREFIX):
|
||||
header = header[len(cls.HTTP_PREFIX):]
|
||||
elif header not in cls.UNPREFIXED_HEADERS:
|
||||
return None
|
||||
return header.replace('_', '-').title()
|
||||
|
||||
|
||||
class QueryDict(MultiValueDict):
|
||||
"""
|
||||
A specialized MultiValueDict which represents a query string.
|
||||
|
||||
A QueryDict can be used to represent GET or POST data. It subclasses
|
||||
MultiValueDict since keys in such data can be repeated, for instance
|
||||
in the data from a form with a <select multiple> field.
|
||||
|
||||
By default QueryDicts are immutable, though the copy() method
|
||||
will always return a mutable copy.
|
||||
|
||||
Both keys and values set on this class are converted from the given encoding
|
||||
(DEFAULT_CHARSET by default) to str.
|
||||
"""
|
||||
|
||||
# These are both reset in __init__, but is specified here at the class
|
||||
# level so that unpickling will have valid values
|
||||
_mutable = True
|
||||
_encoding = None
|
||||
|
||||
def __init__(self, query_string=None, mutable=False, encoding=None):
|
||||
super().__init__()
|
||||
self.encoding = encoding or settings.DEFAULT_CHARSET
|
||||
query_string = query_string or ''
|
||||
parse_qsl_kwargs = {
|
||||
'keep_blank_values': True,
|
||||
'fields_limit': settings.DATA_UPLOAD_MAX_NUMBER_FIELDS,
|
||||
'encoding': self.encoding,
|
||||
}
|
||||
if isinstance(query_string, bytes):
|
||||
# query_string normally contains URL-encoded data, a subset of ASCII.
|
||||
try:
|
||||
query_string = query_string.decode(self.encoding)
|
||||
except UnicodeDecodeError:
|
||||
# ... but some user agents are misbehaving :-(
|
||||
query_string = query_string.decode('iso-8859-1')
|
||||
for key, value in limited_parse_qsl(query_string, **parse_qsl_kwargs):
|
||||
self.appendlist(key, value)
|
||||
self._mutable = mutable
|
||||
|
||||
@classmethod
|
||||
def fromkeys(cls, iterable, value='', mutable=False, encoding=None):
|
||||
"""
|
||||
Return a new QueryDict with keys (may be repeated) from an iterable and
|
||||
values from value.
|
||||
"""
|
||||
q = cls('', mutable=True, encoding=encoding)
|
||||
for key in iterable:
|
||||
q.appendlist(key, value)
|
||||
if not mutable:
|
||||
q._mutable = False
|
||||
return q
|
||||
|
||||
@property
|
||||
def encoding(self):
|
||||
if self._encoding is None:
|
||||
self._encoding = settings.DEFAULT_CHARSET
|
||||
return self._encoding
|
||||
|
||||
@encoding.setter
|
||||
def encoding(self, value):
|
||||
self._encoding = value
|
||||
|
||||
def _assert_mutable(self):
|
||||
if not self._mutable:
|
||||
raise AttributeError("This QueryDict instance is immutable")
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
self._assert_mutable()
|
||||
key = bytes_to_text(key, self.encoding)
|
||||
value = bytes_to_text(value, self.encoding)
|
||||
super().__setitem__(key, value)
|
||||
|
||||
def __delitem__(self, key):
|
||||
self._assert_mutable()
|
||||
super().__delitem__(key)
|
||||
|
||||
def __copy__(self):
|
||||
result = self.__class__('', mutable=True, encoding=self.encoding)
|
||||
for key, value in self.lists():
|
||||
result.setlist(key, value)
|
||||
return result
|
||||
|
||||
def __deepcopy__(self, memo):
|
||||
result = self.__class__('', mutable=True, encoding=self.encoding)
|
||||
memo[id(self)] = result
|
||||
for key, value in self.lists():
|
||||
result.setlist(copy.deepcopy(key, memo), copy.deepcopy(value, memo))
|
||||
return result
|
||||
|
||||
def setlist(self, key, list_):
|
||||
self._assert_mutable()
|
||||
key = bytes_to_text(key, self.encoding)
|
||||
list_ = [bytes_to_text(elt, self.encoding) for elt in list_]
|
||||
super().setlist(key, list_)
|
||||
|
||||
def setlistdefault(self, key, default_list=None):
|
||||
self._assert_mutable()
|
||||
return super().setlistdefault(key, default_list)
|
||||
|
||||
def appendlist(self, key, value):
|
||||
self._assert_mutable()
|
||||
key = bytes_to_text(key, self.encoding)
|
||||
value = bytes_to_text(value, self.encoding)
|
||||
super().appendlist(key, value)
|
||||
|
||||
def pop(self, key, *args):
|
||||
self._assert_mutable()
|
||||
return super().pop(key, *args)
|
||||
|
||||
def popitem(self):
|
||||
self._assert_mutable()
|
||||
return super().popitem()
|
||||
|
||||
def clear(self):
|
||||
self._assert_mutable()
|
||||
super().clear()
|
||||
|
||||
def setdefault(self, key, default=None):
|
||||
self._assert_mutable()
|
||||
key = bytes_to_text(key, self.encoding)
|
||||
default = bytes_to_text(default, self.encoding)
|
||||
return super().setdefault(key, default)
|
||||
|
||||
def copy(self):
|
||||
"""Return a mutable copy of this object."""
|
||||
return self.__deepcopy__({})
|
||||
|
||||
def urlencode(self, safe=None):
|
||||
"""
|
||||
Return an encoded string of all query string arguments.
|
||||
|
||||
`safe` specifies characters which don't require quoting, for example::
|
||||
|
||||
>>> q = QueryDict(mutable=True)
|
||||
>>> q['next'] = '/a&b/'
|
||||
>>> q.urlencode()
|
||||
'next=%2Fa%26b%2F'
|
||||
>>> q.urlencode(safe='/')
|
||||
'next=/a%26b/'
|
||||
"""
|
||||
output = []
|
||||
if safe:
|
||||
safe = safe.encode(self.encoding)
|
||||
|
||||
def encode(k, v):
|
||||
return '%s=%s' % ((quote(k, safe), quote(v, safe)))
|
||||
else:
|
||||
def encode(k, v):
|
||||
return urlencode({k: v})
|
||||
for k, list_ in self.lists():
|
||||
output.extend(
|
||||
encode(k.encode(self.encoding), str(v).encode(self.encoding))
|
||||
for v in list_
|
||||
)
|
||||
return '&'.join(output)
|
||||
|
||||
|
||||
# It's neither necessary nor appropriate to use
|
||||
# django.utils.encoding.force_text for parsing URLs and form inputs. Thus,
|
||||
# this slightly more restricted function, used by QueryDict.
|
||||
def bytes_to_text(s, encoding):
|
||||
"""
|
||||
Convert bytes objects to strings, using the given encoding. Illegally
|
||||
encoded input characters are replaced with Unicode "unknown" codepoint
|
||||
(\ufffd).
|
||||
|
||||
Return any non-bytes objects without change.
|
||||
"""
|
||||
if isinstance(s, bytes):
|
||||
return str(s, encoding, 'replace')
|
||||
else:
|
||||
return s
|
||||
|
||||
|
||||
def split_domain_port(host):
|
||||
"""
|
||||
Return a (domain, port) tuple from a given host.
|
||||
|
||||
Returned domain is lowercased. If the host is invalid, the domain will be
|
||||
empty.
|
||||
"""
|
||||
host = host.lower()
|
||||
|
||||
if not host_validation_re.match(host):
|
||||
return '', ''
|
||||
|
||||
if host[-1] == ']':
|
||||
# It's an IPv6 address without a port.
|
||||
return host, ''
|
||||
bits = host.rsplit(':', 1)
|
||||
domain, port = bits if len(bits) == 2 else (bits[0], '')
|
||||
# Remove a trailing dot (if present) from the domain.
|
||||
domain = domain[:-1] if domain.endswith('.') else domain
|
||||
return domain, port
|
||||
|
||||
|
||||
def validate_host(host, allowed_hosts):
|
||||
"""
|
||||
Validate the given host for this site.
|
||||
|
||||
Check that the host looks valid and matches a host or host pattern in the
|
||||
given list of ``allowed_hosts``. Any pattern beginning with a period
|
||||
matches a domain and all its subdomains (e.g. ``.example.com`` matches
|
||||
``example.com`` and any subdomain), ``*`` matches anything, and anything
|
||||
else must match exactly.
|
||||
|
||||
Note: This function assumes that the given host is lowercased and has
|
||||
already had the port, if any, stripped off.
|
||||
|
||||
Return ``True`` for a valid host, ``False`` otherwise.
|
||||
"""
|
||||
return any(pattern == '*' or is_same_domain(host, pattern) for pattern in allowed_hosts)
|
||||
@@ -0,0 +1,559 @@
|
||||
import datetime
|
||||
import json
|
||||
import mimetypes
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import time
|
||||
from email.header import Header
|
||||
from http.client import responses
|
||||
from urllib.parse import quote, urlparse
|
||||
|
||||
from django.conf import settings
|
||||
from django.core import signals, signing
|
||||
from django.core.exceptions import DisallowedRedirect
|
||||
from django.core.serializers.json import DjangoJSONEncoder
|
||||
from django.http.cookie import SimpleCookie
|
||||
from django.utils import timezone
|
||||
from django.utils.encoding import iri_to_uri
|
||||
from django.utils.http import http_date
|
||||
|
||||
_charset_from_content_type_re = re.compile(r';\s*charset=(?P<charset>[^\s;]+)', re.I)
|
||||
|
||||
|
||||
class BadHeaderError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
class HttpResponseBase:
|
||||
"""
|
||||
An HTTP response base class with dictionary-accessed headers.
|
||||
|
||||
This class doesn't handle content. It should not be used directly.
|
||||
Use the HttpResponse and StreamingHttpResponse subclasses instead.
|
||||
"""
|
||||
|
||||
status_code = 200
|
||||
|
||||
def __init__(self, content_type=None, status=None, reason=None, charset=None):
|
||||
# _headers is a mapping of the lowercase name to the original case of
|
||||
# the header (required for working with legacy systems) and the header
|
||||
# value. Both the name of the header and its value are ASCII strings.
|
||||
self._headers = {}
|
||||
self._closable_objects = []
|
||||
# This parameter is set by the handler. It's necessary to preserve the
|
||||
# historical behavior of request_finished.
|
||||
self._handler_class = None
|
||||
self.cookies = SimpleCookie()
|
||||
self.closed = False
|
||||
if status is not None:
|
||||
try:
|
||||
self.status_code = int(status)
|
||||
except (ValueError, TypeError):
|
||||
raise TypeError('HTTP status code must be an integer.')
|
||||
|
||||
if not 100 <= self.status_code <= 599:
|
||||
raise ValueError('HTTP status code must be an integer from 100 to 599.')
|
||||
self._reason_phrase = reason
|
||||
self._charset = charset
|
||||
if content_type is None:
|
||||
content_type = '%s; charset=%s' % (settings.DEFAULT_CONTENT_TYPE,
|
||||
self.charset)
|
||||
self['Content-Type'] = content_type
|
||||
|
||||
@property
|
||||
def reason_phrase(self):
|
||||
if self._reason_phrase is not None:
|
||||
return self._reason_phrase
|
||||
# Leave self._reason_phrase unset in order to use the default
|
||||
# reason phrase for status code.
|
||||
return responses.get(self.status_code, 'Unknown Status Code')
|
||||
|
||||
@reason_phrase.setter
|
||||
def reason_phrase(self, value):
|
||||
self._reason_phrase = value
|
||||
|
||||
@property
|
||||
def charset(self):
|
||||
if self._charset is not None:
|
||||
return self._charset
|
||||
content_type = self.get('Content-Type', '')
|
||||
matched = _charset_from_content_type_re.search(content_type)
|
||||
if matched:
|
||||
# Extract the charset and strip its double quotes
|
||||
return matched.group('charset').replace('"', '')
|
||||
return settings.DEFAULT_CHARSET
|
||||
|
||||
@charset.setter
|
||||
def charset(self, value):
|
||||
self._charset = value
|
||||
|
||||
def serialize_headers(self):
|
||||
"""HTTP headers as a bytestring."""
|
||||
def to_bytes(val, encoding):
|
||||
return val if isinstance(val, bytes) else val.encode(encoding)
|
||||
|
||||
headers = [
|
||||
(to_bytes(key, 'ascii') + b': ' + to_bytes(value, 'latin-1'))
|
||||
for key, value in self._headers.values()
|
||||
]
|
||||
return b'\r\n'.join(headers)
|
||||
|
||||
__bytes__ = serialize_headers
|
||||
|
||||
@property
|
||||
def _content_type_for_repr(self):
|
||||
return ', "%s"' % self['Content-Type'] if 'Content-Type' in self else ''
|
||||
|
||||
def _convert_to_charset(self, value, charset, mime_encode=False):
|
||||
"""
|
||||
Convert headers key/value to ascii/latin-1 native strings.
|
||||
|
||||
`charset` must be 'ascii' or 'latin-1'. If `mime_encode` is True and
|
||||
`value` can't be represented in the given charset, apply MIME-encoding.
|
||||
"""
|
||||
if not isinstance(value, (bytes, str)):
|
||||
value = str(value)
|
||||
if ((isinstance(value, bytes) and (b'\n' in value or b'\r' in value)) or
|
||||
isinstance(value, str) and ('\n' in value or '\r' in value)):
|
||||
raise BadHeaderError("Header values can't contain newlines (got %r)" % value)
|
||||
try:
|
||||
if isinstance(value, str):
|
||||
# Ensure string is valid in given charset
|
||||
value.encode(charset)
|
||||
else:
|
||||
# Convert bytestring using given charset
|
||||
value = value.decode(charset)
|
||||
except UnicodeError as e:
|
||||
if mime_encode:
|
||||
value = Header(value, 'utf-8', maxlinelen=sys.maxsize).encode()
|
||||
else:
|
||||
e.reason += ', HTTP response headers must be in %s format' % charset
|
||||
raise
|
||||
return value
|
||||
|
||||
def __setitem__(self, header, value):
|
||||
header = self._convert_to_charset(header, 'ascii')
|
||||
value = self._convert_to_charset(value, 'latin-1', mime_encode=True)
|
||||
self._headers[header.lower()] = (header, value)
|
||||
|
||||
def __delitem__(self, header):
|
||||
self._headers.pop(header.lower(), False)
|
||||
|
||||
def __getitem__(self, header):
|
||||
return self._headers[header.lower()][1]
|
||||
|
||||
def has_header(self, header):
|
||||
"""Case-insensitive check for a header."""
|
||||
return header.lower() in self._headers
|
||||
|
||||
__contains__ = has_header
|
||||
|
||||
def items(self):
|
||||
return self._headers.values()
|
||||
|
||||
def get(self, header, alternate=None):
|
||||
return self._headers.get(header.lower(), (None, alternate))[1]
|
||||
|
||||
def set_cookie(self, key, value='', max_age=None, expires=None, path='/',
|
||||
domain=None, secure=False, httponly=False, samesite=None):
|
||||
"""
|
||||
Set a cookie.
|
||||
|
||||
``expires`` can be:
|
||||
- a string in the correct format,
|
||||
- a naive ``datetime.datetime`` object in UTC,
|
||||
- an aware ``datetime.datetime`` object in any time zone.
|
||||
If it is a ``datetime.datetime`` object then calculate ``max_age``.
|
||||
"""
|
||||
self.cookies[key] = value
|
||||
if expires is not None:
|
||||
if isinstance(expires, datetime.datetime):
|
||||
if timezone.is_aware(expires):
|
||||
expires = timezone.make_naive(expires, timezone.utc)
|
||||
delta = expires - expires.utcnow()
|
||||
# Add one second so the date matches exactly (a fraction of
|
||||
# time gets lost between converting to a timedelta and
|
||||
# then the date string).
|
||||
delta = delta + datetime.timedelta(seconds=1)
|
||||
# Just set max_age - the max_age logic will set expires.
|
||||
expires = None
|
||||
max_age = max(0, delta.days * 86400 + delta.seconds)
|
||||
else:
|
||||
self.cookies[key]['expires'] = expires
|
||||
else:
|
||||
self.cookies[key]['expires'] = ''
|
||||
if max_age is not None:
|
||||
self.cookies[key]['max-age'] = max_age
|
||||
# IE requires expires, so set it if hasn't been already.
|
||||
if not expires:
|
||||
self.cookies[key]['expires'] = http_date(time.time() + max_age)
|
||||
if path is not None:
|
||||
self.cookies[key]['path'] = path
|
||||
if domain is not None:
|
||||
self.cookies[key]['domain'] = domain
|
||||
if secure:
|
||||
self.cookies[key]['secure'] = True
|
||||
if httponly:
|
||||
self.cookies[key]['httponly'] = True
|
||||
if samesite:
|
||||
if samesite.lower() not in ('lax', 'strict'):
|
||||
raise ValueError('samesite must be "lax" or "strict".')
|
||||
self.cookies[key]['samesite'] = samesite
|
||||
|
||||
def setdefault(self, key, value):
|
||||
"""Set a header unless it has already been set."""
|
||||
if key not in self:
|
||||
self[key] = value
|
||||
|
||||
def set_signed_cookie(self, key, value, salt='', **kwargs):
|
||||
value = signing.get_cookie_signer(salt=key + salt).sign(value)
|
||||
return self.set_cookie(key, value, **kwargs)
|
||||
|
||||
def delete_cookie(self, key, path='/', domain=None):
|
||||
# Most browsers ignore the Set-Cookie header if the cookie name starts
|
||||
# with __Host- or __Secure- and the cookie doesn't use the secure flag.
|
||||
secure = key.startswith(('__Secure-', '__Host-'))
|
||||
self.set_cookie(
|
||||
key, max_age=0, path=path, domain=domain, secure=secure,
|
||||
expires='Thu, 01 Jan 1970 00:00:00 GMT',
|
||||
)
|
||||
|
||||
# Common methods used by subclasses
|
||||
|
||||
def make_bytes(self, value):
|
||||
"""Turn a value into a bytestring encoded in the output charset."""
|
||||
# Per PEP 3333, this response body must be bytes. To avoid returning
|
||||
# an instance of a subclass, this function returns `bytes(value)`.
|
||||
# This doesn't make a copy when `value` already contains bytes.
|
||||
|
||||
# Handle string types -- we can't rely on force_bytes here because:
|
||||
# - Python attempts str conversion first
|
||||
# - when self._charset != 'utf-8' it re-encodes the content
|
||||
if isinstance(value, bytes):
|
||||
return bytes(value)
|
||||
if isinstance(value, str):
|
||||
return bytes(value.encode(self.charset))
|
||||
# Handle non-string types.
|
||||
return str(value).encode(self.charset)
|
||||
|
||||
# These methods partially implement the file-like object interface.
|
||||
# See https://docs.python.org/library/io.html#io.IOBase
|
||||
|
||||
# The WSGI server must call this method upon completion of the request.
|
||||
# See http://blog.dscpl.com.au/2012/10/obligations-for-calling-close-on.html
|
||||
def close(self):
|
||||
for closable in self._closable_objects:
|
||||
try:
|
||||
closable.close()
|
||||
except Exception:
|
||||
pass
|
||||
self.closed = True
|
||||
signals.request_finished.send(sender=self._handler_class)
|
||||
|
||||
def write(self, content):
|
||||
raise IOError("This %s instance is not writable" % self.__class__.__name__)
|
||||
|
||||
def flush(self):
|
||||
pass
|
||||
|
||||
def tell(self):
|
||||
raise IOError("This %s instance cannot tell its position" % self.__class__.__name__)
|
||||
|
||||
# These methods partially implement a stream-like object interface.
|
||||
# See https://docs.python.org/library/io.html#io.IOBase
|
||||
|
||||
def readable(self):
|
||||
return False
|
||||
|
||||
def seekable(self):
|
||||
return False
|
||||
|
||||
def writable(self):
|
||||
return False
|
||||
|
||||
def writelines(self, lines):
|
||||
raise IOError("This %s instance is not writable" % self.__class__.__name__)
|
||||
|
||||
|
||||
class HttpResponse(HttpResponseBase):
|
||||
"""
|
||||
An HTTP response class with a string as content.
|
||||
|
||||
This content that can be read, appended to, or replaced.
|
||||
"""
|
||||
|
||||
streaming = False
|
||||
|
||||
def __init__(self, content=b'', *args, **kwargs):
|
||||
super().__init__(*args, **kwargs)
|
||||
# Content is a bytestring. See the `content` property methods.
|
||||
self.content = content
|
||||
|
||||
def __repr__(self):
|
||||
return '<%(cls)s status_code=%(status_code)d%(content_type)s>' % {
|
||||
'cls': self.__class__.__name__,
|
||||
'status_code': self.status_code,
|
||||
'content_type': self._content_type_for_repr,
|
||||
}
|
||||
|
||||
def serialize(self):
|
||||
"""Full HTTP message, including headers, as a bytestring."""
|
||||
return self.serialize_headers() + b'\r\n\r\n' + self.content
|
||||
|
||||
__bytes__ = serialize
|
||||
|
||||
@property
|
||||
def content(self):
|
||||
return b''.join(self._container)
|
||||
|
||||
@content.setter
|
||||
def content(self, value):
|
||||
# Consume iterators upon assignment to allow repeated iteration.
|
||||
if hasattr(value, '__iter__') and not isinstance(value, (bytes, str)):
|
||||
content = b''.join(self.make_bytes(chunk) for chunk in value)
|
||||
if hasattr(value, 'close'):
|
||||
try:
|
||||
value.close()
|
||||
except Exception:
|
||||
pass
|
||||
else:
|
||||
content = self.make_bytes(value)
|
||||
# Create a list of properly encoded bytestrings to support write().
|
||||
self._container = [content]
|
||||
|
||||
def __iter__(self):
|
||||
return iter(self._container)
|
||||
|
||||
def write(self, content):
|
||||
self._container.append(self.make_bytes(content))
|
||||
|
||||
def tell(self):
|
||||
return len(self.content)
|
||||
|
||||
def getvalue(self):
|
||||
return self.content
|
||||
|
||||
def writable(self):
|
||||
return True
|
||||
|
||||
def writelines(self, lines):
|
||||
for line in lines:
|
||||
self.write(line)
|
||||
|
||||
|
||||
class StreamingHttpResponse(HttpResponseBase):
|
||||
"""
|
||||
A streaming HTTP response class with an iterator as content.
|
||||
|
||||
This should only be iterated once, when the response is streamed to the
|
||||
client. However, it can be appended to or replaced with a new iterator
|
||||
that wraps the original content (or yields entirely new content).
|
||||
"""
|
||||
|
||||
streaming = True
|
||||
|
||||
def __init__(self, streaming_content=(), *args, **kwargs):
|
||||
super().__init__(*args, **kwargs)
|
||||
# `streaming_content` should be an iterable of bytestrings.
|
||||
# See the `streaming_content` property methods.
|
||||
self.streaming_content = streaming_content
|
||||
|
||||
@property
|
||||
def content(self):
|
||||
raise AttributeError(
|
||||
"This %s instance has no `content` attribute. Use "
|
||||
"`streaming_content` instead." % self.__class__.__name__
|
||||
)
|
||||
|
||||
@property
|
||||
def streaming_content(self):
|
||||
return map(self.make_bytes, self._iterator)
|
||||
|
||||
@streaming_content.setter
|
||||
def streaming_content(self, value):
|
||||
self._set_streaming_content(value)
|
||||
|
||||
def _set_streaming_content(self, value):
|
||||
# Ensure we can never iterate on "value" more than once.
|
||||
self._iterator = iter(value)
|
||||
if hasattr(value, 'close'):
|
||||
self._closable_objects.append(value)
|
||||
|
||||
def __iter__(self):
|
||||
return self.streaming_content
|
||||
|
||||
def getvalue(self):
|
||||
return b''.join(self.streaming_content)
|
||||
|
||||
|
||||
class FileResponse(StreamingHttpResponse):
|
||||
"""
|
||||
A streaming HTTP response class optimized for files.
|
||||
"""
|
||||
block_size = 4096
|
||||
|
||||
def __init__(self, *args, as_attachment=False, filename='', **kwargs):
|
||||
self.as_attachment = as_attachment
|
||||
self.filename = filename
|
||||
super().__init__(*args, **kwargs)
|
||||
|
||||
def _set_streaming_content(self, value):
|
||||
if not hasattr(value, 'read'):
|
||||
self.file_to_stream = None
|
||||
return super()._set_streaming_content(value)
|
||||
|
||||
self.file_to_stream = filelike = value
|
||||
if hasattr(filelike, 'close'):
|
||||
self._closable_objects.append(filelike)
|
||||
value = iter(lambda: filelike.read(self.block_size), b'')
|
||||
self.set_headers(filelike)
|
||||
super()._set_streaming_content(value)
|
||||
|
||||
def set_headers(self, filelike):
|
||||
"""
|
||||
Set some common response headers (Content-Length, Content-Type, and
|
||||
Content-Disposition) based on the `filelike` response content.
|
||||
"""
|
||||
encoding_map = {
|
||||
'bzip2': 'application/x-bzip',
|
||||
'gzip': 'application/gzip',
|
||||
'xz': 'application/x-xz',
|
||||
}
|
||||
filename = getattr(filelike, 'name', None)
|
||||
filename = filename if (isinstance(filename, str) and filename) else self.filename
|
||||
if os.path.isabs(filename):
|
||||
self['Content-Length'] = os.path.getsize(filelike.name)
|
||||
elif hasattr(filelike, 'getbuffer'):
|
||||
self['Content-Length'] = filelike.getbuffer().nbytes
|
||||
|
||||
if self.get('Content-Type', '').startswith(settings.DEFAULT_CONTENT_TYPE):
|
||||
if filename:
|
||||
content_type, encoding = mimetypes.guess_type(filename)
|
||||
# Encoding isn't set to prevent browsers from automatically
|
||||
# uncompressing files.
|
||||
content_type = encoding_map.get(encoding, content_type)
|
||||
self['Content-Type'] = content_type or 'application/octet-stream'
|
||||
else:
|
||||
self['Content-Type'] = 'application/octet-stream'
|
||||
|
||||
if self.as_attachment:
|
||||
filename = self.filename or os.path.basename(filename)
|
||||
if filename:
|
||||
try:
|
||||
filename.encode('ascii')
|
||||
file_expr = 'filename="{}"'.format(filename)
|
||||
except UnicodeEncodeError:
|
||||
file_expr = "filename*=utf-8''{}".format(quote(filename))
|
||||
self['Content-Disposition'] = 'attachment; {}'.format(file_expr)
|
||||
|
||||
|
||||
class HttpResponseRedirectBase(HttpResponse):
|
||||
allowed_schemes = ['http', 'https', 'ftp']
|
||||
|
||||
def __init__(self, redirect_to, *args, **kwargs):
|
||||
super().__init__(*args, **kwargs)
|
||||
self['Location'] = iri_to_uri(redirect_to)
|
||||
parsed = urlparse(str(redirect_to))
|
||||
if parsed.scheme and parsed.scheme not in self.allowed_schemes:
|
||||
raise DisallowedRedirect("Unsafe redirect to URL with protocol '%s'" % parsed.scheme)
|
||||
|
||||
url = property(lambda self: self['Location'])
|
||||
|
||||
def __repr__(self):
|
||||
return '<%(cls)s status_code=%(status_code)d%(content_type)s, url="%(url)s">' % {
|
||||
'cls': self.__class__.__name__,
|
||||
'status_code': self.status_code,
|
||||
'content_type': self._content_type_for_repr,
|
||||
'url': self.url,
|
||||
}
|
||||
|
||||
|
||||
class HttpResponseRedirect(HttpResponseRedirectBase):
|
||||
status_code = 302
|
||||
|
||||
|
||||
class HttpResponsePermanentRedirect(HttpResponseRedirectBase):
|
||||
status_code = 301
|
||||
|
||||
|
||||
class HttpResponseNotModified(HttpResponse):
|
||||
status_code = 304
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super().__init__(*args, **kwargs)
|
||||
del self['content-type']
|
||||
|
||||
@HttpResponse.content.setter
|
||||
def content(self, value):
|
||||
if value:
|
||||
raise AttributeError("You cannot set content to a 304 (Not Modified) response")
|
||||
self._container = []
|
||||
|
||||
|
||||
class HttpResponseBadRequest(HttpResponse):
|
||||
status_code = 400
|
||||
|
||||
|
||||
class HttpResponseNotFound(HttpResponse):
|
||||
status_code = 404
|
||||
|
||||
|
||||
class HttpResponseForbidden(HttpResponse):
|
||||
status_code = 403
|
||||
|
||||
|
||||
class HttpResponseNotAllowed(HttpResponse):
|
||||
status_code = 405
|
||||
|
||||
def __init__(self, permitted_methods, *args, **kwargs):
|
||||
super().__init__(*args, **kwargs)
|
||||
self['Allow'] = ', '.join(permitted_methods)
|
||||
|
||||
def __repr__(self):
|
||||
return '<%(cls)s [%(methods)s] status_code=%(status_code)d%(content_type)s>' % {
|
||||
'cls': self.__class__.__name__,
|
||||
'status_code': self.status_code,
|
||||
'content_type': self._content_type_for_repr,
|
||||
'methods': self['Allow'],
|
||||
}
|
||||
|
||||
|
||||
class HttpResponseGone(HttpResponse):
|
||||
status_code = 410
|
||||
|
||||
|
||||
class HttpResponseServerError(HttpResponse):
|
||||
status_code = 500
|
||||
|
||||
|
||||
class Http404(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class JsonResponse(HttpResponse):
|
||||
"""
|
||||
An HTTP response class that consumes data to be serialized to JSON.
|
||||
|
||||
:param data: Data to be dumped into json. By default only ``dict`` objects
|
||||
are allowed to be passed due to a security flaw before EcmaScript 5. See
|
||||
the ``safe`` parameter for more information.
|
||||
:param encoder: Should be a json encoder class. Defaults to
|
||||
``django.core.serializers.json.DjangoJSONEncoder``.
|
||||
:param safe: Controls if only ``dict`` objects may be serialized. Defaults
|
||||
to ``True``.
|
||||
:param json_dumps_params: A dictionary of kwargs passed to json.dumps().
|
||||
"""
|
||||
|
||||
def __init__(self, data, encoder=DjangoJSONEncoder, safe=True,
|
||||
json_dumps_params=None, **kwargs):
|
||||
if safe and not isinstance(data, dict):
|
||||
raise TypeError(
|
||||
'In order to allow non-dict objects to be serialized set the '
|
||||
'safe parameter to False.'
|
||||
)
|
||||
if json_dumps_params is None:
|
||||
json_dumps_params = {}
|
||||
kwargs.setdefault('content_type', 'application/json')
|
||||
data = json.dumps(data, cls=encoder, **json_dumps_params)
|
||||
super().__init__(content=data, **kwargs)
|
||||
Reference in New Issue
Block a user