collin-lucky7 0.0.1

data/vendor/orbited/pyevent-0.3/event.pyx

@@ -0,0 +1,280 @@
+#
+# event.pyx
+#
+# libevent Python bindings
+#
+# Copyright (c) 2004 Dug Song <dugsong@monkey.org>
+# Copyright (c) 2003 Martin Murray <murrayma@citi.umich.edu>
+#
+# $Id: event.pyx,v 1.12 2005/09/12 03:16:15 dugsong Exp $
+
+"""event library
+
+This module provides a mechanism to execute a function when a
+specific event on a file handle, file descriptor, or signal occurs,
+or after a given time has passed.
+"""
+
+__author__ = ( 'Dug Song <dugsong@monkey.org>',
+               'Martin Murray <mmurray@monkey.org>' )
+__copyright__ = ( 'Copyright (c) 2004 Dug Song',
+                  'Copyright (c) 2003 Martin Murray' )
+__license__ = 'BSD'
+__url__ = 'http://monkey.org/~dugsong/pyevent/'
+__version__ = '0.3'
+
+import sys
+
+cdef extern from "Python.h":
+    void  Py_INCREF(object o)
+    void  Py_DECREF(object o)
+    
+ctypedef void (*event_handler)(int fd, short evtype, void *arg)
+    
+cdef extern from "event.h":
+    struct timeval:
+        unsigned int tv_sec
+        unsigned int tv_usec
+    
+    struct event_t "event":
+        int   ev_fd
+        int   ev_flags
+        void *ev_arg
+
+    void event_init()
+    void event_set(event_t *ev, int fd, short event,
+                   event_handler handler, void *arg)
+    void evtimer_set(event_t *ev, event_handler handler, void *arg)
+    int  event_add(event_t *ev, timeval *tv)
+    int  event_del(event_t *ev)
+    int  event_dispatch()
+    int  event_loop(int loop)
+    int  event_pending(event_t *ev, short, timeval *tv)
+
+    int EVLOOP_ONCE
+    int EVLOOP_NONBLOCK
+
+EV_TIMEOUT = 0x01
+EV_READ    = 0x02
+EV_WRITE   = 0x04
+EV_SIGNAL  = 0x08
+EV_PERSIST = 0x10
+
+__event_exc = None
+
+cdef int __event_sigcb():
+    return -1
+
+cdef void __event_handler(int fd, short evtype, void *arg):
+    (<object>arg).__callback(evtype)
+
+cdef void __simple_event_handler(int fd, short evtype, void *arg):
+    (<object>arg).__simple_callback(evtype)
+
+cdef class event:
+    """event(callback, arg=None, evtype=0, handle=None) -> event object
+    
+    Create a new event object with a user callback.
+
+    Arguments:
+
+    callback -- user callback with (ev, handle, evtype, arg) prototype
+    arg      -- optional callback arguments
+    evtype   -- bitmask of EV_READ or EV_WRITE, or EV_SIGNAL
+    handle   -- for EV_READ or EV_WRITE, a file handle, descriptor, or socket
+                for EV_SIGNAL, a signal number
+    """
+    cdef event_t ev
+    cdef object handle, evtype, callback, args
+    cdef float timeout
+    cdef timeval tv
+
+    def __init__(self, callback, arg=None, short evtype=0, handle=-1,
+                 simple=0):
+        cdef event_handler handler
+        
+        self.callback = callback
+        self.args = arg
+        self.evtype = evtype
+        self.handle = handle
+        if simple:
+            handler = __simple_event_handler
+        else:
+            handler = __event_handler
+        if evtype == 0 and not handle:
+            evtimer_set(&self.ev, handler, <void *>self)
+        else:
+            if not isinstance(handle, int):
+                handle = handle.fileno()
+            event_set(&self.ev, handle, evtype, handler, <void *>self)
+
+    def __simple_callback(self, short evtype):
+        cdef extern int event_gotsig
+        cdef extern int (*event_sigcb)()
+        global __event_exc
+        try:
+            if self.callback(*self.args) != None:
+                if self.tv.tv_sec or self.tv.tv_usec:
+                    event_add(&self.ev, &self.tv)
+                else:
+                    event_add(&self.ev, NULL)
+        except:
+            __event_exc = sys.exc_info()
+            event_sigcb = __event_sigcb
+            event_gotsig = 1
+        # XXX - account for event.signal() EV_PERSIST
+        if not (evtype & EV_SIGNAL) and \
+           not event_pending(&self.ev, EV_READ|EV_WRITE|EV_SIGNAL|EV_TIMEOUT, NULL):
+            Py_DECREF(self)
+    
+    def __callback(self, short evtype):
+        cdef extern int event_gotsig
+        cdef extern int (*event_sigcb)()
+        global __event_exc
+        try:
+            self.callback(self, self.handle, evtype, self.args)
+        except:
+            __event_exc = sys.exc_info()
+            event_sigcb = __event_sigcb
+            event_gotsig = 1
+        if not event_pending(&self.ev, EV_READ|EV_WRITE|EV_SIGNAL|EV_TIMEOUT, NULL):
+            Py_DECREF(self)
+
+    def add(self, float timeout=-1):
+        """Add event to be executed after an optional timeout.
+
+        Arguments:
+        
+        timeout -- seconds after which the event will be executed
+        """
+        if not event_pending(&self.ev, EV_READ|EV_WRITE|EV_SIGNAL|EV_TIMEOUT,
+                             NULL):
+            Py_INCREF(self)
+        self.timeout = timeout
+        if timeout >= 0.0:
+            self.tv.tv_sec = <long>timeout
+            self.tv.tv_usec = (timeout - <float>self.tv.tv_sec) * 1000000.0
+            event_add(&self.ev, &self.tv)
+        else:
+            self.tv.tv_sec = self.tv.tv_usec = 0
+            event_add(&self.ev, NULL)
+
+    def pending(self):
+        """Return 1 if the event is scheduled to run, or else 0."""
+        return event_pending(&self.ev, EV_TIMEOUT|EV_SIGNAL|EV_READ|EV_WRITE, NULL)
+    
+    def delete(self):
+        """Remove event from the event queue."""
+        if self.pending():
+            event_del(&self.ev)
+            Py_DECREF(self)
+    
+    def __dealloc__(self):
+        self.delete()
+    
+    def __repr__(self):
+        return '<event flags=0x%x, handle=%s, callback=%s, arg=%s>' % \
+               (self.ev.ev_flags, self.handle, self.callback, self.args)
+
+cdef class read(event):
+    """read(handle, callback, *args) -> event object
+    
+    Simplified event interface:
+    Create a new read event, and add it to the event queue.
+    
+    Arguments:
+
+    handle   -- file handle, descriptor, or socket
+    callback -- user callback with (*args) prototype, which can return
+                a non-None value to be rescheduled
+    *args    -- optional callback arguments
+    """
+    def __init__(self, handle, callback, *args):
+        event.__init__(self, callback, args, EV_READ, handle, simple=1)
+        self.args = args	# XXX - incref
+        self.add()
+
+cdef class write(event):
+    """write(handle, callback, *args) -> event object
+
+    Simplified event interface:
+    Create a new write event, and add it to the event queue.
+    
+    Arguments:
+
+    handle   -- file handle, descriptor, or socket
+    callback -- user callback with (*args) prototype, which can return
+                a non-None value to be rescheduled
+    *args    -- optional callback arguments
+    """
+    def __init__(self, handle, callback, *args):
+        event.__init__(self, callback, args, EV_WRITE, handle, simple=1)
+        self.args = args	# XXX - incref
+        self.add()
+        
+cdef class signal(event):
+    """signal(sig, callback, *args) -> event object
+
+    Simplified event interface:
+    Create a new signal event, and add it to the event queue.
+    XXX - persistent event is added with EV_PERSIST, like signal_set()
+    
+    Arguments:
+
+    sig      -- signal number
+    callback -- user callback with (*args) prototype, which can return
+                a non-None value to be rescheduled
+    *args    -- optional callback arguments
+    """
+    def __init__(self, sig, callback, *args):
+        event.__init__(self, callback, args, EV_SIGNAL|EV_PERSIST,
+                       sig, simple=1)
+        self.args = args	# XXX - incref
+        self.add()
+
+cdef class timeout(event):
+    """timeout(secs, callback, *args) -> event object
+
+    Simplified event interface:
+    Create a new timer event, and add it to the event queue.
+
+    Arguments:
+
+    secs     -- event timeout in seconds
+    callback -- user callback with (*args) prototype, which can return
+                a non-None value to be rescheduled
+    *args    -- optional callback arguments
+    """
+    def __init__(self, secs, callback, *args):
+        event.__init__(self, callback, args, simple=1)
+        self.args = args	# XXX - incref
+        self.add(secs)
+
+def init():
+    """Initialize event queue."""
+    event_init()
+
+def dispatch():
+    """Dispatch all events on the event queue."""
+    global __event_exc
+    event_dispatch()
+    if __event_exc:
+        raise __event_exc[0], __event_exc[1], __event_exc[2]
+
+def loop(nonblock=False):
+    """Dispatch all pending events on queue in a single pass."""
+    cdef int flags
+    flags = EVLOOP_ONCE
+    if nonblock:
+        flags = EVLOOP_ONCE|EVLOOP_NONBLOCK
+    event_loop(flags)
+
+def abort():
+    """Abort event dispatch loop."""
+    cdef extern int event_gotsig
+    cdef extern int (*event_sigcb)()
+    event_sigcb = __event_sigcb
+    event_gotsig = 1
+
+# XXX - make sure event queue is always initialized.
+init()

