# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-09-28 03:11+0000\n"

"PO-Revision-Date: 2026-05-08 17:17+0000\n"

"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/de/)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

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

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

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../library/asyncio-dev.rst:7

msgid "Developing with asyncio"

msgstr ""

#: ../../library/asyncio-dev.rst:9

msgid ""

"Asynchronous programming is different from classic \"sequential\" "

"programming."

msgstr ""

#: ../../library/asyncio-dev.rst:12

msgid ""

"This page lists common mistakes and traps and explains how to avoid them."

msgstr ""

#: ../../library/asyncio-dev.rst:19

msgid "Debug Mode"

msgstr ""

#: ../../library/asyncio-dev.rst:21

msgid ""

"By default asyncio runs in production mode. In order to ease the "

"development asyncio has a *debug mode*."

msgstr ""

#: ../../library/asyncio-dev.rst:24

msgid "There are several ways to enable asyncio debug mode:"

msgstr ""

#: ../../library/asyncio-dev.rst:26

msgid "Setting the :envvar:`PYTHONASYNCIODEBUG` environment variable to ``1``."

msgstr ""

#: ../../library/asyncio-dev.rst:28

msgid "Using the :ref:`Python Development Mode <devmode>`."

msgstr ""

#: ../../library/asyncio-dev.rst:30

msgid "Passing ``debug=True`` to :func:`asyncio.run`."

msgstr ""

#: ../../library/asyncio-dev.rst:32

msgid "Calling :meth:`loop.set_debug`."

msgstr ""

#: ../../library/asyncio-dev.rst:34

msgid "In addition to enabling the debug mode, consider also:"

msgstr ""

#: ../../library/asyncio-dev.rst:36

msgid ""

"setting the log level of the :ref:`asyncio logger <asyncio-logger>` to :py:"

"const:`logging.DEBUG`, for example the following snippet of code can be run "

"at startup of the application::"

msgstr ""

#: ../../library/asyncio-dev.rst:40

msgid "logging.basicConfig(level=logging.DEBUG)"

msgstr ""

#: ../../library/asyncio-dev.rst:42

msgid ""

"configuring the :mod:`warnings` module to display :exc:`ResourceWarning` "

"warnings. One way of doing that is by using the :option:`-W` ``default`` "

"command line option."

msgstr ""

#: ../../library/asyncio-dev.rst:47

msgid "When the debug mode is enabled:"

msgstr ""

#: ../../library/asyncio-dev.rst:49

msgid ""

"Many non-threadsafe asyncio APIs (such as :meth:`loop.call_soon` and :meth:"

"`loop.call_at` methods) raise an exception if they are called from a wrong "

"thread."

msgstr ""

#: ../../library/asyncio-dev.rst:53

msgid ""

"The execution time of the I/O selector is logged if it takes too long to "

"perform an I/O operation."

msgstr ""

#: ../../library/asyncio-dev.rst:56

msgid ""

"Callbacks taking longer than 100 milliseconds are logged. The :attr:`loop."

"slow_callback_duration` attribute can be used to set the minimum execution "

"duration in seconds that is considered \"slow\"."

msgstr ""

#: ../../library/asyncio-dev.rst:64

msgid "Concurrency and Multithreading"

msgstr ""

#: ../../library/asyncio-dev.rst:66

msgid ""

"An event loop runs in a thread (typically the main thread) and executes all "

"callbacks and Tasks in its thread. While a Task is running in the event "

"loop, no other Tasks can run in the same thread. When a Task executes an "

"``await`` expression, the running Task gets suspended, and the event loop "

"executes the next Task."

msgstr ""

#: ../../library/asyncio-dev.rst:72

msgid ""

"To schedule a :term:`callback` from another OS thread, the :meth:`loop."

"call_soon_threadsafe` method should be used. Example::"

msgstr ""

#: ../../library/asyncio-dev.rst:75

msgid "loop.call_soon_threadsafe(callback, *args)"

msgstr ""

#: ../../library/asyncio-dev.rst:77

msgid ""

"Almost all asyncio objects are not thread safe, which is typically not a "

"problem unless there is code that works with them from outside of a Task or "

"a callback. If there's a need for such code to call a low-level asyncio "

