diff -r d8659dbebfd1 Doc/library/signal.rst --- a/Doc/library/signal.rst Thu Mar 27 20:51:15 2014 -0700 +++ b/Doc/library/signal.rst Fri Mar 28 18:04:41 2014 +0100 @@ -159,6 +159,14 @@ .. versionadded:: 3.3 +.. class:: Signals +.. class:: Handlers +.. class:: Sigmasks + + An :mod:`enum.IntEnum` collection of all the signal, handler and sigmask + related constants listed above. + + .. versionadded:: 3.5 The :mod:`signal` module defines one exception: diff -r d8659dbebfd1 Lib/signal.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Lib/signal.py Fri Mar 28 18:04:41 2014 +0100 @@ -0,0 +1,80 @@ +import _signal +from _signal import * +from enum import IntEnum as _IntEnum + +_globals = globals() + +Signals = _IntEnum( + 'Signals', + {name: value for name, value in _globals.items() + if name.isupper() + and (name.startswith('SIG') and not name.startswith('SIG_')) + or name.startswith('CTRL_')}) + +Handlers = _IntEnum( + 'Handlers', + {name: value for name, value in _globals.items() + if name in {'SIG_DFL', 'SIG_IGN'}}) + +Sigmasks = _IntEnum( + 'Sigmasks', + {name: value for name, value in _globals.items() + if name in {'SIG_BLOCK', 'SIG_UNBLOCK', 'SIG_SETMASK'}}) + +_globals.update(Signals.__members__) +_globals.update(Handlers.__members__) +_globals.update(Sigmasks.__members__) + + +def _int_to_enum(value, enum_klass): + """Convert a numeric value to an IntEnum member. + If it's not a known member, return the numeric value itself. + """ + try: + return enum_klass(value) + except ValueError: + return value + + +def _enum_to_int(value): + """Convert an IntEnum member to a numeric value. + If it's not a IntEnum member return the value itself. + """ + try: + return int(value) + except (ValueError, TypeError): + return value + + +def signal(signalnum, handler): + handler = _signal.signal(_enum_to_int(signalnum), _enum_to_int(handler)) + return _int_to_enum(handler, Handlers) +signal.__doc__ = _signal.signal.__doc__ + + +def getsignal(signalnum): + handler = _signal.getsignal(signalnum) + return _int_to_enum(handler, Handlers) +getsignal.__doc__ = _signal.getsignal.__doc__ + + +if 'pthread_sigmask' in _globals: + def pthread_sigmask(how, mask): + sigs_set = _signal.pthread_sigmask(how, mask) + return set([_int_to_enum(x, Signals) for x in sigs_set]) + pthread_sigmask.__doc__ = _signal.pthread_sigmask.__doc__ + + +def sigpending(): + sigs = _signal.sigpending() + return set([_int_to_enum(x, Signals) for x in sigs]) +sigpending.__doc__ = _signal.sigpending + + +if 'sigwait' in _globals: + def sigwait(sigset): + retsig = _signal.sigwait(sigset) + return _int_to_enum(retsig, Signals) + sigwait.__doc__ = _signal.sigwait + +del _globals diff -r d8659dbebfd1 Lib/test/test_signal.py --- a/Lib/test/test_signal.py Thu Mar 27 20:51:15 2014 -0700 +++ b/Lib/test/test_signal.py Fri Mar 28 18:04:41 2014 +0100 @@ -1,6 +1,7 @@ import unittest from test import support from contextlib import closing +import enum import gc import pickle import select @@ -39,6 +40,22 @@ return None +class GenericTests(unittest.TestCase): + + def test_enums(self): + for name in dir(signal): + sig = getattr(signal, name) + if name in {'SIG_DFL', 'SIG_IGN'}: + self.assertIsInstance(sig, signal.Handlers) + elif name in {'SIG_BLOCK', 'SIG_UNBLOCK', 'SIG_SETMASK'}: + self.assertIsInstance(sig, signal.Sigmasks) + elif name.startswith('SIG'): + self.assertIsInstance(sig, signal.Signals) + elif name.startswith('CTRL_'): + self.assertIsInstance(sig, signal.Signals) + self.assertEqual(sys.platform, "win32") + + @unittest.skipIf(sys.platform == "win32", "Not valid on Windows") class InterProcessSignalTests(unittest.TestCase): MAX_DURATION = 20 # Entire test should last at most 20 sec. @@ -195,6 +212,7 @@ def test_getsignal(self): hup = signal.signal(signal.SIGHUP, self.trivial_signal_handler) + self.assertIsInstance(hup, signal.Handlers) self.assertEqual(signal.getsignal(signal.SIGHUP), self.trivial_signal_handler) signal.signal(signal.SIGHUP, hup) @@ -348,7 +366,7 @@ dt = after_time - mid_time if dt >= TIMEOUT_HALF: raise Exception("%s >= %s" % (dt, TIMEOUT_HALF)) - """, signal.SIGALRM) + """, int(signal.SIGALRM)) def test_wakeup_fd_during(self): self.check_wakeup("""def test(): @@ -371,14 +389,14 @@ dt = after_time - before_time if dt >= TIMEOUT_HALF: raise Exception("%s >= %s" % (dt, TIMEOUT_HALF)) - """, signal.SIGALRM) + """, int(signal.SIGALRM)) def test_signum(self): self.check_wakeup("""def test(): signal.signal(signal.SIGUSR1, handler) os.kill(os.getpid(), signal.SIGUSR1) os.kill(os.getpid(), signal.SIGALRM) - """, signal.SIGUSR1, signal.SIGALRM) + """, int(signal.SIGUSR1), int(signal.SIGALRM)) @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'), 'need signal.pthread_sigmask()') @@ -395,7 +413,7 @@ os.kill(os.getpid(), signum2) # Unblocking the 2 signals calls the C signal handler twice signal.pthread_sigmask(signal.SIG_UNBLOCK, (signum1, signum2)) - """, signal.SIGUSR1, signal.SIGUSR2, ordered=False) + """, int(signal.SIGUSR1), int(signal.SIGUSR2), ordered=False) @unittest.skipIf(sys.platform == "win32", "Not valid on Windows") @@ -604,6 +622,8 @@ signal.pthread_sigmask(signal.SIG_BLOCK, [signum]) os.kill(os.getpid(), signum) pending = signal.sigpending() + for sig in pending: + assert isinstance(sig, signal.Signals), repr(pending) if pending != {signum}: raise Exception('%s != {%s}' % (pending, signum)) try: @@ -660,6 +680,7 @@ code = '''if 1: import signal import sys + from signal import Signals def handler(signum, frame): 1/0 @@ -702,6 +723,7 @@ def test(signum): signal.alarm(1) received = signal.sigwait([signum]) + assert isinstance(received, signal.Signals) if received != signum: raise Exception('received %s, not %s' % (received, signum)) ''') @@ -842,8 +864,14 @@ def kill(signum): os.kill(os.getpid(), signum) + def check_mask(mask): + for sig in mask: + assert isinstance(sig, signal.Signals), repr(sig) + def read_sigmask(): - return signal.pthread_sigmask(signal.SIG_BLOCK, []) + ret = signal.pthread_sigmask(signal.SIG_BLOCK, []) + check_mask(ret) + return ret signum = signal.SIGUSR1 @@ -852,6 +880,7 @@ # Unblock SIGUSR1 (and copy the old mask) to test our signal handler old_mask = signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum]) + check_mask(old_mask) try: kill(signum) except ZeroDivisionError: @@ -861,11 +890,13 @@ # Block and then raise SIGUSR1. The signal is blocked: the signal # handler is not called, and the signal is now pending - signal.pthread_sigmask(signal.SIG_BLOCK, [signum]) + mask = signal.pthread_sigmask(signal.SIG_BLOCK, [signum]) + check_mask(mask) kill(signum) # Check the new mask blocked = read_sigmask() + check_mask(blocked) if signum not in blocked: raise Exception("%s not in %s" % (signum, blocked)) if old_mask ^ blocked != {signum}: @@ -928,7 +959,7 @@ def test_main(): try: - support.run_unittest(PosixTests, InterProcessSignalTests, + support.run_unittest(GenericTests, PosixTests, InterProcessSignalTests, WakeupFDTests, WakeupSignalTests, SiginterruptTest, ItimerTest, WindowsSignalTests, PendingSignalsTests) diff -r d8659dbebfd1 Modules/signalmodule.c --- a/Modules/signalmodule.c Thu Mar 27 20:51:15 2014 -0700 +++ b/Modules/signalmodule.c Fri Mar 28 18:04:41 2014 +0100 @@ -967,7 +967,7 @@ }; PyMODINIT_FUNC -PyInit_signal(void) +PyInit__signal(void) { PyObject *m, *d, *x; int i; @@ -1380,7 +1380,7 @@ void PyOS_InitInterrupts(void) { - PyObject *m = PyImport_ImportModule("signal"); + PyObject *m = PyImport_ImportModule("_signal"); if (m) { Py_DECREF(m); } diff -r d8659dbebfd1 PC/config.c --- a/PC/config.c Thu Mar 27 20:51:15 2014 -0700 +++ b/PC/config.c Fri Mar 28 18:04:41 2014 +0100 @@ -19,7 +19,7 @@ extern PyObject* PyInit__md5(void); extern PyObject* PyInit_nt(void); extern PyObject* PyInit__operator(void); -extern PyObject* PyInit_signal(void); +extern PyObject* PyInit__signal(void); extern PyObject* PyInit__sha1(void); extern PyObject* PyInit__sha256(void); extern PyObject* PyInit__sha512(void);