ConnectionError(<urllib3.connection.HTTPConnection object at 0x7f51847d0ad0>: Failed to establish a new connection: [Errno 111] Connection refused) caused by: NewConnectionError(<urllib3.connection.HTTPConnection object at 0x7f51847d0ad0>: Failed to establish a new connection: [Errno 111] Connection refused)
Request Method: | GET |
---|---|
Request URL: | https://iconolab.iri-research.org/search/model/annotations?q=Lyre&perpage=10 |
Django Version: | 2.0.6 |
Exception Type: | ConnectionError |
Exception Value: | ConnectionError(<urllib3.connection.HTTPConnection object at 0x7f51847d0ad0>: Failed to establish a new connection: [Errno 111] Connection refused) caused by: NewConnectionError(<urllib3.connection.HTTPConnection object at 0x7f51847d0ad0>: Failed to establish a new connection: [Errno 111] Connection refused) |
Exception Location: | /srv/virtualenv/iconolab/lib/python3.7/site-packages/elasticsearch/connection/http_urllib3.py in perform_request, line 175 |
Python Executable: | /srv/virtualenv/iconolab/bin/uwsgi |
Python Version: | 3.7.10 |
Python Path: | ['/etc/www/iconolab/', '.', '', '/etc/www/iconolab', '/usr/lib/python37.zip', '/usr/lib/python3.7', '/usr/lib/python3.7/lib-dynload', '/srv/virtualenv/iconolab/lib/python3.7/site-packages'] |
Server time: | jeu, 28 Mar 2024 18:58:51 +0000 |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/connection.py
in _new_conn
extra_kw['source_address'] = self.source_address
if self.socket_options:
extra_kw['socket_options'] = self.socket_options
try:
conn = connection.create_connection(
(self.host, self.port), self.timeout, **extra_kw)...
except SocketTimeout as e:
raise ConnectTimeoutError(
self, "Connection to %s timed out. (connect timeout=%s)" %
(self.host, self.timeout))
Variable | Value |
---|---|
extra_kw | {'socket_options': [(6, 1, 1)]} |
self | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/util/connection.py
in create_connection
except socket.error as e:
err = e
if sock is not None:
sock.close()
sock = None
if err is not None:
raise err...
raise socket.error("getaddrinfo returns an empty list")
def _set_socket_options(sock, options):
if options is None:
Variable | Value |
---|---|
address | ('10.0.100.13', 9200) |
af | <AddressFamily.AF_INET: 2> |
canonname | '10.0.100.13' |
err | ConnectionRefusedError(111, 'Connection refused') |
family | <AddressFamily.AF_UNSPEC: 0> |
host | '10.0.100.13' |
port | 9200 |
proto | 6 |
res | (<AddressFamily.AF_INET: 2>, <SocketKind.SOCK_STREAM: 1>, 6, '10.0.100.13', ('10.0.100.13', 9200)) |
sa | ('10.0.100.13', 9200) |
sock | None |
socket_options | [(6, 1, 1)] |
socktype | <SocketKind.SOCK_STREAM: 1> |
source_address | None |
timeout | 10 |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/util/connection.py
in create_connection
# If provided, set socket level options before connecting.
_set_socket_options(sock, socket_options)
if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
sock.settimeout(timeout)
if source_address:
sock.bind(source_address)
sock.connect(sa)...
return sock
except socket.error as e:
err = e
if sock is not None:
sock.close()
Variable | Value |
---|---|
address | ('10.0.100.13', 9200) |
af | <AddressFamily.AF_INET: 2> |
canonname | '10.0.100.13' |
err | ConnectionRefusedError(111, 'Connection refused') |
family | <AddressFamily.AF_UNSPEC: 0> |
host | '10.0.100.13' |
port | 9200 |
proto | 6 |
res | (<AddressFamily.AF_INET: 2>, <SocketKind.SOCK_STREAM: 1>, 6, '10.0.100.13', ('10.0.100.13', 9200)) |
sa | ('10.0.100.13', 9200) |
sock | None |
socket_options | [(6, 1, 1)] |
socktype | <SocketKind.SOCK_STREAM: 1> |
source_address | None |
timeout | 10 |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/elasticsearch/connection/http_urllib3.py
in perform_request
request_headers = self.headers
if headers:
request_headers = request_headers.copy()
request_headers.update(headers)
if self.http_compress and body:
body = gzip.compress(body)
response = self.pool.urlopen(method, url, body, retries=False, headers=request_headers, **kw)...
duration = time.time() - start
raw_data = response.data.decode('utf-8')
except Exception as e:
self.log_request_fail(method, full_url, url, body, time.time() - start, exception=e)
if isinstance(e, UrllibSSLError):
raise SSLError('N/A', str(e), e)
Variable | Value |
---|---|
body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
full_url | 'http://10.0.100.13:9200/iconolab_annotations/doc/_count' |
headers | None |
ignore | () |
kw | {} |
method | 'GET' |
params | {} |
request_headers | {'connection': 'keep-alive', 'content-type': 'application/json'} |
self | <Urllib3HttpConnection: http://10.0.100.13:9200> |
start | 1711652331.713982 |
timeout | None |
url | '/iconolab_annotations/doc/_count' |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/connectionpool.py
in urlopen
e = SSLError(e)
elif isinstance(e, (SocketError, NewConnectionError)) and self.proxy:
e = ProxyError('Cannot connect to proxy.', e)
elif isinstance(e, (SocketError, HTTPException)):
e = ProtocolError('Connection aborted.', e)
retries = retries.increment(method, url, error=e, _pool=self,
_stacktrace=sys.exc_info()[2])...
retries.sleep()
# Keep track of the error for the retry warning.
err = e
finally:
Variable | Value |
---|---|
assert_same_host | True |
body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
body_pos | None |
chunked | False |
clean_exit | False |
conn | None |
err | None |
headers | {'connection': 'keep-alive', 'content-type': 'application/json'} |
is_new_proxy_conn | False |
method | 'GET' |
pool_timeout | None |
redirect | True |
release_conn | True |
release_this_conn | True |
response_kw | {} |
retries | Retry(total=False, connect=None, read=None, redirect=0, status=None) |
self | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f5184be3a10> |
timeout | <object object at 0x7f518676fb70> |
timeout_obj | <urllib3.util.timeout.Timeout object at 0x7f51847d0cd0> |
url | '/iconolab_annotations/doc/_count' |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/util/retry.py
in increment
:param Exception error: An error encountered during the request, or
None if the response was received successfully.
:return: A new ``Retry`` object.
"""
if self.total is False and error:
# Disabled, indicate to re-raise the error.
raise six.reraise(type(error), error, _stacktrace)...
total = self.total
if total is not None:
total -= 1
connect = self.connect
Variable | Value |
---|---|
_pool | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f5184be3a10> |
_stacktrace | <traceback object at 0x7f5184965b40> |
error | NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f51847d0ad0>: Failed to establish a new connection: [Errno 111] Connection refused') |
method | 'GET' |
response | None |
self | Retry(total=False, connect=None, read=None, redirect=0, status=None) |
url | '/iconolab_annotations/doc/_count' |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/packages/six.py
in reraise
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:
frame = sys._getframe(1)
Variable | Value |
---|---|
tb | <traceback object at 0x7f5184965b40> |
tp | <class 'urllib3.exceptions.NewConnectionError'> |
value | NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f51847d0ad0>: Failed to establish a new connection: [Errno 111] Connection refused') |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/connectionpool.py
in urlopen
if is_new_proxy_conn:
self._prepare_proxy(conn)
# Make the request on the httplib connection object.
httplib_response = self._make_request(conn, method, url,
timeout=timeout_obj,
body=body, headers=headers,
chunked=chunked)...
# If we're going to release the connection in ``finally:``, then
# the response doesn't need to know about the connection. Otherwise
# it will also try to release it and we'll have a double-release
# mess.
response_conn = conn if not release_conn else None
Variable | Value |
---|---|
assert_same_host | True |
body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
body_pos | None |
chunked | False |
clean_exit | False |
conn | None |
err | None |
headers | {'connection': 'keep-alive', 'content-type': 'application/json'} |
is_new_proxy_conn | False |
method | 'GET' |
pool_timeout | None |
redirect | True |
release_conn | True |
release_this_conn | True |
response_kw | {} |
retries | Retry(total=False, connect=None, read=None, redirect=0, status=None) |
self | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f5184be3a10> |
timeout | <object object at 0x7f518676fb70> |
timeout_obj | <urllib3.util.timeout.Timeout object at 0x7f51847d0cd0> |
url | '/iconolab_annotations/doc/_count' |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/connectionpool.py
in _make_request
raise
# conn.request() calls httplib.*.request, not the method in
# urllib3.request. It also calls makefile (recv) on the socket.
if chunked:
conn.request_chunked(method, url, **httplib_request_kw)
else:
conn.request(method, url, **httplib_request_kw)...
# Reset the timeout for the recv() on the socket
read_timeout = timeout_obj.read_timeout
# App Engine doesn't have a sock attr
if getattr(conn, 'sock', None):
Variable | Value |
---|---|
chunked | False |
conn | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
httplib_request_kw | {'body': b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}', 'headers': {'connection': 'keep-alive', 'content-type': 'application/json'}} |
method | 'GET' |
self | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f5184be3a10> |
timeout | <urllib3.util.timeout.Timeout object at 0x7f51847d0cd0> |
timeout_obj | <urllib3.util.timeout.Timeout object at 0x7f51847d0850> |
url | '/iconolab_annotations/doc/_count' |
/usr/lib/python3.7/http/client.py
in request
else:
raise CannotSendHeader()
self._send_output(message_body, encode_chunked=encode_chunked)
def request(self, method, url, body=None, headers={}, *,
encode_chunked=False):
"""Send a complete request to the server."""
self._send_request(method, url, body, headers, encode_chunked)...
def _send_request(self, method, url, body, headers, encode_chunked):
# Honor explicitly requested Host: and Accept-Encoding: headers.
header_names = frozenset(k.lower() for k in headers)
skips = {}
if 'host' in header_names:
Variable | Value |
---|---|
body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
encode_chunked | False |
headers | {'connection': 'keep-alive', 'content-type': 'application/json'} |
method | 'GET' |
self | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
url | '/iconolab_annotations/doc/_count' |
/usr/lib/python3.7/http/client.py
in _send_request
for hdr, value in headers.items():
self.putheader(hdr, value)
if isinstance(body, str):
# RFC 2616 Section 3.7.1 says that text default has a
# default charset of iso-8859-1.
body = _encode(body, 'body')
self.endheaders(body, encode_chunked=encode_chunked)...
def getresponse(self):
"""Get the response from the server.
If the HTTPConnection is in the correct state, returns an
instance of HTTPResponse or of whatever object is returned by
Variable | Value |
---|---|
body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
content_length | 68 |
encode_chunked | False |
hdr | 'content-type' |
header_names | frozenset({'content-type', 'connection'}) |
headers | {'connection': 'keep-alive', 'content-type': 'application/json'} |
method | 'GET' |
self | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
skips | {} |
url | '/iconolab_annotations/doc/_count' |
value | 'application/json' |
/usr/lib/python3.7/http/client.py
in endheaders
argument can be used to pass a message body associated with the
request.
"""
if self.__state == _CS_REQ_STARTED:
self.__state = _CS_REQ_SENT
else:
raise CannotSendHeader()
self._send_output(message_body, encode_chunked=encode_chunked)...
def request(self, method, url, body=None, headers={}, *,
encode_chunked=False):
"""Send a complete request to the server."""
self._send_request(method, url, body, headers, encode_chunked)
Variable | Value |
---|---|
encode_chunked | False |
message_body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
self | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
/usr/lib/python3.7/http/client.py
in _send_output
Appends an extra \\r\\n to the buffer.
A message_body may be specified, to be appended to the request.
"""
self._buffer.extend((b"", b""))
msg = b"\r\n".join(self._buffer)
del self._buffer[:]
self.send(msg)...
if message_body is not None:
# create a consistent interface to message_body
if hasattr(message_body, 'read'):
# Let file-like take precedence over byte-like. This
Variable | Value |
---|---|
encode_chunked | False |
message_body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
msg | (b'GET /iconolab_annotations/doc/_count HTTP/1.1\r\nHost: 10.0.100.13:9200\r\nA' b'ccept-Encoding: identity\r\nContent-Length: 68\r\nconnection: keep-alive' b'\r\ncontent-type: application/json\r\n\r\n') |
self | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
/usr/lib/python3.7/http/client.py
in send
"""Send `data' to the server.
``data`` can be a string object, a bytes object, an array object, a
file-like object that supports a .read() method, or an iterable object.
"""
if self.sock is None:
if self.auto_open:
self.connect()...
else:
raise NotConnected()
if self.debuglevel > 0:
print("send:", repr(data))
if hasattr(data, "read") :
Variable | Value |
---|---|
data | (b'GET /iconolab_annotations/doc/_count HTTP/1.1\r\nHost: 10.0.100.13:9200\r\nA' b'ccept-Encoding: identity\r\nContent-Length: 68\r\nconnection: keep-alive' b'\r\ncontent-type: application/json\r\n\r\n') |
self | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/connection.py
in connect
if getattr(self, '_tunnel_host', None):
# TODO: Fix tunnel so it doesn't depend on self.sock state.
self._tunnel()
# Mark this connection as not reusable
self.auto_open = 0
def connect(self):
conn = self._new_conn()...
self._prepare_conn(conn)
def request_chunked(self, method, url, body=None, headers=None):
"""
Alternative to the common request method, which sends the
body with chunked encoding and not as one block
Variable | Value |
---|---|
self | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/urllib3/connection.py
in _new_conn
except SocketTimeout as e:
raise ConnectTimeoutError(
self, "Connection to %s timed out. (connect timeout=%s)" %
(self.host, self.timeout))
except SocketError as e:
raise NewConnectionError(
self, "Failed to establish a new connection: %s" % e)...
return conn
def _prepare_conn(self, conn):
self.sock = conn
# the _tunnel_host attribute was added in python 2.6.3 (via
Variable | Value |
---|---|
extra_kw | {'socket_options': [(6, 1, 1)]} |
self | <urllib3.connection.HTTPConnection object at 0x7f51847d0ad0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/core/handlers/exception.py
in inner
This decorator is automatically applied to all middleware to ensure that
no middleware leaks an exception and that the next middleware in the stack
can rely on getting a response instead of an exception.
"""
@wraps(get_response)
def inner(request):
try:
response = get_response(request)...
except Exception as exc:
response = response_for_exception(request, exc)
return response
return inner
Variable | Value |
---|---|
exc | ConnectionError('N/A', '<urllib3.connection.HTTPConnection object at 0x7f51847d0ad0>: Failed to establish a new connection: [Errno 111] Connection refused', NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f51847d0ad0>: Failed to establish a new connection: [Errno 111] Connection refused')) |
get_response | <bound method BaseHandler._get_response of <django.core.handlers.wsgi.WSGIHandler object at 0x7f518583acd0>> |
request | <WSGIRequest: GET '/search/model/annotations?q=Lyre&perpage=10'> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/core/handlers/base.py
in _get_response
break
if response is None:
wrapped_callback = self.make_view_atomic(callback)
try:
response = wrapped_callback(request, *callback_args, **callback_kwargs)
except Exception as e:
response = self.process_exception_by_middleware(e, request)...
# Complain if the view returned None (a common error).
if response is None:
if isinstance(callback, types.FunctionType): # FBV
view_name = callback.__name__
else: # CBV
Variable | Value |
---|---|
callback | <function IconolabSearchView at 0x7f518578c440> |
callback_args | () |
callback_kwargs | {'model_type': 'annotations'} |
middleware_method | <bound method CsrfViewMiddleware.process_view of <django.middleware.csrf.CsrfViewMiddleware object at 0x7f5185856250>> |
request | <WSGIRequest: GET '/search/model/annotations?q=Lyre&perpage=10'> |
resolver | <URLResolver 'iconolab_mcc.urls' (None:None) '^/'> |
resolver_match | ResolverMatch(func=iconolab.search_indexes.views.IconolabSearchView, args=(), kwargs={'model_type': 'annotations'}, url_name=model_search, app_names=['iconolab-search_indexes'], namespaces=['search_indexes']) |
response | None |
self | <django.core.handlers.wsgi.WSGIHandler object at 0x7f518583acd0> |
wrapped_callback | <function IconolabSearchView at 0x7f518578c440> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/core/handlers/base.py
in _get_response
response = middleware_method(request, callback, callback_args, callback_kwargs)
if response:
break
if response is None:
wrapped_callback = self.make_view_atomic(callback)
try:
response = wrapped_callback(request, *callback_args, **callback_kwargs)...
except Exception as e:
response = self.process_exception_by_middleware(e, request)
# Complain if the view returned None (a common error).
if response is None:
if isinstance(callback, types.FunctionType): # FBV
Variable | Value |
---|---|
callback | <function IconolabSearchView at 0x7f518578c440> |
callback_args | () |
callback_kwargs | {'model_type': 'annotations'} |
middleware_method | <bound method CsrfViewMiddleware.process_view of <django.middleware.csrf.CsrfViewMiddleware object at 0x7f5185856250>> |
request | <WSGIRequest: GET '/search/model/annotations?q=Lyre&perpage=10'> |
resolver | <URLResolver 'iconolab_mcc.urls' (None:None) '^/'> |
resolver_match | ResolverMatch(func=iconolab.search_indexes.views.IconolabSearchView, args=(), kwargs={'model_type': 'annotations'}, url_name=model_search, app_names=['iconolab-search_indexes'], namespaces=['search_indexes']) |
response | None |
self | <django.core.handlers.wsgi.WSGIHandler object at 0x7f518583acd0> |
wrapped_callback | <function IconolabSearchView at 0x7f518578c440> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/views/generic/base.py
in view
def view(request, *args, **kwargs):
self = cls(**initkwargs)
if hasattr(self, 'get') and not hasattr(self, 'head'):
self.head = self.get
self.request = request
self.args = args
self.kwargs = kwargs
return self.dispatch(request, *args, **kwargs)...
view.view_class = cls
view.view_initkwargs = initkwargs
# take name and docstring from class
update_wrapper(view, cls, updated=())
Variable | Value |
---|---|
args | () |
cls | <class 'iconolab.search_indexes.views.IconolabSearchView'> |
initkwargs | {} |
kwargs | {'model_type': 'annotations'} |
request | <WSGIRequest: GET '/search/model/annotations?q=Lyre&perpage=10'> |
self | <iconolab.search_indexes.views.IconolabSearchView object at 0x7f518522f3d0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/views/generic/base.py
in dispatch
# Try to dispatch to the right method; if a method doesn't exist,
# defer to the error handler. Also defer to the error handler if the
# request method isn't on the approved list.
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
return handler(request, *args, **kwargs)...
def http_method_not_allowed(self, request, *args, **kwargs):
logger.warning(
'Method Not Allowed (%s): %s', request.method, request.path,
extra={'status_code': 405, 'request': request}
)
Variable | Value |
---|---|
args | () |
handler | <bound method IconolabSearchView.get of <iconolab.search_indexes.views.IconolabSearchView object at 0x7f518522f3d0>> |
kwargs | {'model_type': 'annotations'} |
request | <WSGIRequest: GET '/search/model/annotations?q=Lyre&perpage=10'> |
self | <iconolab.search_indexes.views.IconolabSearchView object at 0x7f518522f3d0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/iconolab/search_indexes/views.py
in get
redirect_url = reverse('search_indexes:collection_with_model_search', kwargs={
'collection_name': self.collection_name, 'model_type': self.model_type})
return redirect(self.complete_url(redirect_url, tags_only))
else:
has_error, redirectView = self.check_kwargs(**kwargs)
if has_error:
return redirectView(request)
return super().get(request, *args, **kwargs)...
def check_kwargs(self, **kwargs):
self.collection = None
if self.collection_name:
self.collection = Collection.objects.filter(name=self.collection_name).first()
Variable | Value |
---|---|
__class__ | <class 'iconolab.search_indexes.views.IconolabSearchView'> |
args | () |
has_error | False |
kwargs | {'model_type': 'annotations'} |
redirectView | None |
request | <WSGIRequest: GET '/search/model/annotations?q=Lyre&perpage=10'> |
self | <iconolab.search_indexes.views.IconolabSearchView object at 0x7f518522f3d0> |
tags_only | False |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/views/generic/list.py
in get
is_empty = not self.object_list.exists()
else:
is_empty = len(self.object_list) == 0
if is_empty:
raise Http404(_("Empty list and '%(class_name)s.allow_empty' is False.") % {
'class_name': self.__class__.__name__,
})
context = self.get_context_data()...
return self.render_to_response(context)
class MultipleObjectTemplateResponseMixin(TemplateResponseMixin):
"""Mixin for responding with a template and list of objects."""
template_name_suffix = '_list'
Variable | Value |
---|---|
allow_empty | True |
args | () |
kwargs | {'model_type': 'annotations'} |
request | <WSGIRequest: GET '/search/model/annotations?q=Lyre&perpage=10'> |
self | <iconolab.search_indexes.views.IconolabSearchView object at 0x7f518522f3d0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/iconolab/search_indexes/views.py
in get_context_data
form = self.get_form()
if form.is_valid():
return form.search()
else:
return []
def get_context_data(self, *args, **kwargs):
context = super().get_context_data(*args, **kwargs)...
context['collection_name'] = self.collection_name
context['collection'] = self.collection
context['form'] = self.get_form(initial=self.request.GET)
context['query'] = self.request.GET.get("q", None)
return context
Variable | Value |
---|---|
__class__ | <class 'iconolab.search_indexes.views.IconolabSearchView'> |
args | () |
kwargs | {} |
self | <iconolab.search_indexes.views.IconolabSearchView object at 0x7f518522f3d0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/views/generic/list.py
in get_context_data
def get_context_data(self, *, object_list=None, **kwargs):
"""Get the context for this view."""
queryset = object_list if object_list is not None else self.object_list
page_size = self.get_paginate_by(queryset)
context_object_name = self.get_context_object_name(queryset)
if page_size:
paginator, page, queryset, is_paginated = self.paginate_queryset(queryset, page_size)...
context = {
'paginator': paginator,
'page_obj': page,
'is_paginated': is_paginated,
'object_list': queryset
}
Variable | Value |
---|---|
__class__ | <class 'django.views.generic.list.MultipleObjectMixin'> |
context_object_name | None |
kwargs | {} |
object_list | None |
page_size | '10' |
queryset | <iconolab.search_indexes.query.QueryResults object at 0x7f5184ad7110> |
self | <iconolab.search_indexes.views.IconolabSearchView object at 0x7f518522f3d0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/views/generic/list.py
in paginate_queryset
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
raise Http404(_("Page is not 'last', nor can it be converted to an int."))
try:
page = paginator.page(page_number)...
return (paginator, page, page.object_list, page.has_other_pages())
except InvalidPage as e:
raise Http404(_('Invalid page (%(page_number)s): %(message)s') % {
'page_number': page_number,
'message': str(e)
})
Variable | Value |
---|---|
page | 1 |
page_kwarg | 'page' |
page_number | 1 |
page_size | '10' |
paginator | <django.core.paginator.Paginator object at 0x7f51848a1950> |
queryset | <iconolab.search_indexes.query.QueryResults object at 0x7f5184ad7110> |
self | <iconolab.search_indexes.views.IconolabSearchView object at 0x7f518522f3d0> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/core/paginator.py
in page
number = 1
except EmptyPage:
number = self.num_pages
return self.page(number)
def page(self, number):
"""Return a Page object for the given 1-based page number."""
number = self.validate_number(number)...
bottom = (number - 1) * self.per_page
top = bottom + self.per_page
if top + self.orphans >= self.count:
top = self.count
return self._get_page(self.object_list[bottom:top], number, self)
Variable | Value |
---|---|
number | 1 |
self | <django.core.paginator.Paginator object at 0x7f51848a1950> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/core/paginator.py
in validate_number
"""Validate the given 1-based page number."""
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger(_('That page number is not an integer'))
if number < 1:
raise EmptyPage(_('That page number is less than 1'))
if number > self.num_pages:...
if number == 1 and self.allow_empty_first_page:
pass
else:
raise EmptyPage(_('That page contains no results'))
return number
Variable | Value |
---|---|
number | 1 |
self | <django.core.paginator.Paginator object at 0x7f51848a1950> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/utils/functional.py
in __get__
"""
Call the function and put the return value in instance.__dict__ so that
subsequent attribute access on the instance returns the cached value
instead of calling cached_property.__get__().
"""
if instance is None:
return self
res = instance.__dict__[self.name] = self.func(instance)...
return res
class Promise:
"""
Base class for the proxy class created in the closure of the lazy function.
Variable | Value |
---|---|
cls | <class 'django.core.paginator.Paginator'> |
instance | <django.core.paginator.Paginator object at 0x7f51848a1950> |
self | <django.utils.functional.cached_property object at 0x7f5186707f50> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/core/paginator.py
in num_pages
# TypeError if object_list.count() requires arguments
# (i.e. is of type list).
return len(self.object_list)
@cached_property
def num_pages(self):
"""Return the total number of pages."""
if self.count == 0 and not self.allow_empty_first_page:...
return 0
hits = max(1, self.count - self.orphans)
return int(ceil(hits / float(self.per_page)))
@property
def page_range(self):
Variable | Value |
---|---|
self | <django.core.paginator.Paginator object at 0x7f51848a1950> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/utils/functional.py
in __get__
"""
Call the function and put the return value in instance.__dict__ so that
subsequent attribute access on the instance returns the cached value
instead of calling cached_property.__get__().
"""
if instance is None:
return self
res = instance.__dict__[self.name] = self.func(instance)...
return res
class Promise:
"""
Base class for the proxy class created in the closure of the lazy function.
Variable | Value |
---|---|
cls | <class 'django.core.paginator.Paginator'> |
instance | <django.core.paginator.Paginator object at 0x7f51848a1950> |
self | <django.utils.functional.cached_property object at 0x7f5186707f10> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/django/core/paginator.py
in count
"""
return Page(*args, **kwargs)
@cached_property
def count(self):
"""Return the total number of objects, across all pages."""
try:
return self.object_list.count()...
except (AttributeError, TypeError):
# AttributeError if object_list has no count() method.
# TypeError if object_list.count() requires arguments
# (i.e. is of type list).
return len(self.object_list)
Variable | Value |
---|---|
self | <django.core.paginator.Paginator object at 0x7f51848a1950> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/elasticsearch_dsl/search.py
in count
d = self.to_dict(count=True)
# TODO: failed shards detection
return es.count(
index=self._index,
doc_type=self._get_doc_type(),
body=d,
**self._params...
)['count']
def execute(self, ignore_cache=False):
"""
Execute the search and return an instance of ``Response`` wrapping all
the data.
Variable | Value |
---|---|
d | {'query': {'simple_query_string': {'fields': ['text'], 'query': 'Lyre'}}} |
es | <Elasticsearch([{'host': '10.0.100.13', 'port': 9200}])> |
self | <django_elasticsearch_dsl.search.Search object at 0x7f5184940c90> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/elasticsearch/client/utils.py
in _wrapped
if v is not None:
params[p] = _escape(v)
# don't treat ignore and request_timeout as other params to avoid escaping
for p in ('ignore', 'request_timeout'):
if p in kwargs:
params[p] = kwargs.pop(p)
return func(*args, params=params, **kwargs)...
return _wrapped
return _wrapper
class NamespacedClient(object):
def __init__(self, client):
Variable | Value |
---|---|
args | (<Elasticsearch([{'host': '10.0.100.13', 'port': 9200}])>,) |
es_query_params | ('allow_no_indices', 'analyze_wildcard', 'analyzer', 'default_operator', 'df', 'expand_wildcards', 'ignore_unavailable', 'lenient', 'min_score', 'preference', 'q', 'routing') |
func | <function Elasticsearch.count at 0x7f5185fa4050> |
kwargs | {'body': {'query': {'simple_query_string': {'fields': ['text'], 'query': 'Lyre'}}}, 'doc_type': ['doc'], 'index': ['iconolab_annotations']} |
p | 'request_timeout' |
params | {} |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/elasticsearch/client/__init__.py
in count
:arg q: Query in the Lucene query string syntax
:arg routing: Specific routing value
"""
if doc_type and not index:
index = '_all'
return self.transport.perform_request('GET', _make_path(index,
doc_type, '_count'), params=params, body=body)...
@query_params('_source', '_source_exclude', '_source_include', 'fields',
'pipeline', 'refresh', 'routing', 'timeout', 'wait_for_active_shards')
def bulk(self, body, index=None, doc_type=None, params=None):
"""
Perform many index/delete operations in a single API call.
Variable | Value |
---|---|
body | {'query': {'simple_query_string': {'fields': ['text'], 'query': 'Lyre'}}} |
doc_type | ['doc'] |
index | ['iconolab_annotations'] |
params | {} |
self | <Elasticsearch([{'host': '10.0.100.13', 'port': 9200}])> |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/elasticsearch/transport.py
in perform_request
if isinstance(ignore, int):
ignore = (ignore, )
for attempt in range(self.max_retries + 1):
connection = self.get_connection()
try:
status, headers_response, data = connection.perform_request(method, url, params, body, headers=headers, ignore=ignore, timeout=timeout)...
except TransportError as e:
if method == 'HEAD' and e.status_code == 404:
return False
retry = False
Variable | Value |
---|---|
attempt | 3 |
body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
connection | <Urllib3HttpConnection: http://10.0.100.13:9200> |
headers | None |
ignore | () |
method | 'GET' |
params | {} |
retry | True |
self | <elasticsearch.transport.Transport object at 0x7f5184821490> |
timeout | None |
url | '/iconolab_annotations/doc/_count' |
/srv/virtualenv/iconolab/lib/python3.7/site-packages/elasticsearch/connection/http_urllib3.py
in perform_request
raw_data = response.data.decode('utf-8')
except Exception as e:
self.log_request_fail(method, full_url, url, body, time.time() - start, exception=e)
if isinstance(e, UrllibSSLError):
raise SSLError('N/A', str(e), e)
if isinstance(e, ReadTimeoutError):
raise ConnectionTimeout('TIMEOUT', str(e), e)
raise ConnectionError('N/A', str(e), e)...
# raise errors based on http status codes, let the client handle those if needed
if not (200 <= response.status < 300) and response.status not in ignore:
self.log_request_fail(method, full_url, url, body, duration, response.status, raw_data)
self._raise_error(response.status, raw_data)
Variable | Value |
---|---|
body | b'{"query":{"simple_query_string":{"query":"Lyre","fields":["text"]}}}' |
full_url | 'http://10.0.100.13:9200/iconolab_annotations/doc/_count' |
headers | None |
ignore | () |
kw | {} |
method | 'GET' |
params | {} |
request_headers | {'connection': 'keep-alive', 'content-type': 'application/json'} |
self | <Urllib3HttpConnection: http://10.0.100.13:9200> |
start | 1711652331.713982 |
timeout | None |
url | '/iconolab_annotations/doc/_count' |
AnonymousUser
Variable | Value |
---|---|
q | 'Lyre' |
perpage | '10' |
No POST data
No FILES data
No cookie data
Variable | Value |
---|---|
CONTENT_LENGTH | '' |
CONTENT_TYPE | '' |
DOCUMENT_ROOT | '/etc/nginx/html' |
HTTPS | 'on' |
HTTP_ACCEPT | '*/*' |
HTTP_HOST | 'iconolab.iri-research.org' |
HTTP_USER_AGENT | 'claudebot' |
PATH_INFO | '/search/model/annotations' |
QUERY_STRING | 'q=Lyre&perpage=10' |
REMOTE_ADDR | '54.89.70.161' |
REMOTE_PORT | '59012' |
REQUEST_METHOD | 'GET' |
REQUEST_SCHEME | 'https' |
REQUEST_URI | '/search/model/annotations?q=Lyre&perpage=10' |
SCRIPT_NAME | '' |
SERVER_NAME | 'iconolab.iri-research.org' |
SERVER_PORT | '443' |
SERVER_PROTOCOL | 'HTTP/2.0' |
uwsgi.node | b'wes.iri.centrepompidou.fr' |
uwsgi.version | b'2.0.18' |
wsgi.errors | <_io.TextIOWrapper name=2 mode='w' encoding='UTF-8'> |
wsgi.file_wrapper | '' |
wsgi.input | <uwsgi._Input object at 0x7f518485f050> |
wsgi.multiprocess | False |
wsgi.multithread | False |
wsgi.run_once | False |
wsgi.url_scheme | 'https' |
wsgi.version | (1, 0) |
iconolab_settings
Setting | Value |
---|---|
ABSOLUTE_URL_OVERRIDES | {} |
ACCURATE_TAGS_MIN_SCORE | 3 |
ADMINS | [('iconolab admin', 'iconolab-admin@iri-research.org')] |
ALLOWED_HOSTS | ['iconolab.iri-research.org'] |
APPEND_SLASH | True |
AUTHENTICATION_BACKENDS | ['django.contrib.auth.backends.ModelBackend'] |
AUTH_PASSWORD_VALIDATORS | '********************' |
AUTH_USER_MODEL | 'auth.User' |
BASE_DIR | '/etc/www' |
BASE_URL | '/' |
CACHES | {'default': {'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', 'KEY_PREFIX': '********************', 'LOCATION': '127.0.0.1:11211'}} |
CACHE_MIDDLEWARE_ALIAS | 'default' |
CACHE_MIDDLEWARE_KEY_PREFIX | '********************' |
CACHE_MIDDLEWARE_SECONDS | 600 |
COMMENTS_APP | 'django_comments_xtd' |
COMMENTS_PER_PAGE_DEFAULT | 10 |
COMMENTS_XTD_FORM_CLASS | 'iconolab.forms.comments.IconolabCommentForm' |
COMMENTS_XTD_MAX_THREAD_LEVEL | 1 |
COMMENTS_XTD_MODEL | 'iconolab.models.IconolabComment' |
CONTACT_EMAIL | 'iconolab@iri-research.org' |
CSRF_COOKIE_AGE | 31449600 |
CSRF_COOKIE_DOMAIN | None |
CSRF_COOKIE_HTTPONLY | False |
CSRF_COOKIE_NAME | 'csrftoken' |
CSRF_COOKIE_PATH | '/' |
CSRF_COOKIE_SECURE | False |
CSRF_FAILURE_VIEW | 'django.views.csrf.csrf_failure' |
CSRF_HEADER_NAME | 'HTTP_X_CSRFTOKEN' |
CSRF_TRUSTED_ORIGINS | [] |
CSRF_USE_SESSIONS | False |
DATABASES | {'default': {'ATOMIC_REQUESTS': False, 'AUTOCOMMIT': True, 'CONN_MAX_AGE': 0, 'ENGINE': 'django.db.backends.postgresql', 'HOST': '10.0.100.12', 'NAME': 'iconolab', 'OPTIONS': {}, 'PASSWORD': '********************', 'PORT': '5432', 'TEST': {'CHARSET': None, 'COLLATION': None, 'MIRROR': None, 'NAME': None}, 'TIME_ZONE': None, 'USER': 'iri'}} |
DATABASE_ROUTERS | [] |
DATA_UPLOAD_MAX_MEMORY_SIZE | 2621440 |
DATA_UPLOAD_MAX_NUMBER_FIELDS | 1000 |
DATETIME_FORMAT | 'N j, Y, P' |
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'] |
DATE_FORMAT | 'N j, Y' |
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'] |
DEBUG | True |
DEBUG_PROPAGATE_EXCEPTIONS | False |
DECIMAL_SEPARATOR | '.' |
DEFAULT_CHARSET | 'utf-8' |
DEFAULT_CONTENT_TYPE | 'text/html' |
DEFAULT_EXCEPTION_REPORTER_FILTER | 'django.views.debug.SafeExceptionReporterFilter' |
DEFAULT_FILE_STORAGE | 'django.core.files.storage.FileSystemStorage' |
DEFAULT_FROM_EMAIL | 'iconolab@iri-research.org' |
DEFAULT_INDEX_TABLESPACE | '' |
DEFAULT_TABLESPACE | '' |
DEV_MODE | False |
DISALLOWED_USER_AGENTS | [] |
DJANGO_RUNSERVER | False |
ELASTICSEARCH_DSL | {'default': {'hosts': '10.0.100.13:9200'}} |
EMAIL_BACKEND | 'django.core.mail.backends.smtp.EmailBackend' |
EMAIL_HOST | 'smtp.sparkpostmail.com' |
EMAIL_HOST_PASSWORD | '********************' |
EMAIL_HOST_USER | 'SMTP_Injection' |
EMAIL_PORT | 587 |
EMAIL_SSL_CERTFILE | None |
EMAIL_SSL_KEYFILE | '********************' |
EMAIL_SUBJECT_PREFIX | '[Django] ' |
EMAIL_TIMEOUT | None |
EMAIL_USE_LOCALTIME | False |
EMAIL_USE_SSL | False |
EMAIL_USE_TLS | True |
FILE_CHARSET | 'utf-8' |
FILE_UPLOAD_DIRECTORY_PERMISSIONS | None |
FILE_UPLOAD_HANDLERS | ['django.core.files.uploadhandler.MemoryFileUploadHandler', 'django.core.files.uploadhandler.TemporaryFileUploadHandler'] |
FILE_UPLOAD_MAX_MEMORY_SIZE | 2621440 |
FILE_UPLOAD_PERMISSIONS | None |
FILE_UPLOAD_TEMP_DIR | None |
FIRST_DAY_OF_WEEK | 0 |
FIXTURE_DIRS | [] |
FORCE_SCRIPT_NAME | None |
FORMAT_MODULE_PATH | None |
FORM_RENDERER | 'django.forms.renderers.DjangoTemplates' |
HAYSTACK_CONNECTIONS | {'default': {'ENGINE': 'haystack.backends.elasticsearch_backend.ElasticsearchSearchEngine', 'INDEX_NAME': 'iconolab', 'URL': 'http://10.0.100.13:9200/'}} |
ICONOLAB_INDEXES_ANALYZER | {'annotations': CustomAnalyzer(filter=[BuiltinTokenFilter(), BuiltinTokenFilter(), CustomTokenFilter(articles=['l', 'm', 't', 'qu', 'n', 's', 'j', 'd', 'c', 'jusqu', 'quoiqu', 'lorsqu', 'puisqu'], articles_case=True), CustomTokenFilter(language='light_french')], tokenizer=BuiltinTokenizer()), 'items': CustomAnalyzer(filter=[BuiltinTokenFilter(), BuiltinTokenFilter(), CustomTokenFilter(articles=['l', 'm', 't', 'qu', 'n', 's', 'j', 'd', 'c', 'jusqu', 'quoiqu', 'lorsqu', 'puisqu'], articles_case=True), CustomTokenFilter(language='light_french')], tokenizer=BuiltinTokenizer())} |
ICONOLAB_INDEXES_CONFIG | {'annotations': {'number_of_replicas': 0, 'number_of_shards': 1}, 'items': {'number_of_replicas': 0, 'number_of_shards': 1}} |
ICONOLAB_INDEXES_DEFAULT_CONFIG | {'number_of_replicas': 0, 'number_of_shards': 1} |
ICONOLAB_INDEXES_FIELD_ANALYZER | {'annotations': CustomAnalyzer(filter=[BuiltinTokenFilter(), BuiltinTokenFilter(), CustomTokenFilter(articles=['l', 'm', 't', 'qu', 'n', 's', 'j', 'd', 'c', 'jusqu', 'quoiqu', 'lorsqu', 'puisqu'], articles_case=True), CustomTokenFilter(language='light_french')], tokenizer=BuiltinTokenizer()), 'items': CustomAnalyzer(filter=[BuiltinTokenFilter(), BuiltinTokenFilter(), CustomTokenFilter(articles=['l', 'm', 't', 'qu', 'n', 's', 'j', 'd', 'c', 'jusqu', 'quoiqu', 'lorsqu', 'puisqu'], articles_case=True), CustomTokenFilter(language='light_french')], tokenizer=BuiltinTokenizer())} |
ICONOLAB_INDEXES_QUERYSET_PAGINATION | 5000 |
ICONOLAB_MAX_IMAGE_PIXELS | None |
ICONOLAB_SEARCH_PAGE_SIZE | 10 |
IGNORABLE_404_URLS | [] |
IMG_CONVERSION_EXTS | ['.tif', '.tiff'] |
IMG_JPG_DEFAULT_QUALITY | 80 |
IMPORT_DEFAULT_FIELD_TO_FILENAME_IDENTIFIER | 'INV' |
IMPORT_FIELDS_DICT | {'APPL': [], 'AUTR': [], 'DECV': [], 'DENO': [], 'DIMS': ['Dimensions'], 'DOM': ['Domaine'], 'ECOLE': [], 'EPOCH': [], 'INV': ['No inventaire'], 'LIEUX': [], 'LOCA': ['Localisation'], 'MILL': [], 'PERI': ['Période'], 'PHOT': ['Photo'], 'REF': ['REFERENCE'], 'TECH': [], 'TITR': ['Titre']} |
IMPORT_LOGGER_NAME | '' |
IMPORT_LOG_FILE | '/var/log/www/iconolab/importcommand.log' |
INSTALLED_APPS | ['iconolab_mcc', 'iconolab.apps.IconolabApp', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'django.contrib.sites', 'django.contrib.humanize', 'django_comments', 'django_comments_xtd', 'django_elasticsearch_dsl', 'sorl.thumbnail', 'notifications'] |
INTERNAL_IPS | [] |
INTERNAL_TAGS_URL | '/' |
LANGUAGES | [('af', 'Afrikaans'), ('ar', 'Arabic'), ('ast', 'Asturian'), ('az', 'Azerbaijani'), ('bg', 'Bulgarian'), ('be', 'Belarusian'), ('bn', 'Bengali'), ('br', 'Breton'), ('bs', 'Bosnian'), ('ca', 'Catalan'), ('cs', 'Czech'), ('cy', 'Welsh'), ('da', 'Danish'), ('de', 'German'), ('dsb', 'Lower Sorbian'), ('el', 'Greek'), ('en', 'English'), ('en-au', 'Australian English'), ('en-gb', 'British English'), ('eo', 'Esperanto'), ('es', 'Spanish'), ('es-ar', 'Argentinian Spanish'), ('es-co', 'Colombian Spanish'), ('es-mx', 'Mexican Spanish'), ('es-ni', 'Nicaraguan Spanish'), ('es-ve', 'Venezuelan Spanish'), ('et', 'Estonian'), ('eu', 'Basque'), ('fa', 'Persian'), ('fi', 'Finnish'), ('fr', 'French'), ('fy', 'Frisian'), ('ga', 'Irish'), ('gd', 'Scottish Gaelic'), ('gl', 'Galician'), ('he', 'Hebrew'), ('hi', 'Hindi'), ('hr', 'Croatian'), ('hsb', 'Upper Sorbian'), ('hu', 'Hungarian'), ('ia', 'Interlingua'), ('id', 'Indonesian'), ('io', 'Ido'), ('is', 'Icelandic'), ('it', 'Italian'), ('ja', 'Japanese'), ('ka', 'Georgian'), ('kab', 'Kabyle'), ('kk', 'Kazakh'), ('km', 'Khmer'), ('kn', 'Kannada'), ('ko', 'Korean'), ('lb', 'Luxembourgish'), ('lt', 'Lithuanian'), ('lv', 'Latvian'), ('mk', 'Macedonian'), ('ml', 'Malayalam'), ('mn', 'Mongolian'), ('mr', 'Marathi'), ('my', 'Burmese'), ('nb', 'Norwegian Bokmål'), ('ne', 'Nepali'), ('nl', 'Dutch'), ('nn', 'Norwegian Nynorsk'), ('os', 'Ossetic'), ('pa', 'Punjabi'), ('pl', 'Polish'), ('pt', 'Portuguese'), ('pt-br', 'Brazilian Portuguese'), ('ro', 'Romanian'), ('ru', 'Russian'), ('sk', 'Slovak'), ('sl', 'Slovenian'), ('sq', 'Albanian'), ('sr', 'Serbian'), ('sr-latn', 'Serbian Latin'), ('sv', 'Swedish'), ('sw', 'Swahili'), ('ta', 'Tamil'), ('te', 'Telugu'), ('th', 'Thai'), ('tr', 'Turkish'), ('tt', 'Tatar'), ('udm', 'Udmurt'), ('uk', 'Ukrainian'), ('ur', 'Urdu'), ('vi', 'Vietnamese'), ('zh-hans', 'Simplified Chinese'), ('zh-hant', 'Traditional Chinese')] |
LANGUAGES_BIDI | ['he', 'ar', 'fa', 'ur'] |
LANGUAGE_CODE | 'fr-fr' |
LANGUAGE_COOKIE_AGE | None |
LANGUAGE_COOKIE_DOMAIN | None |
LANGUAGE_COOKIE_NAME | 'django_language' |
LANGUAGE_COOKIE_PATH | '/' |
LOCALE_PATHS | [] |
LOGGING | {'disable_existing_loggers': True, 'filters': {'require_debug_false': {'()': 'django.utils.log.RequireDebugFalse'}}, 'formatters': {'semi-verbose': {'format': '%(levelname)s %(asctime)s ' '%(module)s %(message)s'}, 'simple': {'format': '%(asctime)s - %(levelname)s : ' '%(message)s'}}, 'handlers': {'file': {'class': 'logging.FileHandler', 'filename': '/var/log/www/iconolab/django.log', 'formatter': 'semi-verbose', 'level': 10}, 'import_file': {'class': 'logging.FileHandler', 'filename': '/var/log/www/iconolab/importcommand.log', 'formatter': 'semi-verbose', 'level': 10}, 'mail_admins': {'class': 'django.utils.log.AdminEmailHandler', 'filters': ['require_debug_false'], 'level': 'ERROR'}, 'stream_to_console': {'class': 'logging.StreamHandler', 'level': 10}}, 'loggers': {'django.request': {'handlers': ['file'], 'level': 10, 'propagate': True}, 'iconolab': {'handlers': ['file'], 'level': 10, 'propagate': True}, 'import_command': {'handlers': ['import_file'], 'level': 10, 'propagate': False}}, 'version': 1} |
LOGGING_CONFIG | 'logging.config.dictConfig' |
LOGIN_REDIRECT_URL | '/accounts/profile/' |
LOGIN_URL | '/account/login/' |
LOGOUT_REDIRECT_URL | None |
LOG_FILE | '/var/log/www/iconolab/django.log' |
LOG_LEVEL | 10 |
MANAGERS | [('iconolab admin', 'iconolab-admin@iri-research.org')] |
MEDIA_ROOT | '/shared/iconolab/media' |
MEDIA_URL | '/media/' |
MESSAGE_STORAGE | 'django.contrib.messages.storage.fallback.FallbackStorage' |
MIDDLEWARE | ['django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware'] |
MIGRATION_MODULES | {} |
MONTH_DAY_FORMAT | 'F j' |
NOTIFICATIONS_NOTIFICATION_MODEL | 'notifications.Notification' |
NO_IMG_CONVERSION_EXTS | ['.jpg'] |
NUMBER_GROUPING | 0 |
PASSWORD_HASHERS | '********************' |
PASSWORD_RESET_TIMEOUT_DAYS | '********************' |
PREGENERATE_THUMBNAILS_SIZES | ['250x250', '100x100'] |
PREPEND_WWW | False |
RELEVANT_TAGS_MIN_SCORE | 3 |
ROOT_URLCONF | 'iconolab_mcc.urls' |
SECRET_KEY | '********************' |
SECURE_BROWSER_XSS_FILTER | False |
SECURE_CONTENT_TYPE_NOSNIFF | False |
SECURE_HSTS_INCLUDE_SUBDOMAINS | False |
SECURE_HSTS_PRELOAD | False |
SECURE_HSTS_SECONDS | 0 |
SECURE_PROXY_SSL_HEADER | ('HTTP_X_FORWARDED_PROTO', 'https') |
SECURE_REDIRECT_EXEMPT | [] |
SECURE_SSL_HOST | None |
SECURE_SSL_REDIRECT | False |
SERVER_EMAIL | 'iconolab@iri-research.org' |
SESSION_CACHE_ALIAS | 'default' |
SESSION_COOKIE_AGE | 1209600 |
SESSION_COOKIE_DOMAIN | None |
SESSION_COOKIE_HTTPONLY | True |
SESSION_COOKIE_NAME | 'sessionid' |
SESSION_COOKIE_PATH | '/' |
SESSION_COOKIE_SECURE | False |
SESSION_ENGINE | 'django.contrib.sessions.backends.db' |
SESSION_EXPIRE_AT_BROWSER_CLOSE | False |
SESSION_FILE_PATH | None |
SESSION_SAVE_EVERY_REQUEST | False |
SESSION_SERIALIZER | 'django.contrib.sessions.serializers.JSONSerializer' |
SETTINGS_MODULE | 'iconolab_settings' |
SHORT_DATETIME_FORMAT | 'm/d/Y P' |
SHORT_DATE_FORMAT | 'm/d/Y' |
SIGNING_BACKEND | 'django.core.signing.TimestampSigner' |
SILENCED_SYSTEM_CHECKS | [] |
SITE_ID | 1 |
SRC_JS_PATH | '/etc/www/../../src_js' |
STATICFILES_DIRS | [] |
STATICFILES_FINDERS | ['django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder'] |
STATICFILES_STORAGE | 'django.contrib.staticfiles.storage.StaticFilesStorage' |
STATIC_ROOT | '/shared/iconolab/static' |
STATIC_URL | '/static/' |
TEMPLATES | [{'APP_DIRS': True, 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [], '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']}}] |
TEST_NON_SERIALIZED_APPS | [] |
TEST_RUNNER | 'django.test.runner.DiscoverRunner' |
THOUSAND_SEPARATOR | ',' |
THUMBNAIL_DEBUG | True |
TIME_FORMAT | 'P' |
TIME_INPUT_FORMATS | ['%H:%M:%S', '%H:%M:%S.%f', '%H:%M'] |
TIME_ZONE | 'UTC' |
USE_ETAGS | False |
USE_I18N | True |
USE_L10N | True |
USE_THOUSAND_SEPARATOR | False |
USE_TZ | True |
USE_X_FORWARDED_HOST | False |
USE_X_FORWARDED_PORT | False |
WSGI_APPLICATION | 'iconolab_mcc.wsgi.application' |
X_FRAME_OPTIONS | 'SAMEORIGIN' |
YEAR_MONTH_FORMAT | 'F Y' |
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.