"API, the :meth:`loop.call_soon_threadsafe` method should be used, e.g.::"

msgstr ""

#: ../../library/asyncio-dev.rst:83

msgid "loop.call_soon_threadsafe(fut.cancel)"

msgstr ""

#: ../../library/asyncio-dev.rst:85

msgid ""

"To schedule a coroutine object from a different OS thread, the :func:"

"`run_coroutine_threadsafe` function should be used. It returns a :class:"

"`concurrent.futures.Future` to access the result::"

msgstr ""

#: ../../library/asyncio-dev.rst:89

msgid ""

"async def coro_func():\n"

" return await asyncio.sleep(1, 42)\n"

"\n"

"# Later in another OS thread:\n"

"\n"

"future = asyncio.run_coroutine_threadsafe(coro_func(), loop)\n"

"# Wait for the result:\n"

"result = future.result()"

msgstr ""

#: ../../library/asyncio-dev.rst:98

msgid "To handle signals the event loop must be run in the main thread."

msgstr ""

#: ../../library/asyncio-dev.rst:101

msgid ""

"The :meth:`loop.run_in_executor` method can be used with a :class:"

"`concurrent.futures.ThreadPoolExecutor` or :class:`~concurrent.futures."

"InterpreterPoolExecutor` to execute blocking code in a different OS thread "

"without blocking the OS thread that the event loop runs in."

msgstr ""

#: ../../library/asyncio-dev.rst:107

msgid ""

"There is currently no way to schedule coroutines or callbacks directly from "

"a different process (such as one started with :mod:`multiprocessing`). The :"

"ref:`asyncio-event-loop-methods` section lists APIs that can read from pipes "

"and watch file descriptors without blocking the event loop. In addition, "

"asyncio's :ref:`Subprocess <asyncio-subprocess>` APIs provide a way to start "

"a process and communicate with it from the event loop. Lastly, the "

"aforementioned :meth:`loop.run_in_executor` method can also be used with a :"

"class:`concurrent.futures.ProcessPoolExecutor` to execute code in a "

"different process."

msgstr ""

#: ../../library/asyncio-dev.rst:121

msgid "Running Blocking Code"

msgstr ""

#: ../../library/asyncio-dev.rst:123

msgid ""

"Blocking (CPU-bound) code should not be called directly. For example, if a "

"function performs a CPU-intensive calculation for 1 second, all concurrent "

"asyncio Tasks and IO operations would be delayed by 1 second."

msgstr ""

#: ../../library/asyncio-dev.rst:128

msgid ""

"An executor can be used to run a task in a different thread, including in a "

"different interpreter, or even in a different process to avoid blocking the "

"OS thread with the event loop. See the :meth:`loop.run_in_executor` method "

"for more details."

msgstr ""

#: ../../library/asyncio-dev.rst:138

msgid "Logging"

msgstr ""

#: ../../library/asyncio-dev.rst:140

msgid ""

"asyncio uses the :mod:`logging` module and all logging is performed via the "

"``\"asyncio\"`` logger."

msgstr ""

#: ../../library/asyncio-dev.rst:143

msgid ""

"The default log level is :py:const:`logging.INFO`, which can be easily "

"adjusted::"

msgstr ""

#: ../../library/asyncio-dev.rst:146

msgid "logging.getLogger(\"asyncio\").setLevel(logging.WARNING)"

msgstr ""

#: ../../library/asyncio-dev.rst:149

msgid ""

"Network logging can block the event loop. It is recommended to use a "

"separate thread for handling logs or use non-blocking IO. For example, see :"

"ref:`blocking-handlers`."

msgstr ""

#: ../../library/asyncio-dev.rst:157

msgid "Detect never-awaited coroutines"

msgstr ""

#: ../../library/asyncio-dev.rst:159

msgid ""

"When a coroutine function is called, but not awaited (e.g. ``coro()`` "

"instead of ``await coro()``) or the coroutine is not scheduled with :meth:"

"`asyncio.create_task`, asyncio will emit a :exc:`RuntimeWarning`::"

msgstr ""

#: ../../library/asyncio-dev.rst:164

msgid ""

"import asyncio\n"

