diff options
Diffstat (limited to 'python')
| -rw-r--r-- | python/Makefile.am | 7 | ||||
| -rw-r--r-- | python/pyzmq.cpp | 756 | ||||
| -rw-r--r-- | python/setup.py.in | 14 |
3 files changed, 777 insertions, 0 deletions
diff --git a/python/Makefile.am b/python/Makefile.am new file mode 100644 index 0000000..effe8b9 --- /dev/null +++ b/python/Makefile.am @@ -0,0 +1,7 @@ +INCLUDES = -I$(top_builddir) -I$(top_srcdir) -I$(top_srcdir)/libzmq \ +-I$(top_builddir)/libzmq $(PYTHON_INCLUDES) + +pyexec_LTLIBRARIES = libpyzmq.la +libpyzmq_la_SOURCES = pyzmq.cpp +libpyzmq_la_LIBADD = $(top_builddir)/src/libzmq.la +libpyzmq_la_LDFLAGS = -avoid-version diff --git a/python/pyzmq.cpp b/python/pyzmq.cpp new file mode 100644 index 0000000..019c73c --- /dev/null +++ b/python/pyzmq.cpp @@ -0,0 +1,756 @@ +/* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <Python.h> + +#include <zmq.hpp> + +struct pyZMQ +{ + PyObject_HEAD + +}; + +void pyZMQ_dealloc (pyZMQ *self) +{ + + self->ob_type->tp_free ((PyObject*) self); +} + +PyObject *pyZMQ_new (PyTypeObject *type, PyObject *args, PyObject *kwdict) +{ + pyZMQ *self = (pyZMQ*) type->tp_alloc (type, 0); + + return (PyObject*) self; +} + +PyObject *pyZMQ_term (PyTypeObject *type, PyObject *args, PyObject *kwdict) +{ + pyZMQ *self = (pyZMQ*) type->tp_alloc (type, 0); + + static const char *kwlist [] = {"context", NULL}; + PyObject *context; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &context)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_term ((void *) context); + assert (rc != 0); + + return (PyObject*) self; +} + +int pyZMQ_init (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + return 0; +} + +PyObject *pyZMQ_context (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"app_threads", "io_threads", NULL}; + + int app_threads; + int io_threads; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "ii", (char**) kwlist, + &app_threads, &io_threads)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + void *context = zmq_init (app_threads, io_threads); + if (context == NULL) { + assert (errno == EINVAL); + PyErr_SetString (PyExc_ValueError, "Invalid argument"); + } + + return (PyObject*) context; +} + +PyObject *pyZMQ_msg_init (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + zmq_msg *msg; + + int rc = zmq_msg_init (msg); + + if (rc == -1) { + assert (rc == ENOMEM); + PyErr_SetString( PyExc_MemoryError, "Out of memory"); + } + + return (PyObject*) msg; +} + + +PyObject *pyZMQ_msg_init_size (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"size", NULL}; + + zmq_msg *msg; + int size; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "i", (char**) kwlist, + &size)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_msg_init_size (msg, size); + + if (rc == -1) { + assert (rc == ENOMEM); + PyErr_SetString( PyExc_ValueError, "Out of memory"); + } + + return (PyObject*) msg; +} + +PyObject *pyZMQ_msg_init_data (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"data", "size", "ffn", NULL}; + + PyObject *data = PyString_FromStringAndSize (NULL, 0); + zmq_msg *msg; + PyObject *ffn; + int size; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "SiO", (char**) kwlist, + &data, &size, &ffn)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_msg_init_data (msg, data, size, NULL); + assert (rc == 0); + + return (PyObject*) msg; +} + +PyObject *pyZMQ_msg_close (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"msg", NULL}; + + PyObject *msg; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &msg)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_msg_close ((zmq_msg *) msg); + assert (rc == 0); + + return (PyObject*) self; +} + +PyObject *pyZMQ_msg_move (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"src", NULL}; + + zmq_msg *dest; + PyObject *src; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &src)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_msg_move (dest, (zmq_msg*) src); + assert (rc == 0); + + return (PyObject*) dest; +} + +PyObject *pyZMQ_msg_copy (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"src", NULL}; + + PyObject *dest; + PyObject *src; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &src)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_msg_copy ((zmq_msg*) dest, (zmq_msg*) src); + assert (rc == 0); + + return (PyObject*) dest; +} + +PyObject *pyZMQ_msg_data (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"msg", NULL}; + + PyObject *msg; + PyObject *data = PyString_FromStringAndSize (NULL, 0); + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &msg)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + data = (PyObject *) zmq_msg_data ((zmq_msg *) msg); + + return (PyObject*) data; +} + +int pyZMQ_msg_size (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"msg", NULL}; + + PyObject *msg; + int size; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &msg)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + size = zmq_msg_size ((zmq_msg*) msg); + + return size; +} + +int pyZMQ_msg_type (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"msg", NULL}; + + PyObject *msg; + int type; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &msg)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + type = zmq_msg_type ((zmq_msg*) msg); + + return type; +} + +PyObject *pyZMQ_socket (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"context", "type", NULL}; + void* context; + int type; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "Oi", (char**) kwlist, + &context, &type)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + void *socket = zmq_socket ((void *) context, type); + + if (socket == NULL) { + assert (errno == EMFILE || errno == EINVAL); + if (errno == EMFILE) + PyErr_SetString (PyExc_MemoryError, "Too many threads"); + else + PyErr_SetString (PyExc_ValueError, "Invalid argument"); + } + + return (PyObject*) socket; +} + +PyObject *pyZMQ_close (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"socket", NULL}; + + PyObject* socket; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &socket)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + + int rc = zmq_close ((void *)socket); + assert (rc == 0); + + return (PyObject *) self; +} + +PyObject *pyZMQ_setsockopt (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {"socket", "option", "optval", NULL}; + printf ("setsockopt\n"); + PyObject* socket; + int option; + PyObject* optval; + int optvallen; + int rc; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "OiO", (char**) kwlist, + &socket, &option, &optval)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + if (PyInt_Check (optval)) + rc = zmq_setsockopt ((void *) socket, option, (void *) optval, + 4); + if (PyBool_Check (optval)) + rc = zmq_setsockopt ((void *) socket, option, (void *) optval, + 1); + if (PyFloat_Check (optval)) + rc = zmq_setsockopt ((void *) socket, option, (void *) optval, + 4); + if (PyString_Check (optval)) + rc = zmq_setsockopt ((void *) socket, option, (void *) optval, + PyString_Size (optval)); + + assert (rc == 0); + + return (PyObject *) self; +} + +PyObject *pyZMQ_bind (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + char const *addr = NULL; + PyObject* socket; + + static const char *kwlist [] = {"socket", "addr", NULL}; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "Os", (char**) kwlist, + &socket, &addr)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_bind ((void*) socket, addr); + if (rc == -1) { + assert (errno == EINVAL || errno == EADDRINUSE); + if (errno == EINVAL) + PyErr_SetString (PyExc_ValueError, "Invalid argument"); + else + PyErr_SetString (PyExc_ValueError, "Address in use"); + } + + return (PyObject *) self; +} +PyObject *pyZMQ_connect (pyZMQ *self, PyObject *args, PyObject *kw) +{ + char const *addr = NULL; + PyObject* socket; + + static const char* kwlist [] = {"socket", "addr", NULL}; + + if (!PyArg_ParseTupleAndKeywords (args, kw, "Os", (char**) kwlist, + &socket, &addr)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_connect ((void *) socket, addr); + if (rc == -1) { + assert (errno == EINVAL || errno == EADDRINUSE); + if (errno == EINVAL) + PyErr_SetString (PyExc_ValueError, "Invalid argument"); + else + PyErr_SetString (PyExc_ValueError, "Address in use"); + } + + return (PyObject *) self; +} + +PyObject *pyZMQ_flush (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + + static const char *kwlist [] = {"socket", NULL}; + PyObject *socket; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "O", (char**) kwlist, + &socket)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_flush ((void*) socket); + assert (rc == 0); + + return (PyObject *) self; +} + +PyObject *pyZMQ_send (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + PyObject *msg; + PyObject *socket; + int flags = 0; + + static const char *kwlist [] = {"socket", "msg", "flags", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwdict, "OOi", (char**) kwlist, + &socket, &msg, &flags)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_send ((void*) socket, (zmq_msg*) msg, flags); + assert (rc == 0 || (rc == -1 && errno == EAGAIN)); + + return (PyObject *) self; +} + +PyObject *pyZMQ_receive (pyZMQ *self, PyObject *args, PyObject *kwdict) +{ + zmq_msg *msg; + zmq_msg_init (msg); + PyObject *socket; + + int flags = 0; + static const char *kwlist [] = {"socket", "flags", NULL}; + + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "Oi", (char**) kwlist, + &socket, &flags)) + PyErr_SetString (PyExc_SystemError, + "PyArg_ParseTupleAndKeywords error"); + + int rc = zmq_recv (socket, msg, flags); + assert (rc == 0 || (rc == -1 && errno == EAGAIN)); + + PyObject *py_message = PyString_FromStringAndSize (NULL, 0); + py_message = (PyObject *) zmq_msg_data (msg); + int py_message_size = zmq_msg_size (msg); + int py_message_type = zmq_msg_type (msg); + + zmq_msg_close (msg); + + return Py_BuildValue ("isi", rc, py_message, + py_message_size, py_message_type); +} + +static PyMethodDef pyZMQ_methods [] = +{ + { + "context", + (PyCFunction) pyZMQ_context, + METH_VARARGS | METH_KEYWORDS, + "context (app_threads, io_threads) -> None\n\n" + "Creates new context\n\n" + "app_threads is the number of application threads.\n\n" + "io_threads is the number of io threads.\n\n" + + }, + { + "msg_init", + (PyCFunction) pyZMQ_msg_init, + METH_VARARGS | METH_KEYWORDS, + "msg_init () -> None\n\n" + "Creates new message\n\n" + + }, + { + "msg_init_size", + (PyCFunction) pyZMQ_msg_init_size, + METH_VARARGS | METH_KEYWORDS, + "msg_init_size (size) -> None\n\n" + "Creates new message of a specified size.\n\n" + "size if integer specifying the size of the message to be created.\n\n" + + }, + { + "msg_init_data", + (PyCFunction) pyZMQ_msg_init_data, + METH_VARARGS | METH_KEYWORDS, + "msg_init_data (data, size, ffn) -> None\n\n" + "Initialises new message with data\n\n" + "data is pointer to the data of the message\n\n" + "size is integer specifying size of data\n\n" + "ffn is function to free alocated data\n\n" + + }, + + { + "msg_close", + (PyCFunction) pyZMQ_msg_close, + METH_VARARGS | METH_KEYWORDS, + "msg_close (msg) -> None\n\n" + "Deletes the message.\n\n" + "msg is the message the be freed\n\n" + + }, + { + "msg_move", + (PyCFunction) pyZMQ_msg_move, + METH_VARARGS | METH_KEYWORDS, + "msg_move (src) -> dest\n\n" + "Move the content of the message from 'src' to 'dest'.\n\n" + "The content isn't copied, just moved. 'src' is an empty\n\n" + "message after the call. Original content of 'dest' message\n\n" + "is deallocated.\n\n" + + }, + { + "msg_copy", + (PyCFunction) pyZMQ_msg_copy, + METH_VARARGS | METH_KEYWORDS, + "msg_copy (src) -> dest\n\n" + "Copy the 'src' message to 'dest'. The content isn't copied, \n\n" + "instead reference count is increased. Don't modify the message \n\n" + "data after the call as they are shared between two messages.\n\n" + "Original content of 'dest' message is deallocated.\n\n" + + }, + { + "msg_data", + (PyCFunction) pyZMQ_msg_data, + METH_VARARGS | METH_KEYWORDS, + "msg_data (msg) -> data\n\n" + "Returns pointer to message data.\n\n" + + }, + { + "msg_size", + (PyCFunction) pyZMQ_msg_size, + METH_VARARGS | METH_KEYWORDS, + "msg_size (msg) -> size\n\n" + "Returns size of a message.\n\n" + + }, + { + "msg_type", + (PyCFunction) pyZMQ_msg_type, + METH_VARARGS | METH_KEYWORDS, + "msg_type (msg) -> type\n\n" + "Returns type of a message.\n\n" + + }, + { + "term", + (PyCFunction) pyZMQ_term, + METH_VARARGS | METH_KEYWORDS, + "term (context) -> None\n\n" + "Deinitialise 0SOCKETS context including all the open sockets.\n\n" + "Closing sockets after zmq_term has been called will result in\n\n" + "undefined behaviour.\n\n" + + }, + { + "close", + (PyCFunction) pyZMQ_close, + METH_VARARGS | METH_KEYWORDS, + "close (socket) -> None\n\n" + "Close the socket.\n\n" + + }, + + { + "socket", + (PyCFunction) pyZMQ_socket, + METH_VARARGS | METH_KEYWORDS, + "socket (context, type) -> None\n\n" + "Creates new socket.\n\n" + "'context' is a context_t object.\n" + "'type' is one of 'ZMQ_NOBLOCK', 'ZMQ_NOFLUSH', 'ZMQ_P2P', 'ZMQ_PUB', " + " 'ZMQ_SUB', 'ZMQ_REQ ZMQ_REP'\n" + }, + { + "setsockopt", + (PyCFunction) pyZMQ_setsockopt, + METH_VARARGS | METH_KEYWORDS, + "setsockopt (socket, option, value) -> None\n\n" + "Set socket options." + "Possible options are: 'ZMQ_HWM', 'ZMQ_LWM', 'ZMQ_SWAP', 'ZMQ_MASK', " + "'ZMQ_AFFINITY', 'ZMQ_IDENTITY'." + }, + { + "bind", + (PyCFunction) pyZMQ_bind, + METH_VARARGS | METH_KEYWORDS, + "bind (addr) -> None\n\n" + "Bind socket to specified address." + }, + { + "connect", + (PyCFunction) pyZMQ_connect, + METH_VARARGS | METH_KEYWORDS, + "connect (addr) -> None\n\n" + "connect socket to specified address." + }, + { + "flush", + (PyCFunction) pyZMQ_flush, + METH_VARARGS | METH_KEYWORDS, + "flush (addr) -> None\n\n" + "flush " + }, + { + "send", + (PyCFunction) pyZMQ_send, + METH_VARARGS | METH_KEYWORDS, + "send (message, flags) -> sent\n\n" + "Send a message to within the socket, " + "returns integer specifying if the message was sent.\n" + "'message' is message to be sent.\n" + "'flags' is integer specifying send options.\n" + }, + { + "receive", + (PyCFunction) pyZMQ_receive, + METH_VARARGS | METH_KEYWORDS, + "receive (flags) -> (received, message, type)\n\n" + "Receive a message." + "'flags' is integer specifying receive options.\n" + "'message' is string storing the message received.\n" + "'type' is type of the message received.\n" + + }, + { + NULL + } +}; + +static const char* pyZMQ_ZMQ_doc = + "0MQ messaging session\n\n" + "Available functions:\n" + " context\n" + " socket\n" + " setsockopt\n" + " bind\n" + " send\n" + " flush\n" + " receive\n\n"; + +static PyTypeObject pyZMQType = +{ + PyObject_HEAD_INIT (NULL) + 0, + "libpyzmq.Zmq", /* tp_name (This will appear in the default + textual representation of our objects and + in some error messages)*/ + sizeof (pyZMQ), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) pyZMQ_dealloc,/* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + (char*) pyZMQ_ZMQ_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + pyZMQ_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc) pyZMQ_init, /* tp_init */ + 0, /* tp_alloc */ + pyZMQ_new, /* tp_new */ +}; + +static PyMethodDef module_methods[] = +{ + { NULL, NULL, 0, NULL } +}; + +#ifndef PyMODINIT_FUNC +#define PyMODINIT_FUNC void +#endif + +static const char* pyZMQ_doc = + "0MQ Python Module\n\n" + "Constructor:\n" + " z = libpyzmq.Zmq ()\n" + "Available functions:\n" + " context\n" + " socket\n" + " setsockopt\n" + " bind\n" + " send\n" + " flush\n" + " receive\n" + "\n" + "For more information see http://www.zeromq.org.\n" + "\n" + "0MQ is distributed under GNU Lesser General Public License v3\n"; + +PyMODINIT_FUNC initlibpyzmq (void) +{ + if (PyType_Ready (&pyZMQType) < 0) + return; + + PyObject *m = Py_InitModule3 ("libpyzmq", module_methods, + (char*) pyZMQ_doc); + if (!m) + return; + + Py_INCREF (&pyZMQType); + + PyModule_AddObject (m, "Zmq", (PyObject*) &pyZMQType); + + PyObject *d = PyModule_GetDict (m); + + + PyObject *t = PyInt_FromLong (ZMQ_NOBLOCK); + PyDict_SetItemString (d, "ZMQ_NOBLOCK", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_NOFLUSH); + PyDict_SetItemString (d, "ZMQ_NOFLUSH", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_P2P); + PyDict_SetItemString (d, "ZMQ_P2P", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_PUB); + PyDict_SetItemString (d, "ZMQ_PUB", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_SUB); + PyDict_SetItemString (d, "ZMQ_SUB", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_REQ); + PyDict_SetItemString (d, "ZMQ_REQ", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_REP); + PyDict_SetItemString (d, "ZMQ_REP", t); + Py_DECREF (t); + + t = PyInt_FromLong (ZMQ_HWM); + PyDict_SetItemString (d, "ZMQ_HWM", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_LWM); + PyDict_SetItemString (d, "ZMQ_LWM", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_SWAP); + PyDict_SetItemString (d, "ZMQ_SWAP", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_MASK); + PyDict_SetItemString (d, "ZMQ_MASK", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_AFFINITY); + PyDict_SetItemString (d, "ZMQ_AFFINITY", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_IDENTITY); + PyDict_SetItemString (d, "ZMQ_IDENTITY", t); + Py_DECREF (t); + + +} diff --git a/python/setup.py.in b/python/setup.py.in new file mode 100644 index 0000000..f7055d5 --- /dev/null +++ b/python/setup.py.in @@ -0,0 +1,14 @@ +from distutils.core import setup, Extension + +module1 = Extension('libpyzmq', + libraries = ['zmq'], + library_dirs = ['@prefix@/lib'], + include_dirs = ['@PYTHON_SETUP_INCLUDES@','@prefix@/include'], + sources = ['pyzmq.cpp']) + +setup (name = 'libyzmq', + version = '@VERSION@', + description = '0MQ Python library', + ext_modules = [module1]) + + |