than a success code, an :exc:`SMTPConnectError` is raised. The optional
*timeout* parameter specifies a timeout in seconds for blocking operations
like the connection attempt (if not specified, the global default timeout
- setting will be used). If the timeout expires, :exc:`socket.timeout` is
+ setting will be used). If the timeout expires, :exc:`TimeoutError` is
raised. The optional source_address parameter allows binding
to some specific source address in a machine with multiple network
interfaces, and/or to some specific source TCP port. It takes a 2-tuple
.. exception:: timeout
+ A deprecated alias of :exc:`TimeoutError`.
+
A subclass of :exc:`OSError`, this exception is raised when a timeout
occurs on a socket which has had timeouts enabled via a prior call to
:meth:`~socket.settimeout` (or implicitly through
.. versionchanged:: 3.3
This class was made a subclass of :exc:`OSError`.
+ .. versionchanged:: 3.10
+ This class was made an alias of :exc:`TimeoutError`.
+
Constants
^^^^^^^^^
address family --- see above.)
If the connection is interrupted by a signal, the method waits until the
- connection completes, or raise a :exc:`socket.timeout` on timeout, if the
+ connection completes, or raise a :exc:`TimeoutError` on timeout, if the
signal handler doesn't raise an exception and the socket is blocking or has
a timeout. For non-blocking sockets, the method raises an
:exc:`InterruptedError` exception if the connection is interrupted by a
When a module does not define ``__loader__``, fall back to ``__spec__.loader``.
(Contributed by Brett Cannon in :issue:`42133`.)
+socket
+------
+
+The exception :exc:`socket.timeout` is now an alias of :exc:`TimeoutError`.
+(Contributed by Christian Heimes in :issue:`42413`.)
+
sys
---
method = getattr(self, mname)
method()
self.wfile.flush() #actually send the response if not already done.
- except socket.timeout as e:
+ except TimeoutError as e:
#a read or a write timed out. Discard this connection
self.log_error("Request timed out: %r", e)
self.close_connection = True
self.rpcclt.listening_sock.settimeout(10)
try:
self.rpcclt.accept()
- except socket.timeout:
+ except TimeoutError:
self.display_no_subprocess_error()
return None
self.rpcclt.register("console", self.tkconsole)
self.spawn_subprocess()
try:
self.rpcclt.accept()
- except socket.timeout:
+ except TimeoutError:
self.display_no_subprocess_error()
return None
self.transfer_path(with_cwd=with_cwd)
try:
while True:
if timeout and not selector_select(timeout):
- raise _socket.timeout('timed out')
+ raise TimeoutError('timed out')
if count:
blocksize = count - total_sent
if blocksize <= 0:
def filter_error(err):
n = getattr(err, 'errno', None)
- if (isinstance(err, socket.timeout) or
+ if (isinstance(err, TimeoutError) or
(isinstance(err, socket.gaierror) and n in gai_errnos) or
(isinstance(err, urllib.error.HTTPError) and
500 <= err.code <= 599) or
conn, addr = self._sock.accept()
except BlockingIOError:
continue
- except socket.timeout:
+ except TimeoutError:
if not self._active:
return
else:
try:
serv.listen()
conn, addr = serv.accept()
- except socket.timeout:
+ except TimeoutError:
pass
else:
n = 200
self.assertIs(EnvironmentError, OSError)
def test_socket_errors(self):
- self.assertIs(socket.error, IOError)
+ self.assertIs(socket.error, OSError)
self.assertIs(socket.gaierror.__base__, OSError)
self.assertIs(socket.herror.__base__, OSError)
- self.assertIs(socket.timeout.__base__, OSError)
+ self.assertIs(socket.timeout, TimeoutError)
def test_select_error(self):
self.assertIs(select.error, OSError)
self.evt.set()
try:
conn, addr = self.sock.accept()
- except socket.timeout:
+ except TimeoutError:
pass
else:
conn.sendall(b"1 Hola mundo\n")
_, server = self._setup(TimeoutHandler)
addr = server.server_address[1]
- with self.assertRaises(socket.timeout):
+ with self.assertRaises(TimeoutError):
client = self.imap_class("localhost", addr, timeout=0.001)
def test_with_statement(self):
conn, addr = serv.accept()
conn.send(b"+ Hola mundo\n")
conn.close()
- except socket.timeout:
+ except TimeoutError:
pass
finally:
serv.close()
while True:
write.send(chunk)
written += chunk_size
- except (BlockingIOError, socket.timeout):
+ except (BlockingIOError, TimeoutError):
pass
print(f"%s bytes written into the socketpair" % written, flush=True)
evt.set()
try:
conn, addr = serv.accept()
- except socket.timeout:
+ except TimeoutError:
pass
else:
n = 500
n -= 1
- except socket.timeout:
+ except TimeoutError:
pass
finally:
if not client_evt.is_set():
if with_timeout:
signal.signal(signal.SIGALRM, ok_handler)
signal.alarm(1)
- self.assertRaises(socket.timeout, c.sendall,
+ self.assertRaises(TimeoutError, c.sendall,
b"x" * support.SOCK_MAX_SIZE)
finally:
signal.alarm(0)
try:
while True:
self.sendmsgToServer([b"a"*512])
- except socket.timeout:
+ except TimeoutError:
pass
except OSError as exc:
if exc.errno != errno.ENOMEM:
# bpo-33937 the test randomly fails on Travis CI with
# "OSError: [Errno 12] Cannot allocate memory"
else:
- self.fail("socket.timeout not raised")
+ self.fail("TimeoutError not raised")
finally:
self.misc_event.set()
# Check that timeout works.
try:
self.serv_sock.settimeout(0.03)
- self.assertRaises(socket.timeout,
+ self.assertRaises(TimeoutError,
self.doRecvmsg, self.serv_sock, len(MSG))
finally:
self.misc_event.set()
self.cli_conn.settimeout(1)
self.read_file.read(3)
# First read raises a timeout
- self.assertRaises(socket.timeout, self.read_file.read, 1)
+ self.assertRaises(TimeoutError, self.read_file.read, 1)
# Second read is disallowed
with self.assertRaises(OSError) as ctx:
self.read_file.read(1)
class MockSocket(socket.socket):
def connect(self, *args):
- raise socket.timeout('timed out')
+ raise TimeoutError('timed out')
@contextlib.contextmanager
def mocked_socket_module(self):
with self.mocked_socket_module():
try:
socket.create_connection((HOST, 1234))
- except socket.timeout:
+ except TimeoutError:
pass
except OSError as exc:
if socket_helper.IPV6_ENABLED or exc.errno != errno.EAFNOSUPPORT:
raise
else:
- self.fail('socket.timeout not raised')
+ self.fail('TimeoutError not raised')
class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest):
def _testOutsideTimeout(self):
self.cli = sock = socket.create_connection((HOST, self.port), timeout=1)
- self.assertRaises(socket.timeout, lambda: sock.recv(5))
+ self.assertRaises(TimeoutError, lambda: sock.recv(5))
class TCPTimeoutTest(SocketTCPTest):
def raise_timeout(*args, **kwargs):
self.serv.settimeout(1.0)
self.serv.accept()
- self.assertRaises(socket.timeout, raise_timeout,
+ self.assertRaises(TimeoutError, raise_timeout,
"Error generating a timeout exception (TCP)")
def testTimeoutZero(self):
try:
self.serv.settimeout(0.0)
foo = self.serv.accept()
- except socket.timeout:
+ except TimeoutError:
self.fail("caught timeout instead of error (TCP)")
except OSError:
ok = True
try:
signal.alarm(2) # POSIX allows alarm to be up to 1 second early
foo = self.serv.accept()
- except socket.timeout:
+ except TimeoutError:
self.fail("caught timeout instead of Alarm")
except Alarm:
pass
def raise_timeout(*args, **kwargs):
self.serv.settimeout(1.0)
self.serv.recv(1024)
- self.assertRaises(socket.timeout, raise_timeout,
+ self.assertRaises(TimeoutError, raise_timeout,
"Error generating a timeout exception (UDP)")
def testTimeoutZero(self):
try:
self.serv.settimeout(0.0)
foo = self.serv.recv(1024)
- except socket.timeout:
+ except TimeoutError:
self.fail("caught timeout instead of error (UDP)")
except OSError:
ok = True
def raise_timeout(*args, **kwargs):
self.serv.settimeout(1.0)
self.serv.recv(1024)
- self.assertRaises(socket.timeout, raise_timeout,
+ self.assertRaises(TimeoutError, raise_timeout,
"Error generating a timeout exception (UDPLITE)")
def testTimeoutZero(self):
try:
self.serv.settimeout(0.0)
foo = self.serv.recv(1024)
- except socket.timeout:
+ except TimeoutError:
self.fail("caught timeout instead of error (UDPLITE)")
except OSError:
ok = True
self.assertTrue(issubclass(socket.herror, OSError))
self.assertTrue(issubclass(socket.gaierror, OSError))
self.assertTrue(issubclass(socket.timeout, OSError))
+ self.assertIs(socket.error, OSError)
+ self.assertIs(socket.timeout, TimeoutError)
def test_setblocking_invalidfd(self):
# Regression test for issue #28471
with socket.create_connection(address) as sock:
sock.settimeout(0.01)
meth = self.meth_from_sock(sock)
- self.assertRaises(socket.timeout, meth, file)
+ self.assertRaises(TimeoutError, meth, file)
def testWithTimeoutTriggeredSend(self):
conn = self.accept_conn()
handler = self.ConnectionHandler(self, newconn, connaddr)
handler.start()
handler.join()
- except socket.timeout:
+ except TimeoutError:
pass
except KeyboardInterrupt:
self.stop()
c.settimeout(0.2)
c.connect((host, port))
# Will attempt handshake and time out
- self.assertRaisesRegex(socket.timeout, "timed out",
+ self.assertRaisesRegex(TimeoutError, "timed out",
test_wrap_socket, c)
finally:
c.close()
c = test_wrap_socket(c)
c.settimeout(0.2)
# Will attempt handshake and time out
- self.assertRaisesRegex(socket.timeout, "timed out",
+ self.assertRaisesRegex(TimeoutError, "timed out",
c.connect, (host, port))
finally:
c.close()
try:
conn, addr = serv.accept()
conn.close()
- except socket.timeout:
+ except TimeoutError:
pass
finally:
serv.close()
"""
Test the specified socket method.
- The method is run at most `count` times and must raise a socket.timeout
+ The method is run at most `count` times and must raise a TimeoutError
within `timeout` + self.fuzz seconds.
"""
self.sock.settimeout(timeout)
t1 = time.monotonic()
try:
method(*args)
- except socket.timeout as e:
+ except TimeoutError as e:
delta = time.monotonic() - t1
break
else:
- self.fail('socket.timeout was not raised')
+ self.fail('TimeoutError was not raised')
# These checks should account for timing unprecision
self.assertLess(delta, timeout + self.fuzz)
self.assertGreater(delta, timeout - 1.0)
sock.settimeout(timeout)
try:
sock.connect((whitehole))
- except socket.timeout:
+ except TimeoutError:
pass
except OSError as err:
if err.errno == errno.ECONNREFUSED:
ioerror_peer_reset:
buf = f.read()
debug("read %d bytes" % len(buf))
- except socket.timeout:
+ except TimeoutError:
print("<timeout: %s>" % url, file=sys.stderr)
f.close()
time.sleep(0.1)
serv.handle_request()
numrequests -= 1
- except socket.timeout:
+ except TimeoutError:
pass
finally:
serv.socket.close()
serv.handle_request()
numrequests -= 1
- except socket.timeout:
+ except TimeoutError:
pass
finally:
serv.socket.close()
--- /dev/null
+The exception :exc:`socket.timeout` is now an alias of :exc:`TimeoutError`.
}
if (sockstate == SOCKET_HAS_TIMED_OUT) {
- PyErr_SetString(PySocketModule.timeout_error,
+ PyErr_SetString(PyExc_TimeoutError,
ERRSTR("The handshake operation timed out"));
goto error;
} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
sockstate = PySSL_select(sock, 1, timeout);
if (sockstate == SOCKET_HAS_TIMED_OUT) {
- PyErr_SetString(PySocketModule.timeout_error,
+ PyErr_SetString(PyExc_TimeoutError,
"The write operation timed out");
goto error;
} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
}
if (sockstate == SOCKET_HAS_TIMED_OUT) {
- PyErr_SetString(PySocketModule.timeout_error,
+ PyErr_SetString(PyExc_TimeoutError,
"The write operation timed out");
goto error;
} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
sockstate = SOCKET_OPERATION_OK;
if (sockstate == SOCKET_HAS_TIMED_OUT) {
- PyErr_SetString(PySocketModule.timeout_error,
+ PyErr_SetString(PyExc_TimeoutError,
"The read operation timed out");
goto error;
} else if (sockstate == SOCKET_IS_NONBLOCKING) {
if (sockstate == SOCKET_HAS_TIMED_OUT) {
if (err.ssl == SSL_ERROR_WANT_READ)
- PyErr_SetString(PySocketModule.timeout_error,
+ PyErr_SetString(PyExc_TimeoutError,
"The read operation timed out");
else
- PyErr_SetString(PySocketModule.timeout_error,
+ PyErr_SetString(PyExc_TimeoutError,
"The write operation timed out");
goto error;
}
by this module (but not argument type or memory errors, etc.). */
static PyObject *socket_herror;
static PyObject *socket_gaierror;
-static PyObject *socket_timeout;
/* A forward reference to the socket type object.
The sock_type variable contains pointers to various functions,
if (err)
*err = SOCK_TIMEOUT_ERR;
else
- PyErr_SetString(socket_timeout, "timed out");
+ PyErr_SetString(PyExc_TimeoutError, "timed out");
return -1;
}
/* Blocking mode for a Python socket object means that operations
like :meth:`recv` or :meth:`sendall` will block the execution of
the current thread until they are complete or aborted with a
- `socket.timeout` or `socket.error` errors. When timeout is `None`,
+ `TimeoutError` or `socket.error` errors. When timeout is `None`,
the underlying FD is in a blocking mode. When timeout is a positive
number, the FD is in a non-blocking mode, and socket ops are
implemented with a `select()` call.
}
if (interval <= 0) {
- PyErr_SetString(socket_timeout, "timed out");
+ PyErr_SetString(PyExc_TimeoutError, "timed out");
goto done;
}
}
return NULL;
Py_INCREF(socket_gaierror);
PyModule_AddObject(m, "gaierror", socket_gaierror);
- socket_timeout = PyErr_NewException("socket.timeout",
- PyExc_OSError, NULL);
- if (socket_timeout == NULL)
- return NULL;
- PySocketModuleAPI.timeout_error = socket_timeout;
- Py_INCREF(socket_timeout);
- PyModule_AddObject(m, "timeout", socket_timeout);
+
+ PySocketModuleAPI.timeout_error = PyExc_TimeoutError;
+ PyModule_AddObjectRef(m, "timeout", PyExc_TimeoutError);
+
Py_INCREF((PyObject *)&sock_type);
if (PyModule_AddObject(m, "SocketType",
(PyObject *)&sock_type) != 0)
projects / thirdparty / Python / cpython.git / commitdiff
