# 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-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:148

msgid "Coroutines"

msgstr ""

#: library/asyncio-task.rst:21

msgid "**Source code:** :source:`Lib/asyncio/coroutines.py`"

msgstr ""

#: library/asyncio-task.rst:25

msgid ""

":term:`Coroutines <coroutine>` 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:30

msgid ""

">>> import asyncio\n"

"\n"

">>> async def main():\n"

"... print('hello')\n"

"... await asyncio.sleep(1)\n"

"... print('world')\n"

"\n"

">>> asyncio.run(main())\n"

"hello\n"

"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:44

msgid ""

">>> main()\n"

"<coroutine object main at 0x1053bb7c8>"

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:56

msgid ""

"import asyncio\n"

"import time\n"

"\n"

"async def say_after(delay, what):\n"

" await asyncio.sleep(delay)\n"

" print(what)\n"

"\n"

"async def main():\n"

" print(f\"started at {time.strftime('%X')}\")\n"

"\n"

" await say_after(1, 'hello')\n"

" await say_after(2, 'world')\n"

"\n"

" print(f\"finished at {time.strftime('%X')}\")\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: library/asyncio-task.rst:73

msgid "Expected output::"

msgstr ""

#: library/asyncio-task.rst:75

msgid ""

"started at 17:13:52\n"

"hello\n"

"world\n"

"finished at 17:13:55"

msgstr ""

#: library/asyncio-task.rst:80

msgid ""

"The :func:`asyncio.create_task` function to run coroutines concurrently as "

"asyncio :class:`Tasks <Task>`."

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:86

msgid ""

"async def main():\n"

" task1 = asyncio.create_task(\n"

" say_after(1, 'hello'))\n"

"\n"

" task2 = asyncio.create_task(\n"

" say_after(2, 'world'))\n"

"\n"

" print(f\"started at {time.strftime('%X')}\")\n"

"\n"

" # Wait until both tasks are completed (should take\n"

" # around 2 seconds.)\n"

" await task1\n"

" await task2\n"

"\n"

" print(f\"finished at {time.strftime('%X')}\")"

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:105

msgid ""

"started at 17:14:32\n"

"hello\n"

"world\n"

"finished at 17:14:34"

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:114

msgid ""

"async def main():\n"

" async with asyncio.TaskGroup() as tg:\n"

" task1 = tg.create_task(\n"

" say_after(1, 'hello'))\n"

"\n"

" task2 = tg.create_task(\n"

" say_after(2, 'world'))\n"

"\n"

" print(f\"started at {time.strftime('%X')}\")\n"

"\n"

" # The await is implicit when the context manager exits.\n"

"\n"

" print(f\"finished at {time.strftime('%X')}\")"

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:152

msgid ""

"import asyncio\n"

"\n"

"async def nested():\n"

" return 42\n"

"\n"

"async def main():\n"

" # Nothing happens if we just call \"nested()\".\n"

" # A coroutine object is created but not awaited,\n"

" # so it *won't run at all*.\n"

" nested() # will raise a \"RuntimeWarning\".\n"

"\n"

" # Let's do it differently now and await it:\n"

" print(await nested()) # will print \"42\".\n"

"\n"

"asyncio.run(main())"

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:187

msgid ""

"import asyncio\n"

"\n"

"async def nested():\n"

" return 42\n"

"\n"

"async def main():\n"

" # Schedule nested() to run soon concurrently\n"

" # with \"main()\".\n"

" task = asyncio.create_task(nested())\n"

"\n"

" # \"task\" can now be used to cancel \"nested()\", or\n"

" # can simply be awaited to wait until it is complete:\n"

" await task\n"

"\n"

"asyncio.run(main())"

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:221

msgid ""

"async def main():\n"

" await function_that_returns_a_future_object()\n"

"\n"

" # this is also valid:\n"

" await asyncio.gather(\n"

" function_that_returns_a_future_object(),\n"

" some_python_coroutine()\n"

" )"

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 ""

#: library/asyncio-task.rst:243

msgid ""

"Wrap the *coro* :ref:`coroutine <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:272

msgid ""

"background_tasks = set()\n"

"\n"

"for i in range(10):\n"

" task = asyncio.create_task(some_coro(param=i))\n"

"\n"

" # Add task to the set. This creates a strong reference.\n"

" background_tasks.add(task)\n"

"\n"

" # To prevent keeping references to finished tasks forever,\n"

" # make each task remove its own reference from the set after\n"

" # completion:\n"

" task.add_done_callback(background_tasks.discard)"

msgstr ""

#: library/asyncio-task.rst:1122

msgid "Added the *name* parameter."

msgstr ""

#: library/asyncio-task.rst:1129

msgid "Added the *context* parameter."

msgstr ""

#: 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 <asyncio.Task.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 <async-context-managers>` 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:519 library/asyncio-task.rst:750

#: library/asyncio-task.rst:816 library/asyncio-task.rst:915

msgid "Example::"

msgstr ""

#: library/asyncio-task.rst:340

msgid ""

"async def main():\n"

