def process_response(self, request, response):
sc = response.status_code
if sc in [404]:
from django.conf import settings
from django.core.mail import mail_admins
if not settings.DEBUG:
subject = '%d error' % response.status_code
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
try:
session_repr = pprint.pformat(request.session._session)
except:
session_repr = "Session repr() unavailable"
from socket import gethostname
from yats import get_version, get_python_version
from django import get_version as get_django_version
yats_data = 'URL: %s\nRAW_POST: %s\nHOST_NAME: %s\nYATS_APP_VERSION: %s\nDJANGO_VERSION: %s\nPYTHON: %s' % (
request.build_absolute_uri(), request.body, gethostname(),
get_version(), get_django_version(), get_python_version())
if hasattr(request, 'user') and request.user.is_authenticated:
yats_data += '\nUSER: %s' % request.user.email
message = "%s\n\n%s" % (yats_data, '%s\n\n%s' %
(session_repr, request_repr))
mail_admins(subject, message, fail_silently=True)
return response
def proxy(self):
"""Retrieve the upstream content and build an HttpResponse."""
headers = self.request.headers.filter(self.ignored_request_headers)
qs = self.request.query_string if self.pass_query_string else ''
# Fix for django 1.10.0 bug https://code.djangoproject.com/ticket/27005
if (self.request.META.get('CONTENT_LENGTH', None) == '' and
get_django_version() == '1.10'):
del self.request.META['CONTENT_LENGTH']
request_kwargs = self.middleware.process_request(
self, self.request, method=self.request.method, url=self.proxy_url,
headers=headers, data=self.request.body, params=qs,
allow_redirects=False, verify=self.verify_ssl, cert=self.cert,
timeout=self.timeout)
result = request(**request_kwargs)
response = HttpResponse(result.content, status=result.status_code)
# Attach forwardable headers to response
forwardable_headers = HeaderDict(result.headers).filter(
self.ignored_upstream_headers)
for header, value in iteritems(forwardable_headers):
response[header] = value
return self.middleware.process_response(
self, self.request, result, response)
def build_suite(self, test_labels=None, *args, **kwargs):
django_version = get_django_version()
if hasattr(settings, 'TESTS_TYPES') and settings.TESTS_TYPES == 'ALL':
tests_type = 'Unit Tests + Selenium Tests'
elif hasattr(settings,
'TESTS_TYPES') and settings.TESTS_TYPES == 'SELENIUM':
tests_type = 'Selenium Tests Only'
self.tags = ['selenium']
else:
tests_type = 'Unit Tests Only'
self.exclude_tags.add('selenium')
print('###### Tests Infos #####################################')
print('### Test Runner : {}'.format(settings.TEST_RUNNER))
print('### Django Version : {}'.format(django_version))
print('### Tests type: {}'.format(tests_type))
if hasattr(settings,
'FUNCT_TESTS_CONFIG') and settings.FUNCT_TESTS_CONFIG:
print('### Virtual Dispaly: {}'.format(
settings.FUNCT_TESTS_CONFIG.get('VIRTUAL_DISPLAY')))
print('########################################################')
print('')
if hasattr(settings, 'MOCK_USER_ROLES_API_CALL'
) and settings.MOCK_USER_ROLES_API_CALL:
self.user_roles_api_call = patch(
settings.USER_ROLES_API_MOCKED_FUNCT)
self.mock_user_roles_api_call = self.user_roles_api_call.start()
self.mock_user_roles_api_call.return_value = self.mock_user_roles_api_return(
)
return super(InstalledAppsTestRunner,
self).build_suite(test_labels or settings.APPS_TO_TEST,
*args, **kwargs)
def info(request):
from socket import gethostname
return render_to_response(
'info.html', {
'hostname': gethostname(),
'version': get_version(),
'date': datetime.datetime.now(),
'django': get_django_version(),
'python': get_python_version()
}, RequestContext(request))
def info(request):
from socket import gethostname
return render(
request, 'info.html', {
'hostname': gethostname(),
'version': get_version(),
'date': timezone.now(),
'django': get_django_version(),
'python': get_python_version()
})
def info(request):
context = {
'django_version': get_django_version(),
'database_engine': get_database_engine(),
'python_version': get_python_version(),
'platform': get_platform(),
}
return render_to_response('info.html', context,
context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
ctx = super(ProfileView, self).get_context_data(**kwargs)
if self.contacts.count() > 0:
ctx['contact'] = self.contacts[0]
vstring = lambda ver: '.'.join([str(x) for x in ver])
ctx.update({'python_version': vstring(version_info),
'django_version': get_django_version(),
'cams_version': vstring(libcams.CAMS_VERSION),
'person': self.request.user.player.person})
return ctx
def process_exception(self, request, exception):
# If this is a 404 ...
#if isinstance(exception, http.Http404):
# raise exception
from django.conf import settings
from django.core.mail import mail_admins
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
exc_info = sys.exc_info()
from socket import gethostname
from yats import get_version, get_python_version
from django import get_version as get_django_version
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
try:
session_repr = pprint.pformat(request.session._session)
except:
session_repr = "Session repr() unavailable"
if settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *exc_info)
# send an error message to the admins, if something fails... => and not a bot
subject = 'BUGTRACK EXCEPTION: %s' % type(exception).__name__[:60]
try:
body = request.body
except:
body = 'not available'
yats_data = 'TS: %s\nURL: %s\nRAW_POST: %s\nHOST_NAME: %s\nYATS_APP_VERSION: %s\nDJANGO_VERSION: %s\nPYTHON: %s' % (
datetime.datetime.now(), request.build_absolute_uri(), body,
gethostname(), get_version(), get_django_version(),
get_python_version())
if hasattr(request, 'organisation'):
yats_data += '\nORGA: %s' % request.organisation.name
else:
if hasattr(request, 'user') and request.user.is_authenticated:
yats_data += '\nUSER: %s' % request.user.email
message = "%s\n\n%s\n\n%s" % (self._get_traceback(exc_info), yats_data,
'%s\n\n%s' %
(session_repr, request_repr))
mail_admins(subject, message, fail_silently=False)
return http.HttpResponseServerError(
loader.get_template('500.html').render(Context()))
def demo_context(request):
context = {
'django_version': django_version,
'django_version_string': get_django_version(),
'url_section': '',
'url_sub_section': '',
'bootstrap_version': '',
'bootstrap4_supported': django_version > (1, 11),
}
url_name_parts = request.resolver_match.url_name.split('.', 1)
if len(url_name_parts) == 2 and url_name_parts[0][:-1] == 'bootstrap':
context['url_section'] = url_name_parts[0]
context['url_sub_section'] = url_name_parts[1]
context['bootstrap_version'] = int(url_name_parts[0][-1])
return context
def demo_context(request):
context = {
"django_version": django_version,
"django_version_string": get_django_version(),
"url_section": "",
"url_sub_section": "",
"bootstrap_version": "",
"bootstrap4_supported": django_version > (1, 11),
}
url_name_parts = request.resolver_match.url_name.split(".", 1)
if len(url_name_parts) == 2 and url_name_parts[0][:-1] == "bootstrap":
context["url_section"] = url_name_parts[0]
context["url_sub_section"] = url_name_parts[1]
context["bootstrap_version"] = int(url_name_parts[0][-1])
return context
def test_index(self):
for url, reverse_kwargs in [('admin:index', {}),
('admin:app_list', {
'app_label': 'tests'
})]:
response = self._get_and_assert_access(
url, 'has_all', OK, reverse_kwargs=reverse_kwargs)
self.assertContains(response, 'Blags')
self.assertContains(response, 'Entries')
if 'index' in url:
self.assertContains(response, 'Comments')
else:
self.assertNotContains(response, 'Comments')
response = self._get_and_assert_access(
url, 'has_aaa', OK, reverse_kwargs=reverse_kwargs)
self.assertContains(response, 'Blags')
self.assertNotContains(response, 'Entries')
self.assertNotContains(response, 'Comments')
if 'index' in url:
# B just sees an empty admin page, following the normal
# django behavior
response = self._get_and_assert_access(
url,
'has_b',
OK,
reverse_kwargs=reverse_kwargs,
message=url)
self.assertNotContains(response, 'Blags')
self.assertNotContains(response, 'Entries')
self.assertContains(response, 'Comments')
else:
# In django <1.7 >1.10 B gets a 404 for app_list.
# In django >=1.7 <=1.10 B get sa 403, like you'd expect.
django_version = StrictVersion(get_django_version())
if (django_version >= StrictVersion('1.7.0')
and django_version < StrictVersion('1.11.0')):
expected_status = DENIED
else:
expected_status = NOT_FOUND
response = self._get_and_assert_access(
url,
'has_b',
expected_status,
reverse_kwargs=reverse_kwargs,
message=url)
def info(request):
context = {
'django_info_version': django_info_version(),
'django_version': get_django_version(),
'database_engine': get_database_engine(),
'python_version': get_python_version(),
'platform': get_platform(),
# settings
'settings_debug_mode': get_debug_mode(),
'settings_template_debug_mode': get_template_debug_mode(),
'settings_installed_apps': get_installed_apps(),
'is_dev_server': is_dev_server(request),
'paths': get_path(request),
}
return render_to_response('django_info/info.html', context,
context_instance=RequestContext(request))
def build_suite(self, test_labels=None, *args, **kwargs):
django_version = get_django_version()
if hasattr(settings, 'TESTS_TYPES') and settings.TESTS_TYPES == 'ALL':
tests_type = 'Unit Tests + Selenium Tests'
elif hasattr(settings, 'TESTS_TYPES') and settings.TESTS_TYPES == 'SELENIUM':
tests_type = 'Selenium Tests Only'
self.tags = ['selenium']
else:
tests_type = 'Unit Tests Only'
self.exclude_tags.add('selenium')
print('###### Tests Infos #####################################')
print('### Test Runner : {}'.format(settings.TEST_RUNNER))
print('### Django Version : {}'.format(django_version))
print('### Tests type: {}'.format(tests_type))
if hasattr(settings, 'FUNCT_TESTS_CONFIG') and settings.FUNCT_TESTS_CONFIG:
print('### Virtual Dispaly: {}'.format(settings.FUNCT_TESTS_CONFIG.get('VIRTUAL_DISPLAY')))
print('########################################################')
print('')
return super(InstalledAppsTestRunner, self).build_suite(test_labels or settings.APPS_TO_TEST, *args, **kwargs)
def urls(cls, name_prefix=None):
"""
A convenience method for hooking up the URLs.
This automatically adds a list & a detail endpoint to your URLconf.
:param name_prefix: (Optional) A prefix for the URL's name (for
resolving). The default is ``None``, which will autocreate a prefix
based on the class name. Ex: ``BlogPostResource`` ->
``api_blogpost_list``
:type name_prefix: string
:returns: A ``patterns`` or a ``list`` object for ``include(...)``
"""
urls = [
url(r'^$', cls.as_list(), name=cls.build_url_name('list', name_prefix)),
url(r'^(?P<pk>\d+)/$', cls.as_detail(), name=cls.build_url_name('detail', name_prefix)),
]
if StrictVersion(get_django_version()) >= StrictVersion('1.7.0'):
return urls
return patterns('', urls[0], urls[1])
def test_index(self):
for url, reverse_kwargs in [
('admin:index', {}),
('admin:app_list', {'app_label': 'tests'})]:
response = self._get_and_assert_access(
url, 'has_all', OK, reverse_kwargs=reverse_kwargs)
self.assertContains(response, 'Blags')
self.assertContains(response, 'Entries')
if 'index' in url:
self.assertContains(response, 'Comments')
else:
self.assertNotContains(response, 'Comments')
response = self._get_and_assert_access(
url, 'has_aaa', OK, reverse_kwargs=reverse_kwargs)
self.assertContains(response, 'Blags')
self.assertNotContains(response, 'Entries')
self.assertNotContains(response, 'Comments')
if 'index' in url:
# B just sees an empty admin page, following the normal
# django behavior
response = self._get_and_assert_access(
url, 'has_b', OK, reverse_kwargs=reverse_kwargs,
message=url)
self.assertNotContains(response, 'Blags')
self.assertNotContains(response, 'Entries')
self.assertContains(response, 'Comments')
else:
# In django <1.7 B gets a 404 for app_list.
# In django >=1.7 B get sa 403, like you'd expect
if StrictVersion('1.7.0') <= StrictVersion(
get_django_version()):
expected_status = DENIED
else:
expected_status = NOT_FOUND
response = self._get_and_assert_access(
url, 'has_b', expected_status,
reverse_kwargs=reverse_kwargs,
message=url)
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.9/howto/static-files/
STATIC_URL = '/static/'
# support for django 1.9+
if StrictVersion(get_django_version()) < StrictVersion('1.9.0'):
TEMPLATE_DIRS = (
os.path.join(BASE_DIR, 'templates'),
)
else:
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [
os.path.join(BASE_DIR, 'templates'),
],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
import importlib
import json
from distutils.version import StrictVersion
from optparse import make_option
from django import get_version as get_django_version
from django.core.management.base import BaseCommand, CommandError
from graphene_django.settings import graphene_settings
LT_DJANGO_1_8 = StrictVersion(get_django_version()) < StrictVersion('1.8')
if LT_DJANGO_1_8:
class CommandArguments(BaseCommand):
option_list = BaseCommand.option_list + (
make_option(
'--schema',
type=str,
dest='schema',
default='',
help='Django app containing schema to dump, e.g. myproject.core.schema.schema',
),
make_option(
'--out',
type=str,
dest='out',
default='',
help='Output file (default: schema.json)'
),
make_option(
'--indent',
from __future__ import unicode_literals
import warnings
from django import get_version as get_django_version
__title__ = "dj-braintree"
__summary__ = "Django + Braintree Marketplace"
__uri__ = "https://github.com/mightbejosh/dj-braintree/"
__version__ = "0.1.0.dev"
__author__ = "Zach Layng"
__email__ = "*****@*****.**"
__license__ = "BSD"
__license__ = "License :: OSI Approved :: BSD License"
__copyright__ = "Copyright 2016 Zach Layng"
if get_django_version() <= '1.7.x':
msg = "dj-braintree deprecation notice: Django 1.7 and lower are not\n" \
"supported. Please upgrade to Django 1.8 or higher.\n"
warnings.warn(msg)
else:
# FIXME: Eventually we're enable this by default for
# versions that support it, but, right now, that's hard to
# do without breaking other things (#10509).
self.features.can_return_id_from_insert = True
return CursorWrapper(cursor)
def closeall(self):
for connection in connection_pools.values():
connection['pool'].closeall()
'''
Choose a version of the DatabaseWrapper class to use based on the Django
version. This is a bit hacky, what's a more elegant way?
'''
django_version = get_django_version()
if django_version.startswith('1.3'):
from django.db.backends.postgresql_psycopg2.base import CursorWrapper
class DatabaseWrapper(DatabaseWrapper13):
pass
elif django_version.startswith('1.4') or django_version.startswith('1.5'):
from django.conf import settings
from django.db.backends.postgresql_psycopg2.base import utc_tzinfo_factory, \
CursorWrapper
# The force_str call around the password seems to be the only change from
# 1.4 to 1.5, so we'll use the same DatabaseWrapper class and make
# force_str a no-op.
try:
from django.utils.encoding import force_str
raise ImproperlyConfigured(
"You cannot use autocommit=True with PostgreSQL prior to 8.2 at the moment."
)
else:
# FIXME: Eventually we're enable this by default for
# versions that support it, but, right now, that's hard to
# do without breaking other things (#10509).
self.features.can_return_id_from_insert = True
return CursorWrapper(cursor)
'''
Choose a version of the DatabaseWrapper class to use based on the Django
version. This is a bit hacky, what's a more elegant way?
'''
django_version = get_django_version()
if django_version.startswith('1.3'):
from django.db.backends.postgresql_psycopg2.base import CursorWrapper
class DatabaseWrapper(DatabaseWrapper13):
pass
elif django_version.startswith('1.4') or django_version.startswith('1.5'):
from django.conf import settings
from django.db.backends.postgresql_psycopg2.base import utc_tzinfo_factory, \
CursorWrapper
# The force_str call around the password seems to be the only change from
# 1.4 to 1.5, so we'll use the same DatabaseWrapper class and make
# force_str a no-op.
try:
from django.utils.encoding import force_str
from __future__ import unicode_literals
import warnings
from django import get_version as get_django_version
__title__ = "dj-stripe"
__summary__ = "Django + Stripe Made Easy"
__uri__ = "https://github.com/pydanny/dj-stripe/"
__version__ = "0.5.0"
__author__ = "Daniel Greenfeld"
__email__ = "*****@*****.**"
__license__ = "BSD"
__license__ = "License :: OSI Approved :: BSD License"
__copyright__ = "Copyright 2015 Daniel Greenfeld"
if get_django_version() <= '1.6.x':
msg = "dj-stripe deprecation notice: Django 1.6 and lower are deprecated\n" \
"and will be removed in dj-stripe 0.6.0.\n" \
"Reference: https://github.com/pydanny/dj-stripe/issues/173"
warnings.warn(msg)
def info(request):
from socket import gethostname
return render(request, 'info.html', {'hostname': gethostname(), 'version': get_version(), 'date': timezone.now(), 'django': get_django_version(), 'python': get_python_version()})
def current_django_version():
return get_django_version()
class PolymorphicQuerySet(QuerySet):
"""
QuerySet for PolymorphicModel
Contains the core functionality for PolymorphicModel
Usually not explicitly needed, except if a custom queryset class
is to be used.
"""
def __init__(self, *args, **kwargs):
super(PolymorphicQuerySet, self).__init__(*args, **kwargs)
self._iterable_class = PolymorphicModelIterable
self.polymorphic_disabled = False
# A parallel structure to django.db.models.query.Query.deferred_loading,
# which we maintain with the untranslated field names passed to
# .defer() and .only() in order to be able to retranslate them when
# retrieving the real instance (so that the deferred fields apply
# to that queryset as well).
self.polymorphic_deferred_loading = (set([]), True)
def _clone(self, *args, **kwargs):
# Django's _clone only copies its own variables, so we need to copy ours here
new = super(PolymorphicQuerySet, self)._clone(*args, **kwargs)
new.polymorphic_disabled = self.polymorphic_disabled
new.polymorphic_deferred_loading = (
copy.copy(self.polymorphic_deferred_loading[0]),
self.polymorphic_deferred_loading[1],
)
return new
def as_manager(cls):
from .managers import PolymorphicManager
manager = PolymorphicManager.from_queryset(cls)()
manager._built_with_as_manager = True
return manager
as_manager.queryset_only = True
as_manager = classmethod(as_manager)
def bulk_create(self, objs, batch_size=None):
objs = list(objs)
for obj in objs:
obj.pre_save_polymorphic()
return super(PolymorphicQuerySet, self).bulk_create(objs, batch_size)
def non_polymorphic(self):
"""switch off polymorphic behaviour for this query.
When the queryset is evaluated, only objects of the type of the
base class used for this query are returned."""
qs = self._clone()
qs.polymorphic_disabled = True
if issubclass(qs._iterable_class, PolymorphicModelIterable):
qs._iterable_class = ModelIterable
return qs
def instance_of(self, *args):
"""Filter the queryset to only include the classes in args (and their subclasses)."""
# Implementation in _translate_polymorphic_filter_defnition.
return self.filter(instance_of=args)
def not_instance_of(self, *args):
"""Filter the queryset to exclude the classes in args (and their subclasses)."""
# Implementation in _translate_polymorphic_filter_defnition."""
return self.filter(not_instance_of=args)
# Makes _filter_or_exclude compatible with the change in signature introduced in django at 9c9a3fe
if get_django_version() >= "3.2":
def _filter_or_exclude(self, negate, args, kwargs):
# We override this internal Django function as it is used for all filter member functions.
q_objects = translate_polymorphic_filter_definitions_in_args(
queryset_model=self.model, args=args, using=self.db)
# filter_field='data'
additional_args = translate_polymorphic_filter_definitions_in_kwargs(
queryset_model=self.model, kwargs=kwargs, using=self.db)
args = list(q_objects) + additional_args
return super(PolymorphicQuerySet,
self)._filter_or_exclude(negate=negate,
args=args,
kwargs=kwargs)
else:
def _filter_or_exclude(self, negate, *args, **kwargs):
# We override this internal Django function as it is used for all filter member functions.
q_objects = translate_polymorphic_filter_definitions_in_args(
self.model, args, using=self.db)
# filter_field='data'
additional_args = translate_polymorphic_filter_definitions_in_kwargs(
self.model, kwargs, using=self.db)
return super(PolymorphicQuerySet, self)._filter_or_exclude(
negate, *(list(q_objects) + additional_args), **kwargs)
def order_by(self, *field_names):
"""translate the field paths in the args, then call vanilla order_by."""
field_names = [
translate_polymorphic_field_path(self.model, a) if isinstance(
a, str) else a # allow expressions to pass unchanged
for a in field_names
]
return super(PolymorphicQuerySet, self).order_by(*field_names)
def defer(self, *fields):
"""
Translate the field paths in the args, then call vanilla defer.
Also retain a copy of the original fields passed, which we'll need
when we're retrieving the real instance (since we'll need to translate
them again, as the model will have changed).
"""
new_fields = [
translate_polymorphic_field_path(self.model, a) for a in fields
]
clone = super(PolymorphicQuerySet, self).defer(*new_fields)
clone._polymorphic_add_deferred_loading(fields)
return clone
def only(self, *fields):
"""
Translate the field paths in the args, then call vanilla only.
Also retain a copy of the original fields passed, which we'll need
when we're retrieving the real instance (since we'll need to translate
them again, as the model will have changed).
"""
new_fields = [
translate_polymorphic_field_path(self.model, a) for a in fields
]
clone = super(PolymorphicQuerySet, self).only(*new_fields)
clone._polymorphic_add_immediate_loading(fields)
return clone
def _polymorphic_add_deferred_loading(self, field_names):
"""
Follows the logic of django.db.models.query.Query.add_deferred_loading(),
but for the non-translated field names that were passed to self.defer().
"""
existing, defer = self.polymorphic_deferred_loading
if defer:
# Add to existing deferred names.
self.polymorphic_deferred_loading = existing.union(
field_names), True
else:
# Remove names from the set of any existing "immediate load" names.
self.polymorphic_deferred_loading = existing.difference(
field_names), False
def _polymorphic_add_immediate_loading(self, field_names):
"""
Follows the logic of django.db.models.query.Query.add_immediate_loading(),
but for the non-translated field names that were passed to self.only()
"""
existing, defer = self.polymorphic_deferred_loading
field_names = set(field_names)
if "pk" in field_names:
field_names.remove("pk")
field_names.add(self.model._meta.pk.name)
if defer:
# Remove any existing deferred names from the current set before
# setting the new names.
self.polymorphic_deferred_loading = field_names.difference(
existing), False
else:
# Replace any existing "immediate load" field names.
self.polymorphic_deferred_loading = field_names, False
def _process_aggregate_args(self, args, kwargs):
"""for aggregate and annotate kwargs: allow ModelX___field syntax for kwargs, forbid it for args.
Modifies kwargs if needed (these are Aggregate objects, we translate the lookup member variable)"""
___lookup_assert_msg = "PolymorphicModel: annotate()/aggregate(): ___ model lookup supported for keyword arguments only"
def patch_lookup(a):
# The field on which the aggregate operates is
# stored inside a complex query expression.
if isinstance(a, Q):
translate_polymorphic_Q_object(self.model, a)
elif hasattr(a, "get_source_expressions"):
for source_expression in a.get_source_expressions():
if source_expression is not None:
patch_lookup(source_expression)
else:
a.name = translate_polymorphic_field_path(self.model, a.name)
def test___lookup(a):
""" *args might be complex expressions too in django 1.8 so
the testing for a '___' is rather complex on this one """
if isinstance(a, Q):
def tree_node_test___lookup(my_model, node):
" process all children of this Q node "
for i in range(len(node.children)):
child = node.children[i]
if type(child) == tuple:
# this Q object child is a tuple => a kwarg like Q( instance_of=ModelB )
assert "___" not in child[0], ___lookup_assert_msg
else:
# this Q object child is another Q object, recursively process this as well
tree_node_test___lookup(my_model, child)
tree_node_test___lookup(self.model, a)
elif hasattr(a, "get_source_expressions"):
for source_expression in a.get_source_expressions():
test___lookup(source_expression)
else:
assert "___" not in a.name, ___lookup_assert_msg
for a in args:
test___lookup(a)
for a in kwargs.values():
patch_lookup(a)
def annotate(self, *args, **kwargs):
"""translate the polymorphic field paths in the kwargs, then call vanilla annotate.
_get_real_instances will do the rest of the job after executing the query."""
self._process_aggregate_args(args, kwargs)
return super(PolymorphicQuerySet, self).annotate(*args, **kwargs)
def aggregate(self, *args, **kwargs):
"""translate the polymorphic field paths in the kwargs, then call vanilla aggregate.
We need no polymorphic object retrieval for aggregate => switch it off."""
self._process_aggregate_args(args, kwargs)
qs = self.non_polymorphic()
return super(PolymorphicQuerySet, qs).aggregate(*args, **kwargs)
# Starting with Django 1.9, the copy returned by 'qs.values(...)' has the
# same class as 'qs', so our polymorphic modifications would apply.
# We want to leave values queries untouched, so we set 'polymorphic_disabled'.
def _values(self, *args, **kwargs):
clone = super(PolymorphicQuerySet, self)._values(*args, **kwargs)
clone.polymorphic_disabled = True
return clone
# Since django_polymorphic 'V1.0 beta2', extra() always returns polymorphic results.
# The resulting objects are required to have a unique primary key within the result set
# (otherwise an error is thrown).
# The "polymorphic" keyword argument is not supported anymore.
# def extra(self, *args, **kwargs):
def _get_real_instances(self, base_result_objects):
"""
Polymorphic object loader
Does the same as:
return [ o.get_real_instance() for o in base_result_objects ]
but more efficiently.
The list base_result_objects contains the objects from the executed
base class query. The class of all of them is self.model (our base model).
Some, many or all of these objects were not created and stored as
class self.model, but as a class derived from self.model. We want to re-fetch
these objects from the db as their original class so we can return them
just as they were created/saved.
We identify these objects by looking at o.polymorphic_ctype, which specifies
the real class of these objects (the class at the time they were saved).
First, we sort the result objects in base_result_objects for their
subclass (from o.polymorphic_ctype), and then we execute one db query per
subclass of objects. Here, we handle any annotations from annotate().
Finally we re-sort the resulting objects into the correct order and
return them as a list.
"""
resultlist = [] # polymorphic list of result-objects
# dict contains one entry per unique model type occurring in result,
# in the format idlist_per_model[modelclass]=[list-of-object-ids]
idlist_per_model = defaultdict(list)
indexlist_per_model = defaultdict(list)
# django's automatic ".pk" field does not always work correctly for
# custom fields in derived objects (unclear yet who to put the blame on).
# We get different type(o.pk) in this case.
# We work around this by using the real name of the field directly
# for accessing the primary key of the the derived objects.
# We might assume that self.model._meta.pk.name gives us the name of the primary key field,
# but it doesn't. Therefore we use polymorphic_primary_key_name, which we set up in base.py.
pk_name = self.model.polymorphic_primary_key_name
# - sort base_result_object ids into idlist_per_model lists, depending on their real class;
# - store objects that already have the correct class into "results"
content_type_manager = ContentType.objects.db_manager(self.db)
self_model_class_id = content_type_manager.get_for_model(
self.model, for_concrete_model=False).pk
self_concrete_model_class_id = content_type_manager.get_for_model(
self.model, for_concrete_model=True).pk
for i, base_object in enumerate(base_result_objects):
if base_object.polymorphic_ctype_id == self_model_class_id:
# Real class is exactly the same as base class, go straight to results
resultlist.append(base_object)
else:
real_concrete_class = base_object.get_real_instance_class()
real_concrete_class_id = (
base_object.get_real_concrete_instance_class_id())
if real_concrete_class_id is None:
# Dealing with a stale content type
continue
elif real_concrete_class_id == self_concrete_model_class_id:
# Real and base classes share the same concrete ancestor,
# upcast it and put it in the results
resultlist.append(
transmogrify(real_concrete_class, base_object))
else:
# This model has a concrete derived class, track it for bulk retrieval.
real_concrete_class = content_type_manager.get_for_id(
real_concrete_class_id).model_class()
idlist_per_model[real_concrete_class].append(
getattr(base_object, pk_name))
indexlist_per_model[real_concrete_class].append(
(i, len(resultlist)))
resultlist.append(None)
# For each model in "idlist_per_model" request its objects (the real model)
# from the db and store them in results[].
# Then we copy the annotate fields from the base objects to the real objects.
# Then we copy the extra() select fields from the base objects to the real objects.
# TODO: defer(), only(): support for these would be around here
for real_concrete_class, idlist in idlist_per_model.items():
indices = indexlist_per_model[real_concrete_class]
real_objects = real_concrete_class._base_objects.db_manager(
self.db).filter(**{("%s__in" % pk_name): idlist})
# copy select related configuration to new qs
real_objects.query.select_related = self.query.select_related
# Copy deferred fields configuration to the new queryset
deferred_loading_fields = []
existing_fields = self.polymorphic_deferred_loading[0]
for field in existing_fields:
try:
translated_field_name = translate_polymorphic_field_path(
real_concrete_class, field)
except AssertionError:
if "___" in field:
# The originally passed argument to .defer() or .only()
# was in the form Model2B___field2, where Model2B is
# now a superclass of real_concrete_class. Thus it's
# sufficient to just use the field name.
translated_field_name = field.rpartition("___")[-1]
# Check if the field does exist.
# Ignore deferred fields that don't exist in this subclass type.
try:
real_concrete_class._meta.get_field(
translated_field_name)
except FieldDoesNotExist:
continue
else:
raise
deferred_loading_fields.append(translated_field_name)
real_objects.query.deferred_loading = (
set(deferred_loading_fields),
self.query.deferred_loading[1],
)
real_objects_dict = {
getattr(real_object, pk_name): real_object
for real_object in real_objects
}
for i, j in indices:
base_object = base_result_objects[i]
o_pk = getattr(base_object, pk_name)
real_object = real_objects_dict.get(o_pk)
if real_object is None:
continue
# need shallow copy to avoid duplication in caches (see PR #353)
real_object = copy.copy(real_object)
real_class = real_object.get_real_instance_class()
# If the real class is a proxy, upcast it
if real_class != real_concrete_class:
real_object = transmogrify(real_class, real_object)
if self.query.annotations:
for anno_field_name in self.query.annotations.keys():
attr = getattr(base_object, anno_field_name)
setattr(real_object, anno_field_name, attr)
if self.query.extra_select:
for select_field_name in self.query.extra_select.keys():
attr = getattr(base_object, select_field_name)
setattr(real_object, select_field_name, attr)
resultlist[j] = real_object
resultlist = [i for i in resultlist if i]
# set polymorphic_annotate_names in all objects (currently just used for debugging/printing)
if self.query.annotations:
# get annotate field list
annotate_names = list(self.query.annotations.keys())
for real_object in resultlist:
real_object.polymorphic_annotate_names = annotate_names
# set polymorphic_extra_select_names in all objects (currently just used for debugging/printing)
if self.query.extra_select:
# get extra select field list
extra_select_names = list(self.query.extra_select.keys())
for real_object in resultlist:
real_object.polymorphic_extra_select_names = extra_select_names
return resultlist
def __repr__(self, *args, **kwargs):
if self.model.polymorphic_query_multiline_output:
result = [repr(o) for o in self.all()]
return "[ " + ",\n ".join(result) + " ]"
else:
return super(PolymorphicQuerySet, self).__repr__(*args, **kwargs)
class _p_list_class(list):
def __repr__(self, *args, **kwargs):
result = [repr(o) for o in self]
return "[ " + ",\n ".join(result) + " ]"
def get_real_instances(self, base_result_objects=None):
"""
Cast a list of objects to their actual classes.
This does roughly the same as::
return [ o.get_real_instance() for o in base_result_objects ]
but more efficiently.
:rtype: PolymorphicQuerySet
"""
"same as _get_real_instances, but make sure that __repr__ for ShowField... creates correct output"
if base_result_objects is None:
base_result_objects = self
olist = self._get_real_instances(base_result_objects)
if not self.model.polymorphic_query_multiline_output:
return olist
clist = PolymorphicQuerySet._p_list_class(olist)
return clist
def site_context(request):
context = {
'django_version': DJANGO_VERSION,
'django_version_string': get_django_version(),
}
return context
from distutils.version import StrictVersion
import six
from django import get_version as get_django_version
from django.conf import settings
if StrictVersion(get_django_version()) >= StrictVersion('1.7.0'):
from django.conf.urls import url
else:
from django.conf.urls import patterns, url
from django.core.exceptions import ObjectDoesNotExist
from django.http import HttpResponse, Http404
from django.views.decorators.csrf import csrf_exempt
from .exceptions import NotFound
from .resources import Resource
class DjangoResource(Resource):
"""
A Django-specific ``Resource`` subclass.
Doesn't require any special configuration, but helps when working in a
Django environment.
"""
# Because Django.
@classmethod
def as_list(cls, *args, **kwargs):
return csrf_exempt(super(DjangoResource, cls).as_list(*args, **kwargs))
@classmethod
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.9/howto/static-files/
STATIC_URL = '/static/'
# support for django 1.9+
if StrictVersion(get_django_version()) < StrictVersion('1.9.0'):
TEMPLATE_DIRS = (os.path.join(BASE_DIR, 'templates'), )
else:
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [
os.path.join(BASE_DIR, 'templates'),
],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
def process_response(self, request, response):
sc = response.status_code
if sc in [404]:
from django.conf import settings
from django.core.mail import mail_admins
if not settings.DEBUG:
subject = '%d error' % response.status_code
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
try:
session_repr = pprint.pformat(request.session._session)
except:
session_repr = "Session repr() unavailable"
from socket import gethostname
from yats import get_version, get_python_version
from django import get_version as get_django_version
yats_data = 'URL: %s\nRAW_POST: %s\nHOST_NAME: %s\nYATS_APP_VERSION: %s\nDJANGO_VERSION: %s\nPYTHON: %s' % (request.build_absolute_uri(), request.body, gethostname(), get_version(), get_django_version(), get_python_version())
if hasattr(request, 'user') and request.user.is_authenticated():
yats_data += '\nUSER: %s' % request.user.email
message = "%s\n\n%s" % (yats_data, '%s\n\n%s' % (session_repr, request_repr))
mail_admins(subject, message, fail_silently=True)
return response
import importlib
import json
from distutils.version import StrictVersion
from optparse import make_option
from django import get_version as get_django_version
from django.core.management.base import BaseCommand, CommandError
from graphene_django.settings import graphene_settings
LT_DJANGO_1_8 = StrictVersion(get_django_version()) < StrictVersion('1.8')
if LT_DJANGO_1_8:
class CommandArguments(BaseCommand):
option_list = BaseCommand.option_list + (
make_option(
'--schema',
type=str,
dest='schema',
default='',
help=
'Django app containing schema to dump, e.g. myproject.core.schema.schema',
),
make_option('--out',
type=str,
dest='out',
default='',
help='Output file (default: schema.json)'),
)
else:
def process_exception(self, request, exception):
# If this is a 404 ...
#if isinstance(exception, http.Http404):
# raise exception
from django.conf import settings
from django.core.mail import mail_admins
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
exc_info = sys.exc_info()
from socket import gethostname
from yats import get_version, get_python_version
from django import get_version as get_django_version
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
try:
session_repr = pprint.pformat(request.session._session)
except:
session_repr = "Session repr() unavailable"
if settings.DEBUG:
from django.views import debug
return debug.technical_500_response(request, *exc_info)
# send an error message to the admins, if something fails... => and not a bot
subject = 'BUGTRACK EXCEPTION: %s' % type(exception).__name__[:60]
try:
body = request.body
except:
body = 'not available'
yats_data = 'TS: %s\nURL: %s\nRAW_POST: %s\nHOST_NAME: %s\nYATS_APP_VERSION: %s\nDJANGO_VERSION: %s\nPYTHON: %s' % (datetime.datetime.now(), request.build_absolute_uri(), body, gethostname(), get_version(), get_django_version(), get_python_version())
if hasattr(request, 'organisation'):
yats_data += '\nORGA: %s' % request.organisation.name
else:
if hasattr(request, 'user') and request.user.is_authenticated():
yats_data += '\nUSER: %s' % request.user.email
message = "%s\n\n%s\n\n%s" % (self._get_traceback(exc_info), yats_data, '%s\n\n%s' % (session_repr, request_repr))
mail_admins(subject, message, fail_silently=False)
return http.HttpResponseServerError(loader.get_template('500.html').render(Context()))
def info(request):
from socket import gethostname
return render_to_response('info.html', {'hostname': gethostname(), 'version': get_version(), 'date': datetime.datetime.now(), 'django': get_django_version(), 'python': get_python_version()}, RequestContext(request))
