asyncio-policy.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, 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.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-10-11 00:13+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\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"

#: ../../library/asyncio-policy.rst:8
msgid "Policies"
msgstr ""

#: ../../library/asyncio-policy.rst:10
msgid ""
"An event loop policy is a global object used to get and set the current :ref:"
"`event loop <asyncio-event-loop>`, as well as create new event loops. The "
"default policy can be :ref:`replaced <asyncio-policy-get-set>` with :ref:"
"`built-in alternatives <asyncio-policy-builtin>` to use different event loop "
"implementations, or substituted by a :ref:`custom policy <asyncio-custom-"
"policies>` that can override these behaviors."
msgstr ""

#: ../../library/asyncio-policy.rst:19
msgid ""
"The :ref:`policy object <asyncio-policy-objects>` gets and sets a separate "
"event loop per *context*. This is per-thread by default, though custom "
"policies could define *context* differently."
msgstr ""

#: ../../library/asyncio-policy.rst:24
msgid ""
"Custom event loop policies can control the behavior of :func:"
"`get_event_loop`, :func:`set_event_loop`, and :func:`new_event_loop`."
msgstr ""

#: ../../library/asyncio-policy.rst:27
msgid ""
"Policy objects should implement the APIs defined in the :class:"
"`AbstractEventLoopPolicy` abstract base class."
msgstr ""

#: ../../library/asyncio-policy.rst:34
msgid "Getting and Setting the Policy"
msgstr ""

#: ../../library/asyncio-policy.rst:36
msgid ""
"The following functions can be used to get and set the policy for the "
"current process:"
msgstr ""

#: ../../library/asyncio-policy.rst:41
msgid "Return the current process-wide policy."
msgstr ""

#: ../../library/asyncio-policy.rst:45
msgid "Set the current process-wide policy to *policy*."
msgstr ""

#: ../../library/asyncio-policy.rst:47
msgid "If *policy* is set to ``None``, the default policy is restored."
msgstr ""

#: ../../library/asyncio-policy.rst:53
msgid "Policy Objects"
msgstr ""

#: ../../library/asyncio-policy.rst:55
msgid "The abstract event loop policy base class is defined as follows:"
msgstr ""

#: ../../library/asyncio-policy.rst:59
msgid "An abstract base class for asyncio policies."
msgstr ""

#: ../../library/asyncio-policy.rst:63
msgid "Get the event loop for the current context."
msgstr ""

#: ../../library/asyncio-policy.rst:65
msgid ""
"Return an event loop object implementing the :class:`AbstractEventLoop` "
"interface."
msgstr ""

#: ../../library/asyncio-policy.rst:68 ../../library/asyncio-policy.rst:80
msgid "This method should never return ``None``."
msgstr ""

#: ../../library/asyncio-policy.rst:74
msgid "Set the event loop for the current context to *loop*."
msgstr ""

#: ../../library/asyncio-policy.rst:78
msgid "Create and return a new event loop object."
msgstr ""

#: ../../library/asyncio-policy.rst:84
msgid "Get a child process watcher object."
msgstr ""

#: ../../library/asyncio-policy.rst:86
msgid ""
"Return a watcher object implementing the :class:`AbstractChildWatcher` "
"interface."
msgstr ""

#: ../../library/asyncio-policy.rst:89 ../../library/asyncio-policy.rst:97
msgid "This function is Unix specific."
msgstr ""

#: ../../library/asyncio-policy.rst:95
msgid "Set the current child process watcher to *watcher*."
msgstr ""

#: ../../library/asyncio-policy.rst:104
msgid "asyncio ships with the following built-in policies:"
msgstr ""

#: ../../library/asyncio-policy.rst:109
msgid ""
"The default asyncio policy.  Uses :class:`SelectorEventLoop` on Unix and :"
"class:`ProactorEventLoop` on Windows."
msgstr ""

#: ../../library/asyncio-policy.rst:112
msgid ""
"There is no need to install the default policy manually. asyncio is "
"configured to use the default policy automatically."
msgstr ""

#: ../../library/asyncio-policy.rst:117
msgid "On Windows, :class:`ProactorEventLoop` is now used by default."
msgstr ""

#: ../../library/asyncio-policy.rst:119
msgid ""
"The :meth:`get_event_loop` method of the default asyncio policy now emits a :"
"exc:`DeprecationWarning` if there is no current event loop set and it "
"decides to create one. In some future Python release this will become an "
"error."
msgstr ""

