# Python Documentation Turkish Translation

# Copyright (C) 2001-2024, Python Software Foundation

# This file is distributed under the same license as the Python package.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2024-11-01 00:21+0000\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: \n"

"Language-Team: TURKISH <python.docs.tr@gmail.com>\n"

"Language: tr\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

#: library/asyncio-eventloop.rst:8

msgid "Event Loop"

msgstr ""

#: library/asyncio-eventloop.rst:10

msgid ""

"**Source code:** :source:`Lib/asyncio/events.py`, :source:`Lib/asyncio/"

"base_events.py`"

msgstr ""

#: library/asyncio-eventloop.rst:16

msgid "Preface"

msgstr ""

#: library/asyncio-eventloop.rst:17

msgid ""

"The event loop is the core of every asyncio application. Event loops run "

"asynchronous tasks and callbacks, perform network IO operations, and run "

"subprocesses."

msgstr ""

#: library/asyncio-eventloop.rst:21

msgid ""

"Application developers should typically use the high-level asyncio "

"functions, such as :func:`asyncio.run`, and should rarely need to reference "

"the loop object or call its methods. This section is intended mostly for "

"authors of lower-level code, libraries, and frameworks, who need finer "

"control over the event loop behavior."

msgstr ""

#: library/asyncio-eventloop.rst:28

msgid "Obtaining the Event Loop"

msgstr ""

#: library/asyncio-eventloop.rst:29

msgid ""

"The following low-level functions can be used to get, set, or create an "

"event loop:"

msgstr ""

#: library/asyncio-eventloop.rst:34

msgid "Return the running event loop in the current OS thread."

msgstr ""

#: library/asyncio-eventloop.rst:36

msgid "Raise a :exc:`RuntimeError` if there is no running event loop."

msgstr ""

#: library/asyncio-eventloop.rst:38

msgid "This function can only be called from a coroutine or a callback."

msgstr ""

#: library/asyncio-eventloop.rst:44

msgid "Get the current event loop."

msgstr ""

#: library/asyncio-eventloop.rst:46

msgid ""

"When called from a coroutine or a callback (e.g. scheduled with call_soon or "

"similar API), this function will always return the running event loop."

msgstr ""

#: library/asyncio-eventloop.rst:50

msgid ""

"If there is no running event loop set, the function will return the result "

"of the ``get_event_loop_policy().get_event_loop()`` call."

msgstr ""

#: library/asyncio-eventloop.rst:53

msgid ""

"Because this function has rather complex behavior (especially when custom "

"event loop policies are in use), using the :func:`get_running_loop` function "

"is preferred to :func:`get_event_loop` in coroutines and callbacks."

msgstr ""

#: library/asyncio-eventloop.rst:58

msgid ""

"As noted above, consider using the higher-level :func:`asyncio.run` "

"function, instead of using these lower level functions to manually create "

"and close an event loop."

msgstr ""

#: library/asyncio-eventloop.rst:62

msgid ""

"Deprecation warning is emitted if there is no current event loop. In some "

"future Python release this will become an error."

msgstr ""

#: library/asyncio-eventloop.rst:68

msgid "Set *loop* as the current event loop for the current OS thread."

msgstr ""

#: library/asyncio-eventloop.rst:72

msgid "Create and return a new event loop object."

msgstr ""

#: library/asyncio-eventloop.rst:74

msgid ""

"Note that the behaviour of :func:`get_event_loop`, :func:`set_event_loop`, "

"and :func:`new_event_loop` functions can be altered by :ref:`setting a "

"custom event loop policy <asyncio-policies>`."

msgstr ""

#: library/asyncio-eventloop.rst:80

msgid "Contents"

msgstr ""

#: library/asyncio-eventloop.rst:81

msgid "This documentation page contains the following sections:"

msgstr ""

#: library/asyncio-eventloop.rst:83

msgid ""

"The `Event Loop Methods`_ section is the reference documentation of the "

"event loop APIs;"

msgstr ""

#: library/asyncio-eventloop.rst:86

msgid ""

"The `Callback Handles`_ section documents the :class:`Handle` and :class:"

"`TimerHandle` instances which are returned from scheduling methods such as :"

"meth:`loop.call_soon` and :meth:`loop.call_later`;"

msgstr ""

#: library/asyncio-eventloop.rst:90

msgid ""

"The `Server Objects`_ section documents types returned from event loop "

"methods like :meth:`loop.create_server`;"

