python-docs-fr/library/signal.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-01-15 22:33+0100\n"
"PO-Revision-Date: 2018-11-29 18:27+0100\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: library/signal.rst:2
msgid ":mod:`signal` --- Set handlers for asynchronous events"
msgstr ""

#: library/signal.rst:7
msgid "**Source code:** :source:`Lib/signal.py`"
msgstr ""

#: library/signal.rst:11
msgid "This module provides mechanisms to use signal handlers in Python."
msgstr ""

#: library/signal.rst:15
msgid "General rules"
msgstr ""

#: library/signal.rst:17
msgid ""
"The :func:`signal.signal` function allows defining custom handlers to be "
"executed when a signal is received.  A small number of default handlers are "
"installed: :const:`SIGPIPE` is ignored (so write errors on pipes and sockets "
"can be reported as ordinary Python exceptions) and :const:`SIGINT` is "
"translated into a :exc:`KeyboardInterrupt` exception if the parent process "
"has not changed it."
msgstr ""

#: library/signal.rst:24
msgid ""
"A handler for a particular signal, once set, remains installed until it is "
"explicitly reset (Python emulates the BSD style interface regardless of the "
"underlying implementation), with the exception of the handler for :const:"
"`SIGCHLD`, which follows the underlying implementation."
msgstr ""

#: library/signal.rst:29
msgid ""
"On WebAssembly platforms ``wasm32-emscripten`` and ``wasm32-wasi``, signals "
"are emulated and therefore behave differently. Several functions and signals "
"are not available on these platforms."
msgstr ""

#: library/signal.rst:34
msgid "Execution of Python signal handlers"
msgstr ""

#: library/signal.rst:36
msgid ""
"A Python signal handler does not get executed inside the low-level (C) "
"signal handler.  Instead, the low-level signal handler sets a flag which "
"tells the :term:`virtual machine` to execute the corresponding Python signal "
"handler at a later point(for example at the next :term:`bytecode` "
"instruction). This has consequences:"
msgstr ""

#: library/signal.rst:42
msgid ""
"It makes little sense to catch synchronous errors like :const:`SIGFPE` or :"
"const:`SIGSEGV` that are caused by an invalid operation in C code.  Python "
"will return from the signal handler to the C code, which is likely to raise "
"the same signal again, causing Python to apparently hang.  From Python 3.3 "
"onwards, you can use the :mod:`faulthandler` module to report on synchronous "
"errors."
msgstr ""

#: library/signal.rst:49
msgid ""
"A long-running calculation implemented purely in C (such as regular "
"expression matching on a large body of text) may run uninterrupted for an "
"arbitrary amount of time, regardless of any signals received.  The Python "
"signal handlers will be called when the calculation finishes."
msgstr ""

#: library/signal.rst:54
msgid ""
"If the handler raises an exception, it will be raised \"out of thin air\" in "
"the main thread. See the :ref:`note below <handlers-and-exceptions>` for a "
"discussion."
msgstr ""

#: library/signal.rst:62
msgid "Signals and threads"
msgstr ""

#: library/signal.rst:64
msgid ""
"Python signal handlers are always executed in the main Python thread of the "
"main interpreter, even if the signal was received in another thread.  This "
"means that signals can't be used as a means of inter-thread communication.  "
"You can use the synchronization primitives from the :mod:`threading` module "
"instead."
msgstr ""

#: library/signal.rst:69
msgid ""
"Besides, only the main thread of the main interpreter is allowed to set a "
"new signal handler."
msgstr ""

#: library/signal.rst:73
#, fuzzy
msgid "Module contents"
msgstr "Contenu du module"

#: library/signal.rst:75
msgid ""
"signal (SIG*), handler (:const:`SIG_DFL`, :const:`SIG_IGN`) and sigmask (:"
"const:`SIG_BLOCK`, :const:`SIG_UNBLOCK`, :const:`SIG_SETMASK`) related "
"constants listed below were turned into :class:`enums <enum.IntEnum>` (:"
"class:`Signals`, :class:`Handlers` and :class:`Sigmasks` respectively). :"
"func:`getsignal`, :func:`pthread_sigmask`, :func:`sigpending` and :func:"
"`sigwait` functions return human-readable :class:`enums <enum.IntEnum>` as :"
"class:`Signals` objects."
msgstr ""