"\n"

"async def test():\n"

" print(\"never scheduled\")\n"

"\n"

"async def main():\n"

" test()\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-dev.rst:174 ../../library/asyncio-dev.rst:219

#: ../../library/asyncio-dev.rst:393 ../../library/asyncio-dev.rst:450

msgid "Output::"

msgstr ""

#: ../../library/asyncio-dev.rst:176

msgid ""

"test.py:7: RuntimeWarning: coroutine 'test' was never awaited\n"

" test()"

msgstr ""

#: ../../library/asyncio-dev.rst:179 ../../library/asyncio-dev.rst:235

msgid "Output in debug mode::"

msgstr ""

#: ../../library/asyncio-dev.rst:181

msgid ""

"test.py:7: RuntimeWarning: coroutine 'test' was never awaited\n"

"Coroutine created at (most recent call last)\n"

" File \"../t.py\", line 9, in <module>\n"

" asyncio.run(main(), debug=True)\n"

"\n"

" < .. >\n"

"\n"

" File \"../t.py\", line 7, in main\n"

" test()\n"

" test()"

msgstr ""

#: ../../library/asyncio-dev.rst:192

msgid ""

"The usual fix is to either await the coroutine or call the :meth:`asyncio."

"create_task` function::"

msgstr ""

#: ../../library/asyncio-dev.rst:195

msgid ""

"async def main():\n"

" await test()"

msgstr ""

#: ../../library/asyncio-dev.rst:200

msgid "Detect never-retrieved exceptions"

msgstr ""

#: ../../library/asyncio-dev.rst:202

msgid ""

"If a :meth:`Future.set_exception` is called but the Future object is never "

"awaited on, the exception would never be propagated to the user code. In "

"this case, asyncio would emit a log message when the Future object is "

"garbage collected."

msgstr ""

#: ../../library/asyncio-dev.rst:207

msgid "Example of an unhandled exception::"

msgstr ""

#: ../../library/asyncio-dev.rst:209

msgid ""

"import asyncio\n"

"\n"

"async def bug():\n"

" raise Exception(\"not consumed\")\n"

"\n"

"async def main():\n"

" asyncio.create_task(bug())\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-dev.rst:221

msgid ""

"Task exception was never retrieved\n"

"future: <Task finished coro=<bug() done, defined at test.py:3>\n"

" exception=Exception('not consumed')>\n"

"\n"

"Traceback (most recent call last):\n"

" File \"test.py\", line 4, in bug\n"

" raise Exception(\"not consumed\")\n"

"Exception: not consumed"

msgstr ""

#: ../../library/asyncio-dev.rst:230

msgid ""

":ref:`Enable the debug mode <asyncio-debug-mode>` to get the traceback where "

"the task was created::"

msgstr ""

#: ../../library/asyncio-dev.rst:233

msgid "asyncio.run(main(), debug=True)"

msgstr ""

#: ../../library/asyncio-dev.rst:237

msgid ""

"Task exception was never retrieved\n"

"future: <Task finished coro=<bug() done, defined at test.py:3>\n"

" exception=Exception('not consumed') created at asyncio/tasks.py:321>\n"

"\n"

"source_traceback: Object created at (most recent call last):\n"

" File \"../t.py\", line 9, in <module>\n"

" asyncio.run(main(), debug=True)\n"

"\n"

"< .. >\n"

"\n"

"Traceback (most recent call last):\n"

" File \"../t.py\", line 4, in bug\n"

" raise Exception(\"not consumed\")\n"

"Exception: not consumed"

msgstr ""

#: ../../library/asyncio-dev.rst:254

msgid "Asynchronous generators best practices"

msgstr ""

#: ../../library/asyncio-dev.rst:256

msgid ""

"Writing correct and efficient asyncio code requires awareness of certain "

"pitfalls. This section outlines essential best practices that can save you "

"hours of debugging."

msgstr ""

#: ../../library/asyncio-dev.rst:261

msgid "Close asynchronous generators explicitly"

msgstr ""

#: ../../library/asyncio-dev.rst:263

msgid ""

"It is recommended to manually close the :term:`asynchronous generator "

"<asynchronous generator iterator>`. If a generator exits early - for "