data/vendor/orbited/pyevent-0.3/license

@@ -0,0 +1,29 @@
+  
+  Copyright (c) 2004 Dug Song <dugsong@monkey.org>
+  Copyright (c) 2003 Martin Murray <murrayma@citi.umich.edu>
+  All rights reserved, all wrongs reversed.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  3. The names of the authors and copyright holders may not be used to
+     endorse or promote products derived from this software without
+     specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+  THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/vendor/orbited/pyevent-0.3/readme

@@ -0,0 +1,12 @@
+
+pyevent
+-------
+
+Python extension module for Niels Provos' libevent:
+
+	http://monkey.org/~provos/libevent/
+
+-d.
+
+---
+http://monkey.org/~dugsong/

data/vendor/orbited/pyevent-0.3/setup.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+#
+# $Id: setup.py,v 1.7 2005/09/12 03:44:04 dugsong Exp $
+
+from distutils.core import setup, Extension
+import glob, os, sys
+
+if glob.glob('/usr/lib/libevent.*'):
+    print 'found system libevent for', sys.platform
+    event = Extension(name='event',
+                       sources=[ 'event.c' ],
+                       libraries=[ 'event' ])
+elif glob.glob('%s/lib/libevent.*' % sys.prefix):
+    print 'found installed libevent in', sys.prefix
+    event = Extension(name='event',
+                       sources=[ 'event.c' ],
+                       include_dirs=[ '%s/include' % sys.prefix ],
+                       library_dirs=[ '%s/lib' % sys.prefix ],
+                       libraries=[ 'event' ])
+else:
+    ev_dir = None
+    l = glob.glob('../libevent*')
+    l.reverse()
+    for dir in l:
+        if os.path.isdir(dir):
+            ev_dir = dir
+            break
+    if not ev_dir:
+        raise "couldn't find libevent installation or build directory"
+    
+    print 'found libevent build directory', ev_dir
+    ev_srcs = [ 'event.c' ]
+    ev_incdirs = [ ev_dir ]
+    ev_extargs = []
+    ev_extobjs = []
+    ev_libraries = []
+    
+    if sys.platform == 'win32':
+        ev_incdirs.extend([ '%s/WIN32-Code' % ev_dir,
+                            '%s/compat' % ev_dir ])
+        ev_srcs.extend([ '%s/%s' % (ev_dir, x) for x in [
+            'WIN32-Code/misc.c', 'WIN32-Code/win32.c',
+            'log.c', 'event.c' ]])
+        ev_extargs = [ '-DWIN32', '-DHAVE_CONFIG_H' ]
+        ev_libraries = [ 'wsock32' ]
+    else:
+        ev_extobjs = glob.glob('%s/*.o' % dir)
+
+    event = Extension(name='event',
+                      sources=ev_srcs,
+                      include_dirs=ev_incdirs,
+                      extra_compile_args=ev_extargs,
+                      extra_objects=ev_extobjs,
+                      libraries=ev_libraries)
+
+setup(name='event',
+      version='0.3',
+      author='Dug Song, Martin Murray',
+      url='http://monkey.org/~dugsong/pyevent',
+      description='event library',
+      ext_modules = [ event ])

