HTTPConnectionPool(host='radio.nordtelekom.hu', port=8000): Max retries exceeded with url: /gazdasagiradio.m3u (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0>: Failed to establish a new connection: [Errno -2] Name or service not known'))
Request Method: | GET |
---|---|
Request URL: | https://broadcasts.com/feed/4211/ |
Django Version: | 3.2 |
Exception Type: | ConnectionError |
Exception Value: | HTTPConnectionPool(host='radio.nordtelekom.hu', port=8000): Max retries exceeded with url: /gazdasagiradio.m3u (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0>: Failed to establish a new connection: [Errno -2] Name or service not known')) |
Exception Location: | /var/django/radiosdbenv/lib/python3.9/site-packages/requests/adapters.py, line 516, in send |
Python Executable: | /var/django/radiosdbenv/bin/python3 |
Python Version: | 3.9.2 |
Python Path: | ['/var/django/radiosdbenv/radiosdbevo', '/var/django/radiosdbenv/radiosdbevo', '/var/django/radiosdbenv/bin', '/usr/lib/python39.zip', '/usr/lib/python3.9', '/usr/lib/python3.9/lib-dynload', '/var/django/radiosdbenv/lib/python3.9/site-packages'] |
Server time: | Thu, 28 Mar 2024 09:09:31 +0000 |
/var/django/radiosdbenv/lib/python3.9/site-packages/urllib3/connection.py
, line 159, in _new_conn
if self.source_address:
extra_kw["source_address"] = self.source_address
if self.socket_options:
extra_kw["socket_options"] = self.socket_options
try:
conn = connection.create_connection(…
(self._dns_host, self.port), self.timeout, **extra_kw
)
except SocketTimeout:
raise ConnectTimeoutError(
self,
Variable | Value |
---|---|
extra_kw | {'socket_options': [(6, 1, 1)]} |
self | <urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0> |
/var/django/radiosdbenv/lib/python3.9/site-packages/urllib3/util/connection.py
, line 61, in create_connection
err = None
# Using the value from allowed_gai_family() in the context of getaddrinfo lets
# us select whether to work with IPv4 DNS records, IPv6 records, or both.
# The original create_connection function always returns all records.
family = allowed_gai_family()
for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM):…
af, socktype, proto, canonname, sa = res
sock = None
try:
sock = socket.socket(af, socktype, proto)
# If provided, set socket level options before connecting.
Variable | Value |
---|---|
address | ('radio.nordtelekom.hu', 8000) |
err | None |
family | <AddressFamily.AF_UNSPEC: 0> |
host | 'radio.nordtelekom.hu' |
port | 8000 |
socket_options | [(6, 1, 1)] |
source_address | None |
timeout | None |
/usr/lib/python3.9/socket.py
, line 953, in getaddrinfo
The family, type and proto arguments can be optionally specified in order to
narrow the list of addresses returned. Passing zero as a value for each of
these arguments selects the full range of results.
"""
# We override this function since we want to translate the numeric family
# and socket type values to enum constants.
addrlist = []
for res in _socket.getaddrinfo(host, port, family, type, proto, flags):…
af, socktype, proto, canonname, sa = res
addrlist.append((_intenum_converter(af, AddressFamily),
_intenum_converter(socktype, SocketKind),
proto, canonname, sa))
return addrlist
Variable | Value |
---|---|
addrlist | [] |
family | <AddressFamily.AF_UNSPEC: 0> |
flags | 0 |
host | 'radio.nordtelekom.hu' |
port | 8000 |
proto | 0 |
type | <SocketKind.SOCK_STREAM: 1> |
/var/django/radiosdbenv/lib/python3.9/site-packages/urllib3/connectionpool.py
, line 670, in urlopen
is_new_proxy_conn = self.proxy is not None and not getattr(
conn, "sock", None
)
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,
Variable | Value |
---|---|
assert_same_host | False |
body | None |
body_pos | None |
chunked | False |
clean_exit | False |
conn | None |
err | None |
headers | {'User-Agent': 'python-requests/2.24.0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'} |
is_new_proxy_conn | False |
method | 'GET' |
pool_timeout | None |
redirect | False |
release_conn | False |
release_this_conn | True |
response_kw | {'decode_content': False, 'preload_content': False} |
retries | Retry(total=0, connect=None, read=False, redirect=None, status=None) |
self | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f8d01f2d430> |
timeout | Timeout(connect=None, read=None, total=None) |
timeout_obj | Timeout(connect=None, read=None, total=None) |
url | '/gazdasagiradio.m3u' |
/var/django/radiosdbenv/lib/python3.9/site-packages/urllib3/connectionpool.py
, line 392, 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 0x7f8d01f2d5e0> |
httplib_request_kw | {'body': None, 'headers': {'User-Agent': 'python-requests/2.24.0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'}} |
method | 'GET' |
self | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f8d01f2d430> |
timeout | Timeout(connect=None, read=None, total=None) |
timeout_obj | Timeout(connect=None, read=None, total=None) |
url | '/gazdasagiradio.m3u' |
/usr/lib/python3.9/http/client.py
, line 1255, 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 | None |
encode_chunked | False |
headers | {'User-Agent': 'python-requests/2.24.0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'} |
method | 'GET' |
self | <urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0> |
url | '/gazdasagiradio.m3u' |
/usr/lib/python3.9/http/client.py
, line 1301, 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 | None |
content_length | None |
encode_chunked | False |
hdr | 'Connection' |
header_names | frozenset({'user-agent', 'connection', 'accept-encoding', 'accept'}) |
headers | {'User-Agent': 'python-requests/2.24.0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'} |
method | 'GET' |
self | <urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0> |
skips | {'skip_accept_encoding': 1} |
url | '/gazdasagiradio.m3u' |
value | 'keep-alive' |
/usr/lib/python3.9/http/client.py
, line 1250, 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 | None |
self | <urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0> |
/usr/lib/python3.9/http/client.py
, line 1010, 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 | None |
msg | (b'GET /gazdasagiradio.m3u HTTP/1.1\r\nHost: radio.nordtelekom.hu:8000\r\nUser-' b'Agent: python-requests/2.24.0\r\nAccept-Encoding: gzip, deflate\r\nAccept: *' b'/*\r\nConnection: keep-alive\r\n\r\n') |
self | <urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0> |
/usr/lib/python3.9/http/client.py
, line 950, 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 /gazdasagiradio.m3u HTTP/1.1\r\nHost: radio.nordtelekom.hu:8000\r\nUser-' b'Agent: python-requests/2.24.0\r\nAccept-Encoding: gzip, deflate\r\nAccept: *' b'/*\r\nConnection: keep-alive\r\n\r\n') |
self | <urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0> |
/var/django/radiosdbenv/lib/python3.9/site-packages/urllib3/connection.py
, line 187, 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 putrequest(self, method, url, *args, **kwargs):
"""Send a request to the server"""
match = _CONTAINS_CONTROL_CHAR_RE.search(method)
if match:
Variable | Value |
---|---|
self | <urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0> |
/var/django/radiosdbenv/lib/python3.9/site-packages/urllib3/connection.py
, line 171, in _new_conn
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):
Variable | Value |
---|---|
extra_kw | {'socket_options': [(6, 1, 1)]} |
self | <urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0> |
/var/django/radiosdbenv/lib/python3.9/site-packages/requests/adapters.py
, line 439, in send
elif isinstance(timeout, TimeoutSauce):
pass
else:
timeout = TimeoutSauce(connect=timeout, read=timeout)
try:
if not chunked:
resp = conn.urlopen(…
method=request.method,
url=url,
body=request.body,
headers=request.headers,
redirect=False,
assert_same_host=False,
Variable | Value |
---|---|
cert | None |
chunked | False |
conn | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f8d01f2d430> |
proxies | OrderedDict() |
request | <PreparedRequest [GET]> |
self | <requests.adapters.HTTPAdapter object at 0x7f8d01f2fb20> |
stream | False |
timeout | Timeout(connect=None, read=None, total=None) |
url | '/gazdasagiradio.m3u' |
verify | True |
/var/django/radiosdbenv/lib/python3.9/site-packages/urllib3/connectionpool.py
, line 726, in urlopen
if isinstance(e, (BaseSSLError, CertificateError)):
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
Variable | Value |
---|---|
assert_same_host | False |
body | None |
body_pos | None |
chunked | False |
clean_exit | False |
conn | None |
err | None |
headers | {'User-Agent': 'python-requests/2.24.0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'} |
is_new_proxy_conn | False |
method | 'GET' |
pool_timeout | None |
redirect | False |
release_conn | False |
release_this_conn | True |
response_kw | {'decode_content': False, 'preload_content': False} |
retries | Retry(total=0, connect=None, read=False, redirect=None, status=None) |
self | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f8d01f2d430> |
timeout | Timeout(connect=None, read=None, total=None) |
timeout_obj | Timeout(connect=None, read=None, total=None) |
url | '/gazdasagiradio.m3u' |
/var/django/radiosdbenv/lib/python3.9/site-packages/urllib3/util/retry.py
, line 439, in increment
read=read,
redirect=redirect,
status=status_count,
history=history,
)
if new_retry.is_exhausted():
raise MaxRetryError(_pool, url, error or ResponseError(cause))…
log.debug("Incremented Retry for (url='%s'): %r", url, new_retry)
return new_retry
def __repr__(self):
Variable | Value |
---|---|
_pool | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f8d01f2d430> |
_stacktrace | <traceback object at 0x7f8d020c23c0> |
cause | 'unknown' |
connect | None |
error | NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0>: Failed to establish a new connection: [Errno -2] Name or service not known') |
history | (RequestHistory(method='GET', url='/gazdasagiradio.m3u', error=NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0>: Failed to establish a new connection: [Errno -2] Name or service not known'), status=None, redirect_location=None),) |
method | 'GET' |
new_retry | Retry(total=-1, connect=None, read=False, redirect=None, status=None) |
read | False |
redirect | None |
redirect_location | None |
response | None |
self | Retry(total=0, connect=None, read=False, redirect=None, status=None) |
status | None |
status_count | None |
total | -1 |
url | '/gazdasagiradio.m3u' |
/var/django/radiosdbenv/lib/python3.9/site-packages/django/core/handlers/exception.py
, line 47, in inner
response = await sync_to_async(response_for_exception, thread_sensitive=False)(request, exc)
return response
return inner
else:
@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(MaxRetryError("HTTPConnectionPool(host='radio.nordtelekom.hu', port=8000): Max retries exceeded with url: /gazdasagiradio.m3u (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f8d01f2d5e0>: Failed to establish a new connection: [Errno -2] Name or service not known'))")) |
get_response | <bound method BaseHandler._get_response of <django.core.handlers.wsgi.WSGIHandler object at 0x7f8d0306cca0>> |
request | <WSGIRequest: GET '/feed/4211/'> |
/var/django/radiosdbenv/lib/python3.9/site-packages/django/core/handlers/base.py
, line 181, in _get_response
if response is None:
wrapped_callback = self.make_view_atomic(callback)
# If it is an asynchronous view, run it in a subthread.
if asyncio.iscoroutinefunction(wrapped_callback):
wrapped_callback = async_to_sync(wrapped_callback)
try:
response = wrapped_callback(request, *callback_args, **callback_kwargs)…
except Exception as e:
response = self.process_exception_by_middleware(e, request)
if response is None:
raise
# Complain if the view returned None (a common error).
Variable | Value |
---|---|
callback | <function get_feed at 0x7f8d02c649d0> |
callback_args | () |
callback_kwargs | {'station_id': 4211} |
middleware_method | <bound method CsrfViewMiddleware.process_view of <django.middleware.csrf.CsrfViewMiddleware object at 0x7f8d02fbeac0>> |
request | <WSGIRequest: GET '/feed/4211/'> |
response | None |
self | <django.core.handlers.wsgi.WSGIHandler object at 0x7f8d0306cca0> |
wrapped_callback | <function get_feed at 0x7f8d02c649d0> |
/var/django/radiosdbenv/radiosdbevo/radiosdb/apps/evoradio/views.py
, line 250, in get_feed
"""
stationobj = get_object_or_404(EvoStations, pk=station_id)
if is_playlist(stationobj.url) is False:
return HttpResponseRedirect(stationobj.url)
final_url = handle_playlist_url(stationobj.url)…
if final_url is None:
return HttpResponseNotFound()
return HttpResponseRedirect(final_url)
Variable | Value |
---|---|
request | <WSGIRequest: GET '/feed/4211/'> |
station_id | 4211 |
stationobj | <EvoStations: Trend FM> |
/var/django/radiosdbenv/radiosdbevo/radiosdb/apps/evoradio/utils.py
, line 20, in handle_playlist_url
def handle_playlist_url(url):
"""
Loads the playlist contents and returns the first entry
:param url:
:return:
"""
contents = requests.get(url)…
c = contents.text.split("\n")
if len(c) == 0:
return None
return c[0].strip()
Variable | Value |
---|---|
url | 'http://radio.nordtelekom.hu:8000/gazdasagiradio.m3u' |
/var/django/radiosdbenv/lib/python3.9/site-packages/requests/api.py
, line 76, in get
in the query string for the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
"""
kwargs.setdefault('allow_redirects', True)
return request('get', url, params=params, **kwargs)…
def options(url, **kwargs):
r"""Sends an OPTIONS request.
:param url: URL for the new :class:`Request` object.
Variable | Value |
---|---|
kwargs | {'allow_redirects': True} |
params | None |
url | 'http://radio.nordtelekom.hu:8000/gazdasagiradio.m3u' |
/var/django/radiosdbenv/lib/python3.9/site-packages/requests/api.py
, line 61, in request
<Response [200]>
"""
# By using the 'with' statement we are sure the session is closed, thus we
# avoid leaving sockets open which can trigger a ResourceWarning in some
# cases, and look like a memory leak in others.
with sessions.Session() as session:
return session.request(method=method, url=url, **kwargs)…
def get(url, params=None, **kwargs):
r"""Sends a GET request.
:param url: URL for the new :class:`Request` object.
Variable | Value |
---|---|
kwargs | {'allow_redirects': True, 'params': None} |
method | 'get' |
session | <requests.sessions.Session object at 0x7f8d01ed20d0> |
url | 'http://radio.nordtelekom.hu:8000/gazdasagiradio.m3u' |
/var/django/radiosdbenv/lib/python3.9/site-packages/requests/sessions.py
, line 530, in request
# Send the request.
send_kwargs = {
'timeout': timeout,
'allow_redirects': allow_redirects,
}
send_kwargs.update(settings)
resp = self.send(prep, **send_kwargs)…
return resp
def get(self, url, **kwargs):
r"""Sends a GET request. Returns :class:`Response` object.
Variable | Value |
---|---|
allow_redirects | True |
auth | None |
cert | None |
cookies | None |
data | None |
files | None |
headers | None |
hooks | None |
json | None |
method | 'get' |
params | None |
prep | <PreparedRequest [GET]> |
proxies | {} |
req | <Request [GET]> |
self | <requests.sessions.Session object at 0x7f8d01ed20d0> |
send_kwargs | {'allow_redirects': True, 'cert': None, 'proxies': OrderedDict(), 'stream': False, 'timeout': None, 'verify': True} |
settings | {'cert': None, 'proxies': OrderedDict(), 'stream': False, 'verify': True} |
stream | None |
timeout | None |
url | 'http://radio.nordtelekom.hu:8000/gazdasagiradio.m3u' |
verify | None |
/var/django/radiosdbenv/lib/python3.9/site-packages/requests/sessions.py
, line 643, in send
# Get the appropriate adapter to use
adapter = self.get_adapter(url=request.url)
# Start time (approximately) of the request
start = preferred_clock()
# Send the request
r = adapter.send(request, **kwargs)…
# Total elapsed time of the request (approximately)
elapsed = preferred_clock() - start
r.elapsed = timedelta(seconds=elapsed)
# Response manipulation hooks
Variable | Value |
---|---|
adapter | <requests.adapters.HTTPAdapter object at 0x7f8d01f2fb20> |
allow_redirects | True |
hooks | {'response': []} |
kwargs | {'cert': None, 'proxies': OrderedDict(), 'stream': False, 'timeout': None, 'verify': True} |
request | <PreparedRequest [GET]> |
self | <requests.sessions.Session object at 0x7f8d01ed20d0> |
start | 1711616971.3770347 |
stream | False |
/var/django/radiosdbenv/lib/python3.9/site-packages/requests/adapters.py
, line 516, in send
if isinstance(e.reason, _ProxyError):
raise ProxyError(e, request=request)
if isinstance(e.reason, _SSLError):
# This branch is for urllib3 v1.22 and later.
raise SSLError(e, request=request)
raise ConnectionError(e, request=request)…
except ClosedPoolError as e:
raise ConnectionError(e, request=request)
except _ProxyError as e:
raise ProxyError(e)
Variable | Value |
---|---|
cert | None |
chunked | False |
conn | <urllib3.connectionpool.HTTPConnectionPool object at 0x7f8d01f2d430> |
proxies | OrderedDict() |
request | <PreparedRequest [GET]> |
self | <requests.adapters.HTTPAdapter object at 0x7f8d01f2fb20> |
stream | False |
timeout | Timeout(connect=None, read=None, total=None) |
url | '/gazdasagiradio.m3u' |
verify | True |
AnonymousUser
No GET data
No POST data
No FILES data
No cookie data
Variable | Value |
---|---|
HTTP_ACCEPT | '*/*' |
HTTP_CONNECTION | 'close' |
HTTP_HOST | 'broadcasts.com' |
HTTP_USER_AGENT | 'claudebot' |
HTTP_X_FORWARDED_FOR | '52.90.50.252' |
HTTP_X_FORWARDED_PROTO | 'https' |
HTTP_X_REAL_IP | '52.90.50.252' |
PATH_INFO | '/feed/4211/' |
QUERY_STRING | '' |
RAW_URI | '/feed/4211/' |
REMOTE_ADDR | '' |
REQUEST_METHOD | 'GET' |
SCRIPT_NAME | '' |
SERVER_NAME | 'broadcasts.com' |
SERVER_PORT | '443' |
SERVER_PROTOCOL | 'HTTP/1.0' |
SERVER_SOFTWARE | 'gunicorn/20.0.4' |
gunicorn.socket | <socket.socket fd=3, family=AddressFamily.AF_UNIX, type=SocketKind.SOCK_STREAM, proto=0, laddr=/var/django/radiosdbenv/radiosdbevo/myproject.sock> |
wsgi.errors | <gunicorn.http.wsgi.WSGIErrorsWrapper object at 0x7f8d01ed2d00> |
wsgi.file_wrapper | <class 'gunicorn.http.wsgi.FileWrapper'> |
wsgi.input | <gunicorn.http.body.Body object at 0x7f8d01ed2a60> |
wsgi.input_terminated | True |
wsgi.multiprocess | True |
wsgi.multithread | False |
wsgi.run_once | False |
wsgi.url_scheme | 'https' |
wsgi.version | (1, 0) |
radiosdb.settings
Setting | Value |
---|---|
ABSOLUTE_URL_OVERRIDES | {} |
ADMINS | [] |
ALLOWED_HOSTS | ['192.168.30.199', 'acoustic.wn.com', 'localhost', 'radiown.com', 'broadcasts.com', 'www.broadcasts.com', '195.149.84.120'] |
APPEND_SLASH | True |
APP_HOSTNAME | 'https://broadcasts.com' |
AUTHENTICATION_BACKENDS | ['django.contrib.auth.backends.ModelBackend'] |
AUTH_PASSWORD_VALIDATORS | '********************' |
AUTH_USER_MODEL | 'auth.User' |
BASE_DIR | '/var/django/radiosdbenv/radiosdbevo' |
CACHES | {'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'}} |
CACHE_HOST | 'localhost' |
CACHE_MIDDLEWARE_ALIAS | 'default' |
CACHE_MIDDLEWARE_KEY_PREFIX | '********************' |
CACHE_MIDDLEWARE_SECONDS | 600 |
CACHE_PORT | 11211 |
CELERY_ACCEPT_CONTENT | ['application/json'] |
CELERY_BROKER_URL | 'redis://localhost:6379/1' |
CELERY_RESULT_BACKEND | 'redis://localhost:6379/1' |
CELERY_RESULT_SERIALIZER | 'json' |
CELERY_TASK_SERIALIZER | 'json' |
CSRF_COOKIE_AGE | 31449600 |
CSRF_COOKIE_DOMAIN | None |
CSRF_COOKIE_HTTPONLY | False |
CSRF_COOKIE_NAME | 'csrftoken' |
CSRF_COOKIE_PATH | '/' |
CSRF_COOKIE_SAMESITE | 'Lax' |
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.mysql', 'HOST': '127.0.0.1', 'NAME': 'radiosdb', 'OPTIONS': {}, 'PASSWORD': '********************', 'PORT': '', 'TEST': {'CHARSET': None, 'COLLATION': None, 'MIGRATE': True, 'MIRROR': None, 'NAME': None}, 'TIME_ZONE': None, 'USER': 'root'}} |
DATABASE_ROUTERS | [] |
DATA_UPLOAD_MAX_MEMORY_SIZE | 2621440 |
DATA_UPLOAD_MAX_NUMBER_FIELDS | 10240 |
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', '%m/%d/%Y %H:%M:%S', '%m/%d/%Y %H:%M:%S.%f', '%m/%d/%Y %H:%M', '%m/%d/%y %H:%M:%S', '%m/%d/%y %H:%M:%S.%f', '%m/%d/%y %H:%M'] |
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_AUTO_FIELD | 'django.db.models.AutoField' |
DEFAULT_CHARSET | 'utf-8' |
DEFAULT_EXCEPTION_REPORTER | 'django.views.debug.ExceptionReporter' |
DEFAULT_EXCEPTION_REPORTER_FILTER | 'django.views.debug.SafeExceptionReporterFilter' |
DEFAULT_FILE_STORAGE | 'django.core.files.storage.FileSystemStorage' |
DEFAULT_FROM_EMAIL | 'webmaster@localhost' |
DEFAULT_HASHING_ALGORITHM | 'sha256' |
DEFAULT_INDEX_TABLESPACE | '' |
DEFAULT_TABLESPACE | '' |
DISALLOWED_USER_AGENTS | [] |
EMAIL_BACKEND | 'django.core.mail.backends.smtp.EmailBackend' |
EMAIL_HOST | 'smtp.mandrillapp.com' |
EMAIL_HOST_PASSWORD | '********************' |
EMAIL_HOST_USER | 'WN' |
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_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 | 420 |
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.elasticsearch2_backend.Elasticsearch2SearchEngine', 'INDEX_NAME': 'radiohaystack', 'URL': 'http://192.168.30.161:9200/'}} |
IGNORABLE_404_URLS | [] |
INSTALLED_APPS | ['django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'radiosdb.apps.radio', 'radiosdb.apps.evoradio', 'radiosdb.apps.audio', 'radiosdb.apps.podcasts', 'radiosdb.apps.audiobooks', 'radiosdb.apps.videos', 'radiosdb.apps.users', 'haystack'] |
INTERNAL_IPS | [] |
LANGUAGES | [('af', 'Afrikaans'), ('ar', 'Arabic'), ('ar-dz', 'Algerian 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'), ('hy', 'Armenian'), ('ia', 'Interlingua'), ('id', 'Indonesian'), ('ig', 'Igbo'), ('io', 'Ido'), ('is', 'Icelandic'), ('it', 'Italian'), ('ja', 'Japanese'), ('ka', 'Georgian'), ('kab', 'Kabyle'), ('kk', 'Kazakh'), ('km', 'Khmer'), ('kn', 'Kannada'), ('ko', 'Korean'), ('ky', 'Kyrgyz'), ('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'), ('tg', 'Tajik'), ('th', 'Thai'), ('tk', 'Turkmen'), ('tr', 'Turkish'), ('tt', 'Tatar'), ('udm', 'Udmurt'), ('uk', 'Ukrainian'), ('ur', 'Urdu'), ('uz', 'Uzbek'), ('vi', 'Vietnamese'), ('zh-hans', 'Simplified Chinese'), ('zh-hant', 'Traditional Chinese')] |
LANGUAGES_BIDI | ['he', 'ar', 'ar-dz', 'fa', 'ur'] |
LANGUAGE_CODE | 'en-us' |
LANGUAGE_COOKIE_AGE | None |
LANGUAGE_COOKIE_DOMAIN | None |
LANGUAGE_COOKIE_HTTPONLY | False |
LANGUAGE_COOKIE_NAME | 'django_language' |
LANGUAGE_COOKIE_PATH | '/' |
LANGUAGE_COOKIE_SAMESITE | None |
LANGUAGE_COOKIE_SECURE | False |
LOCALE_PATHS | [] |
LOGGING | {} |
LOGGING_CONFIG | 'logging.config.dictConfig' |
LOGIN_REDIRECT_URL | '/accounts/profile/' |
LOGIN_URL | '/accounts/login/' |
LOGOUT_REDIRECT_URL | None |
MANAGERS | [] |
MEDIA_ROOT | '/var/django/radiosdbenv/radiosdbevo/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' |
NUMBER_GROUPING | 0 |
PASSWORD_HASHERS | '********************' |
PASSWORD_RESET_TIMEOUT | '********************' |
PASSWORD_RESET_TIMEOUT_DAYS | '********************' |
PREPEND_WWW | False |
REDIS_STR | 'redis://:@localhost:/0' |
ROOT_URLCONF | 'radiosdb.urls' |
SECRET_KEY | '********************' |
SECURE_BROWSER_XSS_FILTER | False |
SECURE_CONTENT_TYPE_NOSNIFF | True |
SECURE_HSTS_INCLUDE_SUBDOMAINS | False |
SECURE_HSTS_PRELOAD | False |
SECURE_HSTS_SECONDS | 0 |
SECURE_PROXY_SSL_HEADER | None |
SECURE_REDIRECT_EXEMPT | [] |
SECURE_REFERRER_POLICY | 'same-origin' |
SECURE_SSL_HOST | None |
SECURE_SSL_REDIRECT | False |
SERVER_EMAIL | 'root@localhost' |
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_SAMESITE | 'Lax' |
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 | 'radiosdb.settings' |
SHORT_DATETIME_FORMAT | 'm/d/Y P' |
SHORT_DATE_FORMAT | 'm/d/Y' |
SIGNING_BACKEND | 'django.core.signing.TimestampSigner' |
SILENCED_SYSTEM_CHECKS | [] |
STATICFILES_DIRS | [] |
STATICFILES_FINDERS | ['django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder'] |
STATICFILES_STORAGE | 'django.contrib.staticfiles.storage.StaticFilesStorage' |
STATIC_ROOT | '/var/django/radiosdbenv/radiosdbevo/static' |
STATIC_URL | '/static/' |
STATS_KEY | '********************' |
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 | ',' |
TIME_FORMAT | 'P' |
TIME_INPUT_FORMATS | ['%H:%M:%S', '%H:%M:%S.%f', '%H:%M'] |
TIME_ZONE | 'UTC' |
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 | 'radiosdb.wsgi.application' |
X_FRAME_OPTIONS | 'DENY' |
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.