#: library/signal.rst:85
#, fuzzy
msgid "The signal module defines three enums:"
msgstr "Le module :mod:`csv` définit les fonctions suivantes :"

#: library/signal.rst:89
msgid ""
":class:`enum.IntEnum` collection of SIG* constants and the CTRL_* constants."
msgstr ""

#: library/signal.rst:95
msgid ""
":class:`enum.IntEnum` collection the constants :const:`SIG_DFL` and :const:"
"`SIG_IGN`."
msgstr ""

#: library/signal.rst:101
msgid ""
":class:`enum.IntEnum` collection the constants :const:`SIG_BLOCK`, :const:"
"`SIG_UNBLOCK` and :const:`SIG_SETMASK`."
msgstr ""

#: library/signal.rst:136 library/signal.rst:154 library/signal.rst:178
#: library/signal.rst:204 library/signal.rst:236 library/signal.rst:499
#: library/signal.rst:506
msgid ":ref:`Availability <availability>`: Unix."
msgstr ":ref:`Disponibilité <availability>` : Unix."

#: library/signal.rst:471
#, fuzzy
msgid ""
"See the man page :manpage:`sigprocmask(2)` and :manpage:`pthread_sigmask(3)` "
"for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:111
msgid "The variables defined in the :mod:`signal` module are:"
msgstr ""

#: library/signal.rst:116
msgid ""
"This is one of two standard signal handling options; it will simply perform "
"the default function for the signal.  For example, on most systems the "
"default action for :const:`SIGQUIT` is to dump core and exit, while the "
"default action for :const:`SIGCHLD` is to simply ignore it."
msgstr ""

#: library/signal.rst:124
msgid ""
"This is another standard signal handler, which will simply ignore the given "
"signal."
msgstr ""

#: library/signal.rst:130
msgid "Abort signal from :manpage:`abort(3)`."
msgstr ""

#: library/signal.rst:134
msgid "Timer signal from :manpage:`alarm(2)`."
msgstr ""

#: library/signal.rst:140
msgid "Interrupt from keyboard (CTRL + BREAK)."
msgstr ""

#: library/signal.rst:261 library/signal.rst:271
msgid ":ref:`Availability <availability>`: Windows."
msgstr ":ref:`Disponibilité <availability>` : Windows."

#: library/signal.rst:146
msgid "Bus error (bad memory access)."
msgstr ""

#: library/signal.rst:152
msgid "Child process stopped or terminated."
msgstr ""

#: library/signal.rst:158
msgid "Alias to :data:`SIGCHLD`."
msgstr ""

#: library/signal.rst:162
msgid "Continue the process if it is currently stopped"
msgstr ""

#: library/signal.rst:168
msgid "Floating-point exception. For example, division by zero."
msgstr ""

#: library/signal.rst:171
msgid ""
":exc:`ZeroDivisionError` is raised when the second argument of a division or "
"modulo operation is zero."
msgstr ""

#: library/signal.rst:176
msgid ""
"Hangup detected on controlling terminal or death of controlling process."
msgstr ""

#: library/signal.rst:182
msgid "Illegal instruction."
msgstr ""

#: library/signal.rst:186
msgid "Interrupt from keyboard (CTRL + C)."
msgstr ""

#: library/signal.rst:188
msgid "Default action is to raise :exc:`KeyboardInterrupt`."
msgstr ""

#: library/signal.rst:192
msgid "Kill signal."
msgstr ""

#: library/signal.rst:194
msgid "It cannot be caught, blocked, or ignored."
msgstr ""

#: library/signal.rst:200
msgid "Broken pipe: write to pipe with no readers."
msgstr ""

#: library/signal.rst:202
msgid "Default action is to ignore the signal."
msgstr ""

#: library/signal.rst:208
msgid "Segmentation fault: invalid memory reference."
msgstr ""

#: library/signal.rst:212
msgid ""
"Stack fault on coprocessor. The Linux kernel does not raise this signal: it "
"can only be raised in user space."
msgstr ""

#: library/signal.rst:None
#, fuzzy
msgid ":ref:`Availability <availability>`: Linux."
msgstr ":ref:`Disponibilité <availability>` : Unix."