data/vendor/orbited/pyevent-0.3/test.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+import glob, os, signal, sys, time, unittest
+sys.path.insert(0, glob.glob('./build/lib.*')[0])
+import event
+
+class EventTest(unittest.TestCase):
+    def setUp(self):
+        event.init()
+
+    def test_timeout(self):
+        def __timeout_cb(ev, handle, evtype, ts):
+            now = time.time()
+            assert int(now - ts['start']) == ts['secs'], 'timeout failed'
+        print 'test_timeout'
+        ts = { 'start':time.time(), 'secs':5 }
+        ev = event.event(__timeout_cb, arg=ts)
+        ev.add(ts['secs'])
+        event.dispatch()
+
+    def test_timeout2(self):
+        def __timeout2_cb(start, secs):
+            dur = int(time.time() - start)
+            assert dur == secs, 'timeout2 failed'
+        print 'test_timeout2'
+        event.timeout(5, __timeout2_cb, time.time(), 5)
+        event.dispatch()
+    
+    def test_signal(self):
+        def __signal_cb(ev, sig, evtype, arg):
+            if evtype == event.EV_SIGNAL:
+                ev.delete()
+            elif evtype == event.EV_TIMEOUT:
+                os.kill(os.getpid(), signal.SIGUSR1)
+        print 'test_signal'
+        event.event(__signal_cb, handle=signal.SIGUSR1,
+                    evtype=event.EV_SIGNAL).add()
+        event.event(__signal_cb).add(2)
+        event.dispatch()
+
+    def test_signal2(self):
+        def __signal2_cb(sig):
+            if sig:
+                event.abort()
+            else:
+                os.kill(os.getpid(), signal.SIGUSR1)
+        print 'test_signal2'
+        event.signal(signal.SIGUSR1, __signal2_cb, signal.SIGUSR1)
+        event.timeout(2, __signal2_cb)
+    
+    def test_read(self):
+        def __read_cb(ev, fd, evtype, pipe):
+            buf = os.read(fd, 1024)
+            assert buf == 'hi niels', 'read event failed'
+        print 'test_read'
+        pipe = os.pipe()
+        event.event(__read_cb, handle=pipe[0],
+                    evtype=event.EV_READ).add()
+        os.write(pipe[1], 'hi niels')
+        event.dispatch()
+
+    def test_read2(self):
+        def __read2_cb(fd, msg):
+            assert os.read(fd, 1024) == msg, 'read2 event failed'
+        print 'test_read2'
+        msg = 'hello world'
+        pipe = os.pipe()
+        event.read(pipe[0], __read2_cb, pipe[0], msg)
+        os.write(pipe[1], msg)
+        event.dispatch()
+        
+if __name__ == '__main__':
+    unittest.main()