# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2018, Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, 2018.

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-04-17 23:44+0000\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: Dong-gweon Oh <flowdas@gmail.com>\n"

"Language-Team: Korean (https://python.flowdas.com)\n"

"MIME-Version: 1.0\n"

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

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

"Generated-By: Babel 2.17.0\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 ""

"사용자 정의 이벤트 루프 정책은 :func:`get_event_loop`, :func:`set_event_loop` 및 "

":func:`new_event_loop`\\의 동작을 제어할 수 있습니다."

#: ../../library/asyncio-policy.rst:27

msgid ""

"Policy objects should implement the APIs defined in the "

":class:`AbstractEventLoopPolicy` abstract base class."

msgstr "정책 객체는 :class:`AbstractEventLoopPolicy` 추상 베이스 클래스에 정의된 API를 구현해야 합니다."

#: ../../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 "현재 프로세스 전반의 정책을 *policy*\\로 설정합니다."

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

msgid "If *policy* is set to ``None``, the default policy is restored."

msgstr "*policy*\\를 ``None``\\으로 설정하면, 기본 정책이 복원됩니다."

#: ../../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 "asyncio 정책의 추상 베이스 클래스."

#: ../../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 ":class:`AbstractEventLoop` 인터페이스를 구현하는 이벤트 루프 객체를 반환합니다."

#: ../../library/asyncio-policy.rst:68 ../../library/asyncio-policy.rst:80

msgid "This method should never return ``None``."

msgstr "이 메서드는 절대 ``None``\\을 반환해서는 안 됩니다."

#: ../../library/asyncio-policy.rst:74

msgid "Set the event loop for the current context to *loop*."

msgstr "현재 컨텍스트에 대한 이벤트 루프를 *loop*\\로 설정합니다."

#: ../../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 ":class:`AbstractChildWatcher` 인터페이스를 구현하고 있는 감시자 객체를 돌려줍니다."

#: ../../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 "현재의 자식 프로세스 감시자를 *watcher*\\로 설정합니다."

#: ../../library/asyncio-policy.rst:104

msgid "asyncio ships with the following built-in policies:"

msgstr "asyncio에는 다음과 같은 내장 정책이 제공됩니다:"

#: ../../library/asyncio-policy.rst:109

msgid ""

"The default asyncio policy. Uses :class:`SelectorEventLoop` on Unix and "

":class:`ProactorEventLoop` on Windows."

msgstr ""

"기본 asyncio 정책. 유닉스에서는 :class:`SelectorEventLoop`\\를, 윈도우에서는 "

":class:`ProactorEventLoop`\\를 사용합니다."

#: ../../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 "수동으로 기본 정책을 설치할 필요는 없습니다. asyncio는 기본 정책을 자동으로 사용하도록 구성됩니다."

#: ../../library/asyncio-policy.rst:117

msgid "On Windows, :class:`ProactorEventLoop` is now used by default."

msgstr "윈도우에서, 이제 기본적으로 :class:`ProactorEventLoop`\\가 사용됩니다."

#: ../../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 ":class:`SelectorEventLoop` 이벤트 루프 구현을 사용하는 대안 이벤트 루프 정책."

#: ../../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 ":class:`ProactorEventLoop` 이벤트 루프 구현을 사용하는 대안 이벤트 루프 정책."

#: ../../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 ""

"asyncio에서, 자식 프로세스는 :func:`create_subprocess_exec` 와 "

":meth:`loop.subprocess_exec` 함수로 만들어집니다."

#: ../../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 ""

"asyncio는 자식 관찰자가 구현해야 하는 :class:`AbstractChildWatcher` 추상 베이스 클래스를 정의하며, "

"네 가지 구현이 있습니다: :class:`ThreadedChildWatcher` (기본적으로 사용하도록 구성됩니다), "

":class:`MultiLoopChildWatcher`, :class:`SafeChildWatcher` 및 "

":class:`FastChildWatcher`."