msgstr ""

#: library/asyncio-eventloop.rst:93

msgid ""

"The `Event Loop Implementations`_ section documents the :class:"

"`SelectorEventLoop` and :class:`ProactorEventLoop` classes;"

msgstr ""

#: library/asyncio-eventloop.rst:96

msgid ""

"The `Examples`_ section showcases how to work with some event loop APIs."

msgstr ""

#: library/asyncio-eventloop.rst:103

msgid "Event Loop Methods"

msgstr ""

#: library/asyncio-eventloop.rst:105

msgid "Event loops have **low-level** APIs for the following:"

msgstr ""

#: library/asyncio-eventloop.rst:113

msgid "Running and stopping the loop"

msgstr ""

#: library/asyncio-eventloop.rst:117

msgid "Run until the *future* (an instance of :class:`Future`) has completed."

msgstr ""

#: library/asyncio-eventloop.rst:120

msgid ""

"If the argument is a :ref:`coroutine object <coroutine>` it is implicitly "

"scheduled to run as a :class:`asyncio.Task`."

msgstr ""

#: library/asyncio-eventloop.rst:123

msgid "Return the Future's result or raise its exception."

msgstr ""

#: library/asyncio-eventloop.rst:127

msgid "Run the event loop until :meth:`stop` is called."

msgstr ""

#: library/asyncio-eventloop.rst:129

msgid ""

"If :meth:`stop` is called before :meth:`run_forever` is called, the loop "

"will poll the I/O selector once with a timeout of zero, run all callbacks "

"scheduled in response to I/O events (and those that were already scheduled), "

"and then exit."

msgstr ""

#: library/asyncio-eventloop.rst:134

msgid ""

"If :meth:`stop` is called while :meth:`run_forever` is running, the loop "

"will run the current batch of callbacks and then exit. Note that new "

"callbacks scheduled by callbacks will not run in this case; instead, they "

"will run the next time :meth:`run_forever` or :meth:`run_until_complete` is "

"called."

msgstr ""

#: library/asyncio-eventloop.rst:142

msgid "Stop the event loop."

msgstr ""

#: library/asyncio-eventloop.rst:146

msgid "Return ``True`` if the event loop is currently running."

msgstr ""

#: library/asyncio-eventloop.rst:150

msgid "Return ``True`` if the event loop was closed."

msgstr ""

#: library/asyncio-eventloop.rst:154

msgid "Close the event loop."

msgstr ""

#: library/asyncio-eventloop.rst:156

msgid ""

"The loop must not be running when this function is called. Any pending "

"callbacks will be discarded."

msgstr ""

#: library/asyncio-eventloop.rst:159

msgid ""

"This method clears all queues and shuts down the executor, but does not wait "

"for the executor to finish."

msgstr ""

#: library/asyncio-eventloop.rst:162

msgid ""

"This method is idempotent and irreversible. No other methods should be "

"called after the event loop is closed."

msgstr ""

#: library/asyncio-eventloop.rst:167

msgid ""

"Schedule all currently open :term:`asynchronous generator` objects to close "

"with an :meth:`~agen.aclose` call. After calling this method, the event "

"loop will issue a warning if a new asynchronous generator is iterated. This "

"should be used to reliably finalize all scheduled asynchronous generators."

msgstr ""

#: library/asyncio-eventloop.rst:173

msgid ""

"Note that there is no need to call this function when :func:`asyncio.run` is "

"used."

msgstr ""

#: library/asyncio-eventloop.rst:176 library/asyncio-eventloop.rst:1253

#: library/asyncio-eventloop.rst:1671

msgid "Example::"

msgstr ""

#: library/asyncio-eventloop.rst:178

msgid ""

"try:\n"

" loop.run_forever()\n"

"finally:\n"

" loop.run_until_complete(loop.shutdown_asyncgens())\n"

" loop.close()"

msgstr ""

#: library/asyncio-eventloop.rst:188

msgid ""

"Schedule the closure of the default executor and wait for it to join all of "

"the threads in the :class:`~concurrent.futures.ThreadPoolExecutor`. Once "

"this method has been called, using the default executor with :meth:`loop."

"run_in_executor` will raise a :exc:`RuntimeError`."

msgstr ""

#: library/asyncio-eventloop.rst:194

msgid ""

"The *timeout* parameter specifies the amount of time (in :class:`float` "

"seconds) the executor will be given to finish joining. With the default, "

