This module provides mechanisms to use signal handlers in Python.

Some general rules for working with signals handlers:

\begin{itemize}

A handler for a particular signal, once set, remains installed until

it is explicitly reset (i.e. Python uses the BSD style interface).

There is no way to ``block'' signals temporarily from critical

sections (since this is not supported by all Unix flavors).

Although Python signal handlers are called asynchronously as far as

the Python user is concerned, they can only occur between the

``atomic'' instructions of the Python interpreter. This means that

signals arriving during long calculations implemented purely in C

(e.g. regular expression matches on large bodies of text) may be

delayed for an arbitrary time.

When a signal arrives during an I/O operation, it is possible that the

I/O operation raises an exception after the signal handler returns.

This is dependent on the underlying Unix system's semantics regarding

interrupted system calls.

Because the C signal handler always returns, it makes little sense to

catch synchronous errors like \code{SIGFPE} or \code{SIGSEGV}.

Python installs a small number of signal handlers by default:

\code{SIGPIPE} is ignored (so write errors on pipes and sockets can be

reported as ordinary Python exceptions), \code{SIGINT} is translated

into a \code{KeyboardInterrupt} exception, and \code{SIGTERM} is

caught so that necessary cleanup (especially \code{sys.exitfunc}) can

be performed before actually terminating. All of these can be

overridden.

Some care must be taken if both signals and threads are used in the

same program. The fundamental thing to remember in using signals and

threads simultaneously is: always perform \code{signal()} operations

in the main thread of execution. Any thread can perform a

\code{alarm()}, \code{getsignal()}, or \code{pause()}; only the main

thread can set a new signal handler, and the main thread will be the

only one to receive signals. This means that signals can't be used as

a means of interthread communication. Use locks instead.

\end{itemize}

\begin{datadesc}{NSIG}

One more than the number of the highest signal number.

\end{datadesc}

special values \code{signal.SIG_IGN}, \code{signal.SIG_DFL} or

\code{None}. Here, \code{signal.SIG_IGN} means that the signal was

previously ignored, \code{signal.SIG_DFL} means that the default way

of handling the signal was previously in use, and \code{None} means

that the previous signal handler was not installed from Python.

\code{signal.SIG_DFL}. The previous signal handler will be returned

(see the description of \code{getsignal()} above). (See the UNIX

man page \code{signal(2)}.)

When threads are enabled, this function can only be called from the