#: ../../library/asyncio-policy.rst:161

msgid ""

"See also the :ref:`Subprocess and Threads <asyncio-subprocess-threads>` "

"section."

msgstr ":ref:`서브 프로세스와 스레드 <asyncio-subprocess-threads>` 절도 참조하십시오."

#: ../../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 "다음 두 함수를 사용하여 asyncio 이벤트 루프에서 사용되는 자식 프로세스 감시자 구현을 사용자 정의할 수 있습니다:"

#: ../../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 ""

"현재 정책에 대한 현재 자식 관찰자를 *watcher*\\로 설정합니다. *watcher*\\는 "

":class:`AbstractChildWatcher` 베이스 클래스에 정의된 메서드를 구현해야 합니다."

#: ../../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 ""

"제삼자 이벤트 루프 구현은 사용자 정의 자식 관찰자를 지원하지 않을 수 있습니다. 이러한 이벤트 루프에서는, "

":func:`set_child_watcher` 사용은 금지되거나 효과가 없습니다."

#: ../../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 ""

"PID가 *pid* 인 프로세스가 종료할 때 ``callback(pid, returncode, *args)``\\가 호출되도록 "

"배치합니다. 같은 프로세스에 대해 다른 콜백을 지정하면 이전 처리기가 교체됩니다."

#: ../../library/asyncio-policy.rst:197

msgid "The *callback* callable must be thread-safe."

msgstr "*callback* 콜러블은 스레드 안전해야 합니다."

#: ../../library/asyncio-policy.rst:201

msgid "Removes the handler for process with PID equal to *pid*."

msgstr "PID가 *pid* 인 프로세스의 처리기를 제거합니다."

#: ../../library/asyncio-policy.rst:203

msgid ""

"The function returns ``True`` if the handler was successfully removed, "

"``False`` if there was nothing to remove."

msgstr "이 함수는 처리기가 성공적으로 제거되면 ``True``\\를, 제거할 것이 없으면 ``False``\\를 반환합니다."

#: ../../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 "참고: loop는 ``None`` 일 수 있습니다."

#: ../../library/asyncio-policy.rst:217

msgid "Return ``True`` if the watcher is ready to use."

msgstr "감시자가 사용할 준비가 되면 ``True``\\를 반환합니다."

#: ../../library/asyncio-policy.rst:219

msgid ""

"Spawning a subprocess with *inactive* current child watcher raises "

":exc:`RuntimeError`."

msgstr "*활성화되지 않은* 현재 자식 감시자를 사용하여 서브 프로세스를 스폰하면 :exc:`RuntimeError`\\가 발생합니다."

#: ../../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 "메인 외의 OS 스레드에서 asyncio 이벤트 루프가 실행되는 경우에도 신뢰성 있게 작동합니다."

#: ../../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 ""

"많은 수의 자식을 처리할 때 눈에 띄는 오버헤드가 없습니다만 (자식이 종료될 때마다 *O*\\ (1)), 프로세스마다 스레드를 "

"시작하는 데 추가 메모리가 필요합니다."

#: ../../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 ""

"이 구현은 인스턴스를 만들 때 :py:data:`SIGCHLD` 시그널 처리기를 등록합니다. :py:data:`SIGCHLD` "

"시그널용 사용자 지정 처리기를 설치하는 제삼자 코드가 손상될 수 있습니다.)."

#: ../../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 ""

"감시자는 :py:data:`SIGCHLD` 시그널에 대해 명시적으로 모든 프로세스를 폴링하여, 프로세스를 스포닝하는 다른 코드를 "

"방해하지 않습니다."

#: ../../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 ""

"이 해법은 안전하지만 많은 수의 프로세스를 처리할 때 상당한 오버헤드가 있습니다 (:py:data:`SIGCHLD`\\가 수신될 "

"때마다 *O*\\ (*n*))."

#: ../../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 ""

"이 구현은 메인 스레드의 활성 이벤트 루프를 사용하여 :py:data:`SIGCHLD` 시그널을 처리합니다. 메인 스레드에 실행 "