"``None``, the executor is allowed an unlimited amount of time."

msgstr ""

#: library/asyncio-eventloop.rst:199

msgid ""

"If the *timeout* is reached, a :exc:`RuntimeWarning` is emitted and the "

"default executor is terminated without waiting for its threads to finish "

"joining."

msgstr ""

#: library/asyncio-eventloop.rst:205

msgid ""

"Do not call this method when using :func:`asyncio.run`, as the latter "

"handles default executor shutdown automatically."

msgstr ""

#: library/asyncio-eventloop.rst:210

msgid "Added the *timeout* parameter."

msgstr ""

#: library/asyncio-eventloop.rst:214

msgid "Scheduling callbacks"

msgstr ""

#: library/asyncio-eventloop.rst:218

msgid ""

"Schedule the *callback* :term:`callback` to be called with *args* arguments "

"at the next iteration of the event loop."

msgstr ""

#: library/asyncio-eventloop.rst:221

msgid ""

"Return an instance of :class:`asyncio.Handle`, which can be used later to "

"cancel the callback."

msgstr ""

#: library/asyncio-eventloop.rst:224

msgid ""

"Callbacks are called in the order in which they are registered. Each "

"callback will be called exactly once."

msgstr ""

#: library/asyncio-eventloop.rst:227

msgid ""

"The optional keyword-only *context* argument specifies a custom :class:"

"`contextvars.Context` for the *callback* to run in. Callbacks use the "

"current context when no *context* is provided."

msgstr ""

#: library/asyncio-eventloop.rst:231

msgid "Unlike :meth:`call_soon_threadsafe`, this method is not thread-safe."

msgstr ""

#: library/asyncio-eventloop.rst:235

msgid ""

"A thread-safe variant of :meth:`call_soon`. When scheduling callbacks from "

"another thread, this function *must* be used, since :meth:`call_soon` is not "

"thread-safe."

msgstr ""

#: library/asyncio-eventloop.rst:239

msgid ""

"Raises :exc:`RuntimeError` if called on a loop that's been closed. This can "

"happen on a secondary thread when the main application is shutting down."

msgstr ""

#: library/asyncio-eventloop.rst:243

msgid ""

"See the :ref:`concurrency and multithreading <asyncio-multithreading>` "

"section of the documentation."

msgstr ""

#: library/asyncio-eventloop.rst:246 library/asyncio-eventloop.rst:296

#: library/asyncio-eventloop.rst:316

msgid ""

"The *context* keyword-only parameter was added. See :pep:`567` for more "

"details."

msgstr ""

#: library/asyncio-eventloop.rst:254

msgid ""

"Most :mod:`asyncio` scheduling functions don't allow passing keyword "

"arguments. To do that, use :func:`functools.partial`::"

msgstr ""

#: library/asyncio-eventloop.rst:257

msgid ""

"# will schedule \"print(\"Hello\", flush=True)\"\n"

"loop.call_soon(\n"

" functools.partial(print, \"Hello\", flush=True))"

msgstr ""

#: library/asyncio-eventloop.rst:261

msgid ""

"Using partial objects is usually more convenient than using lambdas, as "

"asyncio can render partial objects better in debug and error messages."

msgstr ""

#: library/asyncio-eventloop.rst:269

msgid "Scheduling delayed callbacks"

msgstr ""

#: library/asyncio-eventloop.rst:271

msgid ""

"Event loop provides mechanisms to schedule callback functions to be called "

"at some point in the future. Event loop uses monotonic clocks to track time."

msgstr ""

#: library/asyncio-eventloop.rst:278

msgid ""

"Schedule *callback* to be called after the given *delay* number of seconds "

"(can be either an int or a float)."

msgstr ""

#: library/asyncio-eventloop.rst:281 library/asyncio-eventloop.rst:313

msgid ""

"An instance of :class:`asyncio.TimerHandle` is returned which can be used to "

"cancel the callback."

msgstr ""

#: library/asyncio-eventloop.rst:284

msgid ""

"*callback* will be called exactly once. If two callbacks are scheduled for "

"exactly the same time, the order in which they are called is undefined."

msgstr ""

#: library/asyncio-eventloop.rst:288

msgid ""

"The optional positional *args* will be passed to the callback when it is "

"called. If you want the callback to be called with keyword arguments use :"

"func:`functools.partial`."

msgstr ""

#: library/asyncio-eventloop.rst:292

