Lines Matching +full:srv +full:- +full:ipv4 +full:- +full:single +full:- +full:target
11 ------------------------------------
19 Application developers should typically use the high-level asyncio functions,
22 of lower-level code, libraries, and frameworks, who need finer control over
27 The following low-level functions can be used to get, set, or create
66 :ref:`setting a custom event loop policy <asyncio-policies>`.
90 .. _asyncio-event-loop:
95 Event loops have **low-level** APIs for the following:
188 An optional keyword-only *context* argument allows specifying a
195 This method is not thread-safe.
199 A thread-safe variant of :meth:`call_soon`. Must be used to
202 See the :ref:`concurrency and multithreading <asyncio-multithreading>`
206 The *context* keyword-only parameter was added. See :pep:`567`
209 .. _asyncio-pass-keywords:
225 .. _asyncio-delayed-calls:
251 An optional keyword-only *context* argument allows specifying a
256 The *context* keyword-only parameter was added. See :pep:`567`
276 The *context* keyword-only parameter was added. See :pep:`567`
307 third-party event loops provide alternative implementations of
317 Third-party event loops can use their own subclass of :class:`Task`
336 must return a :class:`asyncio.Future`-compatible object.
363 :ref:`asyncio protocol <asyncio-protocol>` implementation.
370 #. The connection is established and a :ref:`transport <asyncio-transport>`
374 return a :ref:`protocol <asyncio-protocol>` instance.
381 The created transport is an implementation-dependent bidirectional
392 .. seealso:: :ref:`SSL/TLS security considerations <ssl-security>`
394 * *server_hostname* sets or overrides the hostname that the target
400 risk, allowing for potential man-in-the-middle attacks).
409 be a floating-point number representing the amount of time in seconds
442 Happy Eyeballs Algorithm: Success with Dual-Stack Hosts.
443 When a server's IPv4 path and protocol are working, but the server's
444 IPv6 path and protocol are not working, a dual-stack client
446 IPv4-only client. This is undesirable because it causes the dual-
448 specifies requirements for algorithms that reduce this user-visible
468 The :func:`open_connection` function is a high-level alternative
502 :ref:`protocol <asyncio-protocol>` implementation.
535 See :ref:`UDP echo client protocol <asyncio-udp-echo-client-protocol>` and
536 :ref:`UDP echo server protocol <asyncio-udp-echo-server-protocol>` examples.
576 The *path* parameter can now be a :term:`path-like object`.
598 :ref:`protocol <asyncio-protocol>` implementation.
603 - If *host* is a string, the TCP server is bound to a single network
606 - If *host* is a sequence of strings, the TCP server is bound to all
609 - If *host* is an empty string or ``None``, all interfaces are
611 one for IPv4 and another one for IPv6).
614 :data:`~socket.AF_INET6` to force the socket to use IPv4 or IPv6.
668 The :func:`start_server` function is a higher-level alternative API
709 :ref:`protocol <asyncio-protocol>` implementation.
739 The method uses high-performance :meth:`os.sendfile` if available.
767 Upgrade an existing transport-based connection to TLS.
781 * *server_side* pass ``True`` when a server-side connection is being
784 * *server_hostname*: sets or overrides the host name that the target
814 <asyncio-pass-keywords>` to *callback*.
820 See also :ref:`Platform Support <asyncio-platform-support>` section
827 In general, protocol implementations that use transport-based APIs
841 *sock* must be a non-blocking socket.
855 *sock* must be a non-blocking socket.
870 *sock* must be a non-blocking socket.
883 *sock* must be a non-blocking socket.
909 *sock* must be a non-blocking socket.
923 Send a file using high-performance :mod:`os.sendfile` if possible.
928 *sock* must be a non-blocking :const:`socket.SOCK_STREAM`
947 *sock* must be a non-blocking socket.
979 :ref:`asyncio protocol <asyncio-protocol>` implementation.
981 *pipe* is a :term:`file-like object <file object>`.
988 non-blocking mode.
995 :ref:`asyncio protocol <asyncio-protocol>` implementation.
997 *pipe* is :term:`file-like object <file object>`.
1004 non-blocking mode.
1033 <asyncio-pass-keywords>` to *callback*.
1074 # CPU-bound operations will block the event loop:
1106 <asyncio-pass-keywords>` to *func*.
1176 * 'protocol' (optional): :ref:`Protocol <asyncio-protocol>` instance;
1177 * 'transport' (optional): :ref:`Transport <asyncio-transport>` instance;
1194 :envvar:`PYTHONASYNCIODEBUG` is set to a non-empty string, ``False``
1203 The new ``-X dev`` command line option can now also be used
1208 The :ref:`debug mode of asyncio <asyncio-debug-mode>`.
1214 Methods described in this subsections are low-level. In regular
1215 async/await code consider using the high-level
1223 <asyncio-windows-subprocess>` for details.
1236 :ref:`filesystem encoding <filesystem-encoding>`.
1245 a single argument which is list of strings, *subprocess_exec*
1255 * a file-like object representing a pipe to be connected to the
1267 * a file-like object representing a pipe to be connected to the
1279 * a file-like object representing a pipe to be connected to the
1313 :ref:`filesystem encoding <filesystem-encoding>`,
1390 srv = await loop.create_server(...)
1392 async with srv:
1395 # At this point, srv is closed and no longer accepts new connections.
1425 The *start_serving* keyword-only parameter to
1452 srv = await asyncio.start_server(
1454 await srv.serve_forever()
1480 .. _asyncio-event-loops:
1520 <https://docs.microsoft.com/en-ca/windows/desktop/FileIO/i-o-completion-ports>`_.
1525 Abstract base class for asyncio-compliant event loops.
1527 The :ref:`Event Loop Methods <asyncio-event-loop>` section lists all
1536 to use the low-level event loop APIs, such as :meth:`loop.run_forever`
1538 need to be written this way; consider using the high-level functions
1659 * Another similar :ref:`example <asyncio_example_create_connection-streams>`
1660 using the high-level :func:`asyncio.open_connection` function