" async with asyncio.TaskGroup() as tg:\n"

" task1 = tg.create_task(some_coro(...))\n"

" task2 = tg.create_task(another_coro(...))\n"

" print(f\"Both tasks have completed now: {task1.result()}, {task2."

"result()}\")"

msgstr ""

#: 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 "Terminating a Task Group"

msgstr ""

#: library/asyncio-task.rst:392

msgid ""

"While terminating a task group is not natively supported by the standard "

"library, termination can be achieved by adding an exception-raising task to "

"the task group and ignoring the raised exception:"

msgstr ""

#: library/asyncio-task.rst:396

msgid ""

"import asyncio\n"

"from asyncio import TaskGroup\n"

"\n"

"class TerminateTaskGroup(Exception):\n"

" \"\"\"Exception raised to terminate a task group.\"\"\"\n"

"\n"

"async def force_terminate_task_group():\n"

" \"\"\"Used to force termination of a task group.\"\"\"\n"

" raise TerminateTaskGroup()\n"

"\n"

"async def job(task_id, sleep_time):\n"

" print(f'Task {task_id}: start')\n"

" await asyncio.sleep(sleep_time)\n"

" print(f'Task {task_id}: done')\n"

"\n"

"async def main():\n"

" try:\n"

" async with TaskGroup() as group:\n"

" # spawn some tasks\n"

" group.create_task(job(1, 0.5))\n"

" group.create_task(job(2, 1.5))\n"

" # sleep for 1 second\n"

" await asyncio.sleep(1)\n"

" # add an exception-raising task to force the group to terminate\n"

" group.create_task(force_terminate_task_group())\n"

" except* TerminateTaskGroup:\n"

" pass\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: library/asyncio-task.rst:428

msgid "Expected output:"

msgstr ""

#: library/asyncio-task.rst:430

msgid ""

"Task 1: start\n"

"Task 2: start\n"

"Task 1: done"

msgstr ""

#: library/asyncio-task.rst:437

msgid "Sleeping"

msgstr ""

#: library/asyncio-task.rst:441

msgid "Block for *delay* seconds."

msgstr ""

#: library/asyncio-task.rst:443

msgid ""

"If *result* is provided, it is returned to the caller when the coroutine "

"completes."

msgstr ""

#: library/asyncio-task.rst:446

msgid ""

"``sleep()`` always suspends the current task, allowing other tasks to run."

msgstr ""

#: library/asyncio-task.rst:449

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:455

msgid ""

"Example of coroutine displaying the current date every second for 5 seconds::"

msgstr ""

#: library/asyncio-task.rst:458

msgid ""

"import asyncio\n"

"import datetime\n"

"\n"

"async def display_date():\n"

" loop = asyncio.get_running_loop()\n"

" end_time = loop.time() + 5.0\n"

" while True:\n"

" print(datetime.datetime.now())\n"

" if (loop.time() + 1.0) >= end_time:\n"

" break\n"

" await asyncio.sleep(1)\n"

"\n"

"asyncio.run(display_date())"

msgstr ""

#: library/asyncio-task.rst:568 library/asyncio-task.rst:841

#: library/asyncio-task.rst:921

msgid "Removed the *loop* parameter."

msgstr ""

#: library/asyncio-task.rst:478

msgid "Running Tasks Concurrently"

msgstr ""

#: library/asyncio-task.rst:482

msgid ""

"Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* sequence "

"*concurrently*."

msgstr ""

#: library/asyncio-task.rst:485

msgid ""

"If any awaitable in *aws* is a coroutine, it is automatically scheduled as a "

"Task."

msgstr ""

#: library/asyncio-task.rst:488

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:492

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:497

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:500

msgid ""

"If ``gather()`` is *cancelled*, all submitted awaitables (that have not "

"completed yet) are also *cancelled*."

msgstr ""

#: library/asyncio-task.rst:503

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:510

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:521

msgid ""

"import asyncio\n"

"\n"

"async def factorial(name, number):\n"

" f = 1\n"

" for i in range(2, number + 1):\n"

" print(f\"Task {name}: Compute factorial({number}), currently i={i}..."

"\")\n"

" await asyncio.sleep(1)\n"

" f *= i\n"

" print(f\"Task {name}: factorial({number}) = {f}\")\n"

" return f\n"

"\n"

"async def main():\n"

" # Schedule three calls *concurrently*:\n"

" L = await asyncio.gather(\n"

" factorial(\"A\", 2),\n"

" factorial(\"B\", 3),\n"

" factorial(\"C\", 4),\n"

" )\n"

" print(L)\n"

"\n"

"asyncio.run(main())\n"

"\n"

"# Expected output:\n"

"#\n"

"# Task A: Compute factorial(2), currently i=2...\n"

"# Task B: Compute factorial(3), currently i=2...\n"

"# Task C: Compute factorial(4), currently i=2...\n"

"# Task A: factorial(2) = 2\n"

"# Task B: Compute factorial(3), currently i=3...\n"

"# Task C: Compute factorial(4), currently i=3...\n"

"# Task B: factorial(3) = 6\n"