msgid ""

"An optional keyword-only *context* argument allows specifying a custom :"

"class:`contextvars.Context` for the *callback* to run in. The current "

"context is used when no *context* is provided."

msgstr ""

#: library/asyncio-eventloop.rst:300

msgid ""

"In Python 3.7 and earlier with the default event loop implementation, the "

"*delay* could not exceed one day. This has been fixed in Python 3.8."

msgstr ""

#: library/asyncio-eventloop.rst:307

msgid ""

"Schedule *callback* to be called at the given absolute timestamp *when* (an "

"int or a float), using the same time reference as :meth:`loop.time`."

msgstr ""

#: library/asyncio-eventloop.rst:311

msgid "This method's behavior is the same as :meth:`call_later`."

msgstr ""

#: library/asyncio-eventloop.rst:320

msgid ""

"In Python 3.7 and earlier with the default event loop implementation, the "

"difference between *when* and the current time could not exceed one day. "

"This has been fixed in Python 3.8."

msgstr ""

#: library/asyncio-eventloop.rst:327

msgid ""

"Return the current time, as a :class:`float` value, according to the event "

"loop's internal monotonic clock."

msgstr ""

#: library/asyncio-eventloop.rst:331

msgid ""

"In Python 3.7 and earlier timeouts (relative *delay* or absolute *when*) "

"should not exceed one day. This has been fixed in Python 3.8."

msgstr ""

#: library/asyncio-eventloop.rst:337

msgid "The :func:`asyncio.sleep` function."

msgstr ""

#: library/asyncio-eventloop.rst:341

msgid "Creating Futures and Tasks"

msgstr ""

#: library/asyncio-eventloop.rst:345

msgid "Create an :class:`asyncio.Future` object attached to the event loop."

msgstr ""

#: library/asyncio-eventloop.rst:347

msgid ""

"This is the preferred way to create Futures in asyncio. This lets third-"

"party event loops provide alternative implementations of the Future object "

"(with better performance or instrumentation)."

msgstr ""

#: library/asyncio-eventloop.rst:355

msgid ""

"Schedule the execution of :ref:`coroutine <coroutine>` *coro*. Return a :"

"class:`Task` object."

msgstr ""

#: library/asyncio-eventloop.rst:358

msgid ""

"Third-party event loops can use their own subclass of :class:`Task` for "

"interoperability. In this case, the result type is a subclass of :class:"

"`Task`."

msgstr ""

#: library/asyncio-eventloop.rst:362

msgid ""

"If the *name* argument is provided and not ``None``, it is set as the name "

"of the task using :meth:`Task.set_name`."

msgstr ""

#: library/asyncio-eventloop.rst:365

msgid ""

"An optional keyword-only *context* argument allows specifying a custom :"

"class:`contextvars.Context` for the *coro* to run in. The current context "

"copy is created when no *context* is provided."

msgstr ""

#: library/asyncio-eventloop.rst:369

msgid "Added the *name* parameter."

msgstr ""

#: library/asyncio-eventloop.rst:372

msgid "Added the *context* parameter."

msgstr ""

#: library/asyncio-eventloop.rst:377

msgid "Set a task factory that will be used by :meth:`loop.create_task`."

msgstr ""

#: library/asyncio-eventloop.rst:380

msgid ""

"If *factory* is ``None`` the default task factory will be set. Otherwise, "

"*factory* must be a *callable* with the signature matching ``(loop, coro, "

"context=None)``, where *loop* is a reference to the active event loop, and "

"*coro* is a coroutine object. The callable must return a :class:`asyncio."

"Future`-compatible object."

msgstr ""

#: library/asyncio-eventloop.rst:388

msgid "Return a task factory or ``None`` if the default one is in use."

msgstr ""

#: library/asyncio-eventloop.rst:392

msgid "Opening network connections"

msgstr ""

#: library/asyncio-eventloop.rst:403

msgid ""

"Open a streaming transport connection to a given address specified by *host* "

"and *port*."

msgstr ""

#: library/asyncio-eventloop.rst:406

msgid ""

"The socket family can be either :py:const:`~socket.AF_INET` or :py:const:"

"`~socket.AF_INET6` depending on *host* (or the *family* argument, if "

"provided)."

msgstr ""

#: library/asyncio-eventloop.rst:410

msgid "The socket type will be :py:const:`~socket.SOCK_STREAM`."

msgstr ""