"example, due to an exception raised in the body of an ``async for`` loop - "

"its asynchronous cleanup code may run in an unexpected context. This can "

"occur after the tasks it depends on have completed, or during the event loop "

"shutdown when the async-generator's garbage collection hook is called."

msgstr ""

#: ../../library/asyncio-dev.rst:271

msgid ""

"To avoid this, explicitly close the generator by calling its :meth:`~agen."

"aclose` method, or use the :func:`contextlib.aclosing` context manager::"

msgstr ""

#: ../../library/asyncio-dev.rst:275

msgid ""

"import asyncio\n"

"import contextlib\n"

"\n"

"async def gen():\n"

" yield 1\n"

" yield 2\n"

"\n"

"async def func():\n"

" async with contextlib.aclosing(gen()) as g:\n"

" async for x in g:\n"

" break # Don't iterate until the end\n"

"\n"

"asyncio.run(func())"

msgstr ""

#: ../../library/asyncio-dev.rst:289

msgid ""

"As noted above, the cleanup code for these asynchronous generators is "

"deferred. The following example demonstrates that the finalization of an "

"asynchronous generator can occur in an unexpected order::"

msgstr ""

#: ../../library/asyncio-dev.rst:293

msgid ""

"import asyncio\n"

"work_done = False\n"

"\n"

"async def cursor():\n"

" try:\n"

" yield 1\n"

" finally:\n"

" assert work_done\n"

"\n"

"async def rows():\n"

" global work_done\n"

" try:\n"

" yield 2\n"

" finally:\n"

" await asyncio.sleep(0.1) # imitate some async work\n"

" work_done = True\n"

"\n"

"\n"

"async def main():\n"

" async for c in cursor():\n"

" async for r in rows():\n"

" break\n"

" break\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-dev.rst:319

msgid "For this example, we get the following output::"

msgstr ""

#: ../../library/asyncio-dev.rst:321

msgid ""

"unhandled exception during asyncio.run() shutdown\n"

"task: <Task finished name='Task-3' coro=<<async_generator_athrow without "

"__name__>()> exception=AssertionError()>\n"

"Traceback (most recent call last):\n"

" File \"example.py\", line 6, in cursor\n"

" yield 1\n"

"asyncio.exceptions.CancelledError\n"

"\n"

"During handling of the above exception, another exception occurred:\n"

"\n"

"Traceback (most recent call last):\n"

" File \"example.py\", line 8, in cursor\n"

" assert work_done\n"

" ^^^^^^^^^\n"

"AssertionError"

msgstr ""

#: ../../library/asyncio-dev.rst:336

msgid ""

"The ``cursor()`` asynchronous generator was finalized before the ``rows`` "

"generator - an unexpected behavior."

msgstr ""

#: ../../library/asyncio-dev.rst:339

msgid ""

"The example can be fixed by explicitly closing the ``cursor`` and ``rows`` "

"async-generators::"

msgstr ""

#: ../../library/asyncio-dev.rst:342

msgid ""

"async def main():\n"

" async with contextlib.aclosing(cursor()) as cursor_gen:\n"

" async for c in cursor_gen:\n"

" async with contextlib.aclosing(rows()) as rows_gen:\n"

" async for r in rows_gen:\n"

" break\n"

" break"

msgstr ""

#: ../../library/asyncio-dev.rst:352

msgid "Create asynchronous generators only when the event loop is running"

msgstr ""

#: ../../library/asyncio-dev.rst:354

msgid ""

"It is recommended to create :term:`asynchronous generators <asynchronous "

"generator iterator>` only after the event loop has been created."

msgstr ""

#: ../../library/asyncio-dev.rst:358

msgid ""

"To ensure that asynchronous generators close reliably, the event loop uses "

"the :func:`sys.set_asyncgen_hooks` function to register callback functions. "

"These callbacks update the list of running asynchronous generators to keep "

"it in a consistent state."

msgstr ""

#: ../../library/asyncio-dev.rst:363

msgid ""

"When the :meth:`loop.shutdown_asyncgens() <asyncio.loop.shutdown_asyncgens>` "

"function is called, the running generators are stopped gracefully and the "

"list is cleared."