#: ../../library/asyncio-policy.rst:128
msgid ""
"An alternative event loop policy that uses the :class:`SelectorEventLoop` "
"event loop implementation."
msgstr ""

#: ../../library/asyncio-policy.rst:131 ../../library/asyncio-policy.rst:139
msgid "Availability"
msgstr ""

#: ../../library/asyncio-policy.rst:136
msgid ""
"An alternative event loop policy that uses the :class:`ProactorEventLoop` "
"event loop implementation."
msgstr ""

#: ../../library/asyncio-policy.rst:145
msgid "Process Watchers"
msgstr ""

#: ../../library/asyncio-policy.rst:147
msgid ""
"A process watcher allows customization of how an event loop monitors child "
"processes on Unix. Specifically, the event loop needs to know when a child "
"process has exited."
msgstr ""

#: ../../library/asyncio-policy.rst:151
msgid ""
"In asyncio, child processes are created with :func:`create_subprocess_exec` "
"and :meth:`loop.subprocess_exec` functions."
msgstr ""

#: ../../library/asyncio-policy.rst:155
msgid ""
"asyncio defines the :class:`AbstractChildWatcher` abstract base class, which "
"child watchers should implement, and has four different implementations: :"
"class:`ThreadedChildWatcher` (configured to be used by default), :class:"
"`MultiLoopChildWatcher`, :class:`SafeChildWatcher`, and :class:"
"`FastChildWatcher`."
msgstr ""

#: ../../library/asyncio-policy.rst:161
msgid ""
"See also the :ref:`Subprocess and Threads <asyncio-subprocess-threads>` "
"section."
msgstr ""

#: ../../library/asyncio-policy.rst:164
msgid ""
"The following two functions can be used to customize the child process "
"watcher implementation used by the asyncio event loop:"
msgstr ""

#: ../../library/asyncio-policy.rst:169
msgid "Return the current child watcher for the current policy."
msgstr ""

#: ../../library/asyncio-policy.rst:175
msgid ""
"Set the current child watcher to *watcher* for the current policy.  "
"*watcher* must implement methods defined in the :class:"
"`AbstractChildWatcher` base class."
msgstr ""

#: ../../library/asyncio-policy.rst:182
msgid ""
"Third-party event loops implementations might not support custom child "
"watchers.  For such event loops, using :func:`set_child_watcher` might be "
"prohibited or have no effect."
msgstr ""

#: ../../library/asyncio-policy.rst:190
msgid "Register a new child handler."
msgstr ""

#: ../../library/asyncio-policy.rst:192
msgid ""
"Arrange for ``callback(pid, returncode, *args)`` to be called when a process "
"with PID equal to *pid* terminates.  Specifying another callback for the "
"same process replaces the previous handler."
msgstr ""

#: ../../library/asyncio-policy.rst:197
msgid "The *callback* callable must be thread-safe."
msgstr ""

#: ../../library/asyncio-policy.rst:201
msgid "Removes the handler for process with PID equal to *pid*."
msgstr ""

#: ../../library/asyncio-policy.rst:203
msgid ""
"The function returns ``True`` if the handler was successfully removed, "
"``False`` if there was nothing to remove."
msgstr ""

#: ../../library/asyncio-policy.rst:208
msgid "Attach the watcher to an event loop."
msgstr ""

#: ../../library/asyncio-policy.rst:210
msgid ""
"If the watcher was previously attached to an event loop, then it is first "
"detached before attaching to the new loop."
msgstr ""

#: ../../library/asyncio-policy.rst:213
msgid "Note: loop may be ``None``."
msgstr ""

#: ../../library/asyncio-policy.rst:217
msgid "Return ``True`` if the watcher is ready to use."
msgstr ""

#: ../../library/asyncio-policy.rst:219
msgid ""
"Spawning a subprocess with *inactive* current child watcher raises :exc:"
"`RuntimeError`."
msgstr ""

#: ../../library/asyncio-policy.rst:226
msgid "Close the watcher."
msgstr ""

#: ../../library/asyncio-policy.rst:228
msgid ""
"This method has to be called to ensure that underlying resources are cleaned-"
"up."
msgstr ""

#: ../../library/asyncio-policy.rst:236
msgid ""
"This implementation starts a new waiting thread for every subprocess spawn."
msgstr ""

#: ../../library/asyncio-policy.rst:238
msgid ""
"It works reliably even when the asyncio event loop is run in a non-main OS "
"thread."
msgstr ""