#: library/signal.rst:217
#, fuzzy
msgid ""
"On architectures where the signal is available. See the man page :manpage:"
"`signal(7)` for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:224
msgid "Termination signal."
msgstr ""

#: library/signal.rst:228
msgid "User-defined signal 1."
msgstr ""

#: library/signal.rst:234
msgid "User-defined signal 2."
msgstr ""

#: library/signal.rst:240
msgid "Window resize signal."
msgstr ""

#: library/signal.rst:246
msgid ""
"All the signal numbers are defined symbolically.  For example, the hangup "
"signal is defined as :const:`signal.SIGHUP`; the variable names are "
"identical to the names used in C programs, as found in ``<signal.h>``.  The "
"Unix man page for ':c:func:`signal`' lists the existing signals (on some "
"systems this is :manpage:`signal(2)`, on others the list is in :manpage:"
"`signal(7)`). Note that not all systems define the same set of signal names; "
"only those names defined by the system are defined by this module."
msgstr ""

#: library/signal.rst:257
msgid ""
"The signal corresponding to the :kbd:`Ctrl+C` keystroke event. This signal "
"can only be used with :func:`os.kill`."
msgstr ""

#: library/signal.rst:267
msgid ""
"The signal corresponding to the :kbd:`Ctrl+Break` keystroke event. This "
"signal can only be used with :func:`os.kill`."
msgstr ""

#: library/signal.rst:277
msgid ""
"One more than the number of the highest signal number. Use :func:"
"`valid_signals` to get valid signal numbers."
msgstr ""

#: library/signal.rst:283
msgid ""
"Decrements interval timer in real time, and delivers :const:`SIGALRM` upon "
"expiration."
msgstr ""

#: library/signal.rst:289
msgid ""
"Decrements interval timer only when the process is executing, and delivers "
"SIGVTALRM upon expiration."
msgstr ""

#: library/signal.rst:295
msgid ""
"Decrements interval timer both when the process executes and when the system "
"is executing on behalf of the process. Coupled with ITIMER_VIRTUAL, this "
"timer is usually used to profile the time spent by the application in user "
"and kernel space. SIGPROF is delivered upon expiration."
msgstr ""

#: library/signal.rst:303
msgid ""
"A possible value for the *how* parameter to :func:`pthread_sigmask` "
"indicating that signals are to be blocked."
msgstr ""

#: library/signal.rst:310
msgid ""
"A possible value for the *how* parameter to :func:`pthread_sigmask` "
"indicating that signals are to be unblocked."
msgstr ""

#: library/signal.rst:317
msgid ""
"A possible value for the *how* parameter to :func:`pthread_sigmask` "
"indicating that the signal mask is to be replaced."
msgstr ""

#: library/signal.rst:323
msgid "The :mod:`signal` module defines one exception:"
msgstr ""

#: library/signal.rst:327
msgid ""
"Raised to signal an error from the underlying :func:`setitimer` or :func:"
"`getitimer` implementation. Expect this error if an invalid interval timer "
"or a negative time is passed to :func:`setitimer`. This error is a subtype "
"of :exc:`OSError`."
msgstr ""

#: library/signal.rst:332
msgid ""
"This error used to be a subtype of :exc:`IOError`, which is now an alias of :"
"exc:`OSError`."
msgstr ""

#: library/signal.rst:337
#, fuzzy
msgid "The :mod:`signal` module defines the following functions:"
msgstr "Le module :mod:`csv` définit les fonctions suivantes :"

#: library/signal.rst:342
msgid ""
"If *time* is non-zero, this function requests that a :const:`SIGALRM` signal "
"be sent to the process in *time* seconds. Any previously scheduled alarm is "
"canceled (only one alarm can be scheduled at any time).  The returned value "
"is then the number of seconds before any previously set alarm was to have "
"been delivered. If *time* is zero, no alarm is scheduled, and any scheduled "
"alarm is canceled.  If the return value is zero, no alarm is currently "
"scheduled."
msgstr ""