msgstr ""

#: ../../library/asyncio-dev.rst:367

msgid ""

"The asynchronous generator invokes the corresponding system hook during its "

"first iteration. At the same time, the generator records that the hook has "

"been called and does not call it again."

msgstr ""

#: ../../library/asyncio-dev.rst:371

msgid ""

"Therefore, if iteration begins before the event loop is created, the event "

"loop will not be able to add the generator to its list of active generators "

"because the hooks are set after the generator attempts to call them. "

"Consequently, the event loop will not be able to terminate the generator if "

"necessary."

msgstr ""

#: ../../library/asyncio-dev.rst:377

msgid "Consider the following example::"

msgstr ""

#: ../../library/asyncio-dev.rst:379

msgid ""

"import asyncio\n"

"\n"

"async def agenfn():\n"

" try:\n"

" yield 10\n"

" finally:\n"

" await asyncio.sleep(0)\n"

"\n"

"\n"

"with asyncio.Runner() as runner:\n"

" agen = agenfn()\n"

" print(runner.run(anext(agen)))\n"

" del agen"

msgstr ""

#: ../../library/asyncio-dev.rst:395

msgid ""

"10\n"

"Exception ignored while closing generator <async_generator object agenfn at "

"0x000002F71CD10D70>:\n"

"Traceback (most recent call last):\n"

" File \"example.py\", line 13, in <module>\n"

" del agen\n"

" ^^^^\n"

"RuntimeError: async generator ignored GeneratorExit"

msgstr ""

#: ../../library/asyncio-dev.rst:403

msgid "This example can be fixed as follows::"

msgstr ""

#: ../../library/asyncio-dev.rst:405

msgid ""

"import asyncio\n"

"\n"

"async def agenfn():\n"

" try:\n"

" yield 10\n"

" finally:\n"

" await asyncio.sleep(0)\n"

"\n"

"async def main():\n"

" agen = agenfn()\n"

" print(await anext(agen))\n"

" del agen\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-dev.rst:422

msgid "Avoid concurrent iteration and closure of the same generator"

msgstr ""

#: ../../library/asyncio-dev.rst:424

msgid ""

"Async generators may be reentered while another :meth:`~agen.__anext__` / :"

"meth:`~agen.athrow` / :meth:`~agen.aclose` call is in progress. This may "

"lead to an inconsistent state of the async generator and can cause errors."

msgstr ""

#: ../../library/asyncio-dev.rst:429

msgid "Let's consider the following example::"

msgstr ""

#: ../../library/asyncio-dev.rst:431

msgid ""

"import asyncio\n"

"\n"

"async def consumer():\n"

" for idx in range(100):\n"

" await asyncio.sleep(0)\n"

" message = yield idx\n"

" print('received', message)\n"

"\n"

"async def amain():\n"

" agenerator = consumer()\n"

" await agenerator.asend(None)\n"

"\n"

" fa = asyncio.create_task(agenerator.asend('A'))\n"

" fb = asyncio.create_task(agenerator.asend('B'))\n"

" await fa\n"

" await fb\n"

"\n"

"asyncio.run(amain())"

msgstr ""

#: ../../library/asyncio-dev.rst:452

msgid ""

"received A\n"

"Traceback (most recent call last):\n"

" File \"test.py\", line 38, in <module>\n"

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

" ~~~~~~~~~~~^^^^^^^^^\n"

" File \"Lib/asyncio/runners.py\", line 204, in run\n"

" return runner.run(main)\n"

" ~~~~~~~~~~^^^^^^\n"

" File \"Lib/asyncio/runners.py\", line 127, in run\n"

" return self._loop.run_until_complete(task)\n"

" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^\n"

" File \"Lib/asyncio/base_events.py\", line 719, in run_until_complete\n"

" return future.result()\n"

" ~~~~~~~~~~~~~^^\n"

" File \"test.py\", line 36, in amain\n"

" await fb\n"

"RuntimeError: anext(): asynchronous generator is already running"

msgstr ""

#: ../../library/asyncio-dev.rst:471

msgid ""

"Therefore, it is recommended to avoid using asynchronous generators in "

"parallel tasks or across multiple event loops."

msgstr ""