Remove windows python distribution from repo and add requirements.txt

1 files changed, 0 insertions, 1340 deletions

diff --git a/python/gevent/libev/corecext.pyx b/python/gevent/libev/corecext.pyx
deleted file mode 100644
index 793b002..0000000
--- a/python/gevent/libev/corecext.pyx
+++ /dev/null
@@ -1,1340 +0,0 @@
-# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details.
-
-# This first directive, supported in Cython 0.24+, causes sources
-# files to be *much* smaller when it's false (139,027 LOC vs 35,000
-# LOC) and thus cythonpp.py (and probably the compiler; also Visual C
-# has limits on source file sizes) to be faster (73s vs 46s). But it does
-# make debugging more difficult. Auto-pickling was added in 0.26, and
-# that's a new feature that we don't need or want to allow in a gevent
-# point release.
-
-# cython: emit_code_comments=False, auto_pickle=False
-
-# NOTE: We generally cannot use the Cython IF directive as documented
-# at
-# http://cython.readthedocs.io/en/latest/src/userguide/language_basics.html#conditional-compilation
-# (e.g., IF UNAME_SYSNAME == "Windows") because when Cython says
-# "compilation", it means when *Cython* compiles, not when the C
-# compiler compiles. We distribute an sdist with a single pre-compiled
-# C file for all platforms so that end users that don't use a binary
-# wheel don't have to sit through cythonpp and other steps the Makefile does.
-# See https://github.com/gevent/gevent/issues/1076
-
-cimport cython
-cimport libev
-
-from cpython.ref cimport Py_INCREF
-from cpython.ref cimport Py_DECREF
-from cpython.mem cimport PyMem_Malloc
-from cpython.mem cimport PyMem_Free
-from libc.errno cimport errno
-
-cdef extern from "Python.h":
-    int    Py_ReprEnter(object)
-    void   Py_ReprLeave(object)
-
-# Work around lack of absolute_import in Cython
-# Note for PY3: not doing so will leave reference to locals() on import
-# (reproducible under Python 3.3, not under Python 3.4; see test__refcount_core.py)
-sys = __import__('sys', level=0)
-os = __import__('os', level=0)
-traceback = __import__('traceback', level=0)
-signalmodule = __import__('signal', level=0)
-getswitchinterval = __import__('gevent', level=0).getswitchinterval
-
-
-__all__ = ['get_version',
-           'get_header_version',
-           'supported_backends',
-           'recommended_backends',
-           'embeddable_backends',
-           'time',
-           'loop']
-
-cdef tuple integer_types
-
-if sys.version_info[0] >= 3:
-    integer_types = int,
-else:
-    integer_types = (int, long)
-
-
-cdef extern from "callbacks.h":
-    void gevent_callback_io(libev.ev_loop, void*, int)
-    void gevent_callback_timer(libev.ev_loop, void*, int)
-    void gevent_callback_signal(libev.ev_loop, void*, int)
-    void gevent_callback_idle(libev.ev_loop, void*, int)
-    void gevent_callback_prepare(libev.ev_loop, void*, int)
-    void gevent_callback_check(libev.ev_loop, void*, int)
-    void gevent_callback_fork(libev.ev_loop, void*, int)
-    void gevent_callback_async(libev.ev_loop, void*, int)
-    void gevent_callback_child(libev.ev_loop, void*, int)
-    void gevent_callback_stat(libev.ev_loop, void*, int)
-    void gevent_run_callbacks(libev.ev_loop, void*, int)
-    void gevent_periodic_signal_check(libev.ev_loop, void*, int)
-    void gevent_call(loop, callback)
-    void gevent_noop(libev.ev_loop, void*, int)
-
-cdef extern from "stathelper.c":
-    object _pystat_fromstructstat(void*)
-
-
-UNDEF = libev.EV_UNDEF
-NONE = libev.EV_NONE
-READ = libev.EV_READ
-WRITE = libev.EV_WRITE
-TIMER = libev.EV_TIMER
-PERIODIC = libev.EV_PERIODIC
-SIGNAL = libev.EV_SIGNAL
-CHILD = libev.EV_CHILD
-STAT = libev.EV_STAT
-IDLE = libev.EV_IDLE
-PREPARE = libev.EV_PREPARE
-CHECK = libev.EV_CHECK
-EMBED = libev.EV_EMBED
-FORK = libev.EV_FORK
-CLEANUP = libev.EV_CLEANUP
-ASYNC = libev.EV_ASYNC
-CUSTOM = libev.EV_CUSTOM
-ERROR = libev.EV_ERROR
-
-READWRITE = libev.EV_READ | libev.EV_WRITE
-
-MINPRI = libev.EV_MINPRI
-MAXPRI = libev.EV_MAXPRI
-
-BACKEND_PORT = libev.EVBACKEND_PORT
-BACKEND_KQUEUE = libev.EVBACKEND_KQUEUE
-BACKEND_EPOLL = libev.EVBACKEND_EPOLL
-BACKEND_POLL = libev.EVBACKEND_POLL
-BACKEND_SELECT = libev.EVBACKEND_SELECT
-FORKCHECK = libev.EVFLAG_FORKCHECK
-NOINOTIFY = libev.EVFLAG_NOINOTIFY
-SIGNALFD = libev.EVFLAG_SIGNALFD
-NOSIGMASK = libev.EVFLAG_NOSIGMASK
-
-
-@cython.internal
-cdef class _EVENTSType:
-
-    def __repr__(self):
-        return 'gevent.core.EVENTS'
-
-
-cdef public object GEVENT_CORE_EVENTS = _EVENTSType()
-EVENTS = GEVENT_CORE_EVENTS
-
-
-def get_version():
-    return 'libev-%d.%02d' % (libev.ev_version_major(), libev.ev_version_minor())
-
-
-def get_header_version():
-    return 'libev-%d.%02d' % (libev.EV_VERSION_MAJOR, libev.EV_VERSION_MINOR)
-
-
-# This list backends in the order they are actually tried by libev
-_flags = [(libev.EVBACKEND_PORT, 'port'),
-          (libev.EVBACKEND_KQUEUE, 'kqueue'),
-          (libev.EVBACKEND_EPOLL, 'epoll'),
-          (libev.EVBACKEND_POLL, 'poll'),
-          (libev.EVBACKEND_SELECT, 'select'),
-          (libev.EVFLAG_NOENV, 'noenv'),
-          (libev.EVFLAG_FORKCHECK, 'forkcheck'),
-          (libev.EVFLAG_NOINOTIFY, 'noinotify'),
-          (libev.EVFLAG_SIGNALFD, 'signalfd'),
-          (libev.EVFLAG_NOSIGMASK, 'nosigmask')]
-
-
-_flags_str2int = dict((string, flag) for (flag, string) in _flags)
-
-
-_events = [(libev.EV_READ,     'READ'),
-           (libev.EV_WRITE,    'WRITE'),
-           (libev.EV__IOFDSET, '_IOFDSET'),
-           (libev.EV_PERIODIC, 'PERIODIC'),
-           (libev.EV_SIGNAL,   'SIGNAL'),
-           (libev.EV_CHILD,    'CHILD'),
-           (libev.EV_STAT,     'STAT'),
-           (libev.EV_IDLE,     'IDLE'),
-           (libev.EV_PREPARE,  'PREPARE'),
-           (libev.EV_CHECK,    'CHECK'),
-           (libev.EV_EMBED,    'EMBED'),
-           (libev.EV_FORK,     'FORK'),
-           (libev.EV_CLEANUP,  'CLEANUP'),
-           (libev.EV_ASYNC,    'ASYNC'),
-           (libev.EV_CUSTOM,   'CUSTOM'),
-           (libev.EV_ERROR,    'ERROR')]
-
-
-cpdef _flags_to_list(unsigned int flags):
-    cdef list result = []
-    for code, value in _flags:
-        if flags & code:
-            result.append(value)
-        flags &= ~code
-        if not flags:
-            break
-    if flags:
-        result.append(flags)
-    return result
-
-
-if sys.version_info[0] >= 3:
-    basestring = (bytes, str)
-else:
-    basestring = __builtins__.basestring
-
-
-cpdef unsigned int _flags_to_int(object flags) except? -1:
-    # Note, that order does not matter, libev has its own predefined order
-    if not flags:
-        return 0
-    if isinstance(flags, integer_types):
-        return flags
-    cdef unsigned int result = 0
-    try:
-        if isinstance(flags, basestring):
-            flags = flags.split(',')
-        for value in flags:
-            value = value.strip().lower()
-            if value:
-                result |= _flags_str2int[value]
-    except KeyError as ex:
-        raise ValueError('Invalid backend or flag: %s\nPossible values: %s' % (ex, ', '.join(sorted(_flags_str2int.keys()))))
-    return result
-
-
-cdef str _str_hex(object flag):
-    if isinstance(flag, integer_types):
-        return hex(flag)
-    return str(flag)
-
-
-cpdef _check_flags(unsigned int flags):
-    cdef list as_list
-    flags &= libev.EVBACKEND_MASK
-    if not flags:
-        return
-    if not (flags & libev.EVBACKEND_ALL):
-        raise ValueError('Invalid value for backend: 0x%x' % flags)
-    if not (flags & libev.ev_supported_backends()):
-        as_list = [_str_hex(x) for x in _flags_to_list(flags)]
-        raise ValueError('Unsupported backend: %s' % '|'.join(as_list))
-
-
-cpdef _events_to_str(int events):
-    cdef list result = []
-    cdef int c_flag
-    for (flag, string) in _events:
-        c_flag = flag
-        if events & c_flag:
-            result.append(string)
-            events = events & (~c_flag)
-        if not events:
-            break
-    if events:
-        result.append(hex(events))
-    return '|'.join(result)
-
-
-def supported_backends():
-    return _flags_to_list(libev.ev_supported_backends())
-
-
-def recommended_backends():
-    return _flags_to_list(libev.ev_recommended_backends())
-
-
-def embeddable_backends():
-    return _flags_to_list(libev.ev_embeddable_backends())
-
-
-def time():
-    return libev.ev_time()
-
-cdef bint _check_loop(loop loop) except -1:
-    if not loop._ptr:
-        raise ValueError('operation on destroyed loop')
-    return 1
-
-
-
-cdef public class callback [object PyGeventCallbackObject, type PyGeventCallback_Type]:
-    cdef public object callback
-    cdef public tuple args
-    cdef callback next
-
-    def __init__(self, callback, args):
-        self.callback = callback
-        self.args = args
-
-    def stop(self):
-        self.callback = None
-        self.args = None
-
-    close = stop
-
-    # Note, that __nonzero__ and pending are different
-    # nonzero is used in contexts where we need to know whether to schedule another callback,
-    # so it's true if it's pending or currently running
-    # 'pending' has the same meaning as libev watchers: it is cleared before entering callback
-
-    def __nonzero__(self):
-        # it's nonzero if it's pending or currently executing
-        return self.args is not None
-
-    @property
-    def pending(self):
-        return self.callback is not None
-
-    def __repr__(self):
-        if Py_ReprEnter(self) != 0:
-            return "<...>"
-        try:
-            format = self._format()
-            result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), format)
-            if self.pending:
-                result += " pending"
-            if self.callback is not None:
-                result += " callback=%r" % (self.callback, )
-            if self.args is not None:
-                result += " args=%r" % (self.args, )
-            if self.callback is None and self.args is None:
-                result += " stopped"
-            return result + ">"
-        finally:
-            Py_ReprLeave(self)
-
-    def _format(self):
-        return ''
-
-DEF CALLBACK_CHECK_COUNT = 50
-
-@cython.final
-@cython.internal
-cdef class CallbackFIFO(object):
-    cdef callback head
-    cdef callback tail
-
-    def __init__(self):
-        self.head = None
-        self.tail = None
-
-    cdef inline callback popleft(self):
-        cdef callback head = self.head
-        self.head = head.next
-        if self.head is self.tail or self.head is None:
-            self.tail = None
-        head.next = None
-        return head
-
-
-    cdef inline append(self, callback new_tail):
-        assert not new_tail.next
-        if self.tail is None:
-            if self.head is None:
-                # Completely empty, so this
-                # is now our head
-                self.head = new_tail
-                return
-            self.tail = self.head
-
-
-        assert self.head is not None
-        old_tail = self.tail
-        old_tail.next = new_tail
-        self.tail = new_tail
-
-    def __nonzero__(self):
-        return self.head is not None
-
-    def __len__(self):
-        cdef Py_ssize_t count = 0
-        head = self.head
-        while head is not None:
-            count += 1
-            head = head.next
-        return count
-
-    def __iter__(self):
-        cdef list objects = []
-        head = self.head
-        while head is not None:
-            objects.append(head)
-            head = head.next
-        return iter(objects)
-
-    cdef bint has_callbacks(self):
-        return self.head
-
-    def __repr__(self):
-        return "<callbacks@%r len=%d head=%r tail=%r>" % (id(self), len(self), self.head, self.tail)
-
-
-cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
-    ## embedded struct members
-    cdef libev.ev_prepare _prepare
-    cdef libev.ev_timer _timer0
-    # We'll only actually start this timer if we're on Windows,
-    # but it doesn't hurt to compile it in on all platforms.
-    cdef libev.ev_timer _periodic_signal_checker
-
-    ## pointer members
-    cdef public object error_handler
-    cdef libev.ev_loop* _ptr
-    cdef public CallbackFIFO _callbacks
-
-    ## data members
-    cdef bint starting_timer_may_update_loop_time
-    # We must capture the 'default' state at initialiaztion
-    # time. Destroying the default loop in libev sets
-    # the libev internal pointer to 0, and ev_is_default_loop will
-    # no longer work.
-    cdef bint _default
-
-    def __cinit__(self, object flags=None, object default=None, libev.intptr_t ptr=0):
-        self.starting_timer_may_update_loop_time = 0
-        self._default = 0
-        libev.ev_prepare_init(&self._prepare,
-                              <void*>gevent_run_callbacks)
-        libev.ev_timer_init(&self._periodic_signal_checker,
-                            <void*>gevent_periodic_signal_check,
-                            0.3, 0.3)
-        libev.ev_timer_init(&self._timer0,
-                            <void*>gevent_noop,
-                            0.0, 0.0)
-
-        cdef unsigned int c_flags
-        cdef object old_handler = None
-        if ptr:
-            self._ptr = <libev.ev_loop*>ptr
-            self._default = libev.ev_is_default_loop(self._ptr)
-        else:
-            c_flags = _flags_to_int(flags)
-            _check_flags(c_flags)
-            c_flags |= libev.EVFLAG_NOENV
-            c_flags |= libev.EVFLAG_FORKCHECK
-            if default is None:
-                default = True
-            if default:
-                self._default = 1
-                self._ptr = libev.gevent_ev_default_loop(c_flags)
-                if not self._ptr:
-                    raise SystemError("ev_default_loop(%s) failed" % (c_flags, ))
-                if sys.platform == "win32":
-                    libev.ev_timer_start(self._ptr, &self._periodic_signal_checker)
-                    libev.ev_unref(self._ptr)
-            else:
-                self._ptr = libev.ev_loop_new(c_flags)
-                if not self._ptr:
-                    raise SystemError("ev_loop_new(%s) failed" % (c_flags, ))
-            if default or __SYSERR_CALLBACK is None:
-                set_syserr_cb(self._handle_syserr)
-
-        # Mark as not destroyed
-        libev.ev_set_userdata(self._ptr, self._ptr)
-
-        libev.ev_prepare_start(self._ptr, &self._prepare)
-        libev.ev_unref(self._ptr)
-
-    def __init__(self, object flags=None, object default=None, libev.intptr_t ptr=0):
-        self._callbacks = CallbackFIFO()
-
-    cdef _run_callbacks(self):
-        cdef callback cb
-        cdef object callbacks
-        cdef int count = CALLBACK_CHECK_COUNT
-        self.starting_timer_may_update_loop_time = True
-        cdef libev.ev_tstamp now = libev.ev_now(self._ptr)
-        cdef libev.ev_tstamp expiration = now + <libev.ev_tstamp>getswitchinterval()
-
-        try:
-            libev.ev_timer_stop(self._ptr, &self._timer0)
-            while self._callbacks.head is not None:
-                cb = self._callbacks.popleft()
-
-                libev.ev_unref(self._ptr)
-                gevent_call(self, cb) # XXX: Why is this a C callback, not cython?
-                count -= 1
-
-                if count == 0 and self._callbacks.head is not None:
-                    # We still have more to run but we've reached
-                    # the end of one check group
-                    count = CALLBACK_CHECK_COUNT
-
-                    libev.ev_now_update(self._ptr)
-                    if libev.ev_now(self._ptr) >= expiration:
-                        now = 0
-                        break
-
-            if now != 0:
-                libev.ev_now_update(self._ptr)
-            if self._callbacks.head is not None:
-                libev.ev_timer_start(self._ptr, &self._timer0)
-        finally:
-            self.starting_timer_may_update_loop_time = False
-
-    cdef _stop_watchers(self, libev.ev_loop* ptr):
-        if not ptr:
-            return
-
-        if libev.ev_is_active(&self._prepare):
-            libev.ev_ref(ptr)
-            libev.ev_prepare_stop(ptr, &self._prepare)
-        if libev.ev_is_active(&self._periodic_signal_checker):
-            libev.ev_ref(ptr)
-            libev.ev_timer_stop(ptr, &self._periodic_signal_checker)
-
-    def destroy(self):
-        cdef libev.ev_loop* ptr = self._ptr
-        self._ptr = NULL
-
-        if ptr:
-            if not libev.ev_userdata(ptr):
-                # Whoops! Program error. They destroyed the loop,
-                # using a different loop object. Our _ptr is still
-                # valid, but the libev loop is gone. Doing anything
-                # else with it will likely cause a crash.
-                return
-            # Mark as destroyed
-            libev.ev_set_userdata(ptr, NULL)
-            self._stop_watchers(ptr)
-            if __SYSERR_CALLBACK == self._handle_syserr:
-                set_syserr_cb(None)
-            libev.ev_loop_destroy(ptr)
-
-    def __dealloc__(self):
-        cdef libev.ev_loop* ptr = self._ptr
-        self._ptr = NULL
-        if ptr != NULL:
-            if not libev.ev_userdata(ptr):
-                # See destroy(). This is a bug in the caller.
-                return
-            self._stop_watchers(ptr)
-            if not self._default:
-                libev.ev_loop_destroy(ptr)
-                # Mark as destroyed
-                libev.ev_set_userdata(ptr, NULL)
-
-    @property
-    def ptr(self):
-        return <size_t>self._ptr
-
-    @property
-    def WatcherType(self):
-        return watcher
-
-    @property
-    def MAXPRI(self):
-        return libev.EV_MAXPRI
-
-    @property
-    def MINPRI(self):
-        return libev.EV_MINPRI
-
-    def _handle_syserr(self, message, errno):
-        if sys.version_info[0] >= 3:
-            message = message.decode()
-        self.handle_error(None, SystemError, SystemError(message + ': ' + os.strerror(errno)), None)
-
-    cpdef handle_error(self, context, type, value, tb):
-        cdef object handle_error
-        cdef object error_handler = self.error_handler
-        if error_handler is not None:
-            # we do want to do getattr every time so that setting Hub.handle_error property just works
-            handle_error = getattr(error_handler, 'handle_error', error_handler)
-            handle_error(context, type, value, tb)
-        else:
-            self._default_handle_error(context, type, value, tb)
-
-    cpdef _default_handle_error(self, context, type, value, tb):
-        # note: Hub sets its own error handler so this is not used by gevent
-        # this is here to make core.loop usable without the rest of gevent
-        traceback.print_exception(type, value, tb)
-        if self._ptr:
-            libev.ev_break(self._ptr, libev.EVBREAK_ONE)
-
-    def run(self, nowait=False, once=False):
-        _check_loop(self)
-        cdef unsigned int flags = 0
-        if nowait:
-            flags |= libev.EVRUN_NOWAIT
-        if once:
-            flags |= libev.EVRUN_ONCE
-        with nogil:
-            libev.ev_run(self._ptr, flags)
-
-    def reinit(self):
-        if self._ptr:
-            libev.ev_loop_fork(self._ptr)
-
-    def ref(self):
-        _check_loop(self)
-        libev.ev_ref(self._ptr)
-
-    def unref(self):
-        _check_loop(self)
-        libev.ev_unref(self._ptr)
-
-    def break_(self, int how=libev.EVBREAK_ONE):
-        _check_loop(self)
-        libev.ev_break(self._ptr, how)
-
-    def verify(self):
-        _check_loop(self)
-        libev.ev_verify(self._ptr)
-
-    cpdef libev.ev_tstamp now(self) except *:
-        _check_loop(self)
-        return libev.ev_now(self._ptr)
-
-    cpdef void update_now(self) except *:
-        _check_loop(self)
-        libev.ev_now_update(self._ptr)
-
-    update = update_now # Old name, deprecated.
-
-    def __repr__(self):
-        return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self._format())
-
-    @property
-    def default(self):
-        # If we're destroyed, we are not the default loop anymore,
-        # as far as Python is concerned.
-        return self._default if self._ptr else False
-
-    @property
-    def iteration(self):
-        _check_loop(self)
-        return libev.ev_iteration(self._ptr)
-
-    @property
-    def depth(self):
-        _check_loop(self)
-        return libev.ev_depth(self._ptr)
-
-    @property
-    def backend_int(self):
-        _check_loop(self)
-        return libev.ev_backend(self._ptr)
-
-    @property
-    def backend(self):
-        _check_loop(self)
-        cdef unsigned int backend = libev.ev_backend(self._ptr)
-        for key, value in _flags:
-            if key == backend:
-                return value
-        return backend
-
-    @property
-    def pendingcnt(self):
-        _check_loop(self)
-        return libev.ev_pending_count(self._ptr)
-
-    def io(self, libev.vfd_socket_t fd, int events, ref=True, priority=None):
-        return io(self, fd, events, ref, priority)
-
-    def timer(self, double after, double repeat=0.0, ref=True, priority=None):
-        return timer(self, after, repeat, ref, priority)
-
-    def signal(self, int signum, ref=True, priority=None):
-        return signal(self, signum, ref, priority)
-
-    def idle(self, ref=True, priority=None):
-        return idle(self, ref, priority)
-
-    def prepare(self, ref=True, priority=None):
-        return prepare(self, ref, priority)
-
-    def check(self, ref=True, priority=None):
-        return check(self, ref, priority)
-
-    def fork(self, ref=True, priority=None):
-        return fork(self, ref, priority)
-
-    def async_(self, ref=True, priority=None):
-        return async_(self, ref, priority)
-
-    # cython doesn't enforce async as a keyword
-    async = async_
-
-    def child(self, int pid, bint trace=0, ref=True):
-        if sys.platform == 'win32':
-            raise AttributeError("Child watchers are not supported on Windows")
-        return child(self, pid, trace, ref)
-
-    def install_sigchld(self):
-        libev.gevent_install_sigchld_handler()
-
-    def reset_sigchld(self):
-        libev.gevent_reset_sigchld_handler()
-
-    def stat(self, str path, float interval=0.0, ref=True, priority=None):
-        return stat(self, path, interval, ref, priority)
-
-    def run_callback(self, func, *args):
-        _check_loop(self)
-        cdef callback cb = callback(func, args)
-        self._callbacks.append(cb)
-        libev.ev_ref(self._ptr)
-        return cb
-
-    def _format(self):
-        if not self._ptr:
-            return 'destroyed'
-        cdef object msg = self.backend
-        if self._default:
-            msg += ' default'
-        msg += ' pending=%s' % self.pendingcnt
-        msg += self._format_details()
-        return msg
-
-    def _format_details(self):
-        cdef str msg = ''
-        cdef object fileno = self.fileno()
-        cdef object activecnt = None
-        try:
-            sigfd = self.sigfd
-        except AttributeError:
-            sigfd = None
-        try:
-            activecnt = self.activecnt
-        except AttributeError:
-            pass
-        if activecnt is not None:
-            msg += ' ref=' + repr(activecnt)
-        if fileno is not None:
-            msg += ' fileno=' + repr(fileno)
-        return msg
-
-    def fileno(self):
-        cdef int fd
-        if self._ptr:
-            fd = libev.gevent_ev_loop_backend_fd(self._ptr)
-            if fd >= 0:
-                return fd
-
-    @property
-    def activecnt(self):
-        _check_loop(self)
-        return libev.gevent_ev_loop_activecnt(self._ptr)
-
-    @property
-    def sig_pending(self):
-        _check_loop(self)
-        return libev.gevent_ev_loop_sig_pending(self._ptr)
-
-    @property
-    def origflags(self):
-        return _flags_to_list(self.origflags_int)
-
-    @property
-    def origflags_int(self):
-        _check_loop(self)
-        return libev.gevent_ev_loop_origflags(self._ptr)
-
-    @property
-    def sigfd(self):
-        _check_loop(self)
-        fd = libev.gevent_ev_loop_sigfd(self._ptr)
-        if fd >= 0:
-            return fd
-
-        # Explicitly not EV_USE_SIGNALFD
-        raise AttributeError("sigfd")
-
-
-# about readonly _flags attribute:
-# bit #1 set if object owns Python reference to itself (Py_INCREF was
-# called and we must call Py_DECREF later)
-DEF FLAG_WATCHER_OWNS_PYREF = 1 << 0 # 0x1
-# bit #2 set if ev_unref() was called and we must call ev_ref() later
-DEF FLAG_WATCHER_NEEDS_EVREF = 1 << 1 # 0x2
-# bit #3 set if user wants to call ev_unref() before start()
-DEF FLAG_WATCHER_UNREF_BEFORE_START = 1 << 2 # 0x4
-# bits 2 and 3 are *both* set when we are active, but the user
-# request us not to be ref'd anymore. We unref us (because going active will
-# ref us) and then make a note of this in the future
-DEF FLAG_WATCHER_MASK_UNREF_NEEDS_REF = 0x6
-
-
-cdef void _python_incref(watcher self):
-    if not self._flags & FLAG_WATCHER_OWNS_PYREF:
-        Py_INCREF(self)
-        self._flags |= FLAG_WATCHER_OWNS_PYREF
-
-cdef void _python_decref(watcher self):
-    if self._flags & FLAG_WATCHER_OWNS_PYREF:
-        Py_DECREF(self)
-        self._flags &= ~FLAG_WATCHER_OWNS_PYREF
-
-cdef void _libev_ref(watcher self):
-    if self._flags & FLAG_WATCHER_NEEDS_EVREF:
-        libev.ev_ref(self.loop._ptr)
-        self._flags &= ~FLAG_WATCHER_NEEDS_EVREF
-
-cdef void _libev_unref(watcher self):
-    if self._flags & FLAG_WATCHER_MASK_UNREF_NEEDS_REF == FLAG_WATCHER_UNREF_BEFORE_START:
-        libev.ev_unref(self.loop._ptr)
-        self._flags |= FLAG_WATCHER_NEEDS_EVREF
-
-
-ctypedef void (*start_stop_func)(libev.ev_loop*, void*) nogil
-
-cdef struct start_and_stop:
-    start_stop_func start
-    start_stop_func stop
-
-cdef start_and_stop make_ss(void* start, void* stop):
-    cdef start_and_stop result = start_and_stop(<start_stop_func>start, <start_stop_func>stop)
-    return result
-
-cdef bint _watcher_start(watcher self, object callback, tuple args) except -1:
-    # This method should be called by subclasses of watcher, if they
-    # override the python-level `start` function: they've already paid
-    # for argument unpacking, and `start` cannot be cpdef since it
-    # uses varargs.
-
-    # We keep this as a function, not a cdef method of watcher.
-    # If it's a cdef method, it could potentially be overridden
-    # by a subclass, which means that the watcher gains a pointer to a
-    # function table (vtable), making each object 8 bytes larger.
-
-    _check_loop(self.loop)
-    if callback is None or not callable(callback):
-        raise TypeError("Expected callable, not %r" % (callback, ))
-    self._callback = callback
-    self.args = args
-    _libev_unref(self)
-    _python_incref(self)
-    self.__ss.start(self.loop._ptr, self.__watcher)
-    return 1
-
-cdef public class watcher [object PyGeventWatcherObject, type PyGeventWatcher_Type]:
-    """Abstract base class for all the watchers"""
-    ## pointer members
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-
-    # By keeping a __watcher cached, the size of the io and timer
-    # structs becomes 152 bytes and child is 160 and stat is 512 (when
-    # the start_and_stop is inlined). On 64-bit macOS CPython 2.7. I
-    # hoped that using libev's data pointer and allocating the
-    # watchers directly and not as inline members would result in
-    # overall savings thanks to better padding, but it didn't. And it
-    # added lots of casts, making the code ugly.
-
-    # Table:
-    # gevent ver   | 1.2 | This | +data
-    # Watcher Kind |     |      |
-    # Timer        | 120 | 152  | 160
-    # IO           | 120 | 152  | 160
-    # Child        | 128 | 160  | 168
-    # Stat         | 480 | 512  | 512
-    cdef libev.ev_watcher* __watcher
-
-    # By inlining the start_and_stop struct, instead of taking the address
-    # of a static struct or using the watcher's data pointer, we
-    # use an additional pointer of memory and incur an additional pointer copy
-    # on creation.
-    # But we use fewer pointer accesses for start/stop, and they have
-    # better cache locality. (Then again, we're bigger).
-    # Right now we're going for size, so we use the pointer. IO/Timer objects
-    # are then 144 bytes.
-    cdef start_and_stop* __ss
-
-    ## Int members
-
-    # Our subclasses will declare the ev_X struct
-    # as an inline member. This is good for locality, but
-    # probably bad for alignment, as it will get tacked on
-    # immediately after our data.
-
-    # But all ev_watchers start with some ints, so maybe we can help that
-    # out by putting our ints here.
-    cdef readonly unsigned int _flags
-
-    def __init__(self, loop loop, ref=True, priority=None):
-        if not self.__watcher or not self.__ss.start or not self.__ss.stop:
-            raise ValueError("Cannot construct a bare watcher")
-        self.loop = loop
-        self._flags = 0 if ref else FLAG_WATCHER_UNREF_BEFORE_START
-        if priority is not None:
-            libev.ev_set_priority(self.__watcher, priority)
-
-    @property
-    def ref(self):
-        return False if self._flags & 4 else True
-
-    @ref.setter
-    def ref(self, object value):
-        _check_loop(self.loop)
-        if value:
-            # self.ref should be true after this.
-            if self.ref:
-               return  # ref is already True
-
-            if self._flags & FLAG_WATCHER_NEEDS_EVREF:  # ev_unref was called, undo
-               libev.ev_ref(self.loop._ptr)
-			# do not want unref, no outstanding unref
-            self._flags &= ~FLAG_WATCHER_MASK_UNREF_NEEDS_REF
-        else:
-			# self.ref must be false after this
-            if not self.ref:
-               return  # ref is already False
-            self._flags |= FLAG_WATCHER_UNREF_BEFORE_START
-            if not self._flags & FLAG_WATCHER_NEEDS_EVREF and libev.ev_is_active(self.__watcher):
-               libev.ev_unref(self.loop._ptr)
-               self._flags |= FLAG_WATCHER_NEEDS_EVREF
-
-    @property
-    def callback(self):
-        return self._callback
-
-    @callback.setter
-    def callback(self, object callback):
-        if callback is not None and not callable(callback):
-           raise TypeError("Expected callable, not %r" % (callback, ))
-        self._callback = callback
-
-    @property
-    def priority(self):
-        return libev.ev_priority(self.__watcher)
-
-    @priority.setter
-    def priority(self, int priority):
-        cdef libev.ev_watcher* w = self.__watcher
-        if libev.ev_is_active(w):
-           raise AttributeError("Cannot set priority of an active watcher")
-        libev.ev_set_priority(w, priority)
-
-    @property
-    def active(self):
-        return True if libev.ev_is_active(self.__watcher) else False
-
-    @property
-    def pending(self):
-        return True if libev.ev_is_pending(self.__watcher) else False
-
-    def start(self, object callback, *args):
-        _watcher_start(self, callback, args)
-
-    def stop(self):
-        _check_loop(self.loop)
-        _libev_ref(self)
-        # The callback cannot possibly fire while we are executing,
-        # so this is safe.
-        self._callback = None
-        self.args = None
-        self.__ss.stop(self.loop._ptr, self.__watcher)
-        _python_decref(self)
-
-    def feed(self, int revents, object callback, *args):
-        _check_loop(self.loop)
-        self.callback = callback
-        self.args = args
-        _libev_unref(self)
-        libev.ev_feed_event(self.loop._ptr, self.__watcher, revents)
-        _python_incref(self)
-
-    def __repr__(self):
-        if Py_ReprEnter(self) != 0:
-            return "<...>"
-        try:
-            format = self._format()
-            result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), format)
-            if self.active:
-                result += " active"
-            if self.pending:
-                result += " pending"
-            if self.callback is not None:
-                result += " callback=%r" % (self.callback, )
-            if self.args is not None:
-                result += " args=%r" % (self.args, )
-            return result + ">"
-        finally:
-            Py_ReprLeave(self)
-
-    def _format(self):
-        return ''
-
-    def close(self):
-        self.stop()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, t, v, tb):
-        self.close()
-        return
-
-cdef start_and_stop io_ss = make_ss(<void*>libev.ev_io_start, <void*>libev.ev_io_stop)
-
-cdef public class io(watcher) [object PyGeventIOObject, type PyGeventIO_Type]:
-
-    cdef libev.ev_io _watcher
-
-    def start(self, object callback, *args, pass_events=False):
-        if pass_events:
-            args = (GEVENT_CORE_EVENTS, ) + args
-        _watcher_start(self, callback, args)
-
-    def __init__(self, loop loop, libev.vfd_socket_t fd, int events, ref=True, priority=None):
-        watcher.__init__(self, loop, ref, priority)
-
-    def __cinit__(self, loop loop, libev.vfd_socket_t fd, int events, ref=True, priority=None):
-        if fd < 0:
-            raise ValueError('fd must be non-negative: %r' % fd)
-        if events & ~(libev.EV__IOFDSET | libev.EV_READ | libev.EV_WRITE):
-            raise ValueError('illegal event mask: %r' % events)
-        # All the vfd_functions are no-ops on POSIX
-        cdef int vfd = libev.vfd_open(fd)
-        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, events)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &io_ss
-
-    def __dealloc__(self):
-        libev.vfd_free(self._watcher.fd)
-
-    @property
-    def fd(self):
-        return libev.vfd_get(self._watcher.fd)
-
-    @fd.setter
-    def fd(self, long fd):
-        if libev.ev_is_active(&self._watcher):
-            raise AttributeError("'io' watcher attribute 'fd' is read-only while watcher is active")
-        cdef int vfd = libev.vfd_open(fd)
-        libev.vfd_free(self._watcher.fd)
-        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, self._watcher.events)
-
-    @property
-    def events(self):
-        return self._watcher.events
-
-    @events.setter
-    def events(self, int events):
-        if libev.ev_is_active(&self._watcher):
-            raise AttributeError("'io' watcher attribute 'events' is read-only while watcher is active")
-        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, self._watcher.fd, events)
-
-    @property
-    def events_str(self):
-        return _events_to_str(self._watcher.events)
-
-    def _format(self):
-        return ' fd=%s events=%s' % (self.fd, self.events_str)
-
-cdef start_and_stop timer_ss = make_ss(<void*>libev.ev_timer_start, <void*>libev.ev_timer_stop)
-
-cdef public class timer(watcher) [object PyGeventTimerObject, type PyGeventTimer_Type]:
-
-    cdef libev.ev_timer _watcher
-
-    def __cinit__(self, loop loop, double after=0.0, double repeat=0.0, ref=True, priority=None):
-        if repeat < 0.0:
-            raise ValueError("repeat must be positive or zero: %r" % repeat)
-        libev.ev_timer_init(&self._watcher, <void *>gevent_callback_timer, after, repeat)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &timer_ss
-
-    def __init__(self, loop loop, double after=0.0, double repeat=0.0, ref=True, priority=None):
-        watcher.__init__(self, loop, ref, priority)
-
-    def start(self, object callback, *args, update=None):
-        update = update if update is not None else self.loop.starting_timer_may_update_loop_time
-        if update:
-            self.loop.update_now()
-        _watcher_start(self, callback, args)
-
-    @property
-    def at(self):
-        return self._watcher.at
-
-    # QQQ: add 'after' and 'repeat' properties?
-
-    def again(self, object callback, *args, update=True):
-        _check_loop(self.loop)
-        self.callback = callback
-        self.args = args
-        _libev_unref(self)
-        if update:
-            libev.ev_now_update(self.loop._ptr)
-        libev.ev_timer_again(self.loop._ptr, &self._watcher)
-        _python_incref(self)
-
-
-
-cdef start_and_stop signal_ss = make_ss(<void*>libev.ev_signal_start, <void*>libev.ev_signal_stop)
-
-cdef public class signal(watcher) [object PyGeventSignalObject, type PyGeventSignal_Type]:
-
-    cdef libev.ev_signal _watcher
-
-    def __cinit__(self, loop loop, int signalnum, ref=True, priority=None):
-        if signalnum < 1 or signalnum >= signalmodule.NSIG:
-            raise ValueError('illegal signal number: %r' % signalnum)
-        # still possible to crash on one of libev's asserts:
-        # 1) "libev: ev_signal_start called with illegal signal number"
-        #    EV_NSIG might be different from signal.NSIG on some platforms
-        # 2) "libev: a signal must not be attached to two different loops"
-        #    we probably could check that in LIBEV_EMBED mode, but not in general
-        libev.ev_signal_init(&self._watcher, <void *>gevent_callback_signal, signalnum)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &signal_ss
-
-    def __init__(self, loop loop, int signalnum, ref=True, priority=None):
-        watcher.__init__(self, loop, ref, priority)
-
-
-
-cdef start_and_stop idle_ss = make_ss(<void*>libev.ev_idle_start, <void*>libev.ev_idle_stop)
-
-cdef public class idle(watcher) [object PyGeventIdleObject, type PyGeventIdle_Type]:
-
-    cdef libev.ev_idle _watcher
-
-    def __cinit__(self, loop loop, ref=True, priority=None):
-        libev.ev_idle_init(&self._watcher, <void*>gevent_callback_idle)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &idle_ss
-
-
-
-cdef start_and_stop prepare_ss = make_ss(<void*>libev.ev_prepare_start, <void*>libev.ev_prepare_stop)
-
-cdef public class prepare(watcher) [object PyGeventPrepareObject, type PyGeventPrepare_Type]:
-
-    cdef libev.ev_prepare _watcher
-
-    def __cinit__(self, loop loop, ref=True, priority=None):
-        libev.ev_prepare_init(&self._watcher, <void*>gevent_callback_prepare)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &prepare_ss
-
-
-
-cdef start_and_stop check_ss = make_ss(<void*>libev.ev_check_start, <void*>libev.ev_check_stop)
-
-cdef public class check(watcher) [object PyGeventCheckObject, type PyGeventCheck_Type]:
-
-    cdef libev.ev_check _watcher
-
-    def __cinit__(self, loop loop, ref=True, priority=None):
-        libev.ev_check_init(&self._watcher, <void*>gevent_callback_check)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &check_ss
-
-
-
-cdef start_and_stop fork_ss = make_ss(<void*>libev.ev_fork_start, <void*>libev.ev_fork_stop)
-
-cdef public class fork(watcher) [object PyGeventForkObject, type PyGeventFork_Type]:
-
-    cdef libev.ev_fork _watcher
-
-    def __cinit__(self, loop loop, ref=True, priority=None):
-        libev.ev_fork_init(&self._watcher, <void*>gevent_callback_fork)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &fork_ss
-
-
-cdef start_and_stop async_ss = make_ss(<void*>libev.ev_async_start, <void*>libev.ev_async_stop)
-
-cdef public class async_(watcher) [object PyGeventAsyncObject, type PyGeventAsync_Type]:
-
-    cdef libev.ev_async _watcher
-
-    @property
-    def pending(self):
-        # Note the use of ev_async_pending instead of ev_is_pending
-        return True if libev.ev_async_pending(&self._watcher) else False
-
-    def __cinit__(self, loop loop, ref=True, priority=None):
-        libev.ev_async_init(&self._watcher, <void*>gevent_callback_async)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &async_ss
-
-
-    def send(self):
-        _check_loop(self.loop)
-        libev.ev_async_send(self.loop._ptr, &self._watcher)
-
-async = async_
-
-cdef start_and_stop child_ss = make_ss(<void*>libev.ev_child_start, <void*>libev.ev_child_stop)
-
-cdef public class child(watcher) [object PyGeventChildObject, type PyGeventChild_Type]:
-
-    cdef libev.ev_child _watcher
-
-    def __cinit__(self, loop loop, int pid, bint trace=0, ref=True):
-        if sys.platform == 'win32':
-            raise AttributeError("Child watchers are not supported on Windows")
-        if not loop.default:
-            raise TypeError('child watchers are only available on the default loop')
-        libev.gevent_install_sigchld_handler()
-        libev.ev_child_init(&self._watcher, <void *>gevent_callback_child, pid, trace)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &child_ss
-
-    def __init__(self, loop loop, int pid, bint trace=0, ref=True):
-        watcher.__init__(self, loop, ref, None)
-
-
-    def _format(self):
-        return ' pid=%r rstatus=%r' % (self.pid, self.rstatus)
-
-    @property
-    def pid(self):
-        return self._watcher.pid
-
-    @property
-    def rpid(self):
-        return self._watcher.rpid
-
-    @rpid.setter
-    def rpid(self, int value):
-        self._watcher.rpid = value
-
-    @property
-    def rstatus(self):
-        return self._watcher.rstatus
-
-    @rstatus.setter
-    def rstatus(self, int value):
-        self._watcher.rstatus = value
-
-cdef start_and_stop stat_ss = make_ss(<void*>libev.ev_stat_start, <void*>libev.ev_stat_stop)
-
-cdef public class stat(watcher) [object PyGeventStatObject, type PyGeventStat_Type]:
-
-    cdef libev.ev_stat _watcher
-    cdef readonly str path
-    cdef readonly bytes _paths
-
-    def __cinit__(self, loop loop, str path, float interval=0.0, ref=True, priority=None):
-        self.path = path
-        cdef bytes paths
-        if isinstance(path, unicode):
-            # the famous Python3 filesystem encoding debacle hits us here. Can we do better?
-            # We must keep a reference to the encoded string so that its bytes don't get freed
-            # and overwritten, leading to strange errors from libev ("no such file or directory")
-            paths = (<unicode>path).encode(sys.getfilesystemencoding())
-            self._paths = paths
-        else:
-            paths = <bytes>path
-            self._paths = paths
-        libev.ev_stat_init(&self._watcher, <void *>gevent_callback_stat, <char*>paths, interval)
-        self.__watcher = <libev.ev_watcher*>&self._watcher
-        self.__ss = &stat_ss
-
-    def __init__(self, loop loop, str path, float interval=0.0, ref=True, priority=None):
-        watcher.__init__(self, loop, ref, priority)
-
-
-    @property
-    def attr(self):
-        if not self._watcher.attr.st_nlink:
-            return
-        return _pystat_fromstructstat(&self._watcher.attr)
-
-    @property
-    def prev(self):
-        if not self._watcher.prev.st_nlink:
-            return
-        return _pystat_fromstructstat(&self._watcher.prev)
-
-    @property
-    def interval(self):
-        return self._watcher.interval
-
-
-
-__SYSERR_CALLBACK = None
-
-
-cdef void _syserr_cb(char* msg) with gil:
-    try:
-        __SYSERR_CALLBACK(msg, errno)
-    except:
-        set_syserr_cb(None)
-        print_exc = getattr(traceback, 'print_exc', None)
-        if print_exc is not None:
-            print_exc()
-
-
-cpdef set_syserr_cb(callback):
-    global __SYSERR_CALLBACK
-    if callback is None:
-        libev.ev_set_syserr_cb(NULL)
-        __SYSERR_CALLBACK = None
-    elif callable(callback):
-        libev.ev_set_syserr_cb(<void *>_syserr_cb)
-        __SYSERR_CALLBACK = callback
-    else:
-        raise TypeError('Expected callable or None, got %r' % (callback, ))
-
-
-
-LIBEV_EMBED = bool(libev.LIBEV_EMBED)
-EV_USE_FLOOR = libev.EV_USE_FLOOR
-EV_USE_CLOCK_SYSCALL = libev.EV_USE_CLOCK_SYSCALL
-EV_USE_REALTIME = libev.EV_USE_REALTIME
-EV_USE_MONOTONIC = libev.EV_USE_MONOTONIC
-EV_USE_NANOSLEEP = libev.EV_USE_NANOSLEEP
-EV_USE_INOTIFY = libev.EV_USE_INOTIFY
-EV_USE_SIGNALFD = libev.EV_USE_SIGNALFD
-EV_USE_EVENTFD = libev.EV_USE_EVENTFD
-EV_USE_4HEAP = libev.EV_USE_4HEAP
-
-# Things used in callbacks.c
-
-from cpython cimport PyErr_Fetch
-from cpython cimport PyObject
-
-cdef public void gevent_handle_error(loop loop, object context):
-    cdef PyObject* typep
-    cdef PyObject* valuep
-    cdef PyObject* tracebackp
-
-    cdef object type
-    cdef object value = None
-    cdef object traceback = None
-    cdef object result
-
-    # If it was set, this will clear it, and we will own
-    # the references.
-    PyErr_Fetch(&typep, &valuep, &tracebackp)
-    # TODO: Should we call PyErr_Normalize? There's code in
-    # Hub.handle_error that works around what looks like an
-    # unnormalized exception.
-
-    if not typep:
-        return
-    # This assignment will do a Py_INCREF
-    # on the value. We already own the reference
-    # returned from PyErr_Fetch,
-    # so we must decref immediately
-    type = <object>typep
-    Py_DECREF(type)
-
-    if valuep:
-        value = <object>valuep
-        Py_DECREF(value)
-    if tracebackp:
-        traceback = <object>tracebackp
-        Py_DECREF(traceback)
-
-    # If this method fails by raising an exception,
-    # cython will print it for us because we don't return a
-    # Python object and we don't declare an `except` clause.
-    loop.handle_error(context, type, value, traceback)
-
-cdef public tuple _empty_tuple = ()
-
-cdef public object gevent_loop_run_callbacks(loop loop):
-    return loop._run_callbacks()