#: library/signal.rst:351
#, fuzzy
msgid "See the man page :manpage:`alarm(2)` for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:356
msgid ""
"Return the current signal handler for the signal *signalnum*. The returned "
"value may be a callable Python object, or one of the special values :const:"
"`signal.SIG_IGN`, :const:`signal.SIG_DFL` or :const:`None`.  Here, :const:"
"`signal.SIG_IGN` means that the signal was previously ignored, :const:"
"`signal.SIG_DFL` means that the default way of handling the signal was "
"previously in use, and ``None`` means that the previous signal handler was "
"not installed from Python."
msgstr ""

#: library/signal.rst:367
msgid ""
"Returns the description of signal *signalnum*, such as \"Interrupt\" for :"
"const:`SIGINT`. Returns :const:`None` if *signalnum* has no description. "
"Raises :exc:`ValueError` if *signalnum* is invalid."
msgstr ""

#: library/signal.rst:376
msgid ""
"Return the set of valid signal numbers on this platform.  This can be less "
"than ``range(1, NSIG)`` if some signals are reserved by the system for "
"internal use."
msgstr ""

#: library/signal.rst:385
msgid ""
"Cause the process to sleep until a signal is received; the appropriate "
"handler will then be called.  Returns nothing."
msgstr ""

#: library/signal.rst:390
#, fuzzy
msgid "See the man page :manpage:`signal(2)` for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:392
msgid ""
"See also :func:`sigwait`, :func:`sigwaitinfo`, :func:`sigtimedwait` and :"
"func:`sigpending`."
msgstr ""

#: library/signal.rst:398
msgid "Sends a signal to the calling process. Returns nothing."
msgstr ""

#: library/signal.rst:405
msgid ""
"Send signal *sig* to the process referred to by file descriptor *pidfd*. "
"Python does not currently support the *siginfo* parameter; it must be "
"``None``.  The *flags* argument is provided for future extensions; no flag "
"values are currently defined."
msgstr ""

#: library/signal.rst:410
msgid "See the :manpage:`pidfd_send_signal(2)` man page for more information."
msgstr ""

#: library/signal.rst:412
#, fuzzy
msgid ":ref:`Availability <availability>`: Linux >= 5.1"
msgstr ":ref:`Disponibilité <availability>` : Unix."

#: library/signal.rst:418
msgid ""
"Send the signal *signalnum* to the thread *thread_id*, another thread in the "
"same process as the caller.  The target thread can be executing any code "
"(Python or not).  However, if the target thread is executing the Python "
"interpreter, the Python signal handlers will be :ref:`executed by the main "
"thread of the main interpreter <signals-and-threads>`.  Therefore, the only "
"point of sending a signal to a particular Python thread would be to force a "
"running system call to fail with :exc:`InterruptedError`."
msgstr ""

#: library/signal.rst:426
#, fuzzy
msgid ""
"Use :func:`threading.get_ident()` or the :attr:`~threading.Thread.ident` "
"attribute of :class:`threading.Thread` objects to get a suitable value for "
"*thread_id*."
msgstr ""
"Utilisez :func:`threading.get_ident` ou l'attribut :attr:`~threading.Thread."
"ident` de :class:`threading.Thread` pour obtenir une valeur appropriée pour "
"*thread_id*."

#: library/signal.rst:430
msgid ""
"If *signalnum* is 0, then no signal is sent, but error checking is still "
"performed; this can be used to check if the target thread is still running."
msgstr ""

#: library/signal.rst:433
msgid ""
"Raises an :ref:`auditing event <auditing>` ``signal.pthread_kill`` with "
"arguments ``thread_id``, ``signalnum``."
msgstr ""

#: library/signal.rst:437
#, fuzzy
msgid "See the man page :manpage:`pthread_kill(3)` for further  information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:439
msgid "See also :func:`os.kill`."
msgstr ""

#: library/signal.rst:446
msgid ""
"Fetch and/or change the signal mask of the calling thread.  The signal mask "
"is the set of signals whose delivery is currently blocked for the caller. "
"Return the old signal mask as a set of signals."
msgstr ""

#: library/signal.rst:450
msgid ""
"The behavior of the call is dependent on the value of *how*, as follows."
msgstr ""

#: library/signal.rst:452
msgid ""
":data:`SIG_BLOCK`: The set of blocked signals is the union of the current "
"set and the *mask* argument."
msgstr ""

#: library/signal.rst:454
msgid ""
":data:`SIG_UNBLOCK`: The signals in *mask* are removed from the current set "
"of blocked signals.  It is permissible to attempt to unblock a signal which "
"is not blocked."
msgstr ""