#: library/asyncio-eventloop.rst:412 library/asyncio-eventloop.rst:1164

#: library/asyncio-eventloop.rst:1180

msgid ""

"*protocol_factory* must be a callable returning an :ref:`asyncio protocol "

"<asyncio-protocol>` implementation."

msgstr ""

#: library/asyncio-eventloop.rst:415

msgid ""

"This method will try to establish the connection in the background. When "

"successful, it returns a ``(transport, protocol)`` pair."

msgstr ""

#: library/asyncio-eventloop.rst:418

msgid "The chronological synopsis of the underlying operation is as follows:"

msgstr ""

#: library/asyncio-eventloop.rst:420

msgid ""

"The connection is established and a :ref:`transport <asyncio-transport>` is "

"created for it."

msgstr ""

#: library/asyncio-eventloop.rst:423

msgid ""

"*protocol_factory* is called without arguments and is expected to return a :"

"ref:`protocol <asyncio-protocol>` instance."

msgstr ""

#: library/asyncio-eventloop.rst:426

msgid ""

"The protocol instance is coupled with the transport by calling its :meth:"

"`~BaseProtocol.connection_made` method."

msgstr ""

#: library/asyncio-eventloop.rst:429

msgid "A ``(transport, protocol)`` tuple is returned on success."

msgstr ""

#: library/asyncio-eventloop.rst:431

msgid ""

"The created transport is an implementation-dependent bidirectional stream."

msgstr ""

#: library/asyncio-eventloop.rst:434 library/asyncio-eventloop.rst:566

msgid "Other arguments:"

msgstr ""

#: library/asyncio-eventloop.rst:436

msgid ""

"*ssl*: if given and not false, a SSL/TLS transport is created (by default a "

"plain TCP transport is created). If *ssl* is a :class:`ssl.SSLContext` "

"object, this context is used to create the transport; if *ssl* is :const:"

"`True`, a default context returned from :func:`ssl.create_default_context` "

"is used."

msgstr ""

#: library/asyncio-eventloop.rst:442

msgid ":ref:`SSL/TLS security considerations <ssl-security>`"

msgstr ""

#: library/asyncio-eventloop.rst:444

msgid ""

"*server_hostname* sets or overrides the hostname that the target server's "

"certificate will be matched against. Should only be passed if *ssl* is not "

"``None``. By default the value of the *host* argument is used. If *host* "

"is empty, there is no default and you must pass a value for "

"*server_hostname*. If *server_hostname* is an empty string, hostname "

"matching is disabled (which is a serious security risk, allowing for "

"potential man-in-the-middle attacks)."

msgstr ""

#: library/asyncio-eventloop.rst:452

msgid ""

"*family*, *proto*, *flags* are the optional address family, protocol and "

"flags to be passed through to getaddrinfo() for *host* resolution. If given, "

"these should all be integers from the corresponding :mod:`socket` module "

"constants."

msgstr ""

#: library/asyncio-eventloop.rst:457

msgid ""

"*happy_eyeballs_delay*, if given, enables Happy Eyeballs for this "

"connection. It should be a floating-point number representing the amount of "

"time in seconds to wait for a connection attempt to complete, before "

"starting the next attempt in parallel. This is the \"Connection Attempt "

"Delay\" as defined in :rfc:`8305`. A sensible default value recommended by "

"the RFC is ``0.25`` (250 milliseconds)."

msgstr ""

#: library/asyncio-eventloop.rst:465

msgid ""

"*interleave* controls address reordering when a host name resolves to "

"multiple IP addresses. If ``0`` or unspecified, no reordering is done, and "

"addresses are tried in the order returned by :meth:`getaddrinfo`. If a "

"positive integer is specified, the addresses are interleaved by address "

"family, and the given integer is interpreted as \"First Address Family "

"Count\" as defined in :rfc:`8305`. The default is ``0`` if "

"*happy_eyeballs_delay* is not specified, and ``1`` if it is."

msgstr ""

#: library/asyncio-eventloop.rst:474

msgid ""

"*sock*, if given, should be an existing, already connected :class:`socket."

"socket` object to be used by the transport. If *sock* is given, none of "

"*host*, *port*, *family*, *proto*, *flags*, *happy_eyeballs_delay*, "

"*interleave* and *local_addr* should be specified."

msgstr ""

#: library/asyncio-eventloop.rst:482 library/asyncio-eventloop.rst:597

#: library/asyncio-eventloop.rst:825

