static PyObject * Pipe_func_write2(Pipe *self, PyObject *args) { Py_buffer pbuf; PyObject *callback, *send_handle; callback = Py_None; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "s*O|O:write2", &pbuf, &send_handle, &callback)) { return NULL; } if (!PyObject_TypeCheck(send_handle, &TCPType) && !PyObject_TypeCheck(send_handle, &PipeType)) { PyErr_SetString(PyExc_TypeError, "Only TCP and Pipe objects are supported for write2"); return NULL; } if (callback != Py_None && !PyCallable_Check(callback)) { PyBuffer_Release(&pbuf); PyErr_SetString(PyExc_TypeError, "a callable or None is required"); return NULL; } return pyuv_stream_write((Stream *)self, pbuf, callback, send_handle); }
static PyObject * Prepare_func_start(Prepare *self, PyObject *args) { int r; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:start", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } r = uv_prepare_start(&self->prepare_h, on_prepare_callback); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PrepareError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static PyObject * UDP_func_set_ttl(UDP *self, PyObject *args) { int r, ttl; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "i:set_multicast_ttl", &ttl)) { return NULL; } if (ttl < 0 || ttl > 255) { PyErr_SetString(PyExc_ValueError, "ttl must be between 0 and 255"); return NULL; } r = uv_udp_set_ttl((uv_udp_t *)UV_HANDLE(self), ttl); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } Py_RETURN_NONE; }
static PyObject * Stream_func_try_write(Stream *self, PyObject *args) { int err; uv_buf_t buf; Py_buffer view; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, PYUV_BYTES"*:try_write", &view)) { return NULL; } buf = uv_buf_init(view.buf, view.len); err = uv_try_write((uv_stream_t *)UV_HANDLE(self), &buf, 1); if (err < 0) { RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self)); PyBuffer_Release(&view); return NULL; } PyBuffer_Release(&view); return PyInt_FromLong((long)err); }
static PyObject * Stream_func_write(Stream *self, PyObject *args) { PyObject *data; PyObject *callback = Py_None; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O|O:write", &data, &callback)) { return NULL; } if (callback != Py_None && !PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "'callback' must be a callable or None"); return NULL; } if (PyObject_CheckBuffer(data)) { return pyuv__stream_write_bytes(self, data, callback, NULL); } else if (!PyUnicode_Check(data) && PySequence_Check(data)) { return pyuv__stream_write_sequence(self, data, callback, NULL); } else { PyErr_SetString(PyExc_TypeError, "only bytes and sequences are supported"); return NULL; } }
static PyObject * TCP_func_accept(TCP *self, PyObject *args) { int r; PyObject *client; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:accept", &client)) { return NULL; } if (!PyObject_IsSubclass((PyObject *)client->ob_type, (PyObject *)&StreamType)) { PyErr_SetString(PyExc_TypeError, "Only stream objects are supported for accept"); return NULL; } r = uv_accept((uv_stream_t *)&self->tcp_h, (uv_stream_t *)UV_HANDLE(client)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); return NULL; } Py_RETURN_NONE; }
static PyObject * Handle_func_close(Handle *self, PyObject *args) { PyObject *callback = Py_None; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "|O:close", &callback)) { return NULL; } if (callback != Py_None && !PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable or None is required"); return NULL; } Py_INCREF(callback); self->on_close_cb = callback; /* Increase refcount so that object is not removed before the callback is called */ Py_INCREF(self); uv_close(self->uv_handle, on_handle_close); Py_RETURN_NONE; }
static PyObject * Pipe_func_start_read2(Pipe *self, PyObject *args) { int r; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:start_read2", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } r = uv_read2_start((uv_stream_t *)UV_HANDLE(self), (uv_alloc_cb)on_stream_alloc, (uv_read2_cb)on_pipe_read2); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PipeError); return NULL; } tmp = ((Stream *)self)->on_read_cb; Py_INCREF(callback); ((Stream *)self)->on_read_cb = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static PyObject * Stream_func_start_read(Stream *self, PyObject *args) { int err; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:start_read", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } err = uv_read_start((uv_stream_t *)UV_HANDLE(self), (uv_alloc_cb)pyuv__alloc_cb, (uv_read_cb)pyuv__stream_read_cb); if (err < 0) { RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self)); return NULL; } tmp = self->on_read_cb; Py_INCREF(callback); self->on_read_cb = callback; Py_XDECREF(tmp); PYUV_HANDLE_INCREF(self); Py_RETURN_NONE; }
static int Timer_repeat_set(Timer *self, PyObject *value, void *closure) { double repeat; UNUSED_ARG(closure); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, -1); if (!value) { PyErr_SetString(PyExc_TypeError, "cannot delete attribute"); return -1; } repeat = PyFloat_AsDouble(value); if (repeat == -1 && PyErr_Occurred()) { return -1; } if (repeat < 0.0) { PyErr_SetString(PyExc_ValueError, "a positive float or 0.0 is required"); return -1; } uv_timer_set_repeat((uv_timer_t *)UV_HANDLE(self), (int64_t)(repeat * 1000)); return 0; }
static PyObject * Pipe_func_accept(Pipe *self, PyObject *args) { int r; PyObject *client; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:accept", &client)) { return NULL; } if (PyObject_IsSubclass((PyObject *)client->ob_type, (PyObject *)&StreamType)) { if (UV_HANDLE(client)->type != UV_TCP && UV_HANDLE(client)->type != UV_NAMED_PIPE) { PyErr_SetString(PyExc_TypeError, "Only TCP and Pipe objects are supported for accept"); return NULL; } } else if (PyObject_IsSubclass((PyObject *)client->ob_type, (PyObject *)&UDPType)) { /* empty */ } else { PyErr_SetString(PyExc_TypeError, "Only Stream and UDP objects are supported for accept"); return NULL; } r = uv_accept((uv_stream_t *)UV_HANDLE(self), (uv_stream_t *)UV_HANDLE(client)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PipeError); return NULL; } Py_RETURN_NONE; }
static PyObject * UDP_func_bind(UDP *self, PyObject *args) { int err, flags; struct sockaddr_storage ss; PyObject *addr; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); flags = 0; if (!PyArg_ParseTuple(args, "O|i:bind", &addr, &flags)) { return NULL; } if (pyuv_parse_addr_tuple(addr, &ss) < 0) { /* Error is set by the function itself */ return NULL; } err = uv_udp_bind(&self->udp_h, (struct sockaddr *)&ss, flags); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_UDPError); return NULL; } Py_RETURN_NONE; }
static PyObject * UDP_func_bind(UDP *self, PyObject *args) { int r, bind_port, address_type; char *bind_ip; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "(si):bind", &bind_ip, &bind_port)) { return NULL; } if (bind_port < 0 || bind_port > 65535) { PyErr_SetString(PyExc_ValueError, "port must be between 0 and 65535"); return NULL; } if (pyuv_guess_ip_family(bind_ip, &address_type)) { PyErr_SetString(PyExc_ValueError, "invalid IP address"); return NULL; } if (address_type == AF_INET) { r = uv_udp_bind((uv_udp_t *)UV_HANDLE(self), uv_ip4_addr(bind_ip, bind_port), 0); } else { r = uv_udp_bind6((uv_udp_t *)UV_HANDLE(self), uv_ip6_addr(bind_ip, bind_port), UV_UDP_IPV6ONLY); } if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } Py_RETURN_NONE; }
static PyObject * UDP_func_start_recv(UDP *self, PyObject *args) { int r; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:start_recv", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } r = uv_udp_recv_start((uv_udp_t *)UV_HANDLE(self), (uv_alloc_cb)on_udp_alloc, (uv_udp_recv_cb)on_udp_read); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } tmp = self->on_read_cb; Py_INCREF(callback); self->on_read_cb = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static PyObject * UDP_func_getsockname(UDP *self) { int r, namelen; char ip[INET6_ADDRSTRLEN]; struct sockaddr sockname; struct sockaddr_in *addr4; struct sockaddr_in6 *addr6; namelen = sizeof(sockname); RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_udp_getsockname((uv_udp_t *)UV_HANDLE(self), &sockname, &namelen); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } if (sockname.sa_family == AF_INET) { addr4 = (struct sockaddr_in*)&sockname; uv_ip4_name(addr4, ip, INET_ADDRSTRLEN); return Py_BuildValue("si", ip, ntohs(addr4->sin_port)); } else if (sockname.sa_family == AF_INET6) { addr6 = (struct sockaddr_in6*)&sockname; uv_ip6_name(addr6, ip, INET6_ADDRSTRLEN); return Py_BuildValue("si", ip, ntohs(addr6->sin6_port)); } else { PyErr_SetString(PyExc_UDPError, "unknown address type detected"); return NULL; } }
static PyObject * Signal_func_start(Signal *self, PyObject *args) { int r, signum; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "Oi:start", &callback, &signum)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } r = uv_signal_start((uv_signal_t *)UV_HANDLE(self), (uv_signal_cb)on_signal_callback, signum); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_SignalError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static PyObject * Pipe_func_getsockname(Pipe *self) { #ifdef _WIN32 /* MAX_PATH is in characters, not bytes. Make sure we have enough headroom. */ char buf[MAX_PATH * 4]; #else char buf[PATH_MAX]; #endif size_t buf_len; int err; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); buf_len = sizeof(buf); err = uv_pipe_getsockname(&self->pipe_h, buf, &buf_len); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_PipeError); return NULL; } if (buf_len == 0) { return PyBytes_FromString(""); } else if (buf[0] == '\0') { /* Linux abstract namespace */ return PyBytes_FromStringAndSize(buf, buf_len); } else { return PyBytes_FromStringAndSize(buf, buf_len-1); } }
static PyObject * TCP_func_bind(TCP *self, PyObject *args) { int r; struct sockaddr sa; PyObject *addr; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:bind", &addr)) { return NULL; } if (pyuv_parse_addr_tuple(addr, &sa) < 0) { /* Error is set by the function itself */ return NULL; } if (sa.sa_family == AF_INET) { r = uv_tcp_bind(&self->tcp_h, *(struct sockaddr_in *)&sa); } else { r = uv_tcp_bind6(&self->tcp_h, *(struct sockaddr_in6 *)&sa); } if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); return NULL; } Py_RETURN_NONE; }
static PyObject * Timer_repeat_get(Timer *self, void *closure) { UNUSED_ARG(closure); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); return PyFloat_FromDouble(uv_timer_get_repeat((uv_timer_t *)UV_HANDLE(self))/1000.0); }
static PyObject * Stream_func_write(Stream *self, PyObject *args) { uv_buf_t buf; stream_write_ctx *ctx; Py_buffer *view; PyObject *callback = Py_None; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); ctx = PyMem_Malloc(sizeof *ctx); if (!ctx) { PyErr_NoMemory(); return NULL; } view = &ctx->view[0]; if (!PyArg_ParseTuple(args, PYUV_BYTES"*|O:write", view, &callback)) { PyMem_Free(ctx); return NULL; } if (callback != Py_None && !PyCallable_Check(callback)) { PyBuffer_Release(view); PyMem_Free(ctx); PyErr_SetString(PyExc_TypeError, "a callable or None is required"); return NULL; } buf = uv_buf_init(view->buf, view->len); return pyuv_stream_write(self, ctx, view, &buf, 1, callback, NULL); }
static PyObject * Idle_func_start(Idle *self, PyObject *args) { int err; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:start", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } err = uv_idle_start(&self->idle_h, pyuv__idle_cb); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_IdleError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); PYUV_HANDLE_INCREF(self); Py_RETURN_NONE; }
static PyObject * Pipe_func_pending_handle_type(Pipe *self) { RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); return PyInt_FromLong(uv_pipe_pending_type(&self->pipe_h)); }
static PyObject * Handle_func_unref(Handle *self) { RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); uv_unref(self->uv_handle); Py_RETURN_NONE; }
static PyObject * TCP_func_connect(TCP *self, PyObject *args) { int r; struct sockaddr sa; uv_connect_t *connect_req = NULL; PyObject *addr, *callback; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "OO:connect", &addr, &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } if (pyuv_parse_addr_tuple(addr, &sa) < 0) { /* Error is set by the function itself */ return NULL; } Py_INCREF(callback); connect_req = PyMem_Malloc(sizeof *connect_req); if (!connect_req) { PyErr_NoMemory(); goto error; } connect_req->data = callback; if (sa.sa_family == AF_INET) { r = uv_tcp_connect(connect_req, &self->tcp_h, *(struct sockaddr_in *)&sa, on_tcp_client_connection); } else { r = uv_tcp_connect6(connect_req, &self->tcp_h, *(struct sockaddr_in6 *)&sa, on_tcp_client_connection); } if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); goto error; } /* Increase refcount so that object is not removed before the callback is called */ Py_INCREF(self); Py_RETURN_NONE; error: Py_DECREF(callback); PyMem_Free(connect_req); return NULL; }
static PyObject * Pipe_func_write2(Pipe *self, PyObject *args) { uv_buf_t buf; stream_write_ctx *ctx; Py_buffer *view; PyObject *callback, *send_handle; callback = Py_None; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); ctx = PyMem_Malloc(sizeof *ctx); if (!ctx) { PyErr_NoMemory(); return NULL; } view = &ctx->view[0]; if (!PyArg_ParseTuple(args, PYUV_BYTES"*O|O:write", view, &send_handle, &callback)) { PyMem_Free(ctx); return NULL; } if (PyObject_IsSubclass((PyObject *)send_handle->ob_type, (PyObject *)&StreamType)) { if (UV_HANDLE(send_handle)->type != UV_TCP && UV_HANDLE(send_handle)->type != UV_NAMED_PIPE) { PyErr_SetString(PyExc_TypeError, "Only TCP and Pipe objects are supported for write2"); goto error; } } else if (PyObject_IsSubclass((PyObject *)send_handle->ob_type, (PyObject *)&UDPType)) { /* empty */ } else { PyErr_SetString(PyExc_TypeError, "Only Stream and UDP objects are supported"); goto error; } if (callback != Py_None && !PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable or None is required"); goto error; } buf = uv_buf_init(view->buf, view->len); return pyuv_stream_write((Stream *)self, ctx, view, &buf, 1, callback, send_handle); error: PyBuffer_Release(view); PyMem_Free(ctx); return NULL; }
static PyObject * Pipe_func_open(Pipe *self, PyObject *args) { int fd; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "i:open", &fd)) { return NULL; } uv_pipe_open((uv_pipe_t *)UV_HANDLE(self), fd); Py_RETURN_NONE; }
static PyObject * Signal_func_stop(Signal *self) { int r; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_signal_stop((uv_signal_t *)UV_HANDLE(self)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_SignalError); return NULL; } Py_RETURN_NONE; }
static PyObject * TTY_func_get_winsize(TTY *self) { int r, width, height; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_tty_get_winsize((uv_tty_t *)UV_HANDLE(self), &width, &height); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TTYError); return NULL; } return Py_BuildValue("(ii)", width, height); }
static PyObject * Timer_func_again(Timer *self) { int r; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_timer_again((uv_timer_t *)UV_HANDLE(self)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TimerError); return NULL; } Py_RETURN_NONE; }
static PyObject * Timer_func_start(Timer *self, PyObject *args, PyObject *kwargs) { int err; double timeout, repeat; PyObject *tmp, *callback; static char *kwlist[] = {"callback", "timeout", "repeat", NULL}; tmp = NULL; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Odd:__init__", kwlist, &callback, &timeout, &repeat)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } if (timeout < 0.0) { PyErr_SetString(PyExc_ValueError, "a positive value or zero is required"); return NULL; } if (repeat < 0.0) { PyErr_SetString(PyExc_ValueError, "a positive value or zero is required"); return NULL; } err = uv_timer_start(&self->timer_h, on_timer_callback, (uint64_t)(timeout * 1000), (uint64_t)(repeat * 1000)); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_TimerError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); PYUV_HANDLE_INCREF(self); Py_RETURN_NONE; }