#: library/signal.rst:457
msgid ""
":data:`SIG_SETMASK`: The set of blocked signals is set to the *mask* "
"argument."
msgstr ""

#: library/signal.rst:460
msgid ""
"*mask* is a set of signal numbers (e.g. {:const:`signal.SIGINT`, :const:"
"`signal.SIGTERM`}). Use :func:`~signal.valid_signals` for a full mask "
"including all signals."
msgstr ""

#: library/signal.rst:464
msgid ""
"For example, ``signal.pthread_sigmask(signal.SIG_BLOCK, [])`` reads the "
"signal mask of the calling thread."
msgstr ""

#: library/signal.rst:467
msgid ":data:`SIGKILL` and :data:`SIGSTOP` cannot be blocked."
msgstr ""

#: library/signal.rst:474
msgid "See also :func:`pause`, :func:`sigpending` and :func:`sigwait`."
msgstr ""

#: library/signal.rst:481
msgid ""
"Sets given interval timer (one of :const:`signal.ITIMER_REAL`, :const:"
"`signal.ITIMER_VIRTUAL` or :const:`signal.ITIMER_PROF`) specified by *which* "
"to fire after *seconds* (float is accepted, different from :func:`alarm`) "
"and after that every *interval* seconds (if *interval* is non-zero). The "
"interval timer specified by *which* can be cleared by setting *seconds* to "
"zero."
msgstr ""

#: library/signal.rst:488
msgid ""
"When an interval timer fires, a signal is sent to the process. The signal "
"sent is dependent on the timer being used; :const:`signal.ITIMER_REAL` will "
"deliver :const:`SIGALRM`, :const:`signal.ITIMER_VIRTUAL` sends :const:"
"`SIGVTALRM`, and :const:`signal.ITIMER_PROF` will deliver :const:`SIGPROF`."
msgstr ""

#: library/signal.rst:494
msgid "The old values are returned as a tuple: (delay, interval)."
msgstr ""

#: library/signal.rst:496
msgid ""
"Attempting to pass an invalid interval timer will cause an :exc:"
"`ItimerError`."
msgstr ""

#: library/signal.rst:504
msgid "Returns current value of a given interval timer specified by *which*."
msgstr ""

#: library/signal.rst:511
msgid ""
"Set the wakeup file descriptor to *fd*.  When a signal is received, the "
"signal number is written as a single byte into the fd.  This can be used by "
"a library to wakeup a poll or select call, allowing the signal to be fully "
"processed."
msgstr ""

#: library/signal.rst:516
msgid ""
"The old wakeup fd is returned (or -1 if file descriptor wakeup was not "
"enabled).  If *fd* is -1, file descriptor wakeup is disabled. If not -1, "
"*fd* must be non-blocking.  It is up to the library to remove any bytes from "
"*fd* before calling poll or select again."
msgstr ""

#: library/signal.rst:576
msgid ""
"When threads are enabled, this function can only be called from :ref:`the "
"main thread of the main interpreter <signals-and-threads>`; attempting to "
"call it from other threads will cause a :exc:`ValueError` exception to be "
"raised."
msgstr ""

#: library/signal.rst:526
msgid ""
"There are two common ways to use this function. In both approaches, you use "
"the fd to wake up when a signal arrives, but then they differ in how they "
"determine *which* signal or signals have arrived."
msgstr ""

#: library/signal.rst:531
msgid ""
"In the first approach, we read the data out of the fd's buffer, and the byte "
"values give you the signal numbers. This is simple, but in rare cases it can "
"run into a problem: generally the fd will have a limited amount of buffer "
"space, and if too many signals arrive too quickly, then the buffer may "
"become full, and some signals may be lost. If you use this approach, then "
"you should set ``warn_on_full_buffer=True``, which will at least cause a "
"warning to be printed to stderr when signals are lost."
msgstr ""

#: library/signal.rst:540
msgid ""
"In the second approach, we use the wakeup fd *only* for wakeups, and ignore "
"the actual byte values. In this case, all we care about is whether the fd's "
"buffer is empty or non-empty; a full buffer doesn't indicate a problem at "
"all. If you use this approach, then you should set "
"``warn_on_full_buffer=False``, so that your users are not confused by "
"spurious warning messages."
msgstr ""

