django-rest-framework/rest_framework/compat.py

301 lines
8.5 KiB
Python
Raw Normal View History

"""
2012-10-27 13:32:49 +04:00
The `compat` module provides support for backwards compatibility with older
2012-11-14 22:36:29 +04:00
versions of django/python, and compatibility wrappers around optional packages.
"""
2012-10-27 13:32:49 +04:00
# flake8: noqa
2012-11-22 03:20:49 +04:00
from __future__ import unicode_literals
import django
import inspect
from django.core.exceptions import ImproperlyConfigured
2013-06-28 20:17:39 +04:00
from django.conf import settings
from django.utils import six
2013-09-25 13:30:04 +04:00
# Handle django.utils.encoding rename in 1.5 onwards.
2013-09-25 13:36:08 +04:00
# smart_unicode -> smart_text
# force_unicode -> force_text
try:
from django.utils.encoding import smart_text
except ImportError:
from django.utils.encoding import smart_unicode as smart_text
try:
from django.utils.encoding import force_text
except ImportError:
from django.utils.encoding import force_unicode as force_text
# HttpResponseBase only exists from 1.5 onwards
try:
from django.http.response import HttpResponseBase
except ImportError:
from django.http import HttpResponse as HttpResponseBase
2013-09-25 13:30:04 +04:00
# django-filter is optional
try:
import django_filters
except ImportError:
django_filters = None
2013-09-25 13:30:04 +04:00
# Django-guardian is optional. Import only if guardian is in INSTALLED_APPS
# Fixes (#1712). We keep the try/except for the test suite.
guardian = None
if 'guardian' in settings.INSTALLED_APPS:
try:
import guardian
import guardian.shortcuts # Fixes #1624
except ImportError:
pass
# cStringIO only if it's available, otherwise StringIO
try:
2012-11-22 03:43:56 +04:00
import cStringIO.StringIO as StringIO
except ImportError:
StringIO = six.StringIO
BytesIO = six.BytesIO
# urlparse compat import (Required because it changed in python 3.x)
try:
from urllib import parse as urlparse
except ImportError:
2013-01-03 13:48:43 +04:00
import urlparse
2013-12-09 13:24:10 +04:00
# UserDict moves in Python 3
try:
from UserDict import UserDict
from UserDict import DictMixin
except ImportError:
from collections import UserDict
from collections import MutableMapping as DictMixin
2016-03-09 18:03:56 +03:00
# http responses move in Python 3
try:
from httplib import responses
except ImportError:
from http.client import responses
2012-12-12 01:07:25 +04:00
# Try to import PIL in either of the two ways it can end up installed.
try:
from PIL import Image
except ImportError:
try:
import Image
except ImportError:
Image = None
def get_model_name(model_cls):
try:
return model_cls._meta.model_name
except AttributeError:
# < 1.6 used module_name instead of model_name
return model_cls._meta.module_name
def get_concrete_model(model_cls):
try:
return model_cls._meta.concrete_model
except AttributeError:
# 1.3 does not include concrete model
return model_cls
2013-09-25 13:30:04 +04:00
# View._allowed_methods only present from 1.5 onwards
2013-04-09 21:22:39 +04:00
if django.VERSION >= (1, 5):
from django.views.generic import View
else:
2013-09-25 13:30:04 +04:00
from django.views.generic import View as DjangoView
class View(DjangoView):
2013-04-09 21:22:39 +04:00
def _allowed_methods(self):
return [m.upper() for m in self.http_method_names if hasattr(self, m)]
# PATCH method is not implemented by Django
if 'patch' not in View.http_method_names:
View.http_method_names = View.http_method_names + ['patch']
2013-09-25 13:30:04 +04:00
# RequestFactory only provides `generic` from 1.5 onwards
2013-06-28 20:17:39 +04:00
from django.test.client import RequestFactory as DjangoRequestFactory
from django.test.client import FakePayload
try:
# In 1.5 the test client uses force_bytes
2014-01-28 18:30:46 +04:00
from django.utils.encoding import force_bytes as force_bytes_or_smart_bytes
2013-06-28 20:17:39 +04:00
except ImportError:
2013-09-25 13:30:04 +04:00
# In 1.4 the test client just uses smart_str
2013-06-28 20:17:39 +04:00
from django.utils.encoding import smart_str as force_bytes_or_smart_bytes
class RequestFactory(DjangoRequestFactory):
def generic(self, method, path,
data='', content_type='application/octet-stream', **extra):
parsed = urlparse.urlparse(path)
data = force_bytes_or_smart_bytes(data, settings.DEFAULT_CHARSET)
r = {
'PATH_INFO': self._get_path(parsed),
'QUERY_STRING': force_text(parsed[4]),
'REQUEST_METHOD': str(method),
}
if data:
r.update({
'CONTENT_LENGTH': len(data),
'CONTENT_TYPE': str(content_type),
'wsgi.input': FakePayload(data),
})
elif django.VERSION <= (1, 4):
# For 1.3 we need an empty WSGI payload
r.update({
'wsgi.input': FakePayload('')
})
r.update(extra)
return self.request(**r)
2013-09-25 13:30:04 +04:00
# Markdown is optional
try:
import markdown
def apply_markdown(text):
"""
Simple wrapper around :func:`markdown.markdown` to set the base level
of '#' style headers to <h2>.
"""
extensions = ['headerid(level=2)']
safe_mode = False
md = markdown.Markdown(extensions=extensions, safe_mode=safe_mode)
return md.convert(text)
except ImportError:
apply_markdown = None
# Yaml is optional
try:
import yaml
except ImportError:
yaml = None
# XML is optional
try:
import defusedxml.ElementTree as etree
except ImportError:
etree = None
2013-09-25 13:30:04 +04:00
# OAuth2 is optional
try:
2013-03-07 13:01:53 +04:00
# Note: The `oauth2` package actually provides oauth1.0a support. Urg.
import oauth2 as oauth
except ImportError:
oauth = None
2013-09-25 13:30:04 +04:00
# OAuthProvider is optional
try:
import oauth_provider
2013-03-07 13:01:53 +04:00
from oauth_provider.store import store as oauth_provider_store
# check_nonce's calling signature in django-oauth-plus changes sometime
# between versions 2.0 and 2.2.1
def check_nonce(request, oauth_request, oauth_nonce, oauth_timestamp):
check_nonce_args = inspect.getargspec(oauth_provider_store.check_nonce).args
if 'timestamp' in check_nonce_args:
return oauth_provider_store.check_nonce(
request, oauth_request, oauth_nonce, oauth_timestamp
)
return oauth_provider_store.check_nonce(
request, oauth_request, oauth_nonce
)
except (ImportError, ImproperlyConfigured):
2013-03-07 13:01:53 +04:00
oauth_provider = None
oauth_provider_store = None
check_nonce = None
2013-03-01 05:08:58 +04:00
2013-09-25 13:30:04 +04:00
2013-03-01 05:08:58 +04:00
# OAuth 2 support is optional
try:
import provider as oauth2_provider
from provider import scope as oauth2_provider_scope
from provider import constants as oauth2_constants
if oauth2_provider.__version__ in ('0.2.3', '0.2.4'):
# 0.2.3 and 0.2.4 are supported version that do not support
# timezone aware datetimes
2013-06-27 23:29:52 +04:00
import datetime
provider_now = datetime.datetime.now
else:
# Any other supported version does use timezone aware datetimes
from django.utils.timezone import now as provider_now
2013-03-01 05:08:58 +04:00
except ImportError:
oauth2_provider = None
oauth2_provider_scope = None
oauth2_constants = None
provider_now = None
2013-05-18 20:04:17 +04:00
2013-09-25 13:30:04 +04:00
# Handle lazy strings across Py2/Py3
2013-05-18 20:04:17 +04:00
from django.utils.functional import Promise
if six.PY3:
def is_non_str_iterable(obj):
if (isinstance(obj, str) or
(isinstance(obj, Promise) and obj._delegate_text)):
return False
return hasattr(obj, '__iter__')
else:
def is_non_str_iterable(obj):
return hasattr(obj, '__iter__')
try:
from django.utils.encoding import python_2_unicode_compatible
except ImportError:
def python_2_unicode_compatible(klass):
"""
A decorator that defines __unicode__ and __str__ methods under Python 2.
Under Python 3 it does nothing.
To support Python 2 and 3 with a single code base, define a __str__ method
returning text and apply this decorator to the class.
"""
if '__str__' not in klass.__dict__:
raise ValueError("@python_2_unicode_compatible cannot be applied "
"to %s because it doesn't define __str__()." %
klass.__name__)
klass.__unicode__ = klass.__str__
klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
return klass
"""
SortedDict deprecated since django 1.8. There is collections.OrderedDict
which available since python 2.7 and python 3.1. There are no need of other
checks because of django 1.7+ requires python 2.7+
"""
try:
from collections import OrderedDict as SortedDict
except ImportError:
from django.utils.datastructures import SortedDict
"""
GenericForeignKey moves from generic to fields in django 1.9 and in 1.8 shows
deprecation warnings
"""
if django.VERSION >= (1, 8):
from django.contrib.contenttypes.fields import GenericForeignKey
else:
from django.contrib.contenttypes.generic import GenericForeignKey
2015-04-24 18:58:14 +03:00
"""
django.utils.importlib is deprecated since django 1.8
"""
try:
import importlib
except ImportError:
from django.utils import importlib