Codestin Search App

579 lines (495 loc) · 15.9 KB
# 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.
# Translators:
# python-doc bot, 2025
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-04-09 15:16+0000\n"
"PO-Revision-Date: 2025-09-16 00:00+0000\n"
"Last-Translator: python-doc bot, 2025\n"
"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pl\n"
"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "
"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "
"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"
msgid "Developing with asyncio"
"Asynchronous programming is different from classic \"sequential\" "
"programming."
"This page lists common mistakes and traps and explains how to avoid them."
msgid "Debug Mode"
"By default asyncio runs in production mode.  In order to ease the "
"development asyncio has a *debug mode*."
msgid "There are several ways to enable asyncio debug mode:"
msgid "Setting the :envvar:`PYTHONASYNCIODEBUG` environment variable to ``1``."
msgid "Using the :ref:`Python Development Mode <devmode>`."
msgid "Passing ``debug=True`` to :func:`asyncio.run`."
msgid "Calling :meth:`loop.set_debug`."
msgid "In addition to enabling the debug mode, consider also:"
"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::"
msgid "logging.basicConfig(level=logging.DEBUG)"
"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."
msgid "When the debug mode is enabled:"
"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 "
"The execution time of the I/O selector is logged if it takes too long to "
"perform an I/O operation."
"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\"."
msgid "Concurrency and Multithreading"
"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."
"To schedule a :term:`callback` from another OS thread, the :meth:`loop."
"call_soon_threadsafe` method should be used. Example::"
msgid "loop.call_soon_threadsafe(callback, *args)"
"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.::"
msgid "loop.call_soon_threadsafe(fut.cancel)"
"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::"
"async def coro_func():\n"
"     return await asyncio.sleep(1, 42)\n"
"# Later in another OS thread:\n"
"future = asyncio.run_coroutine_threadsafe(coro_func(), loop)\n"
"# Wait for the result:\n"
"result = future.result()"
msgid "To handle signals the event loop must be run in the main thread."
"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."
"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."
msgid "Running Blocking Code"
"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."
"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."
msgid "Logging"
msgstr "Logowanie"
"asyncio uses the :mod:`logging` module and all logging is performed via the "
"``\"asyncio\"`` logger."
"The default log level is :py:const:`logging.INFO`, which can be easily "
"adjusted::"
msgid "logging.getLogger(\"asyncio\").setLevel(logging.WARNING)"
"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`."
msgid "Detect never-awaited coroutines"
"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`::"
"import asyncio\n"
"async def test():\n"
"    print(\"never scheduled\")\n"
"async def main():\n"
"    test()\n"
"asyncio.run(main())"
msgid "Output::"
"test.py:7: RuntimeWarning: coroutine 'test' was never awaited\n"
msgid "Output in debug mode::"
"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"
"  File \"../t.py\", line 7, in main\n"
"    test()\n"
"The usual fix is to either await the coroutine or call the :meth:`asyncio."
"create_task` function::"
"async def main():\n"
"    await test()"
msgid "Detect never-retrieved exceptions"
"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."
msgid "Example of an unhandled exception::"
"import asyncio\n"
"async def bug():\n"
"    raise Exception(\"not consumed\")\n"
"async def main():\n"
"    asyncio.create_task(bug())\n"
"asyncio.run(main())"
"Task exception was never retrieved\n"
"future: <Task finished coro=<bug() done, defined at test.py:3>\n"
"  exception=Exception('not consumed')>\n"
"Traceback (most recent call last):\n"
"  File \"test.py\", line 4, in bug\n"
"    raise Exception(\"not consumed\")\n"
"Exception: not consumed"
":ref:`Enable the debug mode <asyncio-debug-mode>` to get the traceback where "
"the task was created::"
msgid "asyncio.run(main(), debug=True)"
"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"
"source_traceback: Object created at (most recent call last):\n"
"  File \"../t.py\", line 9, in <module>\n"
"    asyncio.run(main(), debug=True)\n"
"Traceback (most recent call last):\n"
"  File \"../t.py\", line 4, in bug\n"
"    raise Exception(\"not consumed\")\n"
"Exception: not consumed"
msgid "Asynchronous generators best practices"
"Writing correct and efficient asyncio code requires awareness of certain "
"pitfalls. This section outlines essential best practices that can save you "
"hours of debugging."
msgid "Close asynchronous generators explicitly"
"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."
"To avoid this, explicitly close the generator by calling its :meth:`~agen."
"aclose` method, or use the :func:`contextlib.aclosing` context manager::"
"import asyncio\n"
"import contextlib\n"
"async def gen():\n"
"  yield 1\n"
"  yield 2\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"
"asyncio.run(func())"
"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::"
"import asyncio\n"
"work_done = False\n"
"async def cursor():\n"
"    try:\n"
"        yield 1\n"
"    finally:\n"
"        assert work_done\n"
"async def rows():\n"
"    global work_done\n"
"    try:\n"
"        yield 2\n"
"    finally:\n"
"        await asyncio.sleep(0.1) # immitate some async work\n"
"        work_done = True\n"
"async def main():\n"
"    async for c in cursor():\n"
"        async for r in rows():\n"
"            break\n"
"        break\n"
"asyncio.run(main())"
msgid "For this example, we get the following output::"
"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"
"During handling of the above exception, another exception occurred:\n"
"Traceback (most recent call last):\n"
"  File \"example.py\", line 8, in cursor\n"
"    assert work_done\n"
"           ^^^^^^^^^\n"
"AssertionError"
"The ``cursor()`` asynchronous generator was finalized before the ``rows`` "
"generator - an unexpected behavior."
"The example can be fixed by explicitly closing the ``cursor`` and ``rows`` "
"async-generators::"
"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"
msgid "Create asynchronous generators only when the event loop is running"
"It is recommended to create :term:`asynchronous generators <asynchronous "
"generator iterator>` only after the event loop has been created."
"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."
"When the :meth:`loop.shutdown_asyncgens() <asyncio.loop.shutdown_asyncgens>` "
"function is called, the running generators are stopped gracefully and the "
"list is cleared."
"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."
"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."
msgid "Consider the following example::"
"import asyncio\n"
"async def agenfn():\n"
"    try:\n"
"        yield 10\n"
"    finally:\n"
"        await asyncio.sleep(0)\n"
"with asyncio.Runner() as runner:\n"
"    agen = agenfn()\n"
"    print(runner.run(anext(agen)))\n"
"    del agen"
"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"
msgid "This example can be fixed as follows::"
"import asyncio\n"
"async def agenfn():\n"
"    try:\n"
"        yield 10\n"
"    finally:\n"
"        await asyncio.sleep(0)\n"
"async def main():\n"
"    agen = agenfn()\n"
"    print(await anext(agen))\n"
"    del agen\n"
"asyncio.run(main())"
msgid "Avoid concurrent iteration and closure of the same generator"
"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."
msgid "Let's consider the following example::"
"import asyncio\n"
"async def consumer():\n"
"    for idx in range(100):\n"
"        await asyncio.sleep(0)\n"
"        message = yield idx\n"
"        print('received', message)\n"
"async def amain():\n"
"    agenerator = consumer()\n"
"    await agenerator.asend(None)\n"
"    fa = asyncio.create_task(agenerator.asend('A'))\n"
"    fb = asyncio.create_task(agenerator.asend('B'))\n"
"    await fa\n"
"    await fb\n"
"asyncio.run(amain())"
"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"
"Therefore, it is recommended to avoid using asynchronous generators in "
"parallel tasks or across multiple event loops."
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

asyncio-dev.po

Latest commit

History

asyncio-dev.po

File metadata and controls