msgid ""

"The *sock* argument transfers ownership of the socket to the transport "

"created. To close the socket, call the transport's :meth:`~asyncio."

"BaseTransport.close` method."

msgstr ""

#: library/asyncio-eventloop.rst:486

msgid ""

"*local_addr*, if given, is a ``(local_host, local_port)`` tuple used to bind "

"the socket locally. The *local_host* and *local_port* are looked up using "

"``getaddrinfo()``, similarly to *host* and *port*."

msgstr ""

#: library/asyncio-eventloop.rst:490 library/asyncio-eventloop.rst:919

msgid ""

"*ssl_handshake_timeout* is (for a TLS connection) the time in seconds to "

"wait for the TLS handshake to complete before aborting the connection. "

"``60.0`` seconds if ``None`` (default)."

msgstr ""

#: library/asyncio-eventloop.rst:494 library/asyncio-eventloop.rst:742

#: library/asyncio-eventloop.rst:836 library/asyncio-eventloop.rst:923

msgid ""

"*ssl_shutdown_timeout* is the time in seconds to wait for the SSL shutdown "

"to complete before aborting the connection. ``30.0`` seconds if ``None`` "

"(default)."

msgstr ""

#: library/asyncio-eventloop.rst:498

msgid ""

"*all_errors* determines what exceptions are raised when a connection cannot "

"be created. By default, only a single ``Exception`` is raised: the first "

"exception if there is only one or all errors have same message, or a single "

"``OSError`` with the error messages combined. When ``all_errors`` is "

"``True``, an ``ExceptionGroup`` will be raised containing all exceptions "

"(even if there is only one)."

msgstr ""

#: library/asyncio-eventloop.rst:508 library/asyncio-eventloop.rst:754

msgid "Added support for SSL/TLS in :class:`ProactorEventLoop`."

msgstr ""

#: library/asyncio-eventloop.rst:512

msgid ""

"The socket option :ref:`socket.TCP_NODELAY <socket-unix-constants>` is set "

"by default for all TCP connections."

msgstr ""

#: library/asyncio-eventloop.rst:517 library/asyncio-eventloop.rst:846

msgid "Added the *ssl_handshake_timeout* parameter."

msgstr ""

#: library/asyncio-eventloop.rst:521

msgid "Added the *happy_eyeballs_delay* and *interleave* parameters."

msgstr ""

#: library/asyncio-eventloop.rst:523

msgid ""

"Happy Eyeballs Algorithm: Success with Dual-Stack Hosts. When a server's "

"IPv4 path and protocol are working, but the server's IPv6 path and protocol "

"are not working, a dual-stack client application experiences significant "

"connection delay compared to an IPv4-only client. This is undesirable "

"because it causes the dual-stack client to have a worse user experience. "

"This document specifies requirements for algorithms that reduce this user-"

"visible delay and provides an algorithm."

msgstr ""

#: library/asyncio-eventloop.rst:532

msgid "For more information: https://datatracker.ietf.org/doc/html/rfc6555"

msgstr ""

#: library/asyncio-eventloop.rst:536 library/asyncio-eventloop.rst:660

#: library/asyncio-eventloop.rst:768 library/asyncio-eventloop.rst:803

#: library/asyncio-eventloop.rst:850 library/asyncio-eventloop.rst:931

msgid "Added the *ssl_shutdown_timeout* parameter."

msgstr ""

#: library/asyncio-eventloop.rst:538

msgid "*all_errors* was added."

msgstr ""

#: library/asyncio-eventloop.rst:543

msgid ""

"The :func:`open_connection` function is a high-level alternative API. It "

"returns a pair of (:class:`StreamReader`, :class:`StreamWriter`) that can be "

"used directly in async/await code."

msgstr ""

#: library/asyncio-eventloop.rst:553

msgid "Create a datagram connection."

msgstr ""

#: library/asyncio-eventloop.rst:555

msgid ""

"The socket family can be either :py:const:`~socket.AF_INET`, :py:const:"

"`~socket.AF_INET6`, or :py:const:`~socket.AF_UNIX`, depending on *host* (or "

"the *family* argument, if provided)."

msgstr ""

#: library/asyncio-eventloop.rst:559

msgid "The socket type will be :py:const:`~socket.SOCK_DGRAM`."

msgstr ""

#: library/asyncio-eventloop.rst:561 library/asyncio-eventloop.rst:685