#: ../../library/asyncio-policy.rst:240
msgid ""
"There is no noticeable overhead when handling a big number of children "
"(*O*\\ (1) each time a child terminates), but starting a thread per process "
"requires extra memory."
msgstr ""

#: ../../library/asyncio-policy.rst:243
msgid "This watcher is used by default."
msgstr ""

#: ../../library/asyncio-policy.rst:249
msgid ""
"This implementation registers a :py:data:`SIGCHLD` signal handler on "
"instantiation. That can break third-party code that installs a custom "
"handler for :py:data:`SIGCHLD` signal."
msgstr ""

#: ../../library/asyncio-policy.rst:253 ../../library/asyncio-policy.rst:273
msgid ""
"The watcher avoids disrupting other code spawning processes by polling every "
"process explicitly on a :py:data:`SIGCHLD` signal."
msgstr ""

#: ../../library/asyncio-policy.rst:256
msgid ""
"There is no limitation for running subprocesses from different threads once "
"the watcher is installed."
msgstr ""

#: ../../library/asyncio-policy.rst:259
msgid ""
"The solution is safe but it has a significant overhead when handling a big "
"number of processes (*O*\\ (*n*) each time a :py:data:`SIGCHLD` is received)."
msgstr ""

#: ../../library/asyncio-policy.rst:269
msgid ""
"This implementation uses active event loop from the main thread to handle :"
"py:data:`SIGCHLD` signal. If the main thread has no running event loop "
"another thread cannot spawn a subprocess (:exc:`RuntimeError` is raised)."
msgstr ""

#: ../../library/asyncio-policy.rst:276
msgid ""
"This solution is as safe as :class:`MultiLoopChildWatcher` and has the same "
"*O*\\ (*n*) complexity but requires a running event loop in the main thread "
"to work."
msgstr ""

#: ../../library/asyncio-policy.rst:283
msgid ""
"This implementation reaps every terminated processes by calling ``os."
"waitpid(-1)`` directly, possibly breaking other code spawning processes and "
"waiting for their termination."
msgstr ""

#: ../../library/asyncio-policy.rst:287
msgid ""
"There is no noticeable overhead when handling a big number of children "
"(*O*\\ (1) each time a child terminates)."
msgstr ""

#: ../../library/asyncio-policy.rst:290
msgid ""
"This solution requires a running event loop in the main thread to work, as :"
"class:`SafeChildWatcher`."
msgstr ""

#: ../../library/asyncio-policy.rst:297
msgid ""
"This implementation polls process file descriptors (pidfds) to await child "
"process termination. In some respects, :class:`PidfdChildWatcher` is a "
"\"Goldilocks\" child watcher implementation. It doesn't require signals or "
"threads, doesn't interfere with any processes launched outside the event "
"loop, and scales linearly with the number of subprocesses launched by the "
"event loop. The main disadvantage is that pidfds are specific to Linux, and "
"only work on recent (5.3+) kernels."
msgstr ""

#: ../../library/asyncio-policy.rst:311
msgid "Custom Policies"
msgstr ""

#: ../../library/asyncio-policy.rst:313
msgid ""
"To implement a new event loop policy, it is recommended to subclass :class:"
"`DefaultEventLoopPolicy` and override the methods for which custom behavior "
"is wanted, e.g.::"
msgstr ""

#: ../../library/asyncio-policy.rst:317
msgid ""
"class MyEventLoopPolicy(asyncio.DefaultEventLoopPolicy):\n"
"\n"
"    def get_event_loop(self):\n"
"        \"\"\"Get the event loop.\n"
"\n"
"        This may be None or an instance of EventLoop.\n"
"        \"\"\"\n"
"        loop = super().get_event_loop()\n"
"        # Do something with loop ...\n"
"        return loop\n"
"\n"
"asyncio.set_event_loop_policy(MyEventLoopPolicy())"
msgstr ""
"class MyEventLoopPolicy(asyncio.DefaultEventLoopPolicy):\n"
"\n"
"    def get_event_loop(self):\n"
"        \"\"\"Get the event loop.\n"
"\n"
"        This may be None or an instance of EventLoop.\n"
"        \"\"\"\n"
"        loop = super().get_event_loop()\n"
"        # Do something with loop ...\n"
"        return loop\n"
"\n"
"asyncio.set_event_loop_policy(MyEventLoopPolicy())"