mirror of
https://github.com/davidhalter/typeshed.git
synced 2025-12-08 04:54:47 +08:00
d05a9d3d83
I realized while working on srittau/type-stub-pep#64 that a
few things we do in existing enum definitions in typeshed are
problematic:
- Using "= ..." doesn't allow type checkers to correctly type the
result of Enum.MEMBER.value. In fact, mypy at least infers
.value to be "Ellipsis" if you do this.
- Properties on the enum values themselves, like HTTPStatus.phrase,
should not be specified directly as attributes, because it makes
type checkers think that the properties themselves are enum
members.
I ended up doing a bit more cleanup to the signal module:
- Remove unnecessary ... initializers.
- Remove unnecessary _SIG = Signals alias.
- I don't have Windows to test, but the C code for _signal suggests
that CTRL_C_EVENT and CTRL_BREAK events are not Signals, but just ints:
1dbd084f1f/Modules/signalmodule.c (L1575)
174 lines
3.5 KiB
Python
174 lines
3.5 KiB
Python
"""Stub file for the 'signal' module."""
|
|
|
|
from enum import IntEnum
|
|
from typing import Any, Callable, Tuple, Union, Optional, Iterable, Set
|
|
from types import FrameType
|
|
|
|
class ItimerError(IOError): ...
|
|
|
|
ITIMER_PROF: int
|
|
ITIMER_REAL: int
|
|
ITIMER_VIRTUAL: int
|
|
|
|
NSIG: int
|
|
|
|
class Signals(IntEnum):
|
|
SIGABRT: int
|
|
SIGALRM: int
|
|
SIGBREAK: int # Windows
|
|
SIGBUS: int
|
|
SIGCHLD: int
|
|
SIGCLD: int
|
|
SIGCONT: int
|
|
SIGEMT: int
|
|
SIGFPE: int
|
|
SIGHUP: int
|
|
SIGILL: int
|
|
SIGINFO: int
|
|
SIGINT: int
|
|
SIGIO: int
|
|
SIGIOT: int
|
|
SIGKILL: int
|
|
SIGPIPE: int
|
|
SIGPOLL: int
|
|
SIGPROF: int
|
|
SIGPWR: int
|
|
SIGQUIT: int
|
|
SIGRTMAX: int
|
|
SIGRTMIN: int
|
|
SIGSEGV: int
|
|
SIGSTOP: int
|
|
SIGSYS: int
|
|
SIGTERM: int
|
|
SIGTRAP: int
|
|
SIGTSTP: int
|
|
SIGTTIN: int
|
|
SIGTTOU: int
|
|
SIGURG: int
|
|
SIGUSR1: int
|
|
SIGUSR2: int
|
|
SIGVTALRM: int
|
|
SIGWINCH: int
|
|
SIGXCPU: int
|
|
SIGXFSZ: int
|
|
|
|
class Handlers(IntEnum):
|
|
SIG_DFL: int
|
|
SIG_IGN: int
|
|
|
|
SIG_DFL = Handlers.SIG_DFL
|
|
SIG_IGN = Handlers.SIG_IGN
|
|
|
|
class Sigmasks(IntEnum):
|
|
SIG_BLOCK: int
|
|
SIG_UNBLOCK: int
|
|
SIG_SETMASK: int
|
|
|
|
SIG_BLOCK = Sigmasks.SIG_BLOCK
|
|
SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK
|
|
SIG_SETMASK = Sigmasks.SIG_SETMASK
|
|
|
|
_SIGNUM = Union[int, Signals]
|
|
_HANDLER = Union[Callable[[Signals, FrameType], None], int, Handlers, None]
|
|
|
|
SIGABRT: Signals
|
|
SIGALRM: Signals
|
|
SIGBREAK: Signals # Windows
|
|
SIGBUS: Signals
|
|
SIGCHLD: Signals
|
|
SIGCLD: Signals
|
|
SIGCONT: Signals
|
|
SIGEMT: Signals
|
|
SIGFPE: Signals
|
|
SIGHUP: Signals
|
|
SIGILL: Signals
|
|
SIGINFO: Signals
|
|
SIGINT: Signals
|
|
SIGIO: Signals
|
|
SIGIOT: Signals
|
|
SIGKILL: Signals
|
|
SIGPIPE: Signals
|
|
SIGPOLL: Signals
|
|
SIGPROF: Signals
|
|
SIGPWR: Signals
|
|
SIGQUIT: Signals
|
|
SIGRTMAX: Signals
|
|
SIGRTMIN: Signals
|
|
SIGSEGV: Signals
|
|
SIGSTOP: Signals
|
|
SIGSYS: Signals
|
|
SIGTERM: Signals
|
|
SIGTRAP: Signals
|
|
SIGTSTP: Signals
|
|
SIGTTIN: Signals
|
|
SIGTTOU: Signals
|
|
SIGURG: Signals
|
|
SIGUSR1: Signals
|
|
SIGUSR2: Signals
|
|
SIGVTALRM: Signals
|
|
SIGWINCH: Signals
|
|
SIGXCPU: Signals
|
|
SIGXFSZ: Signals
|
|
|
|
# Windows
|
|
CTRL_C_EVENT: int
|
|
CTRL_BREAK_EVENT: int
|
|
|
|
class struct_siginfo(Tuple[int, int, int, int, int, int, int]):
|
|
def __init__(self, sequence: Iterable[int]) -> None: ...
|
|
@property
|
|
def si_signo(self) -> int: ...
|
|
@property
|
|
def si_code(self) -> int: ...
|
|
@property
|
|
def si_errno(self) -> int: ...
|
|
@property
|
|
def si_pid(self) -> int: ...
|
|
@property
|
|
def si_uid(self) -> int: ...
|
|
@property
|
|
def si_status(self) -> int: ...
|
|
@property
|
|
def si_band(self) -> int: ...
|
|
|
|
def alarm(time: int) -> int: ...
|
|
|
|
def default_int_handler(signum: int, frame: FrameType) -> None:
|
|
raise KeyboardInterrupt()
|
|
|
|
def getitimer(which: int) -> Tuple[float, float]: ...
|
|
|
|
def getsignal(signalnum: _SIGNUM) -> _HANDLER:
|
|
raise ValueError()
|
|
|
|
def pause() -> None: ...
|
|
|
|
def pthread_kill(thread_id: int, signum: int) -> None:
|
|
raise OSError()
|
|
|
|
def pthread_sigmask(how: int, mask: Iterable[int]) -> Set[_SIGNUM]:
|
|
raise OSError()
|
|
|
|
def set_wakeup_fd(fd: int) -> int: ...
|
|
|
|
def setitimer(which: int, seconds: float, interval: float = ...) -> Tuple[float, float]: ...
|
|
|
|
def siginterrupt(signalnum: int, flag: bool) -> None:
|
|
raise OSError()
|
|
|
|
def signal(signalnum: _SIGNUM, handler: _HANDLER) -> _HANDLER:
|
|
raise OSError()
|
|
|
|
def sigpending() -> Any:
|
|
raise OSError()
|
|
|
|
def sigtimedwait(sigset: Iterable[int], timeout: float) -> Optional[struct_siginfo]:
|
|
raise OSError()
|
|
raise ValueError()
|
|
|
|
def sigwait(sigset: Iterable[int]) -> _SIGNUM:
|
|
raise OSError()
|
|
|
|
def sigwaitinfo(sigset: Iterable[int]) -> struct_siginfo:
|
|
raise OSError()
|