# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-08-20 00:03+0000\n"
"PO-Revision-Date: 2018-05-23 14:39+0000\n"
"Last-Translator: Adrian Liaw \n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
#: ../../library/asyncio-task.rst:6
msgid "Coroutines and Tasks"
msgstr ""
#: ../../library/asyncio-task.rst:8
msgid ""
"This section outlines high-level asyncio APIs to work with coroutines and "
"Tasks."
msgstr ""
#: ../../library/asyncio-task.rst:19 ../../library/asyncio-task.rst:148
msgid "Coroutines"
msgstr ""
#: ../../library/asyncio-task.rst:21
msgid "**Source code:** :source:`Lib/asyncio/coroutines.py`"
msgstr "****\\ :source:`Lib/asyncio/coroutines.py`"
#: ../../library/asyncio-task.rst:25
msgid ""
":term:`Coroutines ` declared with the async/await syntax is the "
"preferred way of writing asyncio applications. For example, the following "
"snippet of code prints \"hello\", waits 1 second, and then prints \"world\"::"
msgstr ""
#: ../../library/asyncio-task.rst:41
msgid ""
"Note that simply calling a coroutine will not schedule it to be executed::"
msgstr ""
#: ../../library/asyncio-task.rst:47
msgid "To actually run a coroutine, asyncio provides the following mechanisms:"
msgstr ""
#: ../../library/asyncio-task.rst:49
msgid ""
"The :func:`asyncio.run` function to run the top-level entry point \"main()\" "
"function (see the above example.)"
msgstr ""
#: ../../library/asyncio-task.rst:52
msgid ""
"Awaiting on a coroutine. The following snippet of code will print \"hello\" "
"after waiting for 1 second, and then print \"world\" after waiting for "
"*another* 2 seconds::"
msgstr ""
#: ../../library/asyncio-task.rst:73
msgid "Expected output::"
msgstr ""
#: ../../library/asyncio-task.rst:80
msgid ""
"The :func:`asyncio.create_task` function to run coroutines concurrently as "
"asyncio :class:`Tasks `."
msgstr ""
#: ../../library/asyncio-task.rst:83
msgid ""
"Let's modify the above example and run two ``say_after`` coroutines "
"*concurrently*::"
msgstr ""
#: ../../library/asyncio-task.rst:102
msgid ""
"Note that expected output now shows that the snippet runs 1 second faster "
"than before::"
msgstr ""
#: ../../library/asyncio-task.rst:110
msgid ""
"The :class:`asyncio.TaskGroup` class provides a more modern alternative to :"
"func:`create_task`. Using this API, the last example becomes::"
msgstr ""
#: ../../library/asyncio-task.rst:128
msgid "The timing and output should be the same as for the previous version."
msgstr ""
#: ../../library/asyncio-task.rst:130
msgid ":class:`asyncio.TaskGroup`."
msgstr ""
#: ../../library/asyncio-task.rst:137
msgid "Awaitables"
msgstr ""
#: ../../library/asyncio-task.rst:139
msgid ""
"We say that an object is an **awaitable** object if it can be used in an :"
"keyword:`await` expression. Many asyncio APIs are designed to accept "
"awaitables."
msgstr ""
#: ../../library/asyncio-task.rst:143
msgid ""
"There are three main types of *awaitable* objects: **coroutines**, "
"**Tasks**, and **Futures**."
msgstr ""
#: ../../library/asyncio-task.rst:149
msgid ""
"Python coroutines are *awaitables* and therefore can be awaited from other "
"coroutines::"
msgstr ""
#: ../../library/asyncio-task.rst:170
msgid ""
"In this documentation the term \"coroutine\" can be used for two closely "
"related concepts:"
msgstr ""
#: ../../library/asyncio-task.rst:173
msgid "a *coroutine function*: an :keyword:`async def` function;"
msgstr ""
#: ../../library/asyncio-task.rst:175
msgid ""
"a *coroutine object*: an object returned by calling a *coroutine function*."
msgstr ""
#: ../../library/asyncio-task.rst:180
msgid "Tasks"
msgstr ""
#: ../../library/asyncio-task.rst:181
msgid "*Tasks* are used to schedule coroutines *concurrently*."
msgstr ""
#: ../../library/asyncio-task.rst:183
msgid ""
"When a coroutine is wrapped into a *Task* with functions like :func:`asyncio."
"create_task` the coroutine is automatically scheduled to run soon::"
msgstr ""
#: ../../library/asyncio-task.rst:205
msgid "Futures"
msgstr ""
#: ../../library/asyncio-task.rst:206
msgid ""
"A :class:`Future` is a special **low-level** awaitable object that "
"represents an **eventual result** of an asynchronous operation."
msgstr ""
#: ../../library/asyncio-task.rst:209
msgid ""
"When a Future object is *awaited* it means that the coroutine will wait "
"until the Future is resolved in some other place."
msgstr ""
#: ../../library/asyncio-task.rst:212
msgid ""
"Future objects in asyncio are needed to allow callback-based code to be used "
"with async/await."
msgstr ""
#: ../../library/asyncio-task.rst:215
msgid ""
"Normally **there is no need** to create Future objects at the application "
"level code."
msgstr ""
#: ../../library/asyncio-task.rst:218
msgid ""
"Future objects, sometimes exposed by libraries and some asyncio APIs, can be "
"awaited::"
msgstr ""
#: ../../library/asyncio-task.rst:230
msgid ""
"A good example of a low-level function that returns a Future object is :meth:"
"`loop.run_in_executor`."
msgstr ""
#: ../../library/asyncio-task.rst:235
msgid "Creating Tasks"
msgstr ""
#: ../../library/asyncio-task.rst:237
msgid "**Source code:** :source:`Lib/asyncio/tasks.py`"
msgstr "****\\ :source:`Lib/asyncio/tasks.py`"
#: ../../library/asyncio-task.rst:243
msgid ""
"Wrap the *coro* :ref:`coroutine ` into a :class:`Task` and "
"schedule its execution. Return the Task object."
msgstr ""
#: ../../library/asyncio-task.rst:246
msgid ""
"If *name* is not ``None``, it is set as the name of the task using :meth:"
"`Task.set_name`."
msgstr ""
#: ../../library/asyncio-task.rst:249
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-task.rst:253
msgid ""
"The task is executed in the loop returned by :func:`get_running_loop`, :exc:"
"`RuntimeError` is raised if there is no running loop in current thread."
msgstr ""
#: ../../library/asyncio-task.rst:259
msgid ""
":meth:`asyncio.TaskGroup.create_task` is a new alternative leveraging "
"structural concurrency; it allows for waiting for a group of related tasks "
"with strong safety guarantees."
msgstr ""
#: ../../library/asyncio-task.rst:265
msgid ""
"Save a reference to the result of this function, to avoid a task "
"disappearing mid-execution. The event loop only keeps weak references to "
"tasks. A task that isn't referenced elsewhere may get garbage collected at "
"any time, even before it's done. For reliable \"fire-and-forget\" background "
"tasks, gather them in a collection::"
msgstr ""
#: ../../library/asyncio-task.rst:287 ../../library/asyncio-task.rst:1076
msgid "Added the *name* parameter."
msgstr " *name* "
#: ../../library/asyncio-task.rst:290 ../../library/asyncio-task.rst:1083
msgid "Added the *context* parameter."
msgstr " *context* "
#: ../../library/asyncio-task.rst:295
msgid "Task Cancellation"
msgstr ""
#: ../../library/asyncio-task.rst:297
msgid ""
"Tasks can easily and safely be cancelled. When a task is cancelled, :exc:"
"`asyncio.CancelledError` will be raised in the task at the next opportunity."
msgstr ""
#: ../../library/asyncio-task.rst:301
msgid ""
"It is recommended that coroutines use ``try/finally`` blocks to robustly "
"perform clean-up logic. In case :exc:`asyncio.CancelledError` is explicitly "
"caught, it should generally be propagated when clean-up is complete. :exc:"
"`asyncio.CancelledError` directly subclasses :exc:`BaseException` so most "
"code will not need to be aware of it."
msgstr ""
#: ../../library/asyncio-task.rst:307
msgid ""
"The asyncio components that enable structured concurrency, like :class:"
"`asyncio.TaskGroup` and :func:`asyncio.timeout`, are implemented using "
"cancellation internally and might misbehave if a coroutine swallows :exc:"
"`asyncio.CancelledError`. Similarly, user code should not generally call :"
"meth:`uncancel `. However, in cases when suppressing :"
"exc:`asyncio.CancelledError` is truly desired, it is necessary to also call "
"``uncancel()`` to completely remove the cancellation state."
msgstr ""
#: ../../library/asyncio-task.rst:319
msgid "Task Groups"
msgstr ""
#: ../../library/asyncio-task.rst:321
msgid ""
"Task groups combine a task creation API with a convenient and reliable way "
"to wait for all tasks in the group to finish."
msgstr ""
#: ../../library/asyncio-task.rst:326
msgid ""
"An :ref:`asynchronous context manager ` holding a "
"group of tasks. Tasks can be added to the group using :meth:`create_task`. "
"All tasks are awaited when the context manager exits."
msgstr ""
#: ../../library/asyncio-task.rst:335
msgid ""
"Create a task in this task group. The signature matches that of :func:"
"`asyncio.create_task`."
msgstr ""
#: ../../library/asyncio-task.rst:338 ../../library/asyncio-task.rst:472
#: ../../library/asyncio-task.rst:645 ../../library/asyncio-task.rst:703
#: ../../library/asyncio-task.rst:729 ../../library/asyncio-task.rst:772
#: ../../library/asyncio-task.rst:869
msgid "Example::"
msgstr ""
"\n"
"\n"
"::"
#: ../../library/asyncio-task.rst:346
msgid ""
"The ``async with`` statement will wait for all tasks in the group to finish. "
"While waiting, new tasks may still be added to the group (for example, by "
"passing ``tg`` into one of the coroutines and calling ``tg.create_task()`` "
"in that coroutine). Once the last task has finished and the ``async with`` "
"block is exited, no new tasks may be added to the group."
msgstr ""
#: ../../library/asyncio-task.rst:353
msgid ""
"The first time any of the tasks belonging to the group fails with an "
"exception other than :exc:`asyncio.CancelledError`, the remaining tasks in "
"the group are cancelled. No further tasks can then be added to the group. At "
"this point, if the body of the ``async with`` statement is still active (i."
"e., :meth:`~object.__aexit__` hasn't been called yet), the task directly "
"containing the ``async with`` statement is also cancelled. The resulting :"
"exc:`asyncio.CancelledError` will interrupt an ``await``, but it will not "
"bubble out of the containing ``async with`` statement."
msgstr ""
#: ../../library/asyncio-task.rst:363
msgid ""
"Once all tasks have finished, if any tasks have failed with an exception "
"other than :exc:`asyncio.CancelledError`, those exceptions are combined in "
"an :exc:`ExceptionGroup` or :exc:`BaseExceptionGroup` (as appropriate; see "
"their documentation) which is then raised."
msgstr ""
#: ../../library/asyncio-task.rst:370
msgid ""
"Two base exceptions are treated specially: If any task fails with :exc:"
"`KeyboardInterrupt` or :exc:`SystemExit`, the task group still cancels the "
"remaining tasks and waits for them, but then the initial :exc:"
"`KeyboardInterrupt` or :exc:`SystemExit` is re-raised instead of :exc:"
"`ExceptionGroup` or :exc:`BaseExceptionGroup`."
msgstr ""
#: ../../library/asyncio-task.rst:376
msgid ""
"If the body of the ``async with`` statement exits with an exception (so :"
"meth:`~object.__aexit__` is called with an exception set), this is treated "
"the same as if one of the tasks failed: the remaining tasks are cancelled "
"and then waited for, and non-cancellation exceptions are grouped into an "
"exception group and raised. The exception passed into :meth:`~object."
"__aexit__`, unless it is :exc:`asyncio.CancelledError`, is also included in "
"the exception group. The same special case is made for :exc:"
"`KeyboardInterrupt` and :exc:`SystemExit` as in the previous paragraph."
msgstr ""
#: ../../library/asyncio-task.rst:390
msgid "Sleeping"
msgstr ""
#: ../../library/asyncio-task.rst:394
msgid "Block for *delay* seconds."
msgstr ""
#: ../../library/asyncio-task.rst:396
msgid ""
"If *result* is provided, it is returned to the caller when the coroutine "
"completes."
msgstr ""
#: ../../library/asyncio-task.rst:399
msgid ""
"``sleep()`` always suspends the current task, allowing other tasks to run."
msgstr ""
#: ../../library/asyncio-task.rst:402
msgid ""
"Setting the delay to 0 provides an optimized path to allow other tasks to "
"run. This can be used by long-running functions to avoid blocking the event "
"loop for the full duration of the function call."
msgstr ""
#: ../../library/asyncio-task.rst:408
msgid ""
"Example of coroutine displaying the current date every second for 5 seconds::"
msgstr ""
#: ../../library/asyncio-task.rst:426 ../../library/asyncio-task.rst:521
#: ../../library/asyncio-task.rst:620 ../../library/asyncio-task.rst:767
#: ../../library/asyncio-task.rst:797 ../../library/asyncio-task.rst:849
#: ../../library/asyncio-task.rst:875
msgid "Removed the *loop* parameter."
msgstr " *loop* "
#: ../../library/asyncio-task.rst:431
msgid "Running Tasks Concurrently"
msgstr ""
#: ../../library/asyncio-task.rst:435
msgid ""
"Run :ref:`awaitable objects ` in the *aws* sequence "
"*concurrently*."
msgstr ""
#: ../../library/asyncio-task.rst:438
msgid ""
"If any awaitable in *aws* is a coroutine, it is automatically scheduled as a "
"Task."
msgstr ""
#: ../../library/asyncio-task.rst:441
msgid ""
"If all awaitables are completed successfully, the result is an aggregate "
"list of returned values. The order of result values corresponds to the "
"order of awaitables in *aws*."
msgstr ""
#: ../../library/asyncio-task.rst:445
msgid ""
"If *return_exceptions* is ``False`` (default), the first raised exception is "
"immediately propagated to the task that awaits on ``gather()``. Other "
"awaitables in the *aws* sequence **won't be cancelled** and will continue to "
"run."
msgstr ""
#: ../../library/asyncio-task.rst:450
msgid ""
"If *return_exceptions* is ``True``, exceptions are treated the same as "
"successful results, and aggregated in the result list."
msgstr ""
#: ../../library/asyncio-task.rst:453
msgid ""
"If ``gather()`` is *cancelled*, all submitted awaitables (that have not "
"completed yet) are also *cancelled*."
msgstr ""
#: ../../library/asyncio-task.rst:456
msgid ""
"If any Task or Future from the *aws* sequence is *cancelled*, it is treated "
"as if it raised :exc:`CancelledError` -- the ``gather()`` call is **not** "
"cancelled in this case. This is to prevent the cancellation of one "
"submitted Task/Future to cause other Tasks/Futures to be cancelled."
msgstr ""
#: ../../library/asyncio-task.rst:463
msgid ""
"A new alternative to create and run tasks concurrently and wait for their "
"completion is :class:`asyncio.TaskGroup`. *TaskGroup* provides stronger "
"safety guarantees than *gather* for scheduling a nesting of subtasks: if a "
"task (or a subtask, a task scheduled by a task) raises an exception, "
"*TaskGroup* will, while *gather* will not, cancel the remaining scheduled "
"tasks)."
msgstr ""
#: ../../library/asyncio-task.rst:510
msgid ""
"If *return_exceptions* is False, cancelling gather() after it has been "
"marked done won't cancel any submitted awaitables. For instance, gather can "
"be marked done after propagating an exception to the caller, therefore, "
"calling ``gather.cancel()`` after catching an exception (raised by one of "
"the awaitables) from gather won't cancel any other awaitables."
msgstr ""
#: ../../library/asyncio-task.rst:517
msgid ""
"If the *gather* itself is cancelled, the cancellation is propagated "
"regardless of *return_exceptions*."
msgstr ""
#: ../../library/asyncio-task.rst:524
msgid ""
"Deprecation warning is emitted if no positional arguments are provided or "
"not all positional arguments are Future-like objects and there is no running "
"event loop."
msgstr ""
#: ../../library/asyncio-task.rst:533
msgid "Eager Task Factory"
msgstr ""
#: ../../library/asyncio-task.rst:537
msgid "A task factory for eager task execution."
msgstr ""
#: ../../library/asyncio-task.rst:539
msgid ""
"When using this factory (via :meth:`loop.set_task_factory(asyncio."
"eager_task_factory) `), coroutines begin execution "
"synchronously during :class:`Task` construction. Tasks are only scheduled on "
"the event loop if they block. This can be a performance improvement as the "
"overhead of loop scheduling is avoided for coroutines that complete "
"synchronously."
msgstr ""
#: ../../library/asyncio-task.rst:545
msgid ""
"A common example where this is beneficial is coroutines which employ caching "
"or memoization to avoid actual I/O when possible."
msgstr ""
#: ../../library/asyncio-task.rst:550
msgid ""
"Immediate execution of the coroutine is a semantic change. If the coroutine "
"returns or raises, the task is never scheduled to the event loop. If the "
"coroutine execution blocks, the task is scheduled to the event loop. This "
"change may introduce behavior changes to existing applications. For example, "
"the application's task execution order is likely to change."
msgstr ""
#: ../../library/asyncio-task.rst:561
msgid ""
"Create an eager task factory, similar to :func:`eager_task_factory`, using "
"the provided *custom_task_constructor* when creating a new task instead of "
"the default :class:`Task`."
msgstr ""
#: ../../library/asyncio-task.rst:565
msgid ""
"*custom_task_constructor* must be a *callable* with the signature matching "
"the signature of :class:`Task.__init__ `. The callable must return a :"
"class:`asyncio.Task`-compatible object."
msgstr ""
#: ../../library/asyncio-task.rst:569
msgid ""
"This function returns a *callable* intended to be used as a task factory of "
"an event loop via :meth:`loop.set_task_factory(factory) `)."
msgstr ""
#: ../../library/asyncio-task.rst:576
msgid "Shielding From Cancellation"
msgstr ""
#: ../../library/asyncio-task.rst:580
msgid ""
"Protect an :ref:`awaitable object ` from being :meth:"
"`cancelled `."
msgstr ""
#: ../../library/asyncio-task.rst:583 ../../library/asyncio-task.rst:749
msgid "If *aw* is a coroutine it is automatically scheduled as a Task."
msgstr ""
#: ../../library/asyncio-task.rst:585
msgid "The statement::"
msgstr ""
#: ../../library/asyncio-task.rst:590
msgid "is equivalent to::"
msgstr ""
#: ../../library/asyncio-task.rst:594
msgid ""
"*except* that if the coroutine containing it is cancelled, the Task running "
"in ``something()`` is not cancelled. From the point of view of "
"``something()``, the cancellation did not happen. Although its caller is "
"still cancelled, so the \"await\" expression still raises a :exc:"
"`CancelledError`."
msgstr ""
#: ../../library/asyncio-task.rst:600
msgid ""
"If ``something()`` is cancelled by other means (i.e. from within itself) "
"that would also cancel ``shield()``."
msgstr ""
#: ../../library/asyncio-task.rst:603
msgid ""
"If it is desired to completely ignore cancellation (not recommended) the "
"``shield()`` function should be combined with a try/except clause, as "
"follows::"
msgstr ""
#: ../../library/asyncio-task.rst:615
msgid ""
"Save a reference to tasks passed to this function, to avoid a task "
"disappearing mid-execution. The event loop only keeps weak references to "
"tasks. A task that isn't referenced elsewhere may get garbage collected at "
"any time, even before it's done."
msgstr ""
#: ../../library/asyncio-task.rst:623
msgid ""
"Deprecation warning is emitted if *aw* is not Future-like object and there "
"is no running event loop."
msgstr ""
#: ../../library/asyncio-task.rst:629
msgid "Timeouts"
msgstr ""
#: ../../library/asyncio-task.rst:633
msgid ""
"Return an :ref:`asynchronous context manager ` that "
"can be used to limit the amount of time spent waiting on something."
msgstr ""
#: ../../library/asyncio-task.rst:637
msgid ""
"*delay* can either be ``None``, or a float/int number of seconds to wait. If "
"*delay* is ``None``, no time limit will be applied; this can be useful if "
"the delay is unknown when the context manager is created."
msgstr ""
#: ../../library/asyncio-task.rst:642
msgid ""
"In either case, the context manager can be rescheduled after creation using :"
"meth:`Timeout.reschedule`."
msgstr ""
#: ../../library/asyncio-task.rst:651
msgid ""
"If ``long_running_task`` takes more than 10 seconds to complete, the context "
"manager will cancel the current task and handle the resulting :exc:`asyncio."
"CancelledError` internally, transforming it into a :exc:`TimeoutError` which "
"can be caught and handled."
msgstr ""
#: ../../library/asyncio-task.rst:658
msgid ""
"The :func:`asyncio.timeout` context manager is what transforms the :exc:"
"`asyncio.CancelledError` into a :exc:`TimeoutError`, which means the :exc:"
"`TimeoutError` can only be caught *outside* of the context manager."
msgstr ""
#: ../../library/asyncio-task.rst:663
msgid "Example of catching :exc:`TimeoutError`::"
msgstr ""
#: ../../library/asyncio-task.rst:674
msgid ""
"The context manager produced by :func:`asyncio.timeout` can be rescheduled "
"to a different deadline and inspected."
msgstr ""
#: ../../library/asyncio-task.rst:679
msgid ""
"An :ref:`asynchronous context manager ` for "
"cancelling overdue coroutines."
msgstr ""
#: ../../library/asyncio-task.rst:682
msgid ""
"``when`` should be an absolute time at which the context should time out, as "
"measured by the event loop's clock:"
msgstr ""
#: ../../library/asyncio-task.rst:685
msgid "If ``when`` is ``None``, the timeout will never trigger."
msgstr ""
#: ../../library/asyncio-task.rst:686
msgid ""
"If ``when < loop.time()``, the timeout will trigger on the next iteration of "
"the event loop."
msgstr ""
#: ../../library/asyncio-task.rst:691
msgid ""
"Return the current deadline, or ``None`` if the current deadline is not set."
msgstr ""
#: ../../library/asyncio-task.rst:696
msgid "Reschedule the timeout."
msgstr ""
#: ../../library/asyncio-task.rst:700
msgid "Return whether the context manager has exceeded its deadline (expired)."
msgstr ""
#: ../../library/asyncio-task.rst:720
msgid "Timeout context managers can be safely nested."
msgstr ""
#: ../../library/asyncio-task.rst:726
msgid ""
"Similar to :func:`asyncio.timeout`, except *when* is the absolute time to "
"stop waiting, or ``None``."
msgstr ""
#: ../../library/asyncio-task.rst:746
msgid ""
"Wait for the *aw* :ref:`awaitable ` to complete with a "
"timeout."
msgstr ""
#: ../../library/asyncio-task.rst:751
msgid ""
"*timeout* can either be ``None`` or a float or int number of seconds to wait "
"for. If *timeout* is ``None``, block until the future completes."
msgstr ""
#: ../../library/asyncio-task.rst:755
msgid ""
"If a timeout occurs, it cancels the task and raises :exc:`TimeoutError`."
msgstr ""
#: ../../library/asyncio-task.rst:758
msgid ""
"To avoid the task :meth:`cancellation `, wrap it in :func:"
"`shield`."
msgstr ""
#: ../../library/asyncio-task.rst:761
msgid ""
"The function will wait until the future is actually cancelled, so the total "
"wait time may exceed the *timeout*. If an exception happens during "
"cancellation, it is propagated."
msgstr ""
#: ../../library/asyncio-task.rst:765
msgid "If the wait is cancelled, the future *aw* is also cancelled."
msgstr ""
#: ../../library/asyncio-task.rst:792
msgid ""
"When *aw* is cancelled due to a timeout, ``wait_for`` waits for *aw* to be "
"cancelled. Previously, it raised :exc:`TimeoutError` immediately."
msgstr ""
#: ../../library/asyncio-task.rst:802
msgid "Waiting Primitives"
msgstr ""
#: ../../library/asyncio-task.rst:806
msgid ""
"Run :class:`~asyncio.Future` and :class:`~asyncio.Task` instances in the "
"*aws* iterable concurrently and block until the condition specified by "
"*return_when*."
msgstr ""
#: ../../library/asyncio-task.rst:810
msgid "The *aws* iterable must not be empty."
msgstr ""
#: ../../library/asyncio-task.rst:812
msgid "Returns two sets of Tasks/Futures: ``(done, pending)``."
msgstr ""
#: ../../library/asyncio-task.rst:814
msgid "Usage::"
msgstr ""
"\n"
"\n"
"::"
#: ../../library/asyncio-task.rst:818
msgid ""
"*timeout* (a float or int), if specified, can be used to control the maximum "
"number of seconds to wait before returning."
msgstr ""
#: ../../library/asyncio-task.rst:821
msgid ""
"Note that this function does not raise :exc:`TimeoutError`. Futures or Tasks "
"that aren't done when the timeout occurs are simply returned in the second "
"set."
msgstr ""
#: ../../library/asyncio-task.rst:825
msgid ""
"*return_when* indicates when this function should return. It must be one of "
"the following constants:"
msgstr ""
#: ../../library/asyncio-task.rst:831
msgid "Constant"
msgstr ""
#: ../../library/asyncio-task.rst:831
msgid "Description"
msgstr ""
#: ../../library/asyncio-task.rst:833
msgid ":const:`FIRST_COMPLETED`"
msgstr ":const:`FIRST_COMPLETED`"
#: ../../library/asyncio-task.rst:833
msgid "The function will return when any future finishes or is cancelled."
msgstr ""
#: ../../library/asyncio-task.rst:836
msgid ":const:`FIRST_EXCEPTION`"
msgstr ":const:`FIRST_EXCEPTION`"
#: ../../library/asyncio-task.rst:836
msgid ""
"The function will return when any future finishes by raising an exception. "
"If no future raises an exception then it is equivalent to :const:"
"`ALL_COMPLETED`."
msgstr ""
#: ../../library/asyncio-task.rst:842
msgid ":const:`ALL_COMPLETED`"
msgstr ":const:`ALL_COMPLETED`"
#: ../../library/asyncio-task.rst:842
msgid "The function will return when all futures finish or are cancelled."
msgstr ""
#: ../../library/asyncio-task.rst:846
msgid ""
"Unlike :func:`~asyncio.wait_for`, ``wait()`` does not cancel the futures "
"when a timeout occurs."
msgstr ""
#: ../../library/asyncio-task.rst:852
msgid "Passing coroutine objects to ``wait()`` directly is forbidden."
msgstr ""
#: ../../library/asyncio-task.rst:855 ../../library/asyncio-task.rst:882
msgid "Added support for generators yielding tasks."
msgstr ""
#: ../../library/asyncio-task.rst:861
msgid ""
"Run :ref:`awaitable objects ` in the *aws* iterable "
"concurrently. Return an iterator of coroutines. Each coroutine returned can "
"be awaited to get the earliest next result from the iterable of the "
"remaining awaitables."
msgstr ""
#: ../../library/asyncio-task.rst:866
msgid ""
"Raises :exc:`TimeoutError` if the timeout occurs before all Futures are done."
msgstr ""
#: ../../library/asyncio-task.rst:878
msgid ""
"Deprecation warning is emitted if not all awaitable objects in the *aws* "
"iterable are Future-like objects and there is no running event loop."
msgstr ""
#: ../../library/asyncio-task.rst:887
msgid "Running in Threads"
msgstr ""
#: ../../library/asyncio-task.rst:891
msgid "Asynchronously run function *func* in a separate thread."
msgstr ""
#: ../../library/asyncio-task.rst:893
msgid ""
"Any \\*args and \\*\\*kwargs supplied for this function are directly passed "
"to *func*. Also, the current :class:`contextvars.Context` is propagated, "
"allowing context variables from the event loop thread to be accessed in the "
"separate thread."
msgstr ""
#: ../../library/asyncio-task.rst:898
msgid ""
"Return a coroutine that can be awaited to get the eventual result of *func*."
msgstr ""
#: ../../library/asyncio-task.rst:900
msgid ""
"This coroutine function is primarily intended to be used for executing IO-"
"bound functions/methods that would otherwise block the event loop if they "
"were run in the main thread. For example::"
msgstr ""
#: ../../library/asyncio-task.rst:930
msgid ""
"Directly calling ``blocking_io()`` in any coroutine would block the event "
"loop for its duration, resulting in an additional 1 second of run time. "
"Instead, by using ``asyncio.to_thread()``, we can run it in a separate "
"thread without blocking the event loop."
msgstr ""
#: ../../library/asyncio-task.rst:937
msgid ""
"Due to the :term:`GIL`, ``asyncio.to_thread()`` can typically only be used "
"to make IO-bound functions non-blocking. However, for extension modules that "
"release the GIL or alternative Python implementations that don't have one, "
"``asyncio.to_thread()`` can also be used for CPU-bound functions."
msgstr ""
#: ../../library/asyncio-task.rst:946
msgid "Scheduling From Other Threads"
msgstr ""
#: ../../library/asyncio-task.rst:950
msgid "Submit a coroutine to the given event loop. Thread-safe."
msgstr ""
#: ../../library/asyncio-task.rst:952
msgid ""
"Return a :class:`concurrent.futures.Future` to wait for the result from "
"another OS thread."
msgstr ""
#: ../../library/asyncio-task.rst:955
msgid ""
"This function is meant to be called from a different OS thread than the one "
"where the event loop is running. Example::"
msgstr ""
#: ../../library/asyncio-task.rst:967
msgid ""
"If an exception is raised in the coroutine, the returned Future will be "
"notified. It can also be used to cancel the task in the event loop::"
msgstr ""
#: ../../library/asyncio-task.rst:981
msgid ""
"See the :ref:`concurrency and multithreading ` "
"section of the documentation."
msgstr ""
#: ../../library/asyncio-task.rst:984
msgid ""
"Unlike other asyncio functions this function requires the *loop* argument to "
"be passed explicitly."
msgstr ""
#: ../../library/asyncio-task.rst:991
msgid "Introspection"
msgstr ""
#: ../../library/asyncio-task.rst:996
msgid ""
"Return the currently running :class:`Task` instance, or ``None`` if no task "
"is running."
msgstr ""
#: ../../library/asyncio-task.rst:999
msgid ""
"If *loop* is ``None`` :func:`get_running_loop` is used to get the current "
"loop."
msgstr ""
#: ../../library/asyncio-task.rst:1007
msgid "Return a set of not yet finished :class:`Task` objects run by the loop."
msgstr ""
#: ../../library/asyncio-task.rst:1010
msgid ""
"If *loop* is ``None``, :func:`get_running_loop` is used for getting current "
"loop."
msgstr ""
#: ../../library/asyncio-task.rst:1018
msgid "Return ``True`` if *obj* is a coroutine object."
msgstr ""
#: ../../library/asyncio-task.rst:1024
msgid "Task Object"
msgstr ""
#: ../../library/asyncio-task.rst:1028
msgid ""
"A :class:`Future-like ` object that runs a Python :ref:`coroutine "
"`. Not thread-safe."
msgstr ""
#: ../../library/asyncio-task.rst:1031
msgid ""
"Tasks are used to run coroutines in event loops. If a coroutine awaits on a "
"Future, the Task suspends the execution of the coroutine and waits for the "
"completion of the Future. When the Future is *done*, the execution of the "
"wrapped coroutine resumes."
msgstr ""
#: ../../library/asyncio-task.rst:1037
msgid ""
"Event loops use cooperative scheduling: an event loop runs one Task at a "
"time. While a Task awaits for the completion of a Future, the event loop "
"runs other Tasks, callbacks, or performs IO operations."
msgstr ""
#: ../../library/asyncio-task.rst:1042
msgid ""
"Use the high-level :func:`asyncio.create_task` function to create Tasks, or "
"the low-level :meth:`loop.create_task` or :func:`ensure_future` functions. "
"Manual instantiation of Tasks is discouraged."
msgstr ""
#: ../../library/asyncio-task.rst:1047
msgid ""
"To cancel a running Task use the :meth:`cancel` method. Calling it will "
"cause the Task to throw a :exc:`CancelledError` exception into the wrapped "
"coroutine. If a coroutine is awaiting on a Future object during "
"cancellation, the Future object will be cancelled."
msgstr ""
#: ../../library/asyncio-task.rst:1052
msgid ""
":meth:`cancelled` can be used to check if the Task was cancelled. The method "
"returns ``True`` if the wrapped coroutine did not suppress the :exc:"
"`CancelledError` exception and was actually cancelled."
msgstr ""
#: ../../library/asyncio-task.rst:1057
msgid ""
":class:`asyncio.Task` inherits from :class:`Future` all of its APIs except :"
"meth:`Future.set_result` and :meth:`Future.set_exception`."
msgstr ""
#: ../../library/asyncio-task.rst:1061
msgid ""
"An optional keyword-only *context* argument allows specifying a custom :"
"class:`contextvars.Context` for the *coro* to run in. If no *context* is "
"provided, the Task copies the current context and later runs its coroutine "
"in the copied context."
msgstr ""
#: ../../library/asyncio-task.rst:1066
msgid ""
"An optional keyword-only *eager_start* argument allows eagerly starting the "
"execution of the :class:`asyncio.Task` at task creation time. If set to "
"``True`` and the event loop is running, the task will start executing the "
"coroutine immediately, until the first time the coroutine blocks. If the "
"coroutine returns or raises without blocking, the task will be finished "
"eagerly and will skip scheduling to the event loop."
msgstr ""
#: ../../library/asyncio-task.rst:1073
msgid "Added support for the :mod:`contextvars` module."
msgstr ""
#: ../../library/asyncio-task.rst:1079
msgid ""
"Deprecation warning is emitted if *loop* is not specified and there is no "
"running event loop."
msgstr ""
#: ../../library/asyncio-task.rst:1086
msgid "Added the *eager_start* parameter."
msgstr " *eager_start* "
#: ../../library/asyncio-task.rst:1091
msgid "Return ``True`` if the Task is *done*."
msgstr ""
#: ../../library/asyncio-task.rst:1093
msgid ""
"A Task is *done* when the wrapped coroutine either returned a value, raised "
"an exception, or the Task was cancelled."
msgstr ""
#: ../../library/asyncio-task.rst:1098
msgid "Return the result of the Task."
msgstr ""
#: ../../library/asyncio-task.rst:1100
msgid ""
"If the Task is *done*, the result of the wrapped coroutine is returned (or "
"if the coroutine raised an exception, that exception is re-raised.)"
msgstr ""
#: ../../library/asyncio-task.rst:1104 ../../library/asyncio-task.rst:1118
msgid ""
"If the Task has been *cancelled*, this method raises a :exc:`CancelledError` "
"exception."
msgstr ""
#: ../../library/asyncio-task.rst:1107
msgid ""
"If the Task's result isn't yet available, this method raises a :exc:"
"`InvalidStateError` exception."
msgstr ""
#: ../../library/asyncio-task.rst:1112
msgid "Return the exception of the Task."
msgstr ""
#: ../../library/asyncio-task.rst:1114
msgid ""
"If the wrapped coroutine raised an exception that exception is returned. If "
"the wrapped coroutine returned normally this method returns ``None``."
msgstr ""
#: ../../library/asyncio-task.rst:1121
msgid ""
"If the Task isn't *done* yet, this method raises an :exc:`InvalidStateError` "
"exception."
msgstr ""
#: ../../library/asyncio-task.rst:1126
msgid "Add a callback to be run when the Task is *done*."
msgstr ""
#: ../../library/asyncio-task.rst:1128 ../../library/asyncio-task.rst:1137
msgid "This method should only be used in low-level callback-based code."
msgstr ""
#: ../../library/asyncio-task.rst:1130
msgid ""
"See the documentation of :meth:`Future.add_done_callback` for more details."
msgstr ""
#: ../../library/asyncio-task.rst:1135
msgid "Remove *callback* from the callbacks list."
msgstr ""
#: ../../library/asyncio-task.rst:1139
msgid ""
"See the documentation of :meth:`Future.remove_done_callback` for more "
"details."
msgstr ""
#: ../../library/asyncio-task.rst:1144
msgid "Return the list of stack frames for this Task."
msgstr ""
#: ../../library/asyncio-task.rst:1146
msgid ""
"If the wrapped coroutine is not done, this returns the stack where it is "
"suspended. If the coroutine has completed successfully or was cancelled, "
"this returns an empty list. If the coroutine was terminated by an exception, "
"this returns the list of traceback frames."
msgstr ""
#: ../../library/asyncio-task.rst:1152
msgid "The frames are always ordered from oldest to newest."
msgstr ""
#: ../../library/asyncio-task.rst:1154
msgid "Only one stack frame is returned for a suspended coroutine."
msgstr ""
#: ../../library/asyncio-task.rst:1156
msgid ""
"The optional *limit* argument sets the maximum number of frames to return; "
"by default all available frames are returned. The ordering of the returned "
"list differs depending on whether a stack or a traceback is returned: the "
"newest frames of a stack are returned, but the oldest frames of a traceback "
"are returned. (This matches the behavior of the traceback module.)"
msgstr ""
#: ../../library/asyncio-task.rst:1165
msgid "Print the stack or traceback for this Task."
msgstr ""
#: ../../library/asyncio-task.rst:1167
msgid ""
"This produces output similar to that of the traceback module for the frames "
"retrieved by :meth:`get_stack`."
msgstr ""
#: ../../library/asyncio-task.rst:1170
msgid "The *limit* argument is passed to :meth:`get_stack` directly."
msgstr ""
#: ../../library/asyncio-task.rst:1172
msgid ""
"The *file* argument is an I/O stream to which the output is written; by "
"default output is written to :data:`sys.stdout`."
msgstr ""
#: ../../library/asyncio-task.rst:1177
msgid "Return the coroutine object wrapped by the :class:`Task`."
msgstr ""
#: ../../library/asyncio-task.rst:1181
msgid ""
"This will return ``None`` for Tasks which have already completed eagerly. "
"See the :ref:`Eager Task Factory `."
msgstr ""
#: ../../library/asyncio-task.rst:1188
msgid "Newly added eager task execution means result may be ``None``."
msgstr ""
#: ../../library/asyncio-task.rst:1192
msgid ""
"Return the :class:`contextvars.Context` object associated with the task."
msgstr ""
#: ../../library/asyncio-task.rst:1199
msgid "Return the name of the Task."
msgstr ""
#: ../../library/asyncio-task.rst:1201
msgid ""
"If no name has been explicitly assigned to the Task, the default asyncio "
"Task implementation generates a default name during instantiation."
msgstr ""
#: ../../library/asyncio-task.rst:1209
msgid "Set the name of the Task."
msgstr ""
#: ../../library/asyncio-task.rst:1211
msgid ""
"The *value* argument can be any object, which is then converted to a string."
msgstr ""
#: ../../library/asyncio-task.rst:1214
msgid ""
"In the default Task implementation, the name will be visible in the :func:"
"`repr` output of a task object."
msgstr ""
#: ../../library/asyncio-task.rst:1221
msgid "Request the Task to be cancelled."
msgstr ""
#: ../../library/asyncio-task.rst:1223
msgid ""
"This arranges for a :exc:`CancelledError` exception to be thrown into the "
"wrapped coroutine on the next cycle of the event loop."
msgstr ""
#: ../../library/asyncio-task.rst:1226
msgid ""
"The coroutine then has a chance to clean up or even deny the request by "
"suppressing the exception with a :keyword:`try` ... ... ``except "
"CancelledError`` ... :keyword:`finally` block. Therefore, unlike :meth:"
"`Future.cancel`, :meth:`Task.cancel` does not guarantee that the Task will "
"be cancelled, although suppressing cancellation completely is not common and "
"is actively discouraged. Should the coroutine nevertheless decide to "
"suppress the cancellation, it needs to call :meth:`Task.uncancel` in "
"addition to catching the exception."
msgstr ""
#: ../../library/asyncio-task.rst:1236
msgid "Added the *msg* parameter."
msgstr " *msg* "
#: ../../library/asyncio-task.rst:1239
msgid "The ``msg`` parameter is propagated from cancelled task to its awaiter."
msgstr ""
#: ../../library/asyncio-task.rst:1244
msgid ""
"The following example illustrates how coroutines can intercept the "
"cancellation request::"
msgstr ""
#: ../../library/asyncio-task.rst:1283
msgid "Return ``True`` if the Task is *cancelled*."
msgstr ""
#: ../../library/asyncio-task.rst:1285
msgid ""
"The Task is *cancelled* when the cancellation was requested with :meth:"
"`cancel` and the wrapped coroutine propagated the :exc:`CancelledError` "
"exception thrown into it."
msgstr ""
#: ../../library/asyncio-task.rst:1291
msgid "Decrement the count of cancellation requests to this Task."
msgstr ""
#: ../../library/asyncio-task.rst:1293
msgid "Returns the remaining number of cancellation requests."
msgstr ""
#: ../../library/asyncio-task.rst:1295
msgid ""
"Note that once execution of a cancelled task completed, further calls to :"
"meth:`uncancel` are ineffective."
msgstr ""
#: ../../library/asyncio-task.rst:1300
msgid ""
"This method is used by asyncio's internals and isn't expected to be used by "
"end-user code. In particular, if a Task gets successfully uncancelled, this "
"allows for elements of structured concurrency like :ref:`taskgroups` and :"
"func:`asyncio.timeout` to continue running, isolating cancellation to the "
"respective structured block. For example::"
msgstr ""
#: ../../library/asyncio-task.rst:1318
msgid ""
"While the block with ``make_request()`` and ``make_another_request()`` might "
"get cancelled due to the timeout, ``unrelated_code()`` should continue "
"running even in case of the timeout. This is implemented with :meth:"
"`uncancel`. :class:`TaskGroup` context managers use :func:`uncancel` in a "
"similar fashion."
msgstr ""
#: ../../library/asyncio-task.rst:1324
msgid ""
"If end-user code is, for some reason, suppresing cancellation by catching :"
"exc:`CancelledError`, it needs to call this method to remove the "
"cancellation state."
msgstr ""
#: ../../library/asyncio-task.rst:1330
msgid ""
"Return the number of pending cancellation requests to this Task, i.e., the "
"number of calls to :meth:`cancel` less the number of :meth:`uncancel` calls."
msgstr ""
#: ../../library/asyncio-task.rst:1334
msgid ""
"Note that if this number is greater than zero but the Task is still "
"executing, :meth:`cancelled` will still return ``False``. This is because "
"this number can be lowered by calling :meth:`uncancel`, which can lead to "
"the task not being cancelled after all if the cancellation requests go down "
"to zero."
msgstr ""
#: ../../library/asyncio-task.rst:1340
msgid ""
"This method is used by asyncio's internals and isn't expected to be used by "
"end-user code. See :meth:`uncancel` for more details."
msgstr ""