database disk image is malformed
Request Method: | GET |
---|---|
Request URL: | https://sglab.kaist.ac.kr/projects/OpenCCL/community/ |
Django Version: | 1.9.7 |
Exception Type: | DatabaseError |
Exception Value: | database disk image is malformed |
Exception Location: | c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\backends\sqlite3\base.py in execute, line 323 |
Python Executable: | D:\ServerApps\Bitnami\wampstack-7.2.10-2\apache2\bin\httpd.exe |
Python Version: | 3.5.2 |
Python Path: | ['D:\\Web_OpenSourceProjects', 'C:\\Users\\sglab\\AppData\\Local\\Programs\\Python\\Python35\\python35.zip', 'c:\\users\\sglab\\appdata\\local\\programs\\python\\python35\\DLLs', 'c:\\users\\sglab\\appdata\\local\\programs\\python\\python35\\lib', 'D:\\ServerApps\\Bitnami\\wampstack-7.2.10-2\\apache2\\bin', 'c:\\users\\sglab\\appdata\\local\\programs\\python\\python35', 'c:\\users\\sglab\\appdata\\local\\programs\\python\\python35\\lib\\site-packages'] |
Server time: | Fri, 29 Mar 2024 19:51:15 +0900 |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\backends\utils.py
in execute
def execute(self, sql, params=None):
self.db.validate_no_broken_transaction()
with self.db.wrap_database_errors:
if params is None:
return self.cursor.execute(sql)
else:
return self.cursor.execute(sql, params)...
def executemany(self, sql, param_list):
self.db.validate_no_broken_transaction()
with self.db.wrap_database_errors:
return self.cursor.executemany(sql, param_list)
Variable | Value |
---|---|
self | <django.db.backends.utils.CursorDebugWrapper object at 0x000001FD207DBE80> |
sql | ('SELECT "django_site"."id", "django_site"."domain", "django_site"."name" FROM ' '"django_site" WHERE "django_site"."domain" LIKE %s ESCAPE \'\\\'') |
params | ('sglab.kaist.ac.kr',) |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\backends\sqlite3\base.py
in execute
This fixes it -- but note that if you want to use a literal "%s" in a query,
you'll need to use "%%s".
"""
def execute(self, query, params=None):
if params is None:
return Database.Cursor.execute(self, query)
query = self.convert_query(query)
return Database.Cursor.execute(self, query, params)...
def executemany(self, query, param_list):
query = self.convert_query(query)
return Database.Cursor.executemany(self, query, param_list)
def convert_query(self, query):
Variable | Value |
---|---|
self | <django.db.backends.sqlite3.base.SQLiteCursorWrapper object at 0x000001FD0C7C7678> |
params | ('sglab.kaist.ac.kr',) |
query | ('SELECT "django_site"."id", "django_site"."domain", "django_site"."name" FROM ' '"django_site" WHERE "django_site"."domain" LIKE ? ESCAPE \'\\\'') |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\core\handlers\base.py
in get_response
resolver_match = resolver.resolve(request.path_info)
callback, callback_args, callback_kwargs = resolver_match
request.resolver_match = resolver_match
# Apply view middleware
for middleware_method in self._view_middleware:
response = middleware_method(request, callback, callback_args, callback_kwargs)...
if response:
break
if response is None:
wrapped_callback = self.make_view_atomic(callback)
try:
Variable | Value |
---|---|
request | <WSGIRequest: GET '/projects/OpenCCL/community/'> |
response | None |
urlconf | 'OpenCCL.urls' |
callback_args | () |
resolver_match | ResolverMatch(func=mezzanine.pages.views.page, args=(), kwargs={'slug': 'community'}, url_name=page, app_names=[], namespaces=[]) |
response_is_rendered | False |
callback_kwargs | {'slug': 'community'} |
self | <django.core.handlers.wsgi.WSGIHandler object at 0x000001FD03305128> |
callback | <function page at 0x000001FD03DAAF28> |
resolver | <RegexURLResolver 'OpenCCL.urls' (None:None) ^/> |
middleware_method | <bound method PageMiddleware.process_view of <mezzanine.pages.middleware.PageMiddleware object at 0x000001FD03C2EA58>> |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\mezzanine\pages\middleware.py
in process_view
Per-request mechanics for the current page object.
"""
# Load the closest matching page by slug, and assign it to the
# request object. If none found, skip all further processing.
slug = path_to_slug(request.path_info)
pages = Page.objects.with_ascendants_for_slug(slug,
for_user=request.user, include_login_required=True)...
if pages:
page = pages[0]
setattr(request, "page", page)
context_processors.page(request)
else:
return
Variable | Value |
---|---|
request | <WSGIRequest: GET '/projects/OpenCCL/community/'> |
view_kwargs | {'slug': 'community'} |
view_func | <function page at 0x000001FD03DAAF28> |
self | <mezzanine.pages.middleware.PageMiddleware object at 0x000001FD03C2EA58> |
view_args | () |
slug | 'community' |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\mezzanine\pages\managers.py
in with_ascendants_for_slug
# eg: ['about', 'about/team', 'about/team/mike']
parts = slug.split("/")
slugs = ["/".join(parts[:i]) for i in range(1, len(parts) + 1)]
# Find the deepest page that matches one of our slugs.
# Sorting by "-slug" should ensure that the pages are in
# descendant -> ascendant order.
pages_for_user = self.published(**kwargs)...
pages = list(pages_for_user.filter(slug__in=slugs).order_by("-slug"))
if not pages:
return []
# Check to see if the other pages retrieved form a valid path
# in the page tree, i.e. pages[0].parent == pages[1],
Variable | Value |
---|---|
self | <mezzanine.pages.managers.PageManager object at 0x000001FD039274A8> |
parts | ['community'] |
kwargs | {'for_user': <SimpleLazyObject: <django.contrib.auth.models.AnonymousUser object at 0x000001FD207DB470>>, 'include_login_required': True} |
slug | 'community' |
slugs | ['community'] |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\mezzanine\pages\managers.py
in published
The extra ``include_login_required`` arg allows callers to
override the ``PAGES_PUBLISHED_INCLUDE_LOGIN_REQUIRED``
behaviour in special cases where they want to deal with the
``login_required`` field manually, such as the case in
``PageMiddleware``.
"""
published = super(PageManager, self).published(for_user=for_user)...
unauthenticated = for_user and not for_user.is_authenticated()
if (unauthenticated and not include_login_required and
not settings.PAGES_PUBLISHED_INCLUDE_LOGIN_REQUIRED):
published = published.exclude(login_required=True)
return published
Variable | Value |
---|---|
include_login_required | True |
self | <mezzanine.pages.managers.PageManager object at 0x000001FD039274A8> |
for_user | <SimpleLazyObject: <django.contrib.auth.models.AnonymousUser object at 0x000001FD207DB470>> |
__class__ | <class 'mezzanine.pages.managers.PageManager'> |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\mezzanine\core\managers.py
in published
"""
from mezzanine.core.models import CONTENT_STATUS_PUBLISHED
if for_user is not None and for_user.is_staff:
return self.all()
return self.filter(
Q(publish_date__lte=now()) | Q(publish_date__isnull=True),
Q(expiry_date__gte=now()) | Q(expiry_date__isnull=True),
Q(status=CONTENT_STATUS_PUBLISHED))...
def get_by_natural_key(self, slug):
return self.get(slug=slug)
def search_fields_to_dict(fields):
Variable | Value |
---|---|
CONTENT_STATUS_PUBLISHED | 2 |
self | <mezzanine.pages.managers.PageManager object at 0x000001FD039274A8> |
for_user | <SimpleLazyObject: <django.contrib.auth.models.AnonymousUser object at 0x000001FD207DB470>> |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\models\manager.py
in manager_method
def check(self, **kwargs):
return []
@classmethod
def _get_queryset_methods(cls, queryset_class):
def create_method(name, method):
def manager_method(self, *args, **kwargs):
return getattr(self.get_queryset(), name)(*args, **kwargs)...
manager_method.__name__ = method.__name__
manager_method.__doc__ = method.__doc__
return manager_method
new_methods = {}
# Refs http://bugs.python.org/issue1785.
Variable | Value |
---|---|
self | <mezzanine.pages.managers.PageManager object at 0x000001FD039274A8> |
kwargs | {} |
args | (<Q: (OR: ('publish_date__lte', datetime.datetime(2024, 3, 29, 10, 51, 15, 103635, tzinfo=<UTC>)), ('publish_date__isnull', True))>, <Q: (OR: ('expiry_date__gte', datetime.datetime(2024, 3, 29, 10, 51, 15, 103635, tzinfo=<UTC>)), ('expiry_date__isnull', True))>, <Q: (AND: ('status', 2))>) |
name | 'filter' |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\mezzanine\core\managers.py
in get_queryset
super(DjangoCSM, self).__init__(*args, **kwargs)
self.__field_name = field_name
self.__is_validated = False
def get_queryset(self):
if not self.__is_validated:
self._get_field_name()
lookup = {self.__field_name + "__id__exact": current_site_id()}...
return super(DjangoCSM, self).get_queryset().filter(**lookup)
class DisplayableManager(CurrentSiteManager, PublishedManager,
SearchableManager):
"""
Variable | Value |
---|---|
self | <mezzanine.pages.managers.PageManager object at 0x000001FD039274A8> |
__class__ | <class 'mezzanine.core.managers.CurrentSiteManager'> |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\mezzanine\utils\sites.py
in current_site_id
# uses this very function we're in right now to create a
# per-site cache key.
bits = (settings.CACHE_MIDDLEWARE_KEY_PREFIX, domain)
cache_key = "%s.site_id.%s" % bits
site_id = cache_get(cache_key)
if not site_id:
try:
site = Site.objects.get(domain__iexact=domain)...
except Site.DoesNotExist:
pass
else:
site_id = site.id
if cache_installed():
cache_set(cache_key, site_id)
Variable | Value |
---|---|
cache_get | <function cache_get at 0x000001FD03DE9048> |
request | <WSGIRequest: GET '/projects/OpenCCL/community/'> |
cache_set | <function cache_set at 0x000001FD03DECF28> |
site_id | None |
domain | 'sglab.kaist.ac.kr' |
cache_installed | <functools._lru_cache_wrapper object at 0x000001FD03DBD630> |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\models\manager.py
in manager_method
def check(self, **kwargs):
return []
@classmethod
def _get_queryset_methods(cls, queryset_class):
def create_method(name, method):
def manager_method(self, *args, **kwargs):
return getattr(self.get_queryset(), name)(*args, **kwargs)...
manager_method.__name__ = method.__name__
manager_method.__doc__ = method.__doc__
return manager_method
new_methods = {}
# Refs http://bugs.python.org/issue1785.
Variable | Value |
---|---|
self | <django.contrib.sites.models.SiteManager object at 0x000001FD033EA3C8> |
kwargs | {'domain__iexact': 'sglab.kaist.ac.kr'} |
args | () |
name | 'get' |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\models\query.py
in get
"""
Performs the query and returns a single object matching the given
keyword arguments.
"""
clone = self.filter(*args, **kwargs)
if self.query.can_filter() and not self.query.distinct_fields:
clone = clone.order_by()
num = len(clone)...
if num == 1:
return clone._result_cache[0]
if not num:
raise self.model.DoesNotExist(
"%s matching query does not exist." %
self.model._meta.object_name
Variable | Value |
---|---|
self | Error in formatting: DatabaseError: database disk image is malformed |
clone | Error in formatting: DatabaseError: database disk image is malformed |
kwargs | {'domain__iexact': 'sglab.kaist.ac.kr'} |
args | () |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\models\query.py
in __len__
def __repr__(self):
data = list(self[:REPR_OUTPUT_SIZE + 1])
if len(data) > REPR_OUTPUT_SIZE:
data[-1] = "...(remaining elements truncated)..."
return repr(data)
def __len__(self):
self._fetch_all()...
return len(self._result_cache)
def __iter__(self):
"""
The queryset iterator protocol uses three nested iterators in the
default case:
Variable | Value |
---|---|
self | Error in formatting: DatabaseError: database disk image is malformed |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\models\query.py
in _fetch_all
clone._fields = self._fields
clone.__dict__.update(kwargs)
return clone
def _fetch_all(self):
if self._result_cache is None:
self._result_cache = list(self.iterator())...
if self._prefetch_related_lookups and not self._prefetch_done:
self._prefetch_related_objects()
def _next_is_sticky(self):
"""
Indicates that the next filter call and the one following that should
Variable | Value |
---|---|
self | Error in formatting: DatabaseError: database disk image is malformed |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\models\query.py
in __iter__
def __iter__(self):
queryset = self.queryset
db = queryset.db
compiler = queryset.query.get_compiler(using=db)
# Execute the query. This will also fill compiler.select, klass_info,
# and annotations.
results = compiler.execute_sql()...
select, klass_info, annotation_col_map = (compiler.select, compiler.klass_info,
compiler.annotation_col_map)
if klass_info is None:
return
model_cls = klass_info['model']
select_fields = klass_info['select_fields']
Variable | Value |
---|---|
self | <django.db.models.query.ModelIterable object at 0x000001FD207DB588> |
compiler | <django.db.models.sql.compiler.SQLCompiler object at 0x000001FD207DBDD8> |
db | 'default' |
queryset | Error in formatting: DatabaseError: database disk image is malformed |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\models\sql\compiler.py
in execute_sql
if result_type == MULTI:
return iter([])
else:
return
cursor = self.connection.cursor()
try:
cursor.execute(sql, params)...
except Exception:
cursor.close()
raise
if result_type == CURSOR:
# Caller didn't specify a result_type, so just give them back the
Variable | Value |
---|---|
cursor | <django.db.backends.utils.CursorDebugWrapper object at 0x000001FD207DBE80> |
self | <django.db.models.sql.compiler.SQLCompiler object at 0x000001FD207DBDD8> |
sql | ('SELECT "django_site"."id", "django_site"."domain", "django_site"."name" FROM ' '"django_site" WHERE "django_site"."domain" LIKE %s ESCAPE \'\\\'') |
params | ('sglab.kaist.ac.kr',) |
result_type | 'multi' |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\backends\utils.py
in execute
class CursorDebugWrapper(CursorWrapper):
# XXX callproc isn't instrumented at this time.
def execute(self, sql, params=None):
start = time()
try:
return super(CursorDebugWrapper, self).execute(sql, params)...
finally:
stop = time()
duration = stop - start
sql = self.db.ops.last_executed_query(self.cursor, sql, params)
self.db.queries_log.append({
'sql': sql,
Variable | Value |
---|---|
start | 1711709475.1036358 |
self | <django.db.backends.utils.CursorDebugWrapper object at 0x000001FD207DBE80> |
stop | 1711709475.1036358 |
duration | 0.0 |
params | ('sglab.kaist.ac.kr',) |
sql | ('SELECT "django_site"."id", "django_site"."domain", "django_site"."name" FROM ' '"django_site" WHERE "django_site"."domain" LIKE \'sglab.kaist.ac.kr\' ESCAPE ' "'\\'") |
__class__ | <class 'django.db.backends.utils.CursorDebugWrapper'> |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\backends\utils.py
in execute
def execute(self, sql, params=None):
self.db.validate_no_broken_transaction()
with self.db.wrap_database_errors:
if params is None:
return self.cursor.execute(sql)
else:
return self.cursor.execute(sql, params)...
def executemany(self, sql, param_list):
self.db.validate_no_broken_transaction()
with self.db.wrap_database_errors:
return self.cursor.executemany(sql, param_list)
Variable | Value |
---|---|
self | <django.db.backends.utils.CursorDebugWrapper object at 0x000001FD207DBE80> |
sql | ('SELECT "django_site"."id", "django_site"."domain", "django_site"."name" FROM ' '"django_site" WHERE "django_site"."domain" LIKE %s ESCAPE \'\\\'') |
params | ('sglab.kaist.ac.kr',) |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\utils.py
in __exit__
if issubclass(exc_type, db_exc_type):
dj_exc_value = dj_exc_type(*exc_value.args)
dj_exc_value.__cause__ = exc_value
# Only set the 'errors_occurred' flag for errors that may make
# the connection unusable.
if dj_exc_type not in (DataError, IntegrityError):
self.wrapper.errors_occurred = True
six.reraise(dj_exc_type, dj_exc_value, traceback)...
def __call__(self, func):
# Note that we are intentionally not using @wraps here for performance
# reasons. Refs #21109.
def inner(*args, **kwargs):
with self:
Variable | Value |
---|---|
exc_type | <class 'sqlite3.DatabaseError'> |
db_exc_type | <class 'sqlite3.DatabaseError'> |
dj_exc_value | DatabaseError('database disk image is malformed',) |
self | <django.db.utils.DatabaseErrorWrapper object at 0x000001FD37C1C8D0> |
traceback | <traceback object at 0x000001FD37C2F988> |
exc_value | DatabaseError('database disk image is malformed',) |
dj_exc_type | <class 'django.db.utils.DatabaseError'> |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\utils\six.py
in reraise
if PY3:
exec_ = getattr(moves.builtins, "exec")
def reraise(tp, value, tb=None):
if value is None:
value = tp()
if value.__traceback__ is not tb:
raise value.with_traceback(tb)...
raise value
else:
def exec_(_code_, _globs_=None, _locs_=None):
"""Execute code in a namespace."""
if _globs_ is None:
Variable | Value |
---|---|
tb | <traceback object at 0x000001FD37C2F988> |
value | DatabaseError('database disk image is malformed',) |
tp | <class 'django.db.utils.DatabaseError'> |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\backends\utils.py
in execute
def execute(self, sql, params=None):
self.db.validate_no_broken_transaction()
with self.db.wrap_database_errors:
if params is None:
return self.cursor.execute(sql)
else:
return self.cursor.execute(sql, params)...
def executemany(self, sql, param_list):
self.db.validate_no_broken_transaction()
with self.db.wrap_database_errors:
return self.cursor.executemany(sql, param_list)
Variable | Value |
---|---|
self | <django.db.backends.utils.CursorDebugWrapper object at 0x000001FD207DBE80> |
sql | ('SELECT "django_site"."id", "django_site"."domain", "django_site"."name" FROM ' '"django_site" WHERE "django_site"."domain" LIKE %s ESCAPE \'\\\'') |
params | ('sglab.kaist.ac.kr',) |
c:\users\sglab\appdata\local\programs\python\python35\lib\site-packages\django\db\backends\sqlite3\base.py
in execute
This fixes it -- but note that if you want to use a literal "%s" in a query,
you'll need to use "%%s".
"""
def execute(self, query, params=None):
if params is None:
return Database.Cursor.execute(self, query)
query = self.convert_query(query)
return Database.Cursor.execute(self, query, params)...
def executemany(self, query, param_list):
query = self.convert_query(query)
return Database.Cursor.executemany(self, query, param_list)
def convert_query(self, query):
Variable | Value |
---|---|
self | <django.db.backends.sqlite3.base.SQLiteCursorWrapper object at 0x000001FD0C7C7678> |
params | ('sglab.kaist.ac.kr',) |
query | ('SELECT "django_site"."id", "django_site"."domain", "django_site"."name" FROM ' '"django_site" WHERE "django_site"."domain" LIKE ? ESCAPE \'\\\'') |
No GET data
No POST data
No FILES data
No cookie data
Variable | Value |
---|---|
mod_wsgi.request_start | '1711709475103635' |
REQUEST_SCHEME | 'https' |
mod_wsgi.thread_requests | 4 |
mod_wsgi.total_requests | 821 |
SERVER_SOFTWARE | 'Apache' |
HTTP_USER_AGENT | 'claudebot' |
wsgi.url_scheme | 'https' |
QUERY_STRING | '' |
REMOTE_ADDR | '44.200.191.146' |
SCRIPT_NAME | '/projects/OpenCCL' |
mod_wsgi.path_info | '/community/' |
mod_wsgi.thread_id | 55 |
SERVER_ADMIN | 'admin@example.com' |
mod_wsgi.script_reloading | '1' |
wsgi.input | <mod_wsgi.Input object at 0x000001FD20775180> |
CONTEXT_DOCUMENT_ROOT | 'D:/ServerApps/Bitnami/wampstack-7.2.10-2/apache2/htdocs' |
REMOTE_PORT | '41078' |
HTTP_ACCEPT | '*/*' |
PATH_TRANSLATED | 'redirect:\\index.php\\' |
wsgi.version | (1, 0) |
SERVER_SIGNATURE | '' |
wsgi.run_once | False |
SystemRoot | 'C:\\WINDOWS' |
PATH_INFO | '/community/' |
mod_wsgi.handler_script | '' |
mod_wsgi.request_handler | 'wsgi-script' |
wsgi.multithread | True |
SERVER_NAME | 'sglab.kaist.ac.kr' |
GATEWAY_INTERFACE | 'CGI/1.1' |
COMSPEC | 'C:\\WINDOWS\\system32\\cmd.exe' |
mod_wsgi.callable_object | 'application' |
SSL_TLS_SNI | 'sglab.kaist.ac.kr' |
DOCUMENT_ROOT | 'D:/ServerApps/Bitnami/wampstack-7.2.10-2/apache2/htdocs' |
SERVER_ADDR | '143.248.137.136' |
mod_wsgi.enable_sendfile | '0' |
mod_wsgi.process_group | '' |
SERVER_PORT | '443' |
wsgi.errors | <_io.TextIOWrapper name='<wsgi.errors>' encoding='utf-8'> |
SCRIPT_FILENAME | 'D:/Web_OpenSourceProjects/OpenCCL/wsgi.py' |
PATHEXT | '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC' |
mod_wsgi.script_name | '/projects/OpenCCL' |
HTTP_HOST | 'sglab.kaist.ac.kr' |
wsgi.input_terminated | True |
SERVER_PROTOCOL | 'HTTP/1.1' |
wsgi.file_wrapper | '' |
mod_wsgi.version | (4, 6, 4) |
mod_wsgi.script_start | '1711709475103635' |
mod_wsgi.request_id | 'k+M4a/oszX8' |
apache.version | (2, 4, 33) |
WINDIR | 'C:\\WINDOWS' |
CONTEXT_PREFIX | '' |
REQUEST_METHOD | 'GET' |
mod_wsgi.ignore_activity | '0' |
wsgi.multiprocess | False |
mod_wsgi.application_group | 'localhost|/projects/openccl' |
OPENSSL_CONF | 'D:\\ServerApps\\Bitnami\\wampstack-7.2.10-2/apache2/conf/openssl.cnf' |
REQUEST_URI | '/projects/OpenCCL/community/' |
OpenCCL.settings
Setting | Value |
---|---|
MONTH_DAY_FORMAT | 'F j' |
FIRST_DAY_OF_WEEK | 0 |
TIME_ZONE | 'Asia/Seoul' |
SESSION_FILE_PATH | None |
MEDIA_URL | '/projects/OpenCCL/static/media/' |
EMAIL_SSL_CERTFILE | None |
PROJECT_DIRNAME | 'OpenCCL' |
CSRF_TRUSTED_ORIGINS | [] |
EMAIL_BACKEND | 'django.core.mail.backends.smtp.EmailBackend' |
APPEND_SLASH | True |
EMAIL_PORT | 25 |
FILE_CHARSET | 'utf-8' |
STATICFILES_FINDERS | ('django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder') |
STATICFILES_DIRS | [] |
USE_X_FORWARDED_PORT | False |
FORCE_SCRIPT_NAME | None |
THOUSAND_SEPARATOR | ',' |
LOGIN_REDIRECT_URL | '/accounts/profile/' |
LOGGING_CONFIG | 'logging.config.dictConfig' |
EMAIL_USE_SSL | False |
SECURE_HSTS_INCLUDE_SUBDOMAINS | False |
DEFAULT_CONTENT_TYPE | 'text/html' |
FILE_UPLOAD_HANDLERS | ['django.core.files.uploadhandler.MemoryFileUploadHandler', 'django.core.files.uploadhandler.TemporaryFileUploadHandler'] |
EMAIL_HOST_PASSWORD | '********************' |
LANGUAGES | (('en', 'English'),) |
SILENCED_SYSTEM_CHECKS | [] |
DEBUG_PROPAGATE_EXCEPTIONS | False |
SESSION_COOKIE_AGE | 1209600 |
DEFAULT_INDEX_TABLESPACE | '' |
EMAIL_SUBJECT_PREFIX | '[Django] ' |
FILE_UPLOAD_MAX_MEMORY_SIZE | 2621440 |
PASSWORD_RESET_TIMEOUT_DAYS | '********************' |
CSRF_COOKIE_AGE | 31449600 |
TESTING | False |
X_FRAME_OPTIONS | 'SAMEORIGIN' |
DEFAULT_CHARSET | 'utf-8' |
LANGUAGE_COOKIE_AGE | None |
CSRF_COOKIE_SECURE | False |
SECURE_PROXY_SSL_HEADER | None |
NEVERCACHE_KEY | '********************' |
CSRF_COOKIE_DOMAIN | None |
TEMPLATES | [] |
DEFAULT_TABLESPACE | '' |
DATE_INPUT_FORMATS | ['%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', '%b %d %Y', '%b %d, %Y', '%d %b %Y', '%d %b, %Y', '%B %d %Y', '%B %d, %Y', '%d %B %Y', '%d %B, %Y'] |
LOCALE_PATHS | [] |
AUTHENTICATION_BACKENDS | ('mezzanine.core.auth_backends.MezzanineBackend',) |
SHORT_DATETIME_FORMAT | 'm/d/Y P' |
DEV_SERVER | False |
EMAIL_HOST | 'localhost' |
SITE_ID | 1 |
MANAGERS | () |
CSRF_COOKIE_HTTPONLY | False |
SESSION_SERIALIZER | 'django.contrib.sessions.serializers.JSONSerializer' |
DISALLOWED_USER_AGENTS | [] |
LANGUAGE_COOKIE_NAME | 'django_language' |
USE_ETAGS | False |
MIDDLEWARE_CLASSES | ('django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.locale.LocaleMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'mezzanine.core.request.CurrentRequestMiddleware', 'mezzanine.core.middleware.RedirectFallbackMiddleware', 'mezzanine.core.middleware.TemplateForDeviceMiddleware', 'mezzanine.core.middleware.TemplateForHostMiddleware', 'mezzanine.core.middleware.AdminLoginInterfaceSelectorMiddleware', 'mezzanine.core.middleware.SitePermissionMiddleware', 'mezzanine.pages.middleware.PageMiddleware') |
LOGGING | {} |
CSRF_FAILURE_VIEW | 'django.views.csrf.csrf_failure' |
CACHE_MIDDLEWARE_ALIAS | 'default' |
PACKAGE_NAME_GRAPPELLI | 'grappelli_safe' |
YEAR_MONTH_FORMAT | 'F Y' |
DEFAULT_EXCEPTION_REPORTER_FILTER | 'django.views.debug.SafeExceptionReporterFilter' |
ALLOWED_INCLUDE_ROOTS | [] |
CACHE_MIDDLEWARE_SECONDS | 600 |
SECRET_KEY | '********************' |
DEFAULT_FROM_EMAIL | 'webmaster@localhost' |
TEST_NON_SERIALIZED_APPS | [] |
SITE_ROOT | 'D:\\Web_OpenSourceProjects\\OpenCCL' |
EMAIL_SSL_KEYFILE | '********************' |
USE_THOUSAND_SEPARATOR | False |
LANGUAGE_CODE | 'en' |
USE_I18N | False |
PREPEND_WWW | False |
IGNORABLE_404_URLS | [] |
ROOT_URLCONF | 'OpenCCL.urls' |
CSRF_COOKIE_NAME | 'csrftoken' |
GRAPPELLI_INSTALLED | True |
SECURE_CONTENT_TYPE_NOSNIFF | False |
TEST_RUNNER | 'django.test.runner.DiscoverRunner' |
EMAIL_HOST_USER | '' |
STATICFILES_STORAGE | 'django.contrib.staticfiles.storage.StaticFilesStorage' |
LANGUAGE_COOKIE_PATH | '/' |
PASSWORD_HASHERS | '********************' |
TIME_INPUT_FORMATS | ['%H:%M:%S', '%H:%M:%S.%f', '%H:%M'] |
INTERNAL_IPS | ('127.0.0.1',) |
PACKAGE_NAME_FILEBROWSER | 'filebrowser_safe' |
INSTALLED_APPS | ('mezzanine.boot', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.redirects', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.sitemaps', 'mezzanine.conf', 'mezzanine.core', 'mezzanine.generic', 'mezzanine.blog', 'mezzanine.forms', 'mezzanine.pages', 'mezzanine.galleries', 'mezzanine.twitter', 'filebrowser_safe', 'grappelli_safe', 'django.contrib.admin', 'django.contrib.staticfiles', 'django_comments') |
DEBUG | True |
AUTH_PASSWORD_VALIDATORS | '********************' |
SECURE_SSL_HOST | None |
SECURE_REDIRECT_EXEMPT | [] |
CSRF_HEADER_NAME | 'HTTP_X_CSRFTOKEN' |
DATETIME_FORMAT | 'N j, Y, P' |
TEMPLATE_CONTEXT_PROCESSORS | ('django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', 'django.core.context_processors.debug', 'django.core.context_processors.i18n', 'django.core.context_processors.static', 'django.core.context_processors.media', 'django.core.context_processors.request', 'django.core.context_processors.tz', 'mezzanine.conf.context_processors.settings', 'mezzanine.pages.context_processors.page') |
USE_MODELTRANSLATION | False |
DATABASES | {'default': {'ATOMIC_REQUESTS': False, 'AUTOCOMMIT': True, 'CONN_MAX_AGE': 0, 'ENGINE': 'django.db.backends.sqlite3', 'HOST': '', 'NAME': 'D:\\Web_OpenSourceProjects\\OpenCCL\\dev.db', 'OPTIONS': {}, 'PASSWORD': '********************', 'PORT': '', 'TEST': {'CHARSET': None, 'COLLATION': None, 'MIRROR': None, 'NAME': None}, 'TIME_ZONE': None, 'USER': ''}} |
LANGUAGES_BIDI | ['he', 'ar', 'fa', 'ur'] |
SESSION_ENGINE | 'django.contrib.sessions.backends.db' |
MEDIA_ROOT | 'D:\\Web_OpenSourceProjects\\OpenCCL\\static/media' |
SIGNING_BACKEND | 'django.core.signing.TimestampSigner' |
OPTIONAL_APPS | ('debug_toolbar', 'django_extensions', 'compressor', 'filebrowser_safe', 'grappelli_safe') |
USE_SOUTH | True |
SESSION_SAVE_EVERY_REQUEST | False |
SESSION_COOKIE_PATH | '/' |
TEMPLATE_DEBUG | False |
TEMPLATE_STRING_IF_INVALID | '' |
ADMINS | () |
PROJECT_ROOT | 'D:\\Web_OpenSourceProjects\\OpenCCL' |
COMMENTS_APP | 'mezzanine.generic' |
ALLOWED_HOSTS | ['sglab.kaist.ac.kr'] |
SESSION_CACHE_ALIAS | 'default' |
EMAIL_TIMEOUT | None |
FIXTURE_DIRS | [] |
SESSION_COOKIE_SECURE | False |
DATETIME_INPUT_FORMATS | ['%Y-%m-%d %H:%M:%S', '%Y-%m-%d %H:%M:%S.%f', '%Y-%m-%d %H:%M', '%Y-%m-%d', '%m/%d/%Y %H:%M:%S', '%m/%d/%Y %H:%M:%S.%f', '%m/%d/%Y %H:%M', '%m/%d/%Y', '%m/%d/%y %H:%M:%S', '%m/%d/%y %H:%M:%S.%f', '%m/%d/%y %H:%M', '%m/%d/%y'] |
DEFAULT_FILE_STORAGE | 'django.core.files.storage.FileSystemStorage' |
LOGIN_URL | '/accounts/login/' |
FILE_UPLOAD_PERMISSIONS | 420 |
TEMPLATE_LOADERS | ('django.template.loaders.filesystem.Loader', 'django.template.loaders.app_directories.Loader') |
LOGOUT_URL | '/accounts/logout/' |
SETTINGS_MODULE | 'OpenCCL.settings' |
FILE_UPLOAD_TEMP_DIR | None |
TIME_FORMAT | 'P' |
DATE_FORMAT | 'N j, Y' |
DATABASE_ROUTERS | [] |
SHORT_DATE_FORMAT | 'm/d/Y' |
WSGI_APPLICATION | None |
USE_TZ | True |
MESSAGE_STORAGE | 'django.contrib.messages.storage.cookie.CookieStorage' |
SERVER_EMAIL | 'root@localhost' |
CACHE_MIDDLEWARE_KEY_PREFIX | '********************' |
SESSION_COOKIE_DOMAIN | None |
STATIC_ROOT | 'D:\\Web_OpenSourceProjects\\OpenCCL\\projects/OpenCCL/static' |
DECIMAL_SEPARATOR | '.' |
SESSION_COOKIE_NAME | 'sessionid' |
CSRF_COOKIE_PATH | '/' |
NUMBER_GROUPING | 0 |
SECURE_BROWSER_XSS_FILTER | False |
USE_L10N | False |
SECURE_HSTS_SECONDS | 0 |
USE_X_FORWARDED_HOST | False |
LANGUAGE_COOKIE_DOMAIN | None |
SECURE_SSL_REDIRECT | False |
AUTH_USER_MODEL | 'auth.User' |
FILE_UPLOAD_DIRECTORY_PERMISSIONS | None |
SESSION_EXPIRE_AT_BROWSER_CLOSE | True |
SESSION_COOKIE_HTTPONLY | True |
ABSOLUTE_URL_OVERRIDES | {} |
TEMPLATE_DIRS | ('D:\\Web_OpenSourceProjects\\OpenCCL\\templates',) |
FORMAT_MODULE_PATH | None |
MIGRATION_MODULES | {} |
CACHES | {'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'}} |
EMAIL_USE_TLS | False |
STATIC_URL | '/projects/OpenCCL/static/' |
You're seeing this error because you have DEBUG = True
in your
Django settings file. Change that to False
, and Django will
display a standard page generated by the handler for this status code.