def content(self): context = self.context.copy() context.update({ 'settings': get_safe_settings(), }) return render_to_string('debug_toolbar/panels/settings_vars.html', context)
def selftest_index(request): if not request.user.is_superuser: raise Http404 emailform = EmailForm(request.POST or None) if request.method == 'POST': if emailform.is_valid(): subj = "Test email from FUN server %s %s" % (settings.SERVICE_VARIANT, settings.SITE_NAME) msg = emailform.cleaned_data['text'] to = emailform.cleaned_data['to'] send_mail(subj, msg, settings.SERVER_EMAIL, [to]) messages.add_message(request, messages.INFO, 'Mail sent to %s.' % to) return HttpResponseRedirect(reverse('self-test-index')) misc = {} misc['get_language'] = get_language() misc['platform_node'] = platform.node() revisions = {} for repo in repositories: os.chdir(settings.BASE_ROOT / repo) git.path = settings.BASE_ROOT / repo git.init_repo() revisions[repo] = mark_safe(git.repo.git('log -1 --format=<strong>%h</strong> %aD<br><strong>%s</strong> %ae')) return render(request, 'selftest/index.html', { 'emailform': emailform, 'misc': misc, 'settings': get_safe_settings(), 'environ': os.environ, 'revisions': revisions, })
def handle404(request): # This code is modified from views/debug.py in Django, as we want to display # a debug style view, just modified slightly. exc_info = sys.exc_info() exception = exc_info[1] try: tried = exception.args[0]['tried'] except (IndexError, TypeError, KeyError): tried = [] urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF) if isinstance(urlconf, types.ModuleType): urlconf = urlconf.__name__ c = Context({ 'urlconf': urlconf, 'root_urlconf': settings.ROOT_URLCONF, 'request_path': request.path_info[1:], # Trim leading slash 'urlpatterns': tried, 'reason': force_bytes(exception, errors='replace'), 'request': request, 'settings': get_safe_settings(), }) return HttpResponseNotFound( render_to_string('splunkdj:404.html', context_instance=c))
def settings_view(request, setting): if not getattr(settings, 'CLEANSED_SETTINGS_ACCESS', False): raise PermissionDenied return Response({ 'key': setting, 'value': debug.get_safe_settings()[setting] })
def handle404(request): # This code is modified from views/debug.py in Django, as we want to display # a debug style view, just modified slightly. exc_info = sys.exc_info() exception = exc_info[1] try: tried = exception.args[0]['tried'] except (IndexError, TypeError, KeyError): tried = [] urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF) if isinstance(urlconf, types.ModuleType): urlconf = urlconf.__name__ c = Context({ 'urlconf': urlconf, 'root_urlconf': settings.ROOT_URLCONF, 'request_path': request.path_info[1:], # Trim leading slash 'urlpatterns': tried, 'reason': force_bytes(exception, errors='replace'), 'request': request, 'settings': get_safe_settings(), }) return HttpResponseNotFound(render_to_string('splunkdj:404.html', context_instance=c))
def generate_stats(self, request, response): self.record_stats( { "settings": OrderedDict( sorted(get_safe_settings().items(), key=lambda s: s[0]) ) } )
def get_context(self): """ Override this to change context """ return { 'settings': get_safe_settings(), 'bundles': get_bundles(), }
def __getattr__(self, name): if self._settings is None: self._settings = get_safe_settings() name = name.upper() try: return self._settings[name] except KeyError: raise AttributeError
def _parse_environment(request): """Return an environment mapping for a notification from the given request.""" env = dict( (str(k), str(v)) for (k, v) in get_safe_settings().items() ) env.update( dict( (str(k), str(v)) for (k, v) in request.META.items() ) ) env['REQUEST_URI'] = request.build_absolute_uri() return env
def settings(request): """Admin view that displays the django settings.""" settings = debug.get_safe_settings() sorted_settings = [{'key': key, 'value': settings[key]} for key in sorted(settings.keys())] return render_to_response('kadmin/settings.html', {'settings': sorted_settings}, RequestContext(request, {}))
def process_response(self, request, response): if settings.DEBUG: # Request report. req_report = { 'path': request.path_info, 'get': [(k, request.GET.getlist(k)) for k in request.GET], 'post': [(k, request.POST.getlist(k)) for k in request.POST], 'cookies': [(k, request.COOKIES.get(k)) for k in request.COOKIES], 'view': { 'func': '<no view>', 'args': 'None', 'kwargs': 'None', 'url': 'None', }, 'headers': dict( [(k, request.META[k]) for k in self.HEADER_FILTER if k in request.META] ), 'settings': SortedDict(sorted(get_safe_settings().items(), key=lambda s: s[0])), } try: match = resolve(request.path) func, args, kwargs = match req_report['view']['func'] = self._get_name_from_obj(func) req_report['view']['args'] = args req_report['view']['kwargs'] = kwargs req_report['view']['url'] = getattr(match, 'url_name', '<unavailable>') except Http404: req_report['view']['func'] = request.path pass if hasattr(request, 'session'): req_report['session'] = [ (k, request.session.get(k)) for k in request.session.iterkeys() ] # MySQL report. mysql_report = { 'time': sum([float(q['time']) for q in connection.queries]), 'log': [{'time': q['time'], 'sql': q['sql']} for q in connection.queries], } # Log. context = Context({'req': req_report, 'mysql': mysql_report}) if settings.DEBUG: logging.\ getLogger('vbm').\ debug(loader.get_template('varnish-bans-manager/partials/_debug.txt').render(context)) report = loader.get_template('varnish-bans-manager/partials/_debug.html').render(context) if isinstance(response, HttpResponseAjax): response.add_command(commands.debug(report)) elif _can_append_script(response): script = '<script type="text/javascript">(function ($) { vbm.ready(function(context) { vbm.commands.debug(%s); });})(jQuery);</script>' % (json.dumps(report)) _append_script(response, script) return response
def show_internals(request): apps_info = [] for app in get_apps(): model_info = [] for model in get_models(app): model_info.append({ "name":model._meta.object_name, }) apps_info.append({ "app_name": app.__name__, "app_models": model_info, }) # from http://www.djangosnippets.org/snippets/1434/ # generate a list of (pattern-name, pattern) tuples resolver = urlresolvers.get_resolver(None) urlpatterns = sorted([ (key, value[0][0][0]) for key, value in resolver.reverse_dict.items() if isinstance(key, basestring) ]) context = { "title": "Show internals", "pid": os.getpid(), "cache_information": LocalSyncCache.get_cache_information(), "permissions": Permission.objects.all(), "urlpatterns": urlpatterns, "settings": hightlighter.make_html( pformat(get_safe_settings()), source_type="py", django_escape=True ), "db_backend_name": backend.Database.__name__, "db_backend_module": backend.Database.__file__, "db_backend_version": getattr(backend.Database, "version", "?"), "apps_info": apps_info, "db_table_names": sorted(connection.introspection.table_names()), "django_tables": sorted(connection.introspection.django_table_names()), "request_meta": hightlighter.make_html( pformat(request.META), source_type="py", django_escape=True ), "request_session": hightlighter.make_html( pformat(dict(request.session)), source_type="py", django_escape=True ), "sys_path": sys.path, "os_environ": os.environ, } return context
def settings(request): """Admin view that displays the django settings.""" settings = debug.get_safe_settings() sorted_settings = [{'key': key, 'value': settings[key]} for key in sorted(settings.keys())] return render('base/settings.html', {'settings': sorted_settings, 'title': 'Settings'}, RequestContext(request, {}))
def process_response(self, request, response): if getattr(settings, 'DEBUG_LOGGING_CONFIG', {}).get('ENABLED', False): # Logging is enabled, so log the settings safe_settings = get_safe_settings() log_settings = {} for k, v in safe_settings.items(): if self.logged_settings_re.search(k): log_settings[k] = v request.debug_logging_stats['settings'] = log_settings
def show_settings(request): settings_dict = debug.get_safe_settings() for i in ['GOOGLE_ANALYTICS_CREDENTIALS']: settings_dict[i] = debug.cleanse_setting(i, getattr(settings, i, {})) settings_dict['WEBAPPS_RECEIPT_KEY'] = '********************' return render(request, 'zadmin/settings.html', {'settings_dict': settings_dict})
def settings_view(request): """Admin view that displays the django settings.""" settings = debug.get_safe_settings() sorted_settings = [{'key': key, 'value': settings[key]} for key in sorted(settings.keys())] return render(request, 'admin/settings_view.html', { 'settings': sorted_settings, 'title': 'App Settings' })
def settings(request): """Admin view that displays the django settings.""" settings = debug.get_safe_settings() sorted_settings = [{"key": key, "value": settings[key]} for key in sorted(settings.keys())] return render_to_response( "kadmin/settings.html", {"pythonpath": sys.path, "settings": sorted_settings, "title": "Settings"}, RequestContext(request, {}), )
def settings(request): settings_dict = debug.get_safe_settings() # sigh settings_dict['HERA'] = [] for i in site_settings.HERA: settings_dict['HERA'].append(debug.cleanse_setting('HERA', i)) return jingo.render(request, 'zadmin/settings.html', {'settings_dict': settings_dict})
def process_response(self, request, response): if getattr(request, 'debug_logging', {}).get('ENABLED', False): # Logging is enabled, so log the settings safe_settings = get_safe_settings() log_settings = {} for k, v in safe_settings.items(): if request.debug_logging['LOGGED_SETTINGS_RE'].search(k): log_settings[k] = v request.debug_logging_stats['settings'] = log_settings
def show_settings(request): settings_dict = debug.get_safe_settings() # Retain this so that GOOGLE_ANALYTICS_CREDENTIALS variables in local # settings are not exposed. google_cred = 'GOOGLE_ANALYTICS_CREDENTIALS' settings_dict[google_cred] = debug.cleanse_setting( google_cred, getattr(settings, google_cred, {})) return render(request, 'zadmin/settings.html', {'settings_dict': settings_dict, 'title': 'Settings!'})
def settings(request): """Admin view that displays the django settings.""" settings = debug.get_safe_settings() sorted_settings = [ {"key": key, "value": settings[key]} for key in sorted(settings.keys()) ] return render_to_response( "kadmin/settings.html", {"pythonpath": sys.path, "settings": sorted_settings, "title": "Settings"}, RequestContext(request, {}), )
def _parse_environment(request): """Return an environment mapping for a notification from the given request. """ env = dict((str(k), str(v)) for (k, v) in get_safe_settings().items()) env.update(dict((str(k), str(v)) for (k, v) in request.META.items())) env['REQUEST_URI'] = request.build_absolute_uri() return env
def settings(request): settings_dict = debug.get_safe_settings() # sigh settings_dict["HERA"] = [] for i in site_settings.HERA: settings_dict["HERA"].append(debug.cleanse_setting("HERA", i)) for i in ["PAYPAL_EMBEDDED_AUTH", "PAYPAL_CGI_AUTH"]: settings_dict[i] = debug.cleanse_setting(i, getattr(site_settings, i)) return jingo.render(request, "zadmin/settings.html", {"settings_dict": settings_dict})
def show_settings(request): settings_dict = debug.get_safe_settings() # Retain this so that legacy PAYPAL_CGI_AUTH variables in local settings # are not exposed. for i in ['PAYPAL_EMBEDDED_AUTH', 'PAYPAL_CGI_AUTH', 'GOOGLE_ANALYTICS_CREDENTIALS']: settings_dict[i] = debug.cleanse_setting(i, getattr(settings, i, {})) return render(request, 'zadmin/settings.html', {'settings_dict': settings_dict})
def debug_payload(request, response, view_data): current_session = {} if 'django.contrib.sessions' in settings.INSTALLED_APPS: if request.session.items(): for k,v in request.session.items(): current_session[k] = v if request.user.is_anonymous: user_data = "[\"Anonymous User\"]" else: user_data = serializers.serialize("json", [request.user]) resolved_url = resolve(request.path) view = { 'view_name': resolved_url._func_path, 'view_args': resolved_url.args, 'view_kwargs': resolved_url.kwargs, 'view_methods': VIEW_METHOD_DATA, 'cbv': view_data.get('cbv', False), 'bases': view_data.get('bases', []), } checks = {} raw_checks = run_checks(include_deployment_checks=True) for check in raw_checks: checks[check.id] = check.msg json_friendly_settings = OrderedDict() s = get_safe_settings() for key in sorted(s.keys()): json_friendly_settings[key] = str(s[key]) payload = { 'version': django.VERSION, 'current_user': json.loads(user_data)[0], 'db_queries': connection.queries, 'session': current_session, 'view_data': view, 'url_name': resolved_url.url_name, 'url_namespaces': resolved_url.namespaces, 'checks': checks, 'settings': json_friendly_settings } payload_script = "<script>var dj_chrome = {};</script>".format(json.dumps(payload, cls=LazyEncoder)) return payload_script
def task_failure_callback( sender, task_id=None, exception=None, args=None, kwargs=None, traceback=None, einfo=None, **remaining ): tracked_request = TrackedRequest.instance() tracked_request.tag("error", "true") custom_controller = sender.name custom_params = { "celery": { "task_id": task_id, "args": args, "kwargs": kwargs, } } # Look up the django settings if populated. environment = None if get_safe_settings: try: environment = get_safe_settings() except django.core.exceptions.ImproperlyConfigured as exc: # Django not setup correctly logger.debug( "Celery integration does not have django configured properly: %r", exc ) pass except Exception as exc: logger.debug( "Celery task_failure callback exception: %r", exc, exc_info=exc ) pass # Celery occassionally will send the traceback as a string rather # than a Stack trace object as the docs indicate. In that case, # fall back to the billiard ExceptionInfo instance traceback = ( traceback if traceback and not isinstance(traceback, string_type) else einfo.tb ) exc_info = (exception.__class__, exception, traceback) ErrorMonitor.send( exc_info, environment=environment, custom_params=custom_params, custom_controller=custom_controller, )
def __getattr__(self, name): # Lazy load of settings. if self._settings is None: self._settings = get_safe_settings() # get_safe_settings only returns upper case settings, so let's not worry # about case sensitivity. name = name.upper() try: return self._settings[name] except KeyError: # This method should return the (computed) attribute value or raise # an AttributeError exception. raise AttributeError
def show_settings(request): settings_dict = debug.get_safe_settings() # Retain this so that GOOGLE_ANALYTICS_CREDENTIALS variables in local # settings are not exposed. google_cred = 'GOOGLE_ANALYTICS_CREDENTIALS' settings_dict[google_cred] = debug.cleanse_setting( google_cred, getattr(settings, google_cred, {})) return render(request, 'zadmin/settings.html', { 'settings_dict': settings_dict, 'title': 'Settings!' })
def settings(request): settings_dict = debug.get_safe_settings() # sigh settings_dict['HERA'] = [] for i in site_settings.HERA: settings_dict['HERA'].append(debug.cleanse_setting('HERA', i)) for i in ['PAYPAL_EMBEDDED_AUTH', 'PAYPAL_CGI_AUTH']: settings_dict[i] = debug.cleanse_setting(i, getattr(site_settings, i)) return jingo.render(request, 'zadmin/settings.html', {'settings_dict': settings_dict})
def on_got_request_exception(self, request, **kwargs): """ Process this exception with the error monitoring solution. """ ErrorMonitor.send( sys.exc_info(), request_components=get_request_components(request), request_path=request.path, request_params=dict(request.GET.lists()), session=dict(request.session.items()) if hasattr( request, "session") else None, environment=get_safe_settings(), )
def show_internals(request): apps_info = [] for app in get_apps(): model_info = [] for model in get_models(app): model_info.append({ "name":model._meta.object_name, }) apps_info.append({ "app_name": app.__name__, "app_models": model_info, }) # Information about the current used url patterns urlpatterns = UrlPatternInfo().get_url_info() context = { "title": "Show internals", "pid": os.getpid(), "cache_information": LocalSyncCache.get_cache_information(), "permissions": Permission.objects.all(), "urlpatterns": urlpatterns, "settings": hightlighter.make_html( pformat(get_safe_settings()), source_type="py", django_escape=True ), "db_backend_name": backend.Database.__name__, "db_backend_module": backend.Database.__file__, "db_backend_version": getattr(backend.Database, "version", "?"), "apps_info": apps_info, "db_table_names": sorted(connection.introspection.table_names()), "django_tables": sorted(connection.introspection.django_table_names()), "request_meta": hightlighter.make_html( pformat(request.META), source_type="py", django_escape=True ), "request_session": hightlighter.make_html( pformat(dict(request.session)), source_type="py", django_escape=True ), "sys_path": sys.path, "os_environ": os.environ, } return context
def settings_info(self): """ display current used 'settings.py' """ context = [] safe_settings = get_safe_settings() for key, value in safe_settings.iteritems(): value = pprint.pformat(value) value = escape(value) context.append({"attrname": key, "value": value}) context.sort() return context
def status(request): def anyfn(fn, iterable): for e in iterable: if fn(e): return True return False render_data = { 'request': request, 'title': 'Admin Status', 'user': request.user, 'root_path': webhelpers.url("/"), 'settings': get_safe_settings(), } return render(request, 'yabi/admin_status.html', render_data)
def settings(request): settings_dict = debug.get_safe_settings() # sigh settings_dict["HERA"] = [] for i in site_settings.HERA: settings_dict["HERA"].append(debug.cleanse_setting("HERA", i)) # Retain this so that legacy PAYPAL_CGI_AUTH variables in settings_local # are not exposed. for i in ["PAYPAL_EMBEDDED_AUTH", "PAYPAL_CGI_AUTH"]: settings_dict[i] = debug.cleanse_setting(i, getattr(site_settings, i)) settings_dict["WEBAPPS_RECEIPT_KEY"] = "********************" return jingo.render(request, "zadmin/settings.html", {"settings_dict": settings_dict})
def scripts(request): """ Scripts communs: """ context = {} for key, value in get_safe_settings().items(): try: json_encode(value) except TypeError: continue context[key] = value return { 'urls': json_encode(get_urls(request).data), 'user': json_encode(user_infos(request).data), 'context': json_encode(context), }
def admin_site_version(request): if request.user.is_superuser: from zorna import get_version import django import sys from django.views import debug extra_context = {} extra_context['zorna_version'] = get_version() extra_context['django_version'] = django.get_version() extra_context['python_version'] = sys.version extra_context['settings'] = debug.get_safe_settings() context = RequestContext(request) return render_to_response('site/version.html', extra_context, context_instance=context) else: return HttpResponseForbidden()
def settings(request): settings_dict = debug.get_safe_settings() # sigh settings_dict['HERA'] = [] for i in site_settings.HERA: settings_dict['HERA'].append(debug.cleanse_setting('HERA', i)) # Retain this so that legacy PAYPAL_CGI_AUTH variables in settings_local # are not exposed. for i in ['PAYPAL_EMBEDDED_AUTH', 'PAYPAL_CGI_AUTH']: settings_dict[i] = debug.cleanse_setting(i, getattr(site_settings, i)) settings_dict['WEBAPPS_RECEIPT_KEY'] = '********************' return jingo.render(request, 'zadmin/settings.html', {'settings_dict': settings_dict})
def technical_404_response(request, exception): """Create a technical 404 error response. The exception should be the Http404. Based on Django. """ fake_url_pattern = FakeUrlPattern(utils.get_path_to_serve(request)) t = Template(debug.TECHNICAL_404_TEMPLATE, name='Technical 404 template') c = Context({ 'urlconf': 'DHP', 'root_urlconf': 'N/A', 'request_path': request.path_info[1:], # Trim leading slash 'urlpatterns': fake_url_pattern, 'reason': smart_str(exception, errors='replace'), 'request': request, 'settings': debug.get_safe_settings(), }) return HttpResponseNotFound(t.render(c), mimetype='text/html')
def environment_settings_view(request, template_name='environment-report.html'): """ Generate a report of the django environment. Only Superusers have access to it. """ context = { 'settings': get_safe_settings(), 'installed_packages': get_installed_packages(), 'versions': get_versions(), 'python_paths': get_python_paths(), 'db': get_db_info(), 'migrations': get_migrations(), 'locales': get_system_locales(), 'locale_info': get_locale_info(), } return render(request, template_name, context)
def selftest_index(request): if not request.user.is_superuser: raise Http404 emailform = EmailForm(request.POST or None) if request.method == 'POST': if emailform.is_valid(): subj = "Test email from FUN server %s %s" % ( settings.SERVICE_VARIANT, settings.SITE_NAME) msg = emailform.cleaned_data['text'] to = emailform.cleaned_data['to'] send_mail(subj, msg, settings.SERVER_EMAIL, [to]) messages.add_message(request, messages.INFO, 'Mail sent to %s.' % to) return HttpResponseRedirect(reverse('self-test-index')) misc = {} misc['get_language'] = get_language() misc['platform_node'] = platform.node() revisions = {} for repo in repositories: try: os.chdir(settings.BASE_ROOT / repo) git.path = settings.BASE_ROOT / repo git.init_repo() revisions[repo] = mark_safe( git.repo.git( 'log -1 --decorate --format=<strong>%h</strong> %aD %d<br><strong>%s</strong> %ae' )) except Exception as e: revisions[repo] = mark_safe("<strong>Unknown</strong> %r" % e) return render( request, 'selftest/index.html', { 'emailform': emailform, 'misc': misc, 'settings': get_safe_settings(), 'environ': os.environ, 'revisions': revisions, })
def settings_list(request): """ Custom admin view that displays the settings for this Django project. """ if not request.user.is_superuser: return HttpResponseRedirect(reverse('admin:index')) settings = get_safe_settings() for setting in PRIVATE_SETTINGS: if setting in settings: settings[setting] = '********************' sorted_settings = sorted(settings.items()) return render_to_response('admin/settings_list.html', RequestContext(request, { 'title': 'Django Settings', 'sorted_settings': sorted_settings, }))
def __init__(self, *args, **kwargs): request = kwargs.pop('request', None) super(InfoForm, self).__init__(*args, **kwargs) _settings = [{'key': k, 'value': v} for k, v in six.iteritems(get_safe_settings())] table = SettingsTable(request, data=_settings) leonardo_table = LeonardoTable(request, data=leonardo.get_modules_as_list()) self.helper.layout = forms.Layout( forms.TabHolder( forms.Tab('Leonardo modules', forms.HTML(leonardo_table.render()) ), forms.Tab('Settings', forms.HTML(table.render()) ), ) )
def technical_404_response(request, exception): "Create a technical 404 error response. The exception should be the Http404." try: tried = exception.args[0]['tried'] except (IndexError, TypeError): tried = [] else: if not tried: # tried exists but is an empty list. The URLconf must've been empty. return empty_urlconf(request) t = Template(TECHNICAL_404_TEMPLATE, name='Technical 404 template') c = Context({ 'root_urlconf': settings.ROOT_URLCONF, 'request_path': request.path_info[1:], # Trim leading slash 'urlpatterns': tried, 'reason': smart_str(exception, errors='replace'), 'request': request, 'request_protocol': request.is_secure() and "https" or "http", 'settings': get_safe_settings(), }) return HttpResponseNotFound(t.render(c), mimetype='text/html')
def __init__(self): self._settings = get_safe_settings()
def technical_404_response(request, exception): "Create a technical 404 error response. The exception should be the Http404." try: error_url = exception.args[0]['path'] except (IndexError, TypeError, KeyError): error_url = request.path_info[1:] # Trim leading slash try: tried = exception.args[0]['tried'] except (IndexError, TypeError, KeyError): tried = [] else: if (not tried # empty URLconf or (request.path == '/' and len(tried) == 1 # default URLconf and len(tried[0]) == 1 and getattr(tried[0][0], 'app_name', '') == getattr(tried[0][0], 'namespace', '') == 'admin')): return default_urlconf(request) urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF) if isinstance(urlconf, types.ModuleType): urlconf = urlconf.__name__ caller = '' try: resolver_match = resolve(request.path) except Resolver404: pass else: obj = resolver_match.func if hasattr(obj, '__name__'): caller = obj.__name__ elif hasattr(obj, '__class__') and hasattr(obj.__class__, '__name__'): caller = obj.__class__.__name__ if hasattr(obj, '__module__'): module = obj.__module__ caller = '%s.%s' % (module, caller) try: from leonardo.module.web.models import Page feincms_page = Page.objects.for_request(request, best_match=True) template = feincms_page.theme.template except: feincms_page = Page.objects.filter(parent=None).first() template = feincms_page.theme.template else: # nested path is not allowed for this time try: slug = request.path_info.split("/")[-2:-1][0] except KeyError: raise Exception("Nested path is not allowed !") c = RequestContext( request, { 'urlconf': urlconf, 'root_urlconf': settings.ROOT_URLCONF, 'request_path': error_url, 'urlpatterns': tried, 'reason': force_bytes(exception, errors='replace'), 'request': request, 'settings': get_safe_settings(), 'raising_view_name': caller, 'feincms_page': feincms_page, 'template': template or 'base.html', 'standalone': True, 'slug': slug, }) try: t = render_to_string('404_technical.html', c) except: from django.views.debug import TECHNICAL_404_TEMPLATE t = Template(TECHNICAL_404_TEMPLATE).render(c) return HttpResponseNotFound(t, content_type='text/html')
def settings_list(request): if not getattr(settings, 'CLEANSED_SETTINGS_ACCESS', False): raise PermissionDenied return Response(sorted(debug.get_safe_settings().keys()))
def process_response(self, request, response): self.record_stats({ 'settings': SortedDict(sorted(get_safe_settings().items(), key=lambda s: s[0])), })
def get_original_settings_without_onthefly(self): all_settings = get_safe_settings().keys() original_settings_without_onthefly = set(all_settings).difference( self.backend.get_fields()) return list(original_settings_without_onthefly)