#: library/asyncio-eventloop.rst:817

msgid ""

"*protocol_factory* must be a callable returning a :ref:`protocol <asyncio-"

"protocol>` implementation."

msgstr ""

#: library/asyncio-eventloop.rst:564 library/asyncio-eventloop.rst:642

msgid "A tuple of ``(transport, protocol)`` is returned on success."

msgstr ""

#: library/asyncio-eventloop.rst:568

msgid ""

"*local_addr*, if given, is a ``(local_host, local_port)`` tuple used to bind "

"the socket locally. The *local_host* and *local_port* are looked up using :"

"meth:`getaddrinfo`."

msgstr ""

#: library/asyncio-eventloop.rst:572

msgid ""

"*remote_addr*, if given, is a ``(remote_host, remote_port)`` tuple used to "

"connect the socket to a remote address. The *remote_host* and *remote_port* "

"are looked up using :meth:`getaddrinfo`."

msgstr ""

#: library/asyncio-eventloop.rst:576

msgid ""

"*family*, *proto*, *flags* are the optional address family, protocol and "

"flags to be passed through to :meth:`getaddrinfo` for *host* resolution. If "

"given, these should all be integers from the corresponding :mod:`socket` "

"module constants."

msgstr ""

#: library/asyncio-eventloop.rst:581

msgid ""

"*reuse_port* tells the kernel to allow this endpoint to be bound to the same "

"port as other existing endpoints are bound to, so long as they all set this "

"flag when being created. This option is not supported on Windows and some "

"Unixes. If the :ref:`socket.SO_REUSEPORT <socket-unix-constants>` constant "

"is not defined then this capability is unsupported."

msgstr ""

#: library/asyncio-eventloop.rst:587

msgid ""

"*allow_broadcast* tells the kernel to allow this endpoint to send messages "

"to the broadcast address."

msgstr ""

#: library/asyncio-eventloop.rst:590

msgid ""

"*sock* can optionally be specified in order to use a preexisting, already "

"connected, :class:`socket.socket` object to be used by the transport. If "

"specified, *local_addr* and *remote_addr* should be omitted (must be :const:"

"`None`)."

msgstr ""

#: library/asyncio-eventloop.rst:601

msgid ""

"See :ref:`UDP echo client protocol <asyncio-udp-echo-client-protocol>` and :"

"ref:`UDP echo server protocol <asyncio-udp-echo-server-protocol>` examples."

msgstr ""

#: library/asyncio-eventloop.rst:604

msgid ""

"The *family*, *proto*, *flags*, *reuse_address*, *reuse_port*, "

"*allow_broadcast*, and *sock* parameters were added."

msgstr ""

#: library/asyncio-eventloop.rst:608

msgid "Added support for Windows."

msgstr ""

#: library/asyncio-eventloop.rst:611

msgid ""

"The *reuse_address* parameter is no longer supported, as using :ref:`socket."

"SO_REUSEADDR <socket-unix-constants>` poses a significant security concern "

"for UDP. Explicitly passing ``reuse_address=True`` will raise an exception."

msgstr ""

#: library/asyncio-eventloop.rst:617

msgid ""

"When multiple processes with differing UIDs assign sockets to an identical "

"UDP socket address with ``SO_REUSEADDR``, incoming packets can become "

"randomly distributed among the sockets."

msgstr ""

#: library/asyncio-eventloop.rst:621

msgid ""

"For supported platforms, *reuse_port* can be used as a replacement for "

"similar functionality. With *reuse_port*, :ref:`socket.SO_REUSEPORT <socket-"

"unix-constants>` is used instead, which specifically prevents processes with "

"differing UIDs from assigning sockets to the same socket address."

msgstr ""

#: library/asyncio-eventloop.rst:628

msgid ""

"The *reuse_address* parameter, disabled since Python 3.8.1, 3.7.6 and "

"3.6.10, has been entirely removed."

msgstr ""

#: library/asyncio-eventloop.rst:637

msgid "Create a Unix connection."

msgstr ""

#: library/asyncio-eventloop.rst:639

msgid ""

"The socket family will be :py:const:`~socket.AF_UNIX`; socket type will be :"

"py:const:`~socket.SOCK_STREAM`."

msgstr ""

#: library/asyncio-eventloop.rst:644

msgid ""

"*path* is the name of a Unix domain socket and is required, unless a *sock* "

"parameter is specified. Abstract Unix sockets, :class:`str`, :class:"

