summaryrefslogtreecommitdiff
path: root/python
diff options
context:
space:
mode:
Diffstat (limited to 'python')
-rw-r--r--python/Makefile.am7
-rw-r--r--python/pyzmq.cpp756
-rw-r--r--python/setup.py.in14
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])
+
+