#: library/signal.rst:547
msgid "On Windows, the function now also supports socket handles."
msgstr ""

#: library/signal.rst:550
msgid "Added ``warn_on_full_buffer`` parameter."
msgstr ""

#: library/signal.rst:555
msgid ""
"Change system call restart behaviour: if *flag* is :const:`False`, system "
"calls will be restarted when interrupted by signal *signalnum*, otherwise "
"system calls will be interrupted.  Returns nothing."
msgstr ""

#: library/signal.rst:561
#, fuzzy
msgid "See the man page :manpage:`siginterrupt(3)` for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:563
msgid ""
"Note that installing a signal handler with :func:`signal` will reset the "
"restart behaviour to interruptible by implicitly calling :c:func:"
"`siginterrupt` with a true *flag* value for the given signal."
msgstr ""

#: library/signal.rst:570
msgid ""
"Set the handler for signal *signalnum* to the function *handler*.  *handler* "
"can be a callable Python object taking two arguments (see below), or one of "
"the special values :const:`signal.SIG_IGN` or :const:`signal.SIG_DFL`.  The "
"previous signal handler will be returned (see the description of :func:"
"`getsignal` above).  (See the Unix man page :manpage:`signal(2)` for further "
"information.)"
msgstr ""

#: library/signal.rst:581
msgid ""
"The *handler* is called with two arguments: the signal number and the "
"current stack frame (``None`` or a frame object; for a description of frame "
"objects, see the :ref:`description in the type hierarchy <frame-objects>` or "
"see the attribute descriptions in the :mod:`inspect` module)."
msgstr ""

#: library/signal.rst:586
msgid ""
"On Windows, :func:`signal` can only be called with :const:`SIGABRT`, :const:"
"`SIGFPE`, :const:`SIGILL`, :const:`SIGINT`, :const:`SIGSEGV`, :const:"
"`SIGTERM`, or :const:`SIGBREAK`. A :exc:`ValueError` will be raised in any "
"other case. Note that not all systems define the same set of signal names; "
"an :exc:`AttributeError` will be raised if a signal name is not defined as "
"``SIG*`` module level constant."
msgstr ""

#: library/signal.rst:597
msgid ""
"Examine the set of signals that are pending for delivery to the calling "
"thread (i.e., the signals which have been raised while blocked).  Return the "
"set of the pending signals."
msgstr ""

#: library/signal.rst:603
#, fuzzy
msgid "See the man page :manpage:`sigpending(2)` for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:605
msgid "See also :func:`pause`, :func:`pthread_sigmask` and :func:`sigwait`."
msgstr ""

#: library/signal.rst:612
msgid ""
"Suspend execution of the calling thread until the delivery of one of the "
"signals specified in the signal set *sigset*.  The function accepts the "
"signal (removes it from the pending list of signals), and returns the signal "
"number."
msgstr ""

#: library/signal.rst:618
#, fuzzy
msgid "See the man page :manpage:`sigwait(3)` for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:620
msgid ""
"See also :func:`pause`, :func:`pthread_sigmask`, :func:`sigpending`, :func:"
"`sigwaitinfo` and :func:`sigtimedwait`."
msgstr ""

#: library/signal.rst:628
msgid ""
"Suspend execution of the calling thread until the delivery of one of the "
"signals specified in the signal set *sigset*.  The function accepts the "
"signal and removes it from the pending list of signals. If one of the "
"signals in *sigset* is already pending for the calling thread, the function "
"will return immediately with information about that signal. The signal "
"handler is not called for the delivered signal. The function raises an :exc:"
"`InterruptedError` if it is interrupted by a signal that is not in *sigset*."
msgstr ""

#: library/signal.rst:637
msgid ""
"The return value is an object representing the data contained in the :c:type:"
"`siginfo_t` structure, namely: :attr:`si_signo`, :attr:`si_code`, :attr:"
"`si_errno`, :attr:`si_pid`, :attr:`si_uid`, :attr:`si_status`, :attr:"
"`si_band`."
msgstr ""

#: library/signal.rst:644
#, fuzzy
msgid "See the man page :manpage:`sigwaitinfo(2)` for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:646
msgid "See also :func:`pause`, :func:`sigwait` and :func:`sigtimedwait`."
msgstr ""