"`bytes`, and :class:`~pathlib.Path` paths are supported."

msgstr ""

#: library/asyncio-eventloop.rst:649

msgid ""

"See the documentation of the :meth:`loop.create_connection` method for "

"information about arguments to this method."

msgstr ""

#: library/asyncio-eventloop.rst:652 library/asyncio-eventloop.rst:794

#: library/asyncio-eventloop.rst:1233 library/asyncio-eventloop.rst:1741

#: library/asyncio-eventloop.rst:1748

msgid "Availability"

msgstr ""

#: library/asyncio-eventloop.rst:654

msgid ""

"Added the *ssl_handshake_timeout* parameter. The *path* parameter can now be "

"a :term:`path-like object`."

msgstr ""

#: library/asyncio-eventloop.rst:664

msgid "Creating network servers"

msgstr ""

#: library/asyncio-eventloop.rst:678

msgid ""

"Create a TCP server (socket type :const:`~socket.SOCK_STREAM`) listening on "

"*port* of the *host* address."

msgstr ""

#: library/asyncio-eventloop.rst:681

msgid "Returns a :class:`Server` object."

msgstr ""

#: library/asyncio-eventloop.rst:683

msgid "Arguments:"

msgstr ""

#: library/asyncio-eventloop.rst:688

msgid ""

"The *host* parameter can be set to several types which determine where the "

"server would be listening:"

msgstr ""

#: library/asyncio-eventloop.rst:691

msgid ""

"If *host* is a string, the TCP server is bound to a single network interface "

"specified by *host*."

msgstr ""

#: library/asyncio-eventloop.rst:694

msgid ""

"If *host* is a sequence of strings, the TCP server is bound to all network "

"interfaces specified by the sequence."

msgstr ""

#: library/asyncio-eventloop.rst:697

msgid ""

"If *host* is an empty string or ``None``, all interfaces are assumed and a "

"list of multiple sockets will be returned (most likely one for IPv4 and "

"another one for IPv6)."

msgstr ""

#: library/asyncio-eventloop.rst:701

msgid ""

"The *port* parameter can be set to specify which port the server should "

"listen on. If ``0`` or ``None`` (the default), a random unused port will be "

"selected (note that if *host* resolves to multiple network interfaces, a "

"different random port will be selected for each interface)."

msgstr ""

#: library/asyncio-eventloop.rst:706

msgid ""

"*family* can be set to either :const:`socket.AF_INET` or :const:`~socket."

"AF_INET6` to force the socket to use IPv4 or IPv6. If not set, the *family* "

"will be determined from host name (defaults to :const:`~socket.AF_UNSPEC`)."

msgstr ""

#: library/asyncio-eventloop.rst:711

msgid "*flags* is a bitmask for :meth:`getaddrinfo`."

msgstr ""

#: library/asyncio-eventloop.rst:713

msgid ""

"*sock* can optionally be specified in order to use a preexisting socket "

"object. If specified, *host* and *port* must not be specified."

msgstr ""

#: library/asyncio-eventloop.rst:718

msgid ""

"The *sock* argument transfers ownership of the socket to the server created. "

"To close the socket, call the server's :meth:`~asyncio.Server.close` method."

msgstr ""

#: library/asyncio-eventloop.rst:722

msgid ""

"*backlog* is the maximum number of queued connections passed to :meth:"

"`~socket.socket.listen` (defaults to 100)."

msgstr ""

#: library/asyncio-eventloop.rst:725

msgid ""

"*ssl* can be set to an :class:`~ssl.SSLContext` instance to enable TLS over "

"the accepted connections."

msgstr ""

#: library/asyncio-eventloop.rst:728

msgid ""

"*reuse_address* tells the kernel to reuse a local socket in ``TIME_WAIT`` "

"state, without waiting for its natural timeout to expire. If not specified "

"will automatically be set to ``True`` on Unix."

msgstr ""

#: library/asyncio-eventloop.rst:733

msgid ""

"*reuse_port* tells the kernel to allow this endpoint to be bound to the same "

"port as other existing endpoints are bound to, so long as they all set this "

"flag when being created. This option is not supported on Windows."

msgstr ""

#: library/asyncio-eventloop.rst:738

msgid ""

"*ssl_handshake_timeout* is (for a TLS server) the time in seconds to wait "

"for the TLS handshake to complete before aborting the connection. ``60.0`` "

"seconds if ``None`` (default)."