"# Task C: Compute factorial(4), currently i=4...\n"

"# Task C: factorial(4) = 24\n"

"# [2, 6, 24]"

msgstr ""

#: library/asyncio-task.rst:557

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:564

msgid ""

"If the *gather* itself is cancelled, the cancellation is propagated "

"regardless of *return_exceptions*."

msgstr ""

#: library/asyncio-task.rst:571

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:580

msgid "Eager Task Factory"

msgstr ""

#: library/asyncio-task.rst:584

msgid "A task factory for eager task execution."

msgstr ""

#: library/asyncio-task.rst:586

msgid ""

"When using this factory (via :meth:`loop.set_task_factory(asyncio."

"eager_task_factory) <loop.set_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:592

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:597

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:608

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:612

msgid ""

"*custom_task_constructor* must be a *callable* with the signature matching "

"the signature of :class:`Task.__init__ <Task>`. The callable must return a :"

"class:`asyncio.Task`-compatible object."

msgstr ""

#: library/asyncio-task.rst:616

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) <loop."

"set_task_factory>`)."

msgstr ""

#: library/asyncio-task.rst:623

msgid "Shielding From Cancellation"

msgstr ""

#: library/asyncio-task.rst:627

msgid ""

"Protect an :ref:`awaitable object <asyncio-awaitables>` from being :meth:"

"`cancelled <Task.cancel>`."

msgstr ""

#: library/asyncio-task.rst:796

msgid "If *aw* is a coroutine it is automatically scheduled as a Task."

msgstr ""

#: library/asyncio-task.rst:632

msgid "The statement::"

msgstr ""

#: library/asyncio-task.rst:634

msgid ""

"task = asyncio.create_task(something())\n"

"res = await shield(task)"

msgstr ""

#: library/asyncio-task.rst:637

msgid "is equivalent to::"

msgstr ""

#: library/asyncio-task.rst:639

msgid "res = await something()"

msgstr ""

#: library/asyncio-task.rst:641

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:647

msgid ""

"If ``something()`` is cancelled by other means (i.e. from within itself) "

"that would also cancel ``shield()``."

msgstr ""

#: library/asyncio-task.rst:650

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:654

msgid ""

"task = asyncio.create_task(something())\n"

"try:\n"

" res = await shield(task)\n"

"except CancelledError:\n"

" res = None"

msgstr ""

#: library/asyncio-task.rst:662

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:670

msgid ""

"Deprecation warning is emitted if *aw* is not Future-like object and there "

"is no running event loop."

msgstr ""

#: library/asyncio-task.rst:676

msgid "Timeouts"

msgstr ""

#: library/asyncio-task.rst:680

msgid ""

"Return an :ref:`asynchronous context manager <async-context-managers>` that "

"can be used to limit the amount of time spent waiting on something."

msgstr ""

#: library/asyncio-task.rst:684

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:689

msgid ""

"In either case, the context manager can be rescheduled after creation using :"

"meth:`Timeout.reschedule`."

msgstr ""

#: library/asyncio-task.rst:694

msgid ""

"async def main():\n"

" async with asyncio.timeout(10):\n"

" await long_running_task()"

msgstr ""

#: library/asyncio-task.rst:698

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:705

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:710

msgid "Example of catching :exc:`TimeoutError`::"

msgstr ""

#: library/asyncio-task.rst:712

msgid ""

"async def main():\n"

" try:\n"

" async with asyncio.timeout(10):\n"

" await long_running_task()\n"

" except TimeoutError:\n"

" print(\"The long operation timed out, but we've handled it.\")\n"

"\n"

" print(\"This statement will run regardless.\")"

msgstr ""

#: library/asyncio-task.rst:721

msgid ""

"The context manager produced by :func:`asyncio.timeout` can be rescheduled "

"to a different deadline and inspected."

msgstr ""

#: library/asyncio-task.rst:726

msgid ""

"An :ref:`asynchronous context manager <async-context-managers>` for "

"cancelling overdue coroutines."

msgstr ""

#: library/asyncio-task.rst:729

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:732

msgid "If ``when`` is ``None``, the timeout will never trigger."

msgstr ""

#: library/asyncio-task.rst:733

msgid ""

"If ``when < loop.time()``, the timeout will trigger on the next iteration of "

"the event loop."

msgstr ""

#: library/asyncio-task.rst:738

msgid ""

"Return the current deadline, or ``None`` if the current deadline is not set."

msgstr ""

#: library/asyncio-task.rst:743

msgid "Reschedule the timeout."

msgstr ""

#: library/asyncio-task.rst:747

msgid "Return whether the context manager has exceeded its deadline (expired)."

msgstr ""

#: library/asyncio-task.rst:752

msgid ""

"async def main():\n"

" try:\n"

" # We do not know the timeout when starting, so we pass ``None``.\n"

" async with asyncio.timeout(None) as cm:\n"

" # We know the timeout now, so we reschedule it.\n"

" new_deadline = get_running_loop().time() + 10\n"

" cm.reschedule(new_deadline)\n"

"\n"

" await long_running_task()\n"