"중인 이벤트 루프가 없으면 다른 스레드는 서브 프로세스를 스폰할 수 없습니다 (:exc:`RuntimeError`\\가 "

"발생합니다)."

#: ../../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 ""

"이 해법은 :class:`MultiLoopChildWatcher`\\만큼 안전하고 같은 *O*\\ (*n*) 복잡성을 갖고 있지만,"

" 작동하려면 메인 스레드에서 실행 중인 이벤트 루프가 필요합니다."

#: ../../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 ""

"이 구현은 ``os.waitpid(-1)``\\를 직접 호출하여 종료된 모든 프로세스를 거둡니다. 프로세스를 스포닝하는 다른 코드를"

" 망가뜨리고 그들의 종료를 기다릴 수 있습니다."

#: ../../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 "많은 수의 자식을 처리할 때 눈에 띄는 오버헤드가 없습니다 (자식이 종료될 때마다 *O*\\ (1))."

#: ../../library/asyncio-policy.rst:290

msgid ""

"This solution requires a running event loop in the main thread to work, "

"as :class:`SafeChildWatcher`."

msgstr "이 해법은 :class:`SafeChildWatcher`\\처럼 작동하려면 메인 스레드에서 실행 중인 이벤트 루프가 필요합니다."

#: ../../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 ""

"이 구현은 프로세스 파일 기술자(pidfd)를 폴링하여 자식 프로세스 종료를 어웨이트 합니다. 어떤 면에서, "

":class:`PidfdChildWatcher`\\는 \"골디락스(Goldilocks)\" 자식 감시자 구현입니다. 시그널이나 "

"스레드가 필요하지 않고, 이벤트 루프 외부에서 시작된 프로세스를 방해하지 않으며, 이벤트 루프에 의해 시작된 서브 프로세스 수에 "

"선형으로 확장됩니다. 가장 큰 단점은 pidfd가 리눅스에만 해당하며 최근 (5.3+) 커널에서만 작동한다는 것입니다."

#: ../../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 ""

"새로운 이벤트 루프 정책을 구현하려면, :class:`DefaultEventLoopPolicy`\\의 서브 클래스를 만들고 사용자 "

"정의 동작이 필요한 메서드를 재정의하는 것이 좋습니다, 예를 들어::"

#: ../../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"

" \"\"\"이벤트 루프를 가져옵니다.\n"

"\n"

" None이거나 EventLoop의 인스턴스일 수 있습니다.\n"

" \"\"\"\n"

" loop = super().get_event_loop()\n"

" # loop로 무언가를 합니다 ...\n"

" return loop\n"

"\n"

"asyncio.set_event_loop_policy(MyEventLoopPolicy())"

#~ msgid ""

#~ "An event loop policy is a global"

#~ " per-process object that controls the"

#~ " management of the event loop. Each"

#~ " event loop has a default policy, "

#~ "which can be changed and customized "

#~ "using the policy API."

#~ msgstr ""

#~ "이벤트 루프 정책은 이벤트 루프의 관리를 제어하는 "

#~ "프로세스별 전역 객체입니다. 각 이벤트 루프는 기본 "

#~ "정책이 있는데, 정책 API를 사용하여 변경하고 사용자 "

#~ "정의할 수 있습니다."

#~ msgid ""

#~ "A policy defines the notion of "

#~ "*context* and manages a separate event"

#~ " loop per context. The default policy"

#~ " defines *context* to be the current"

#~ " thread."

#~ msgstr ""

#~ "정책은 *컨텍스트*\\의 개념을 정의하고 컨텍스트마다 별도의 "

#~ "이벤트 루프를 관리합니다. 기본 정책은 *컨텍스트*\\를 현재"

#~ " 스레드로 정의합니다."

#~ msgid ":ref:`Availability <availability>`: Windows."

#~ msgstr ":ref:`가용성 <availability>`: 윈도우."