return me
def atoms():
+ """atoms() -> ITER: return iterator over known atoms"""
return AtomIter()
###----- That's all, folks --------------------------------------------------
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cdef class SelResolve:
+ """Abstract superclass for background name resolution."""
cdef bres_client r
cdef int _activep
cdef _resolved
me._dead()
bres_abort(&me.r)
property activep:
+ """BR.activep: is lookup still waiting?"""
def __get__(me):
return _tobool(me._activep)
def kill(me):
+ """BR.kill(): cancel in-progress lookup"""
if not me._activep:
raise ValueError, 'already dead'
me._dead()
me._activep = 0
me.dead()
def dead(me):
+ """BR.dead(): called when lookup completes or is cancelled"""
pass
property resolvedproc:
+ """BR.resolvedproc -> FUNC: call FUNC(NAME, ALIASES, ADDRS) when ok"""
def __get__(me):
return me._resolved
def __set__(me, proc):
def __del__(me):
me._resolved = None
property failedproc:
+ """BR.failedproc -> FUNC: call FUNC() when lookup fails"""
def __get__(me):
return me._failed
def __set__(me, proc):
def __del__(me):
me._failed = None
def resolved(me, name, aliases, addrs):
+ """BR.resolved(NAME, ALIASES, ADDRS): called when lookup completes"""
return _maybecall(me._resolved, (name, aliases, addrs))
def failed(me):
+ """BR.failed(): called when lookup fails"""
return _maybecall(me._failed, ())
cdef class SelResolveByName (SelResolve):
+ """
+ Resolve a hostname to an IP address, asynchronously.
+
+ SelResolveByName(NAME, [resolvedproc = None], [failedproc = None])
+
+ Calls RESOLVEDPROC(NAME, ALIASES, ADDRS) on success, or FAILEDPROC() on
+ failure.
+ """
def __cinit__(me, char *name, resolvedproc = None, failedproc = None,
*hunoz, **hukairz):
me._resolved = _checkcallable(resolvedproc, 'resolved proc')
pass
cdef class SelResolveByAddr (SelResolve):
+ """
+ Resolve an IPv4 address to a hostname, asynchronously.
+
+ SelResolveByAddr(ADDR, [resolvedproc = None], [failedproc = None])
+
+ Calls RESOLVEDPROC(NAME, ALIASES, ADDRS) on success, or FAILEDPROC() on
+ failure.
+ """
def __cinit__(me, char *addr, resolvedproc = None, failedproc = None,
*hunoz, **hukairz):
cdef in_addr ia
INVZPAD = CDCERR_INVZPAD
class CodecError (Exception):
+ """
+ Exception from decoding operation.
+
+ Attributes: err = CDCERR.* code, msg = message string
+ """
def __init__(me, err):
me.err = err
me.msg = _codec_strerror(err)
return me.msg
def codec_strerror(err):
+ """codec_strerror(ERR) -> STR: message for CDCERR.* code"""
return _codec_strerror(err)
cdef int code(codec *c, void *p, size_t len, dstr *d) except -1:
return 0
cdef class _BaseCodec:
+ """Abstract superclass for codecs."""
cdef codec *c
def __cinit__(me, *hunoz, **hukairz):
me.c = NULL
finally:
dstr_destroy(&d)
def done(me):
+ """C.done() -> OUT: final output"""
me.code('', True)
cdef class _BaseEncoder (_BaseCodec):
def encode(me, text, finishp = False):
+ """C.encode(IN, [finishp = False]) -> OUT: continue/finish encoding"""
return me.code(text, finishp)
cdef class _BaseDecoder (_BaseCodec):
def decode(me, text, finishp = False):
+ """C.decode(IN, [finishp = False]) -> OUT: continue/finish decoding"""
return me.code(text, finishp)
###--------------------------------------------------------------------------
codec_class base64url_class
cdef class Base64Encoder (_BaseEncoder):
+ """
+ Base64Encoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base64 encoder.
+ """
def __init__(me, indent = '\n', maxline = 72, flags = CDCF_IGNJUNK):
me.c = base64_class.encoder(flags, indent, maxline)
cdef class Base64Decoder (_BaseDecoder):
+ """
+ Base64Decoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base64 decoder.
+ """
def __init__(me, flags = CDCF_IGNJUNK):
me.c = base64_class.decoder(flags)
cdef class File64Encoder (_BaseEncoder):
+ """
+ File64Encoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base64 encoder, using `%' instead of `/', so encoded strings are safe as
+ filenames.
+ """
def __init__(me, indent = '\n', maxline = 72, flags = CDCF_IGNJUNK):
me.c = file64_class.encoder(flags, indent, maxline)
cdef class File64Decoder (_BaseDecoder):
+ """
+ File64Decoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base64 encoder, using `%' instead of `/', so encoded strings are safe as
+ filenames.
+ """
def __init__(me, flags = CDCF_IGNJUNK):
me.c = file64_class.decoder(flags)
cdef class Base64URLEncoder (_BaseEncoder):
+ """
+ Base64URLEncoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base64 encoder, using `-' and `_' instead of `+' and `/', so encoded
+ strings are safe as URL components.
+ """
def __init__(me, indent = '\n', maxline = 72, flags = CDCF_IGNJUNK):
me.c = base64url_class.encoder(flags, indent, maxline)
cdef class Base64URLDecoder (_BaseDecoder):
+ """
+ Base64URLDecoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base64 decoder, using `-' and `_' instead of `+' and `/', so encoded
+ strings are safe as URL components.
+ """
def __init__(me, flags = CDCF_IGNJUNK):
me.c = base64url_class.decoder(flags)
codec_class base32hex_class
cdef class Base32Encoder (_BaseEncoder):
+ """
+ Base32Encoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base32 encoder.
+ """
def __init__(me, indent = '\n', maxline = 72, flags = CDCF_IGNJUNK):
me.c = base32_class.encoder(flags, indent, maxline)
cdef class Base32Decoder (_BaseDecoder):
+ """
+ Base32Decoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base32 decoder.
+ """
def __init__(me, flags = CDCF_IGNJUNK):
me.c = base32_class.decoder(flags)
cdef class Base32HexEncoder (_BaseEncoder):
+ """
+ Base32Encoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base32 encoder, using digits and letters in ascending order, rather than
+ avoiding digits which visually resemble letters.
+ """
def __init__(me, indent = '\n', maxline = 72, flags = CDCF_IGNJUNK):
me.c = base32hex_class.encoder(flags, indent, maxline)
cdef class Base32HexDecoder (_BaseDecoder):
+ """
+ Base32Decoder([indent = '\\n'], [maxline = 72], [flags = CDCF.IGNJUNK])
+
+ Base32 decoder, using digits and letters in ascending order, rather than
+ avoiding digits which visually resemble letters.
+ """
def __init__(me, flags = CDCF_IGNJUNK):
me.c = base32hex_class.decoder(flags)
codec_class hex_class
cdef class HexEncoder (_BaseEncoder):
+ """
+ HexEncoder([indent = '\\n'], [maxline = 72],
+ [flags = CDCF.IGNJUNK | CDCF.LOWERC])
+
+ Hexadecimal encoder.
+ """
def __init__(me, indent = '\n', maxline = 72,
flags = CDCF_IGNJUNK | CDCF_LOWERC):
me.c = hex_class.encoder(flags, indent, maxline)
cdef class HexDecoder (_BaseDecoder):
+ """
+ HexDecoder([indent = '\\n'], [maxline = 72],
+ [flags = CDCF.IGNJUNK | CDCF.LOWERC])
+
+ Hexadecimal decoder.
+ """
def __init__(me, flags = CDCF_IGNJUNK | CDCF_LOWERC):
me.c = hex_class.decoder(flags)
void *p, size_t sz, dstr *d)
cdef class %CLASS%Encode:
+ """
+ %CLASS%([indent = '\\n'], [maxline = 72])
+
+ Obsolete %CLASS% encoder.
+ """
cdef %PREFIX%_ctx ctx
def __cinit__(me, *hunoz, **hukairz):
_%PREFIX%_init(&me.ctx)
if me.ctx.indent:
xfree(<void *>me.ctx.indent)
property indent:
+ """E.indent -> INT: indent level for new lines"""
def __get__(me):
return me.ctx.indent
def __set__(me, indent):
xfree(<void *>me.ctx.indent)
me.ctx.indent = xstrdup(indent)
property maxline:
+ """E.maxline -> INT: maximum length of line, or 0 to prevent splitting"""
def __get__(me):
return me.ctx.maxline
def __set__(me, maxline):
me.ctx.maxline = maxline
def encode(me, text):
+ """E.encode(IN) -> OUT: continue encoding"""
cdef void *p
cdef Py_ssize_t len
cdef dstr d
dstr_destroy(&d)
return rc
def done(me):
+ """E.done() -> OUT: finish encoding, returning final output"""
cdef dstr d
DCREATE(&d)
try:
return rc
def %PREFIX%_encode(text, *arg, **kw):
+ """%PREFIX%_encode(IN, [ARGS...]) -> OUT: %CLASS%-encode the string IN"""
e = %CLASS%Encode(*arg, **kw)
return e.encode(text) + e.done()
cdef class %CLASS%Decode:
+ """
+ %CLASS%()
+
+ Obsolete %CLASS% decoder.
+ """
cdef %PREFIX%_ctx ctx
def __cinit__(me, *hunoz, **hukairz):
_%PREFIX%_init(&me.ctx)
me.ctx.indent = NULL
def decode(me, text):
+ """D.encode(IN) -> OUT: continue decoding"""
cdef void *p
cdef Py_ssize_t len
cdef dstr d
dstr_destroy(&d)
return rc
def done(me):
+ """D.done() -> OUT: finish decoding, returning final output"""
cdef dstr d
DCREATE(&d)
try:
return rc
def %PREFIX%_decode(text, *arg, **kw):
+ """%PREFIX%_decode(IN) -> OUT: %CLASS%-decode the string IN"""
d = %CLASS%Decode(*arg, **kw)
return d.decode(text) + d.done()
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cdef class SelConnect:
+ """
+ SelConnect(SK, [connectedproc = FUNC], [errorproc = FUNC])
+
+ When socket SK connects, call CONNECTEDPROC(); if connection fails, call
+ ERRORPROC(ERRNO, MESSAGE).
+
+ Attributes: C.socket, C.activep, C.connectedproc, C.errorproc.
+ """
cdef conn c
cdef int _activep
cdef readonly object socket
if me._activep:
conn_kill(&me.c)
property activep:
+ """C.activep -> BOOL: is connection still in progress?"""
def __get__(me):
return _tobool(me._activep)
property connectedproc:
+ """C.connectedproc -> FUNC: call FUNC() when connection completes"""
def __get__(me):
return me._connected
def __set__(me, proc):
def __del__(me):
me._connected = None
property errorproc:
+ """
+ C.errorproc -> FUNC: call FUNC(ERRNO, MSG) if connection fails
+ """
def __get__(me):
return me._error
def __set__(me, proc):
def __del__(me):
me._error = None
def kill(me):
+ """C.kill(): give up on connection"""
if not me._activep:
raise ValueError, 'already dead'
conn_kill(&me.c);
me._activep = 0
me.dead()
def dead(me):
+ """C.dead(): called when connection completes or fails"""
pass
def connected(me):
+ """C.connected(): called when connection completes successfully"""
return _maybecall(me._connected, ())
def error(me, errno, strerror):
+ """C.error(ERRNO, MSG): called when connection fails"""
return _maybecall(me._error, ())
cdef void _connfunc(int fd, void *arg):
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cdef class CRC32:
+ """CRC32(): calculate CRC32 of a stream"""
cdef uint32 _a
def __cinit__(me, *hunoz, **hukairz):
me._a = 0
def __init__(me):
pass
def chunk(me, data):
+ """C.chunk(STR): process another chunk of input"""
cdef void *p
cdef Py_ssize_t n
PyObject_AsReadBuffer(data, <cvp *>&p, &n)
me._a = c_crc32(me._a, p, n)
return me
def done(me):
+ """C.done() -> INT: return CRC of data"""
return _u32(me._a)
def crc32(data):
+ """crc32(STR) -> INT"""
cdef void *p
cdef Py_ssize_t n
cdef uint32 c
def fdflags(file,
unsigned fbic = 0, unsigned fxor = 0,
unsigned fdbic = 0, unsigned fdxor = 0):
+ """
+ fdflags(FILE, [fbic = 0], [fxor = 0], [fdbic = 0], [fdxor = 0])
+
+ Set fcntl(2) file and descriptor flags. If these are FL and FD, then
+ update:
+
+ * FL = (FL & ~FBIC) ^ FXOR
+ * FD = (FD & ~FDBIC) ^ FDXOR
+
+ FILE may be integer file descriptor or an object with `fileno' method.
+ """
cdef int rc
rc = _fdflags(_getfd(fd), fbix, fxor, fdbic, fdxor)
if rc < 0:
return rc
def fdsend(sock, file, buffer):
+ """
+ fdsend(SOCK, FILE, BUFFER) -> RC:
+ send FILE over Unix-domain socket SOCK, along with BUFFER
+ """
cdef void *p
cdef Py_ssize_t len
cdef int rc
return rc
def fdrecv(sock, unsigned size):
+ """
+ fdrecv(SOCK, SIZE) -> FD, BUFFER
+ receive file FD and BUFFER of length up to SIZE from Unix-domain SOCK
+ """
cdef void *p
cdef buf
cdef Py_ssize_t len
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cdef class FWatch:
+ """
+ FWatch(FILE): watch FILE for changes
+
+ FILE may be a string, file descriptor, or an object with a `fileno' method.
+ """
cdef fwatch fw
cdef public file
def __cinit__(me, file):
fwatch_initfd(&me.fw, _getfd(file))
me.file = file
def update(me):
+ """FW.update() -> RC: nonzero if the file has changed state"""
cdef int rc
if isinstance(me.file, str):
rc = fwatch_update(&me.fw, me.file)
return inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)
cdef class SelIdentify:
+ """
+ SelIdentify(SK, [userproc = None], [bogusproc = None],
+ [badproc = None], [errorproc = None],)
+
+ Asynchronously enquire about remote user of socket SK.
+ """
cdef ident_request irq
cdef int _activep
cdef readonly localaddr
if me._activep:
ident_abort(&me.irq)
property activep:
+ """I.activep -> BOOL: query still in progress?"""
def __get__(me):
return _tobool(me._activep)
property userproc:
+ """I.userproc -> FUNC: call FUNC(OS, USER) if server replied"""
def __get__(me):
return me._user
def __set__(me, proc):
def __del__(me):
me._user = None
property badproc:
+ """I.badproc -> FUNC: call FUNC() if server's reply was broken"""
def __get__(me):
return me._bad
def __set__(me, proc):
def __del__(me):
me._bad = None
property errorproc:
+ """I.errorproc -> FUNC: call FUNC(ERR) if server reported error"""
def __get__(me):
return me._error
def __set__(me, proc):
def __del__(me):
me._error = None
property bogusproc:
+ """I.bogusproc -> FUNC: call FUNC() on failure if no specific handler"""
def __get__(me):
return me._bogus
def __set__(me, proc):
def __del__(me):
me._bogus = None
def kill(me):
+ """I.kill(): cancel ident query"""
if not me._activep:
raise ValueError, 'already disabled'
ident_abort(&me.irq)
me._activep = 0
me.dead()
def dead(me):
+ """I.dead(): called when operation completes or fails"""
pass
def user(me, os, user):
+ """I.user(OS, USER): called if server returns user name"""
return _maybecall(me._user, (os, user))
def bad(me):
+ """I.bad(): called if server's reply is invalid"""
if me._bad is not None:
return me._bad()
return me.bogus()
def error(me, error):
+ """I.error(ERR): called if server returns an error"""
if me._error is not None:
return me._error(error)
return me.bogus()
def bogus(me):
+ """I.bogus(): called on failure if there's no more specific handler"""
return _maybecall(me._bogus, ())
cdef void _identfunc(ident_reply *i, void *arg):
LBUF_STRICTCRLF = _LBUF_STRICTCRLF
cdef class LineBuffer:
+ """
+ LineBuffer([lineproc = None], [eofproc = None])
+
+ Split an incoming stream into lines.
+ """
cdef lbuf b
cdef _line
cdef _eof
def __dealloc__(me):
lbuf_destroy(&me.b)
property activep:
+ """LB.activep -> BOOL: is the buffer still active?"""
def __get__(me):
return _tobool(me.b.f & LBUF_ENABLE)
property delim:
+ """LB.delim -> CHAR | LBUF_...: line-end delimiter"""
def __get__(me):
if me.b.delim == _LBUF_CRLF or me.b.delim == _LBUF_STRICTCRLF:
return me.b.delim
else:
me.b.delim = ord(d)
property size:
+ """LB.size -> INT: buffer size limit"""
def __get__(me):
return me.b.sz
def __set__(me, sz):
raise TypeError, 'size must be positive'
lbuf_setsize(&me.b, sz)
property lineproc:
+ """LB.lineproc -> FUNC: call FUNC(LINE) on each line"""
def __get__(me):
return me._line
def __set__(me, proc):
def __del__(me):
me._line = None
property eofproc:
+ """LB.eofproc -> FUNC: call FUNC() at end-of-file"""
def __get__(me):
return me._eof
def __set__(me, proc):
def __del__(me):
me._eof = None
def enable(me):
+ """LB.enable(): enable the buffer, allowing lines to be emitted"""
if me.b.f & LBUF_ENABLE:
raise ValueError, 'already enabled'
me.b.f = me.b.f | LBUF_ENABLE
me.enabled()
return me
def disable(me):
+ """LB.disable(): disable the buffer, suspending line emission"""
if not (me.b.f & LBUF_ENABLE):
raise ValueError, 'already disabled'
me.b.f = me.b.f & ~LBUF_ENABLE
me.disabled()
return me
def close(me):
+ """LB.close(): report the end of the input stream"""
if not (me.b.f & LBUF_ENABLE):
raise ValueError, 'buffer disabled'
lbuf_close(&me.b)
return me
property free:
+ """LB.free -> INT: amount of space remaining in buffer"""
def __get__(me):
cdef char *p
return lbuf_free(&me.b, &p)
def flush(me, str):
+ """LB.flush(STR) -> insert STR into the buffer and emit lines"""
cdef Py_ssize_t len
cdef char *p
cdef char *q
lbuf_flush(&me.b, q, n)
return PyString_FromStringAndSize(p, len)
def enabled(me):
+ """LB.enabled(): called when buffer is enabled"""
pass
def disabled(me):
+ """LB.disabled(): called when buffer is disabled"""
pass
def line(me, line):
+ """LB.line(LINE): called for each completed line"""
return _maybecall(me._line, (line,))
def eof(me):
+ """LB.eof(): called at end-of-file"""
return _maybecall(me._eof, ())
cdef void _lbfunc(char *s, size_t n, void *arg):
## Bulk update
def update(me, stuff = None, **kw):
+ """D.update([MAP], **KW): insert mappings from MAP and KW"""
cdef unsigned f
if stuff is None:
pass
raise KeyError, key
me._del(e)
def get(me, key, default = None):
+ """D.get(KEY, [default = None]) -> VALUE: value at KEY, or DEFAULT"""
cdef void *e
e = me._find(key, NULL)
if not e:
return default
return me._value(e)
def setdefault(me, key, default = None):
+ """
+ D.setdefault(KEY, [default = None]) -> VALUE:
+ return value at key, or store DEFAULT at key and return that"""
cdef void *e
cdef unsigned f
e = me._find(key, &f)
me._setval(e, default)
return default
def pop(me, key, default = None):
+ """
+ D.pop(KEY, [default = None]) -> VALUE:
+ return value at key or DEFAULT, and remove KEY"""
cdef void *e
e = me._find(key, NULL)
if not e:
me._del(e)
return rc
def popitem(me):
+ """D.popitem() -> KEY, VALUE: return and remove an association pair"""
cdef _MapIterator i
cdef void *e
i = me._iter()
return l
def keys(me):
+ """D.keys() -> LIST: return a list of known keys"""
return me._list(_map_key)
def values(me):
+ """D.values() -> LIST: return a list of known values"""
return me._list(_map_value)
def items(me):
+ """D.values() -> LIST: return a list of known (KEY, VALUE) pairs"""
return me._list(_map_item)
def clear(me):
+ """D.clear(): remove all mappings"""
cdef _MapIterator i
cdef void *e
i = me._iter()
def __iter__(me):
return MapKeyIter(me)
def iterkeys(me):
+ """D.iterkeys() -> ITER: return iterator over keys"""
return MapKeyIter(me)
def itervalues(me):
+ """D.itervalues() -> ITER: return iterator over values"""
return MapValueIter(me)
def iteritems(me):
+ """D.iteritems() -> ITER: return iterator over (KEY, VALUE) pairs"""
return MapItemIter(me)
cdef class MapIterBase:
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
def mdup(v):
+ """
+ mdup(LIST) -> LIST:
+ LIST is a list (mutable sequence) of pairs (CUR, WANT). Duplicate each
+ CUR file descriptor as WANT (may be -1 to mean `don't care'), closing
+ original CUR. Works even if there are cycles. LIST is updated in place
+ with CUR reflecting the new file descriptors even on error. Returns the
+ same LIST on success.
+ """
cdef mdup_fd *vv
cdef size_t n
cdef int i
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cdef class PacketBuffer:
+ """
+ PacketBuffer([packetproc = None], [eofproc = None])
+
+ Split an incoming stream into packets.
+ """
cdef pkbuf pk
cdef _packet
cdef _eof
def __dealloc__(me):
pkbuf_destroy(&me.pk)
property activep:
+ """PK.activep -> BOOL: is the buffer still active?"""
def __get__(me):
return _tobool(me.pk.f & PKBUF_ENABLE)
property want:
+ """PK.want -> INT: size of next packet to return"""
def __get__(me):
return me.pk.want
def __set__(me, want):
raise TypeError, 'want must be positive'
pkbuf_want(&me.pk, pk)
property packetproc:
+ """PK.packetproc -> FUNC: call FUNC(PACKET) on each packet"""
def __get__(me):
return me._packet
def __set__(me, proc):
def __del__(me):
me._line = None
property eofproc:
+ """PK.eofproc -> FUNC: call FUNC() at end-of-file"""
def __get__(me):
return me._eof
def __set__(me, proc):
def __del__(me):
me._eof = None
def enable(me):
+ """PK.enable(): enable the buffer, allowing packets to be emitted"""
if me.pk.f & PKBUF_ENABLE:
raise ValueError, 'already enabled'
me.pk.f = me.pk.f | PKBUF_ENABLE
me.enabled()
return me
def disable(me):
+ """PK.disable(): disable the buffer, suspending packet emission"""
if not (me.pk.f & PKBUF_ENABLE):
raise ValueError, 'already disabled'
me.pk.f = me.pk.f & ~PKBUF_ENABLE
me.disabled()
return me
def close(me):
+ """PK.close(): report the end of the input stream"""
if not (me.pk.f & PKBUF_ENABLE):
raise ValueError, 'buffer disabled'
pkbuf_close(&me.pk)
return me
property free:
+ """PK.free -> INT: amount of space remaining in buffer"""
def __get__(me):
cdef unsigned char *p
return pkbuf_free(&me.pk, &p)
def flush(me, str):
+ """PK.flush(STR) -> insert STR into the buffer and emit packets"""
cdef Py_ssize_t len
cdef unsigned char *p
cdef unsigned char *q
pkbuf_flush(&me.pk, q, n)
return PyString_FromStringAndSize(<char *>p, len)
def enabled(me):
+ """PK.enabled(): called when buffer is enabled"""
pass
def disabled(me):
+ """PK.disabled(): called when buffer is disabled"""
pass
def packet(me, pk):
+ """PK.packet(PACKET): called for each completed packet"""
return _maybecall(me._packet, (pk,))
def eof(me):
+ """PK.eof(): called at end-of-file"""
return _maybecall(me._eof, ())
cdef void _pkfunc(unsigned char *p, size_t n, pkbuf *pk,
_progstring = NULL
def ego(char *prog):
+ """ego(PROG): set program name"""
global quis, _progstring
if _progstring:
xfree(_progstring)
quis = _quis()
def moan(char *msg):
+ """moan(MSG): report a warning"""
_moan('%s', msg)
def die(char *msg, rc = 126):
+ """die(MSG, [rc = 126]): report a fatal error and exit"""
_moan('%s', msg)
raise SystemExit, rc
cdef sel_state _sel
def select():
+ """select(): wait for I/O and/or timeouts"""
if sel_select(&_sel) and errno != EINTR and errno != EAGAIN:
_oserror()
SEL_EXCEPT = _SEL_EXC
cdef class SelFile:
+ """
+ SelFile(FILE, [mode = SEL_READ], [readyproc = None])
+
+ Register a file (or socket, or, ...) with the select loop.
+ """
cdef sel_file f
cdef int _activep
cdef readonly unsigned mode
if me._activep:
sel_rmfile(&me.f)
property fd:
+ """SF.fd -> INT: the file descriptor"""
def __get__(me):
return me.f.fd
property activep:
+ """SF.activep -> BOOL: is the descriptor active?"""
def __get__(me):
return _tobool(me._activep)
property readyproc:
+ """SF.readyproc -> FUNC: call FUNC() when file is ready for I/O"""
def __get__(me):
return me._readyfunc
def __set__(me, proc):
def __del__(me):
me._readyfunc = None
def enable(me):
+ """SF.enable(): enable waiting on file"""
if me._activep:
raise ValueError, 'already enabled'
sel_addfile(&me.f)
me._enabled()
return me
def disable(me):
+ """SF.disable(): disable waiting on file"""
if not me._activep:
raise ValueError, 'already disabled'
sel_rmfile(&me.f)
me._disabled()
return me
def force(me):
+ """SF.force(): artificially mark file as ready"""
sel_force(&me.f)
return me
cdef _enabled(me):
me._activep = 0
me.disabled()
def enabled(me):
+ """SF.enabled(): called when file is enabled"""
pass
def disabled(me):
+ """SF.disabled(): called when file is disabled"""
pass
def ready(me):
+ """SF.ready(): called when file is ready for I/O"""
return _maybecall(me._readyfunc, ())
cdef void _filefunc(int fd, unsigned mode, void *arg):
tv.tv_usec = <int>(us * 1000000)
cdef class SelTimer:
+ """
+ SelTimer(WHEN, [timerproc = None])
+
+ Arrange to perform some action at time WHEN.
+ """
cdef sel_timer t
cdef int _activep
cdef readonly double time
if me._activep:
sel_rmtimer(&me.t)
property activep:
+ """ST.activep -> BOOL: is the timer active?"""
def __get__(me):
return _tobool(me._activep)
property timerproc:
+ """ST.timerproc -> FUNC: call FUNC() when the timer pops"""
def __get__(me):
return me._timer
def __set__(me, proc):
def __del__(me):
me._timer = None
def kill(me):
+ """ST.kill(): deactivate timer permanently"""
if not me._activep:
raise ValueError, 'already dead'
sel_rmtimer(&me.t)
me._activep = 0
me.dead()
def dead(me):
+ """ST.dead(): called when timer is deactivated"""
pass
def timer(me, now):
+ """ST.timer(NOW): called when the timer pops"""
return _maybecall(me._timer, ())
cdef void _timerfunc(timeval *now, void *arg):
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cdef class SelLineBuffer:
+ """
+ SelLineBuffer(FILE, [lineproc = None], [eofproc = None])
+
+ Split an asynchronous stream into lines.
+ """
cdef selbuf b
cdef _line
cdef _eof
def __dealloc__(me):
selbuf_destroy(&me.b)
property activep:
+ """SLB.activep -> BOOL: is the buffer still active?"""
def __get__(me):
return _tobool(me.b.b.f & LBUF_ENABLE)
property fd:
+ """SLB.fd -> INT: the file descriptor"""
def __get__(me):
return me.b.reader.fd
property delim:
+ """SLB.delim -> CHAR | LBUF_...: line-end delimiter"""
def __get__(me):
if me.b.b.delim == _LBUF_CRLF or me.b.b.delim == _LBUF_STRICTCRLF:
return me.b.b.delim
else:
me.b.b.delim = ord(d)
property size:
+ """SLB.size -> INT: buffer size limit"""
def __get__(me):
return me.b.b.sz
def __set__(me, sz):
raise TypeError, 'size must be positive'
selbuf_setsize(&me.b, sz)
property lineproc:
+ """SLB.lineproc -> FUNC: call FUNC(LINE) on each line"""
def __get__(me):
return me._line
def __set__(me, proc):
def __del__(me):
me._line = None
property eofproc:
+ """SLB.eofproc -> FUNC: call FUNC() at end-of-file"""
def __get__(me):
return me._eof
def __set__(me, proc):
def __del__(me):
me._eof = None
def enable(me):
+ """SLB.enable(): enable the buffer, allowing lines to be emitted"""
if me.b.b.f & LBUF_ENABLE:
raise ValueError, 'already enabled'
selbuf_enable(&me.b)
me.enabled()
return me
def disable(me):
+ """SLB.disable(): disable the buffer, suspending line emission"""
if not (me.b.b.f & LBUF_ENABLE):
raise ValueError, 'already disabled'
selbuf_disable(&me.b)
me.disabled()
return me
def enabled(me):
+ """SLB.enabled(): called when buffer is enabled"""
pass
def disabled(me):
+ """SLB.disabled(): called when buffer is disabled"""
pass
def line(me, line):
+ """SLB.line(LINE): called for each completed line"""
return _maybecall(me._line, (line,))
def eof(me):
+ """SLB.eof(): called at end-of-file"""
return _maybecall(me._eof, ())
cdef void _selbfunc(char *s, size_t n, void *arg):
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cdef class SelPacketBuffer:
+ """
+ SelPacketBuffer(FILE, [packetproc = None], [eofproc = None])
+
+ Split an incoming stream into packets.
+ """
cdef selpk p
cdef _packet
cdef _eof
def __dealloc__(me):
selpk_destroy(&me.p)
property activep:
+ """SPK.activep -> BOOL: is the buffer still active?"""
def __get__(me):
return _to_bool(me.p.pk.f & PKBUF_ENABLE)
property fd:
+ """SPK.fd -> INT: the file descriptor"""
def __get__(me):
return me.p.reader.fd
property want:
+ """SPK.want -> INT: size of next packet to return"""
def __get__(me):
return me.p.pk.want
def __set__(me, n):
raise TypeError, 'size must be positive'
selpk_want(&me.p, n)
property packetproc:
+ """SPK.packetproc -> FUNC: call FUNC(PACKET) on each packet"""
def __get__(me):
return me._packet
def __set__(me, proc):
def __del__(me):
me._packet = None
property eofproc:
+ """SPK.eofproc -> FUNC: call FUNC() at end-of-file"""
def __get__(me):
return me._eof
def __set__(me, proc):
def __del__(me):
me._eof = None
def enable(me):
+ """SPK.enable(): enable the buffer, allowing packets to be emitted"""
if me.p.pk.f & PKBUF_ENABLE:
raise ValueError, 'already enabled'
selpk_enable(&me.p)
me.enabled()
return me
def disable(me):
+ """SPK.disable(): disable the buffer, suspending packet emission"""
if not (me.p.pk.f & PKBUF_ENABLE):
raise ValueError, 'already disabled'
selpk_disable(&me.p)
me.disabled()
return me
def enabled(me):
+ """SPK.enabled(): called when buffer is enabled"""
pass
def disabled(me):
+ """SPK.disabled(): called when buffer is disabled"""
pass
def packet(me, pk):
+ """SPK.packet(PACKET): called for each completed packet"""
return _maybecall(me._packet, (pk,))
def eof(me):
+ """SPK.eof(): called at end-of-file"""
return _maybecall(me._eof, ())
cdef void _selpkfunc(unsigned char *p, size_t n, pkbuf *pk,
import signal
cdef class SelSignal:
+ """
+ SelSignal(SIG, [signalledproc = None])
+
+ Collect signals from the event loop.
+ """
cdef sig s
cdef int _activep
cdef readonly int signal
if me._activep:
sig_remove(&me.s)
property activep:
+ """SS.activep -> BOOL: is the handler still active?"""
def __get__(me):
return _tobool(me._activep)
property signalledproc:
+ """SS.signalledproc -> FUNC: call FUNC() when the signal is received"""
def __get__(me):
return me._signalled
def __set__(me, proc):
def __del__(me):
me._signalled = None
def enable(me):
+ """SS.enable(): enable the handler"""
if me._activep:
raise ValueError, 'already enabled'
sig_add(&me.s, me.signal, _sigfunc, <void *>me)
me._enabled()
return me
def disable(me):
+ """SS.disable(): disable the handler"""
if not me._activep:
raise ValueError, 'already disabled'
sig_remove(&me.s)
me._activep = 0
me.disabled()
def enabled(me):
+ """SS.enabled(): called when handler is enabled"""
pass
def disabled(me):
+ """SS.disabled(): called when handler is disabled"""
pass
def signalled(me):
+ """SS.signalled(): called when the signal is received"""
return _maybecall(me._signalled, ())
cdef void _sigfunc(int sig, void *arg):
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
def word(char *p, quotep = False):
+ """word(STR, [quotep = False]) -> WORD, REST"""
cdef unsigned f
cdef char *op
cdef char *pp
return w, r
def split(char *p, int n = -1, quotep = False):
+ """split(STR, [n = -1], [quotep = False]) -> WORDS, REST"""
cdef unsigned f
cdef char *op
cdef char *pp
return l, r
def match(char *p, char *s, prefixp = False):
+ """match(PAT, STR, [prefixp = False]) -> BOOL"""
cdef unsigned f
f = 0
return _tobool(str_matchx(p, s, f))
def sanitize(char *p, int n = -1):
+ """sanitize(STR, [n = -1]) -> STR"""
cdef char *buf
cdef object d
return d
def versioncmp(char *va, char *vb):
+ """versioncmp(V0, V1) -> -1 | 0 | +1"""
return _versioncmp(va, vb)
###----- That's all, folks --------------------------------------------------
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
def detachtty():
+ """detachtty(): detach from terminal and fork"""
_detachtty()
def daemonize():
+ """daemonize(): become a daemon"""
if _daemonize():
_oserror()
PyObject *v
cdef class SymTable (Mapping):
+ """
+ SymTable([DICT], **KW)
+
+ A mapping keyed by strings.
+ """
cdef sym_table _t
cdef int _init(me) except -1:
sym_create(&me._t)
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
def setglobalkey(uint32 k):
+ """setglobalkey(K): set global hash key"""
unihash_setkey(&unihash_global, k)
cdef class Key:
+ """Key(K): universal hashing key"""
cdef unihash_info _i
cdef uint32 _k
def __cinit__(me, uint32 k):
unihash_setkey(&me._i, k)
me._k = k
property k:
+ """K.k -> INT: the key value"""
def __get__(me):
return _u32(me._k)
cdef class Unihash:
+ """Unihash([key = None]): universal hashing context"""
cdef uint32 _a
cdef readonly Key key
cdef unihash_info *_i
me._i = &k._i
me._a = UNIHASH_INIT(me._i)
def chunk(me, data):
+ """U.chunk(STR): hash the STR"""
cdef void *p
cdef Py_ssize_t n
PyObject_AsReadBuffer(data, <cvp *>&p, &n)
me._a = unihash_hash(me._i, me._a, p, n)
def done(me):
+ """U.done() -> INT: the hash of the data"""
return _u32(me._a)
###----- That's all, folks --------------------------------------------------
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
cdef class URLEncode:
+ """URLEncode([strictp = False], [laxp = False], [semip = False])"""
cdef url_ectx ctx
cdef dstr d
f = f | URLF_SEMI
me.ctx.f = f
def encode(me, char *name, char *value):
+ """UE.encode(NAME, VALUE): encode a key/value pair"""
url_enc(&me.ctx, &me.d, name, value)
return me
property result:
+ """UE.result -> STR: the encoded string"""
def __get__(me):
return PyString_FromStringAndSize(me.d.buf, me.d.len)
property strictp:
+ """UE.strictp -> BOOL: strictly escape non-alphanumerics?"""
def __get__(me):
return _tobool(me.ctx.f & URLF_STRICT)
def __set__(me, val):
else:
me.ctx.f = me.ctx.f & ~URLF_STRICT
property laxp:
+ """UE.laxp -> BOOL: only escape obviously unsafe characters?"""
def __get__(me):
return _tobool(me.ctx.f & URLF_LAX)
def __set__(me, val):
else:
me.ctx.f = me.ctx.f & ~URLF_LAX
property semip:
+ """UE.semip -> BOOL: separate key/value pairs with semicolons?"""
def __get__(me):
return _tobool(me.ctx.f & URLF_SEMI)
def __set__(me, val):
dstr_destroy(&me.d)
cdef class URLDecode:
+ """URLDecode(STR, [semip = False]): iterator over (KEY, VALUE) pairs"""
cdef url_dctx ctx
cdef char *p
raise StopIteration
return nn, vv
property semip:
+ """UD.semip -> BOOL: key/value pairs separated with semicolons?"""
def __get__(me):
return _tobool(me.ctx.f & URLF_SEMI)
def __set__(me, val):
~mdw / mLib-python / commitdiff