#: library/signal.rst:650
msgid ""
"The function is now retried if interrupted by a signal not in *sigset* and "
"the signal handler does not raise an exception (see :pep:`475` for the "
"rationale)."
msgstr ""

#: library/signal.rst:658
msgid ""
"Like :func:`sigwaitinfo`, but takes an additional *timeout* argument "
"specifying a timeout. If *timeout* is specified as :const:`0`, a poll is "
"performed. Returns :const:`None` if a timeout occurs."
msgstr ""

#: library/signal.rst:664
#, fuzzy
msgid "See the man page :manpage:`sigtimedwait(2)` for further information."
msgstr ""
":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
"manpage:`pthread_getcpuclockid(3)` pour plus d’information)."

#: library/signal.rst:666
msgid "See also :func:`pause`, :func:`sigwait` and :func:`sigwaitinfo`."
msgstr ""

#: library/signal.rst:670
msgid ""
"The function is now retried with the recomputed *timeout* if interrupted by "
"a signal not in *sigset* and the signal handler does not raise an exception "
"(see :pep:`475` for the rationale)."
msgstr ""

#: library/signal.rst:679
#, fuzzy
msgid "Examples"
msgstr "Exemple"

#: library/signal.rst:681
msgid ""
"Here is a minimal example program. It uses the :func:`alarm` function to "
"limit the time spent waiting to open a file; this is useful if the file is "
"for a serial device that may not be turned on, which would normally cause "
"the :func:`os.open` to hang indefinitely.  The solution is to set a 5-second "
"alarm before opening the file; if the operation takes too long, the alarm "
"signal will be sent, and the handler raises an exception. ::"
msgstr ""

#: library/signal.rst:705
msgid "Note on SIGPIPE"
msgstr ""

#: library/signal.rst:707
msgid ""
"Piping output of your program to tools like :manpage:`head(1)` will cause a :"
"const:`SIGPIPE` signal to be sent to your process when the receiver of its "
"standard output closes early.  This results in an exception like :code:"
"`BrokenPipeError: [Errno 32] Broken pipe`.  To handle this case, wrap your "
"entry point to catch this exception as follows::"
msgstr ""

#: library/signal.rst:734
msgid ""
"Do not set :const:`SIGPIPE`'s disposition to :const:`SIG_DFL` in order to "
"avoid :exc:`BrokenPipeError`.  Doing that would cause your program to exit "
"unexpectedly whenever any socket connection is interrupted while your "
"program is still writing to it."
msgstr ""

#: library/signal.rst:743
msgid "Note on Signal Handlers and Exceptions"
msgstr ""

#: library/signal.rst:745
msgid ""
"If a signal handler raises an exception, the exception will be propagated to "
"the main thread and may be raised after any :term:`bytecode` instruction. "
"Most notably, a :exc:`KeyboardInterrupt` may appear at any point during "
"execution. Most Python code, including the standard library, cannot be made "
"robust against this, and so a :exc:`KeyboardInterrupt` (or any other "
"exception resulting from a signal handler) may on rare occasions put the "
"program in an unexpected state."
msgstr ""

#: library/signal.rst:752
msgid "To illustrate this issue, consider the following code::"
msgstr ""

#: library/signal.rst:769
msgid ""
"For many programs, especially those that merely want to exit on :exc:"
"`KeyboardInterrupt`, this is not a problem, but applications that are "
"complex or require high reliability should avoid raising exceptions from "
"signal handlers. They should also avoid catching :exc:`KeyboardInterrupt` as "
"a means of gracefully shutting down.  Instead, they should install their "
"own :const:`SIGINT` handler. Below is an example of an HTTP server that "
"avoids :exc:`KeyboardInterrupt`::"
msgstr ""

#, fuzzy
#~ msgid ""
#~ ":ref:`Availability <availability>`: Unix.  See the man page :manpage:"
#~ "`sigprocmask(2)` and :manpage:`pthread_sigmask(3)` for further "
#~ "information."
#~ msgstr ""
#~ ":ref:`Disponibilité <availability>` : Unix (regardez la page man pour :"
#~ "manpage:`pthread_getcpuclockid(3)` pour plus d’information)."