Build system for statically-linked Python.

ports/python_modules/pyzmq/nacl.patch

+diff --git a/buildutils/config.py b/buildutils/config.py
+index 66f61e3..de2cd6e 100644
+--- a/buildutils/config.py
++++ b/buildutils/config.py
+@@ -87,6 +87,11 @@ def get_cfg_args():
+     cfg = cfg2dict(cfg)
+ 
+     g = cfg.setdefault('global', {})
++    if "NACL_BUILD_TREE" in os.environ:
++        NACL_TREE = os.environ["NACL_BUILD_TREE"]
++        cfg["global"]["zmq_prefix"] = NACL_TREE
++        cfg["global"]["have_sys_un_h"] = "False"
++
+     # boolean keys:
+     for key in ['libzmq_extension',
+                 'bundle_libzmq_dylib',
+diff --git a/setup.cfg b/setup.cfg
+new file mode 100644
+index 0000000..15686fc
+--- /dev/null
++++ b/setup.cfg
+@@ -0,0 +1,3 @@
++[bdist_egg]
++plat-name = pnacl
++
+diff --git a/setup.py b/setup.py
+index 5348c61..a204e23 100755
+--- a/setup.py
++++ b/setup.py
+@@ -270,6 +270,10 @@ class Configure(build_ext):
+         # include internal directories
+         settings.setdefault('include_dirs', [])
+         settings['include_dirs'] += [pjoin('zmq', sub) for sub in ('utils','core','devices')]
++        if "NACL_BUILD_TREE" in os.environ:
++            settings['include_dirs'].append(pjoin(
++              os.environ["NACL_BUILD_TREE"],
++              "include", "glibc-compat"))
+         
+         for ext in self.distribution.ext_modules:
+             if ext.name == 'zmq.libzmq':
+@@ -826,29 +830,29 @@ def dotc(subdir, name):
+ 
+ libzmq = pxd('core', 'libzmq')
+ buffers = pxd('utils', 'buffers')
+-message = pxd('core', 'message')
+-context = pxd('core', 'context')
+-socket = pxd('core', 'socket')
++message = pxd('core', '_zmessage')
++context = pxd('core', '_zcontext')
++socket = pxd('core', '_zsocket')
+ checkrc = pxd('core', 'checkrc')
+-monqueue = pxd('devices', 'monitoredqueue')
++monqueue = pxd('devices', '_zmonitoredqueue')
+ 
+ submodules = dict(
+-    core = {'constants': [libzmq],
+-            'error':[libzmq, checkrc],
+-            '_poll':[libzmq, socket, context, checkrc],
+-            'stopwatch':[libzmq, pxd('core','stopwatch'), checkrc],
+-            'context':[context, libzmq, checkrc],
+-            'message':[libzmq, buffers, message, checkrc],
+-            'socket':[context, message, socket, libzmq, buffers, checkrc],
+-            '_device':[libzmq, socket, context, checkrc],
+-            '_version':[libzmq],
++    core = {'_zconstants': [libzmq],
++            '_zerror':[libzmq, checkrc],
++            '__zpoll':[libzmq, socket, context, checkrc],
++            '_zstopwatch':[libzmq, pxd('core','_zstopwatch'), checkrc],
++            '_zcontext':[context, libzmq, checkrc],
++            '_zmessage':[libzmq, buffers, message, checkrc],
++            '_zsocket':[context, message, socket, libzmq, buffers, checkrc],
++            '__zdevice':[libzmq, socket, context, checkrc],
++            '__zversion':[libzmq],
+     },
+     devices = {
+-            'monitoredqueue':[buffers, libzmq, monqueue, socket, context, checkrc],
++            '_zmonitoredqueue':[buffers, libzmq, monqueue, socket, context, checkrc],
+     },
+     utils = {
+-            'initthreads':[libzmq],
+-            'rebuffer':[buffers],
++            '_zinitthreads':[libzmq],
++            '_zrebuffer':[buffers],
+     },
+ )
+ 
+ #-----------------------------------------------------------------------------
+ # Main setup
+ #-----------------------------------------------------------------------------
+diff --git a/zmq/__init__.py b/zmq/__init__.py
+index 19cb4a9..c55ac5c 100644
+--- a/zmq/__init__.py
++++ b/zmq/__init__.py
+@@ -39,7 +39,7 @@ if bundled:
+ 
+ if 'PyPy' not in sys.version:
+     try:
+-        from zmq.utils import initthreads # initialize threads
++        from zmq.utils import _zinitthreads as initthreads # initialize threads
+     except ImportError as e:
+         raise ImportError("%s\nAre you trying to `import zmq` from the pyzmq source dir?" % e)
+     else:
+diff --git a/zmq/core/__init__.py b/zmq/core/__init__.py
+index 862f1d5..275e47a 100644
+--- a/zmq/core/__init__.py
++++ b/zmq/core/__init__.py
+@@ -23,21 +23,21 @@
+ # Imports
+ #-----------------------------------------------------------------------------
+ 
+-from zmq.core import (constants, error, message, context,
+-                      socket, stopwatch, _poll, _version, _device )
++from zmq.core import (_zconstants, _zerror, _zmessage, _zcontext,
++                      _zsocket, _zstopwatch, __zpoll, __zversion, __zdevice )
+ 
+ __all__ = []
+-for submod in (constants, error, message, context,
+-               socket, stopwatch, _poll, _version, _device):
++for submod in (_zconstants, _zerror, _zmessage, _zcontext,
++               _zsocket, _zstopwatch, __zpoll, __zversion, __zdevice):
+     __all__.extend(submod.__all__)
+ 
+-from zmq.core.constants import *
+-from zmq.core.error import *
+-from zmq.core.message import *
+-from zmq.core.context import *
+-from zmq.core.socket import *
+-from zmq.core._poll import *
+-from zmq.core.stopwatch import *
+-from zmq.core._device import *
+-from zmq.core._version import *
++from zmq.core._zconstants import *
++from zmq.core._zerror import *
++from zmq.core._zmessage import *
++from zmq.core._zcontext import *
++from zmq.core._zsocket import *
++from zmq.core.__zpoll import *
++from zmq.core._zstopwatch import *
++from zmq.core.__zdevice import *
++from zmq.core.__zversion import *
+ 
+diff --git a/zmq/core/__zdevice.pyx b/zmq/core/__zdevice.pyx
+new file mode 100644
+index 0000000..99bcc27
+--- /dev/null
++++ b/zmq/core/__zdevice.pyx
+@@ -0,0 +1,86 @@
++"""Python binding for 0MQ device function."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from libzmq cimport zmq_device, zmq_proxy, ZMQ_VERSION_MAJOR
++from zmq.core._zsocket cimport Socket as cSocket
++from zmq.core.checkrc cimport _check_rc
++
++#-----------------------------------------------------------------------------
++# Basic device API
++#-----------------------------------------------------------------------------
++
++def device(int device_type, cSocket frontend, cSocket backend=None):
++    """device(device_type, frontend, backend)
++
++    Start a zeromq device.
++    
++    WARNING: zmq.device is deprecated as of libzmq-3.2,
++    in favor of zmq.proxy.
++
++    Parameters
++    ----------
++    device_type : (QUEUE, FORWARDER, STREAMER)
++        The type of device to start.
++    frontend : Socket
++        The Socket instance for the incoming traffic.
++    backend : Socket
++        The Socket instance for the outbound traffic.
++    """
++    if ZMQ_VERSION_MAJOR >= 3:
++        return proxy(frontend, backend)
++
++    cdef int rc = 0
++    with nogil:
++        rc = zmq_device(device_type, frontend.handle, backend.handle)
++    _check_rc(rc)
++    return rc
++
++def proxy(cSocket frontend, cSocket backend, cSocket capture=None):
++    """proxy(frontend, backend, capture)
++
++    Start a zeromq proxy (replacement for device).
++
++    Parameters
++    ----------
++    frontend : Socket
++        The Socket instance for the incoming traffic.
++    backend : Socket
++        The Socket instance for the outbound traffic.
++    capture : Socket
++        The Socket instance for capturing traffic.
++    """
++    cdef int rc = 0
++    cdef void* capture_handle
++    if isinstance(capture, cSocket):
++        capture_handle = capture.handle
++    else:
++        capture_handle = NULL
++    with nogil:
++        rc = zmq_proxy(frontend.handle, backend.handle, capture_handle)
++    _check_rc(rc)
++    return rc
++
++__all__ = ['device', 'proxy']
++
+diff --git a/zmq/core/__zpoll.pyx b/zmq/core/__zpoll.pyx
+new file mode 100644
+index 0000000..799b20b
+--- /dev/null
++++ b/zmq/core/__zpoll.pyx
+@@ -0,0 +1,136 @@
++"""0MQ polling related functions and classes."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from libc.stdlib cimport free, malloc
++
++from libzmq cimport zmq_pollitem_t, ZMQ_VERSION_MAJOR
++from libzmq cimport zmq_poll as zmq_poll_c
++from _zsocket cimport Socket
++
++import sys
++
++from zmq.core.checkrc cimport _check_rc
++
++#-----------------------------------------------------------------------------
++# Polling related methods
++#-----------------------------------------------------------------------------
++
++# version-independent typecheck for int/long
++if sys.version_info[0] >= 3:
++    int_t = int
++else:
++    int_t = (int,long)
++
++def zmq_poll(sockets, long timeout=-1):
++    """zmq_poll(sockets, timeout=-1)
++
++    Poll a set of 0MQ sockets, native file descs. or sockets.
++
++    Parameters
++    ----------
++    sockets : list of tuples of (socket, flags)
++        Each element of this list is a two-tuple containing a socket
++        and a flags. The socket may be a 0MQ socket or any object with
++        a ``fileno()`` method. The flags can be zmq.POLLIN (for detecting
++        for incoming messages), zmq.POLLOUT (for detecting that send is OK)
++        or zmq.POLLIN|zmq.POLLOUT for detecting both.
++    timeout : int
++        The number of milliseconds to poll for. Negative means no timeout.
++    """
++    cdef int rc, i
++    cdef zmq_pollitem_t *pollitems = NULL
++    cdef int nsockets = <int>len(sockets)
++    cdef Socket current_socket
++    
++    if nsockets == 0:
++        return []
++    
++    pollitems = <zmq_pollitem_t *>malloc(nsockets*sizeof(zmq_pollitem_t))
++    if pollitems == NULL:
++        raise MemoryError("Could not allocate poll items")
++        
++    if ZMQ_VERSION_MAJOR < 3:
++        # timeout is us in 2.x, ms in 3.x
++        # expected input is ms (matches 3.x)
++        timeout = 1000*timeout
++
++    for i in range(nsockets):
++        s = sockets[i][0]
++        events = sockets[i][1]
++        if isinstance(s, Socket):
++            current_socket = s
++            pollitems[i].socket = current_socket.handle
++            pollitems[i].events = events
++            pollitems[i].revents = 0
++        elif isinstance(s, int_t):
++            pollitems[i].socket = NULL
++            pollitems[i].fd = s
++            pollitems[i].events = events
++            pollitems[i].revents = 0
++        elif hasattr(s, 'fileno'):
++            try:
++                fileno = int(s.fileno())
++            except:
++                free(pollitems)
++                raise ValueError('fileno() must return an valid integer fd')
++            else:
++                pollitems[i].socket = NULL
++                pollitems[i].fd = fileno
++                pollitems[i].events = events
++                pollitems[i].revents = 0
++        else:
++            free(pollitems)
++            raise TypeError(
++                "Socket must be a 0MQ socket, an integer fd or have "
++                "a fileno() method: %r" % s
++            )
++    
++
++    with nogil:
++        rc = zmq_poll_c(pollitems, nsockets, timeout)
++    
++    if rc < 0:
++        free(pollitems)
++        _check_rc(rc)
++    
++    results = []
++    for i in range(nsockets):
++        s = sockets[i][0]
++        # Return the fd for sockets, for compat. with select.poll.
++        if hasattr(s, 'fileno'):
++            s = s.fileno()
++        revents = pollitems[i].revents
++        # Only return sockets with non-zero status for compat. with select.poll.
++        if revents > 0:
++            results.append((s, revents))
++
++    free(pollitems)
++    return results
++
++#-----------------------------------------------------------------------------
++# Symbols to export
++#-----------------------------------------------------------------------------
++
++__all__ = [ 'zmq_poll' ]
+diff --git a/zmq/core/__zversion.pyx b/zmq/core/__zversion.pyx
+new file mode 100644
+index 0000000..02cf6fc
+--- /dev/null
++++ b/zmq/core/__zversion.pyx
+@@ -0,0 +1,43 @@
++"""PyZMQ and 0MQ version functions."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from libzmq cimport _zmq_version
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++def zmq_version_info():
++    """zmq_version_info()
++
++    Return the version of ZeroMQ itself as a 3-tuple of ints.
++    """
++    cdef int major, minor, patch
++    _zmq_version(&major, &minor, &patch)
++    return (major, minor, patch)
++
++
++__all__ = ['zmq_version_info']
++
+diff --git a/zmq/core/_device.pyx b/zmq/core/_device.pyx
+deleted file mode 100644
+index 5471e73..0000000
+--- a/zmq/core/_device.pyx
++++ /dev/null
+@@ -1,86 +0,0 @@
+-"""Python binding for 0MQ device function."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from libzmq cimport zmq_device, zmq_proxy, ZMQ_VERSION_MAJOR
+-from zmq.core.socket cimport Socket as cSocket
+-from zmq.core.checkrc cimport _check_rc
+-
+-#-----------------------------------------------------------------------------
+-# Basic device API
+-#-----------------------------------------------------------------------------
+-
+-def device(int device_type, cSocket frontend, cSocket backend=None):
+-    """device(device_type, frontend, backend)
+-
+-    Start a zeromq device.
+-    
+-    WARNING: zmq.device is deprecated as of libzmq-3.2,
+-    in favor of zmq.proxy.
+-
+-    Parameters
+-    ----------
+-    device_type : (QUEUE, FORWARDER, STREAMER)
+-        The type of device to start.
+-    frontend : Socket
+-        The Socket instance for the incoming traffic.
+-    backend : Socket
+-        The Socket instance for the outbound traffic.
+-    """
+-    if ZMQ_VERSION_MAJOR >= 3:
+-        return proxy(frontend, backend)
+-
+-    cdef int rc = 0
+-    with nogil:
+-        rc = zmq_device(device_type, frontend.handle, backend.handle)
+-    _check_rc(rc)
+-    return rc
+-
+-def proxy(cSocket frontend, cSocket backend, cSocket capture=None):
+-    """proxy(frontend, backend, capture)
+-
+-    Start a zeromq proxy (replacement for device).
+-
+-    Parameters
+-    ----------
+-    frontend : Socket
+-        The Socket instance for the incoming traffic.
+-    backend : Socket
+-        The Socket instance for the outbound traffic.
+-    capture : Socket
+-        The Socket instance for capturing traffic.
+-    """
+-    cdef int rc = 0
+-    cdef void* capture_handle
+-    if isinstance(capture, cSocket):
+-        capture_handle = capture.handle
+-    else:
+-        capture_handle = NULL
+-    with nogil:
+-        rc = zmq_proxy(frontend.handle, backend.handle, capture_handle)
+-    _check_rc(rc)
+-    return rc
+-
+-__all__ = ['device', 'proxy']
+-
+diff --git a/zmq/core/_poll.pyx b/zmq/core/_poll.pyx
+deleted file mode 100644
+index 9db19e1..0000000
+--- a/zmq/core/_poll.pyx
++++ /dev/null
+@@ -1,136 +0,0 @@
+-"""0MQ polling related functions and classes."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from libc.stdlib cimport free, malloc
+-
+-from libzmq cimport zmq_pollitem_t, ZMQ_VERSION_MAJOR
+-from libzmq cimport zmq_poll as zmq_poll_c
+-from socket cimport Socket
+-
+-import sys
+-
+-from zmq.core.checkrc cimport _check_rc
+-
+-#-----------------------------------------------------------------------------
+-# Polling related methods
+-#-----------------------------------------------------------------------------
+-
+-# version-independent typecheck for int/long
+-if sys.version_info[0] >= 3:
+-    int_t = int
+-else:
+-    int_t = (int,long)
+-
+-def zmq_poll(sockets, long timeout=-1):
+-    """zmq_poll(sockets, timeout=-1)
+-
+-    Poll a set of 0MQ sockets, native file descs. or sockets.
+-
+-    Parameters
+-    ----------
+-    sockets : list of tuples of (socket, flags)
+-        Each element of this list is a two-tuple containing a socket
+-        and a flags. The socket may be a 0MQ socket or any object with
+-        a ``fileno()`` method. The flags can be zmq.POLLIN (for detecting
+-        for incoming messages), zmq.POLLOUT (for detecting that send is OK)
+-        or zmq.POLLIN|zmq.POLLOUT for detecting both.
+-    timeout : int
+-        The number of milliseconds to poll for. Negative means no timeout.
+-    """
+-    cdef int rc, i
+-    cdef zmq_pollitem_t *pollitems = NULL
+-    cdef int nsockets = <int>len(sockets)
+-    cdef Socket current_socket
+-    
+-    if nsockets == 0:
+-        return []
+-    
+-    pollitems = <zmq_pollitem_t *>malloc(nsockets*sizeof(zmq_pollitem_t))
+-    if pollitems == NULL:
+-        raise MemoryError("Could not allocate poll items")
+-        
+-    if ZMQ_VERSION_MAJOR < 3:
+-        # timeout is us in 2.x, ms in 3.x
+-        # expected input is ms (matches 3.x)
+-        timeout = 1000*timeout
+-
+-    for i in range(nsockets):
+-        s = sockets[i][0]
+-        events = sockets[i][1]
+-        if isinstance(s, Socket):
+-            current_socket = s
+-            pollitems[i].socket = current_socket.handle
+-            pollitems[i].events = events
+-            pollitems[i].revents = 0
+-        elif isinstance(s, int_t):
+-            pollitems[i].socket = NULL
+-            pollitems[i].fd = s
+-            pollitems[i].events = events
+-            pollitems[i].revents = 0
+-        elif hasattr(s, 'fileno'):
+-            try:
+-                fileno = int(s.fileno())
+-            except:
+-                free(pollitems)
+-                raise ValueError('fileno() must return an valid integer fd')
+-            else:
+-                pollitems[i].socket = NULL
+-                pollitems[i].fd = fileno
+-                pollitems[i].events = events
+-                pollitems[i].revents = 0
+-        else:
+-            free(pollitems)
+-            raise TypeError(
+-                "Socket must be a 0MQ socket, an integer fd or have "
+-                "a fileno() method: %r" % s
+-            )
+-    
+-
+-    with nogil:
+-        rc = zmq_poll_c(pollitems, nsockets, timeout)
+-    
+-    if rc < 0:
+-        free(pollitems)
+-        _check_rc(rc)
+-    
+-    results = []
+-    for i in range(nsockets):
+-        s = sockets[i][0]
+-        # Return the fd for sockets, for compat. with select.poll.
+-        if hasattr(s, 'fileno'):
+-            s = s.fileno()
+-        revents = pollitems[i].revents
+-        # Only return sockets with non-zero status for compat. with select.poll.
+-        if revents > 0:
+-            results.append((s, revents))
+-
+-    free(pollitems)
+-    return results
+-
+-#-----------------------------------------------------------------------------
+-# Symbols to export
+-#-----------------------------------------------------------------------------
+-
+-__all__ = [ 'zmq_poll' ]
+diff --git a/zmq/core/_version.pyx b/zmq/core/_version.pyx
+deleted file mode 100644
+index 02cf6fc..0000000
+--- a/zmq/core/_version.pyx
++++ /dev/null
+@@ -1,43 +0,0 @@
+-"""PyZMQ and 0MQ version functions."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from libzmq cimport _zmq_version
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-def zmq_version_info():
+-    """zmq_version_info()
+-
+-    Return the version of ZeroMQ itself as a 3-tuple of ints.
+-    """
+-    cdef int major, minor, patch
+-    _zmq_version(&major, &minor, &patch)
+-    return (major, minor, patch)
+-
+-
+-__all__ = ['zmq_version_info']
+-
+diff --git a/zmq/core/_zconstants.pyx b/zmq/core/_zconstants.pyx
+new file mode 100644
+index 0000000..fa2695d
+--- /dev/null
++++ b/zmq/core/_zconstants.pyx
+@@ -0,0 +1,190 @@
++"""0MQ Constants."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from libzmq cimport *
++
++#-----------------------------------------------------------------------------
++# Python module level constants
++#-----------------------------------------------------------------------------
++
++_optionals = []
++
++if ZMQ_VERSION < 30000:
++    # backport DONTWAIT as alias to NOBLOCK
++    NOBLOCK = ZMQ_NOBLOCK
++    DONTWAIT = ZMQ_NOBLOCK
++else:
++    # keep NOBLOCK as alias for new DONTWAIT
++    NOBLOCK = ZMQ_DONTWAIT
++    DONTWAIT = ZMQ_DONTWAIT
++
++VERSION = ZMQ_VERSION
++
++# socket types
++PAIR = ZMQ_PAIR
++PUB = ZMQ_PUB
++SUB = ZMQ_SUB
++REQ = ZMQ_REQ
++REP = ZMQ_REP
++DEALER = ZMQ_DEALER
++ROUTER = ZMQ_ROUTER
++PULL = ZMQ_PULL
++PUSH = ZMQ_PUSH
++XPUB = ZMQ_XPUB
++XSUB = ZMQ_XSUB
++
++# keep deprecated aliases
++XREQ = DEALER
++XREP = ROUTER
++UPSTREAM = PULL
++DOWNSTREAM = PUSH
++
++
++# socket options
++AFFINITY = ZMQ_AFFINITY
++IDENTITY = ZMQ_IDENTITY
++SUBSCRIBE = ZMQ_SUBSCRIBE
++UNSUBSCRIBE = ZMQ_UNSUBSCRIBE
++RATE = ZMQ_RATE
++RECOVERY_IVL = ZMQ_RECOVERY_IVL
++RECONNECT_IVL_MAX = ZMQ_RECONNECT_IVL_MAX
++SNDBUF = ZMQ_SNDBUF
++RCVBUF = ZMQ_RCVBUF
++RCVMORE = ZMQ_RCVMORE
++SNDMORE = ZMQ_SNDMORE
++POLLIN = ZMQ_POLLIN
++POLLOUT = ZMQ_POLLOUT
++POLLERR = ZMQ_POLLERR
++
++STREAMER = ZMQ_STREAMER
++FORWARDER = ZMQ_FORWARDER
++QUEUE = ZMQ_QUEUE
++
++# sockopts new in 2.2.0
++SNDTIMEO = ZMQ_SNDTIMEO
++RCVTIMEO = ZMQ_RCVTIMEO
++
++# sockopts removed in 3.0.0
++HWM = ZMQ_HWM
++SWAP = ZMQ_SWAP
++MCAST_LOOP = ZMQ_MCAST_LOOP
++RECOVERY_IVL_MSEC = ZMQ_RECOVERY_IVL_MSEC
++
++# new in 3.x
++IO_THREADS = ZMQ_IO_THREADS
++MAX_SOCKETS = ZMQ_MAX_SOCKETS
++
++MORE = ZMQ_MORE
++    
++MAXMSGSIZE = ZMQ_MAXMSGSIZE
++SNDHWM = ZMQ_SNDHWM
++RCVHWM = ZMQ_RCVHWM
++MULTICAST_HOPS = ZMQ_MULTICAST_HOPS
++IPV4ONLY = ZMQ_IPV4ONLY
++LAST_ENDPOINT = ZMQ_LAST_ENDPOINT
++
++ROUTER_MANDATORY = ZMQ_ROUTER_MANDATORY
++# aliases
++ROUTER_BEHAVIOR = ROUTER_MANDATORY
++FAIL_UNROUTABLE = ROUTER_MANDATORY
++
++TCP_KEEPALIVE = ZMQ_TCP_KEEPALIVE
++TCP_KEEPALIVE_CNT = ZMQ_TCP_KEEPALIVE_CNT
++TCP_KEEPALIVE_IDLE = ZMQ_TCP_KEEPALIVE_IDLE
++TCP_KEEPALIVE_INTVL = ZMQ_TCP_KEEPALIVE_INTVL
++TCP_ACCEPT_FILTER = ZMQ_TCP_ACCEPT_FILTER
++DELAY_ATTACH_ON_CONNECT = ZMQ_DELAY_ATTACH_ON_CONNECT
++XPUB_VERBOSE = ZMQ_XPUB_VERBOSE
++ROUTER_RAW = ZMQ_ROUTER_RAW
++
++EVENT_CONNECTED = ZMQ_EVENT_CONNECTED
++EVENT_CONNECT_DELAYED = ZMQ_EVENT_CONNECT_DELAYED
++EVENT_CONNECT_RETRIED = ZMQ_EVENT_CONNECT_RETRIED
++EVENT_LISTENING = ZMQ_EVENT_LISTENING
++EVENT_BIND_FAILED = ZMQ_EVENT_BIND_FAILED
++EVENT_ACCEPTED = ZMQ_EVENT_ACCEPTED
++EVENT_ACCEPT_FAILED = ZMQ_EVENT_ACCEPT_FAILED
++EVENT_CLOSED = ZMQ_EVENT_CLOSED
++EVENT_CLOSE_FAILED = ZMQ_EVENT_CLOSE_FAILED
++EVENT_DISCONNECTED = ZMQ_EVENT_DISCONNECTED
++
++FD = ZMQ_FD
++EVENTS = ZMQ_EVENTS
++TYPE = ZMQ_TYPE
++LINGER = ZMQ_LINGER
++RECONNECT_IVL = ZMQ_RECONNECT_IVL
++BACKLOG = ZMQ_BACKLOG
++
++# As new constants are added in future versions, add a new block here
++# like the two above, checking agains the relevant value for ZMQ_VERSION.
++# The constants will need to be added to libzmq.pxd and utils/zmq_compat.h
++# as well.
++
++#-----------------------------------------------------------------------------
++# Error handling
++#-----------------------------------------------------------------------------
++
++# Often used standard errnos
++from errno import (
++    EAGAIN,
++    EINVAL,
++    EFAULT,
++    ENOMEM,
++    ENODEV
++)
++
++# For Windows compatability
++ENOTSUP = ZMQ_ENOTSUP
++EPROTONOSUPPORT = ZMQ_EPROTONOSUPPORT
++ENOBUFS = ZMQ_ENOBUFS
++ENETDOWN = ZMQ_ENETDOWN
++EADDRINUSE = ZMQ_EADDRINUSE
++EADDRNOTAVAIL = ZMQ_EADDRNOTAVAIL
++ECONNREFUSED = ZMQ_ECONNREFUSED
++EINPROGRESS = ZMQ_EINPROGRESS
++ENOTSOCK = ZMQ_ENOTSOCK
++
++# new errnos in zmq3
++EMSGSIZE = ZMQ_EMSGSIZE
++EAFNOSUPPORT = ZMQ_EAFNOSUPPORT
++ENETUNREACH = ZMQ_ENETUNREACH
++ECONNABORTED = ZMQ_ECONNABORTED
++ECONNRESET = ZMQ_ECONNRESET
++ENOTCONN = ZMQ_ENOTCONN
++ETIMEDOUT = ZMQ_ETIMEDOUT
++EHOSTUNREACH = ZMQ_EHOSTUNREACH
++ENETRESET = ZMQ_ENETRESET
++
++# 0MQ Native
++EFSM = ZMQ_EFSM
++ENOCOMPATPROTO = ZMQ_ENOCOMPATPROTO
++ETERM = ZMQ_ETERM
++EMTHREAD = ZMQ_EMTHREAD
++
++#-----------------------------------------------------------------------------
++# Symbols to export
++#-----------------------------------------------------------------------------
++_names = list(locals().keys())
++__all__ = [ key for key in _names if not key.startswith('_') ]
+diff --git a/zmq/core/_zcontext.pxd b/zmq/core/_zcontext.pxd
+new file mode 100644
+index 0000000..e399de5
+--- /dev/null
++++ b/zmq/core/_zcontext.pxd
+@@ -0,0 +1,40 @@
++"""0MQ Context class declaration."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++cdef class Context:
++    """Manage the lifecycle of a 0MQ context."""
++
++    cdef object __weakref__     # enable weakref
++    cdef void *handle           # The C handle for the underlying zmq object.
++    cdef void **_sockets        # A C-array containg socket handles
++    cdef size_t _n_sockets       # the number of sockets
++    cdef size_t _max_sockets     # the size of the _sockets array
++    cdef int _pid               # the pid of the process which created me (for fork safety)
++
++    cdef public object closed   # bool property for a closed context.
++    # helpers for events on _sockets in Socket.__cinit__()/close()
++    cdef inline void _add_socket(self, void* handle)
++    cdef inline void _remove_socket(self, void* handle)
++
+diff --git a/zmq/core/_zcontext.pyx b/zmq/core/_zcontext.pyx
+new file mode 100644
+index 0000000..0917c66
+--- /dev/null
++++ b/zmq/core/_zcontext.pyx
+@@ -0,0 +1,254 @@
++"""0MQ Context class."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from libc.stdlib cimport free, malloc, realloc
++
++from libzmq cimport *
++
++cdef extern from "getpid_compat.h":
++    int getpid()
++
++from zmq.error import ZMQError
++from zmq.core.checkrc cimport _check_rc
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++_instance = None
++
++cdef class Context:
++    """Context(io_threads=1)
++
++    Manage the lifecycle of a 0MQ context.
++
++    Parameters
++    ----------
++    io_threads : int
++        The number of IO threads.
++    """
++    
++    def __cinit__(self, int io_threads = 1, **kwargs):
++        self.handle = NULL
++        self._sockets = NULL
++        
++        if ZMQ_VERSION_MAJOR >= 3:
++            self.handle = zmq_ctx_new()
++        else:
++            self.handle = zmq_init(io_threads)
++        
++        if self.handle == NULL:
++            raise ZMQError()
++        
++        cdef int rc = 0
++        if ZMQ_VERSION_MAJOR >= 3:
++            rc = zmq_ctx_set(self.handle, ZMQ_IO_THREADS, io_threads)
++            _check_rc(rc)
++        
++        self.closed = False
++        self._n_sockets = 0
++        self._max_sockets = 32
++        
++        self._sockets = <void **>malloc(self._max_sockets*sizeof(void *))
++        if self._sockets == NULL:
++            raise MemoryError("Could not allocate _sockets array")
++        
++        self._pid = getpid()
++    
++    def __init__(self, io_threads=1):
++        # no-op
++        pass
++    
++
++    def __del__(self):
++        """deleting a Context should terminate it, without trying non-threadsafe destroy"""
++        self.term()
++    
++    def __dealloc__(self):
++        """don't touch members in dealloc, just cleanup allocations"""
++        cdef int rc
++        if self._sockets != NULL:
++            free(self._sockets)
++            self._sockets = NULL
++            self._n_sockets = 0
++        self.term()
++    
++    cdef inline void _add_socket(self, void* handle):
++        """Add a socket handle to be closed when Context terminates.
++        
++        This is to be called in the Socket constructor.
++        """
++        # print self._n_sockets, self._max_sockets
++        if self._n_sockets >= self._max_sockets:
++            self._max_sockets *= 2
++            self._sockets = <void **>realloc(self._sockets, self._max_sockets*sizeof(void *))
++            if self._sockets == NULL:
++                raise MemoryError("Could not reallocate _sockets array")
++        
++        self._sockets[self._n_sockets] = handle
++        self._n_sockets += 1
++        # print self._n_sockets, self._max_sockets
++
++    cdef inline void _remove_socket(self, void* handle):
++        """Remove a socket from the collected handles.
++        
++        This should be called by Socket.close, to prevent trying to
++        close a socket a second time.
++        """
++        cdef bint found = False
++        
++        for idx in range(self._n_sockets):
++            if self._sockets[idx] == handle:
++                found=True
++                break
++        
++        if found:
++            self._n_sockets -= 1
++            if self._n_sockets:
++                # move last handle to closed socket's index
++                self._sockets[idx] = self._sockets[self._n_sockets]
++    
++    @property
++    def _handle(self):
++        return <Py_ssize_t> self.handle
++    
++    def term(self):
++        """ctx.term()
++
++        Close or terminate the context.
++        
++        This can be called to close the context by hand. If this is not called,
++        the context will automatically be closed when it is garbage collected.
++        """
++        cdef int rc
++        cdef int i=-1
++
++        if self.handle != NULL and not self.closed and getpid() == self._pid:
++            with nogil:
++                rc = zmq_ctx_destroy(self.handle)
++            _check_rc(rc)
++            self.handle = NULL
++            self.closed = True
++    
++    def set(self, int option, optval):
++        """ctx.set(option, optval)
++
++        Set context options.
++
++        See the 0MQ API documentation for zmq_ctx_set
++        for details on specific options.
++        
++        New in libzmq-3.2
++
++        Parameters
++        ----------
++        option : int
++            The option to set.  Available values will depend on your
++            version of libzmq.  Examples include::
++            
++                zmq.IO_THREADS, zmq.MAX_SOCKETS
++        
++        optval : int
++            The value of the option to set.
++        """
++        cdef int optval_int_c
++        cdef int rc
++        cdef char* optval_c
++
++        if self.closed:
++            raise RuntimeError("Context has been destroyed")
++        
++        if not isinstance(optval, int):
++            raise TypeError('expected int, got: %r' % optval)
++        optval_int_c = optval
++        rc = zmq_ctx_set(self.handle, option, optval_int_c)
++        _check_rc(rc)
++
++    def get(self, int option):
++        """ctx.get(option)
++
++        Get the value of a context option.
++
++        See the 0MQ API documentation for zmq_ctx_get
++        for details on specific options.
++        
++        New in libzmq-3.2
++
++        Parameters
++        ----------
++        option : int
++            The option to get.  Available values will depend on your
++            version of libzmq.  Examples include::
++            
++                zmq.IO_THREADS, zmq.MAX_SOCKETS
++            
++        Returns
++        -------
++        optval : int
++            The value of the option as an integer.
++        """
++        cdef int optval_int_c
++        cdef size_t sz
++        cdef int rc
++
++        if self.closed:
++            raise RuntimeError("Context has been destroyed")
++
++        rc = zmq_ctx_get(self.handle, option)
++        _check_rc(rc)
++
++        return rc
++
++    def destroy(self, linger=None):
++        """ctx.destroy(linger=None)
++        
++        Close all sockets associated with this context, and then terminate
++        the context. If linger is specified,
++        the LINGER sockopt of the sockets will be set prior to closing.
++        
++        WARNING:
++        
++        destroy involves calling zmq_close(), which is *NOT* threadsafe.
++        If there are active sockets in other threads, this must not be called.
++        """
++        
++        cdef int linger_c
++        cdef bint setlinger=False
++        
++        if linger is not None:
++            linger_c = linger
++            setlinger=True
++        if self.handle != NULL and not self.closed and self._n_sockets:
++            while self._n_sockets:
++                if setlinger:
++                    zmq_setsockopt(self._sockets[0], ZMQ_LINGER, &linger_c, sizeof(int))
++                rc = zmq_close(self._sockets[0])
++                if rc < 0 and zmq_errno() != ZMQ_ENOTSOCK:
++                    raise ZMQError()
++                self._n_sockets -= 1
++                self._sockets[0] = self._sockets[self._n_sockets]
++            self.term()
++    
++__all__ = ['Context']
+diff --git a/zmq/core/_zerror.pyx b/zmq/core/_zerror.pyx
+new file mode 100644
+index 0000000..85e785f
+--- /dev/null
++++ b/zmq/core/_zerror.pyx
+@@ -0,0 +1,56 @@
++"""0MQ Error classes and functions."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++# allow const char*
++cdef extern from *:
++    ctypedef char* const_char_ptr "const char*"
++
++from libzmq cimport zmq_strerror, zmq_errno as zmq_errno_c
++
++from zmq.utils.strtypes import bytes
++
++def strerror(int errno):
++    """strerror(errno)
++
++    Return the error string given the error number.
++    """
++    cdef const_char_ptr str_e
++    # char * will be a bytes object:
++    str_e = zmq_strerror(errno)
++    if str is bytes:
++        # Python 2: str is bytes, so we already have the right type
++        return str_e
++    else:
++        # Python 3: decode bytes to unicode str
++        return str_e.decode()
++
++def zmq_errno():
++    """zmq_errno()
++    
++    Return the integer errno of the most recent zmq error.
++    """
++    return zmq_errno_c()
++
++__all__ = ['strerror', 'zmq_errno']
+diff --git a/zmq/core/_zmessage.pxd b/zmq/core/_zmessage.pxd
+new file mode 100644
+index 0000000..a86a8e0
+--- /dev/null
++++ b/zmq/core/_zmessage.pxd
+@@ -0,0 +1,66 @@
++"""0MQ Message related class declarations."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from cpython cimport PyBytes_FromStringAndSize
++
++from libzmq cimport zmq_msg_t, zmq_msg_data, zmq_msg_size
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++cdef class MessageTracker(object):
++    """A class for tracking if 0MQ is done using one or more messages."""
++
++    cdef set events  # Message Event objects to track.
++    cdef set peers   # Other Message or MessageTracker objects.
++
++
++cdef class Frame:
++    """A Message Frame class for non-copy send/recvs."""
++
++    cdef zmq_msg_t zmq_msg
++    cdef object _data      # The actual message data as a Python object.
++    cdef object _buffer    # A Python Buffer/View of the message contents
++    cdef object _bytes     # A bytes/str copy of the message.
++    cdef bint _failed_init # Flag to handle failed zmq_msg_init
++    cdef public object tracker_event  # Event for use with zmq_free_fn.
++    cdef public object tracker        # MessageTracker object.
++    cdef public bint more             # whether RCVMORE was set
++
++    cdef Frame fast_copy(self) # Create shallow copy of Message object.
++    cdef object _getbuffer(self) # Construct self._buffer.
++
++
++cdef inline object copy_zmq_msg_bytes(zmq_msg_t *zmq_msg):
++    """ Copy the data from a zmq_msg_t """
++    cdef char *data_c = NULL
++    cdef Py_ssize_t data_len_c
++    with nogil:
++        data_c = <char *>zmq_msg_data(zmq_msg)
++        data_len_c = zmq_msg_size(zmq_msg)
++    return PyBytes_FromStringAndSize(data_c, data_len_c)
++
++
+diff --git a/zmq/core/_zmessage.pyx b/zmq/core/_zmessage.pyx
+new file mode 100644
+index 0000000..1d358ab
+--- /dev/null
++++ b/zmq/core/_zmessage.pyx
+@@ -0,0 +1,297 @@
++"""0MQ Message related classes."""
++
++#
++#    Copyright (c) 2013 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++# get version-independent aliases:
++cdef extern from "pyversion_compat.h":
++    pass
++
++from cpython cimport Py_DECREF, Py_INCREF
++
++from buffers cimport asbuffer_r, viewfromobject_r
++
++cdef extern from "Python.h":
++    ctypedef int Py_ssize_t
++
++from libzmq cimport *
++
++import time
++
++try:
++    # below 3.3
++    from threading import _Event as Event
++except (ImportError, AttributeError):
++    # python throws ImportError, cython throws AttributeError
++    from threading import Event
++
++import zmq
++from zmq.core.checkrc cimport _check_rc
++from zmq.utils.strtypes import bytes,unicode,basestring
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++
++cdef void free_python_msg(void *data, void *hint) with gil:
++    """A function for DECREF'ing Python based messages."""
++    if hint != NULL:
++        tracker_event = (<tuple>hint)[1]
++        Py_DECREF(<object>hint)
++        if isinstance(tracker_event, Event):
++            # don't assert before DECREF:
++            # assert tracker_queue.empty(), "somebody else wrote to my Queue!"
++            tracker_event.set()
++        tracker_event = None
++
++
++cdef class Frame:
++    """Frame(data=None, track=False)
++
++    A zmq message Frame class for non-copy send/recvs.
++
++    This class is only needed if you want to do non-copying send and recvs.
++    When you pass a string to this class, like ``Frame(s)``, the 
++    ref-count of `s` is increased by two: once because the Frame saves `s` as 
++    an instance attribute and another because a ZMQ message is created that
++    points to the buffer of `s`. This second ref-count increase makes sure
++    that `s` lives until all messages that use it have been sent. Once 0MQ
++    sends all the messages and it doesn't need the buffer of s, 0MQ will call
++    ``Py_DECREF(s)``.
++
++    Parameters
++    ----------
++
++    data : object, optional
++        any object that provides the buffer interface will be used to
++        construct the 0MQ message data.
++    track : bool [default: False]
++        whether a MessageTracker_ should be created to track this object.
++        Tracking a message has a cost at creation, because it creates a threadsafe
++        Event object.
++    
++    """
++
++    def __cinit__(self, object data=None, track=False, **kwargs):
++        cdef int rc
++        cdef char *data_c = NULL
++        cdef Py_ssize_t data_len_c=0
++        cdef object hint
++
++        # init more as False
++        self.more = False
++
++        # Save the data object in case the user wants the the data as a str.
++        self._data = data
++        self._failed_init = True  # bool switch for dealloc
++        self._buffer = None       # buffer view of data
++        self._bytes = None        # bytes copy of data
++
++        # Event and MessageTracker for monitoring when zmq is done with data:
++        if track:
++            evt = Event()
++            self.tracker_event = evt
++            self.tracker = zmq.MessageTracker(evt)
++        else:
++            self.tracker_event = None
++            self.tracker = None
++
++        if isinstance(data, unicode):
++            raise TypeError("Unicode objects not allowed. Only: str/bytes, buffer interfaces.")
++
++        if data is None:
++            with nogil:
++                rc = zmq_msg_init(&self.zmq_msg)
++            _check_rc(rc)
++            self._failed_init = False
++            return
++        else:
++            asbuffer_r(data, <void **>&data_c, &data_len_c)
++        # We INCREF the *original* Python object (not self) and pass it
++        # as the hint below. This allows other copies of this Frame
++        # object to take over the ref counting of data properly.
++        hint = (data, self.tracker_event)
++        Py_INCREF(hint)
++        with nogil:
++            rc = zmq_msg_init_data(
++                &self.zmq_msg, <void *>data_c, data_len_c, 
++                <zmq_free_fn *>free_python_msg, <void *>hint
++            )
++        if rc != 0:
++            Py_DECREF(hint)
++            _check_rc(rc)
++        self._failed_init = False
++    
++    def __init__(self, object data=None, track=False):
++        """Enforce signature"""
++        pass
++
++    def __dealloc__(self):
++        cdef int rc
++        if self._failed_init:
++            return
++        # This simply decreases the 0MQ ref-count of zmq_msg.
++        with nogil:
++            rc = zmq_msg_close(&self.zmq_msg)
++        _check_rc(rc)
++    
++    # buffer interface code adapted from petsc4py by Lisandro Dalcin, a BSD project
++    
++    def __getbuffer__(self, Py_buffer* buffer, int flags):
++        # new-style (memoryview) buffer interface
++        with nogil:
++            buffer.buf = zmq_msg_data(&self.zmq_msg)
++            buffer.len = zmq_msg_size(&self.zmq_msg)
++        
++        buffer.obj = self
++        buffer.readonly = 1
++        buffer.format = "B"
++        buffer.ndim = 0
++        buffer.shape = NULL
++        buffer.strides = NULL
++        buffer.suboffsets = NULL
++        buffer.itemsize = 1
++        buffer.internal = NULL
++    
++    def __getsegcount__(self, Py_ssize_t *lenp):
++        # required for getreadbuffer
++        if lenp != NULL:
++            with nogil:
++                lenp[0] = zmq_msg_size(&self.zmq_msg)
++        return 1
++    
++    def __getreadbuffer__(self, Py_ssize_t idx, void **p):
++        # old-style (buffer) interface
++        cdef char *data_c = NULL
++        cdef Py_ssize_t data_len_c
++        if idx != 0:
++            raise SystemError("accessing non-existent buffer segment")
++        # read-only, because we don't want to allow
++        # editing of the message in-place
++        with nogil:
++            data_c = <char *>zmq_msg_data(&self.zmq_msg)
++            data_len_c = zmq_msg_size(&self.zmq_msg)
++        if p != NULL:
++            p[0] = <void*>data_c
++        return data_len_c
++    
++    # end buffer interface
++    
++    def __copy__(self):
++        """Create a shallow copy of the message.
++
++        This does not copy the contents of the Frame, just the pointer.
++        This will increment the 0MQ ref count of the message, but not
++        the ref count of the Python object. That is only done once when
++        the Python is first turned into a 0MQ message.
++        """
++        return self.fast_copy()
++
++    cdef Frame fast_copy(self):
++        """Fast, cdef'd version of shallow copy of the Frame."""
++        cdef Frame new_msg
++        new_msg = Frame()
++        # This does not copy the contents, but just increases the ref-count 
++        # of the zmq_msg by one.
++        with nogil:
++            zmq_msg_copy(&new_msg.zmq_msg, &self.zmq_msg)
++        # Copy the ref to data so the copy won't create a copy when str is
++        # called.
++        if self._data is not None:
++            new_msg._data = self._data
++        if self._buffer is not None:
++            new_msg._buffer = self._buffer
++        if self._bytes is not None:
++            new_msg._bytes = self._bytes
++
++        # Frame copies share the tracker and tracker_event
++        new_msg.tracker_event = self.tracker_event
++        new_msg.tracker = self.tracker
++
++        return new_msg
++
++    def __len__(self):
++        """Return the length of the message in bytes."""
++        cdef size_t sz
++        with nogil:
++            sz = zmq_msg_size(&self.zmq_msg)
++        return sz
++        # return <int>zmq_msg_size(&self.zmq_msg)
++
++    def __str__(self):
++        """Return the str form of the message."""
++        if isinstance(self._data, bytes):
++            b = self._data
++        else:
++            b = self.bytes
++        if str is unicode:
++            return b.decode()
++        else:
++            return b
++
++    cdef inline object _getbuffer(self):
++        """Create a Python buffer/view of the message data.
++
++        This will be called only once, the first time the `buffer` property
++        is accessed. Subsequent calls use a cached copy.
++        """
++        if self._data is None:
++            return viewfromobject_r(self)
++        else:
++            return viewfromobject_r(self._data)
++    
++    @property
++    def buffer(self):
++        """Get a read-only buffer view of the message contents."""
++        if self._buffer is None:
++            self._buffer = self._getbuffer()
++        return self._buffer
++
++    @property
++    def bytes(self):
++        """Get the message content as a Python str/bytes object.
++
++        The first time this property is accessed, a copy of the message 
++        contents is made. From then on that same copy of the message is
++        returned.
++        """
++        if self._bytes is None:
++            self._bytes = copy_zmq_msg_bytes(&self.zmq_msg)
++        return self._bytes
++    
++    def set(self, int option, int value):
++        """Set a message property"""
++        cdef int rc = zmq_msg_set(&self.zmq_msg, option, value)
++        _check_rc(rc)
++    
++    def get(self, int option):
++        """Get a message property"""
++        cdef int rc = zmq_msg_get(&self.zmq_msg, option)
++        _check_rc(rc)
++        return rc
++
++# legacy Message name
++Message = Frame
++
++__all__ = ['Frame', 'Message']
+diff --git a/zmq/core/_zsocket.pxd b/zmq/core/_zsocket.pxd
+new file mode 100644
+index 0000000..68f96c8
+--- /dev/null
++++ b/zmq/core/_zsocket.pxd
+@@ -0,0 +1,48 @@
++"""0MQ Socket class declaration."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from _zcontext cimport Context
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++
++cdef class Socket:
++    """A 0MQ socket."""
++
++    cdef object __weakref__     # enable weakref
++    cdef void *handle           # The C handle for the underlying zmq object.
++    cdef public int socket_type # The 0MQ socket type - REQ,REP, etc.
++    # Hold on to a reference to the context to make sure it is not garbage
++    # collected until the socket it done with it.
++    cdef public Context context # The zmq Context object that owns this.
++    cdef public bint _closed    # bool property for a closed socket.
++    cdef int _pid               # the pid of the process which created me (for fork safety)
++
++    # cpdef methods for direct-cython access:
++    cpdef object send(self, object data, int flags=*, copy=*, track=*)
++    cpdef object recv(self, int flags=*, copy=*, track=*)
++
+diff --git a/zmq/core/_zsocket.pyx b/zmq/core/_zsocket.pyx
+new file mode 100644
+index 0000000..a5e507d
+--- /dev/null
++++ b/zmq/core/_zsocket.pyx
+@@ -0,0 +1,628 @@
++"""0MQ Socket class."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Cython Imports
++#-----------------------------------------------------------------------------
++
++# get version-independent aliases:
++cdef extern from "pyversion_compat.h":
++    pass
++
++from libc.errno cimport ENAMETOOLONG
++from libc.string cimport memcpy
++
++from cpython cimport PyBytes_FromStringAndSize
++from cpython cimport PyBytes_AsString, PyBytes_Size
++from cpython cimport Py_DECREF, Py_INCREF
++
++from buffers cimport asbuffer_r, viewfromobject_r
++
++from libzmq cimport *
++from _zmessage cimport Frame, copy_zmq_msg_bytes
++
++from _zcontext cimport Context
++
++cdef extern from "Python.h":
++    ctypedef int Py_ssize_t
++
++cdef extern from "ipcmaxlen.h":
++    int get_ipc_path_max_len()
++
++cdef extern from "getpid_compat.h":
++    int getpid()
++
++
++#-----------------------------------------------------------------------------
++# Python Imports
++#-----------------------------------------------------------------------------
++
++import copy as copy_mod
++import time
++import sys
++import random
++import struct
++import codecs
++
++from zmq.utils import jsonapi
++
++try:
++    import cPickle
++    pickle = cPickle
++except:
++    cPickle = None
++    import pickle
++
++import zmq
++from zmq.core import _zconstants as constants
++from zmq.core._zconstants import *
++from zmq.core.checkrc cimport _check_rc
++from zmq.error import ZMQError, ZMQBindError
++from zmq.utils.strtypes import bytes,unicode,basestring
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++IPC_PATH_MAX_LEN = get_ipc_path_max_len()
++
++# inline some small socket submethods:
++# true methods frequently cannot be inlined, acc. Cython docs
++
++cdef inline _check_closed(Socket s, bint raise_notsup):
++    cdef int rc
++    cdef int errno
++    cdef int stype
++    cdef size_t sz=sizeof(int)
++    if s._closed:
++        if raise_notsup:
++            raise ZMQError(ENOTSUP)
++        else:
++            return True
++    else:
++        rc = zmq_getsockopt(s.handle, ZMQ_TYPE, <void *>&stype, &sz)
++        if rc < 0 and zmq_errno() == ENOTSOCK:
++            s._closed = True
++            if raise_notsup:
++                raise ZMQError(ENOTSUP)
++            else:
++                return True
++        else:
++            _check_rc(rc)
++    return False
++
++cdef inline Frame _recv_frame(void *handle, int flags=0, track=False):
++    """Receive a message in a non-copying manner and return a Frame."""
++    cdef int rc
++    cdef Frame msg
++    msg = Frame(track=track)
++
++    with nogil:
++        rc = zmq_msg_recv(&msg.zmq_msg, handle, flags)
++    
++    _check_rc(rc)
++    return msg
++
++cdef inline object _recv_copy(void *handle, int flags=0):
++    """Receive a message and return a copy"""
++    cdef zmq_msg_t zmq_msg
++    with nogil:
++        zmq_msg_init (&zmq_msg)
++        rc = zmq_msg_recv(&zmq_msg, handle, flags)
++    _check_rc(rc)
++    msg_bytes = copy_zmq_msg_bytes(&zmq_msg)
++    with nogil:
++        zmq_msg_close(&zmq_msg)
++    return msg_bytes
++
++cdef inline object _send_frame(void *handle, Frame msg, int flags=0):
++    """Send a Frame on this socket in a non-copy manner."""
++    cdef int rc
++    cdef Frame msg_copy
++
++    # Always copy so the original message isn't garbage collected.
++    # This doesn't do a real copy, just a reference.
++    msg_copy = msg.fast_copy()
++
++    with nogil:
++        rc = zmq_msg_send(&msg_copy.zmq_msg, handle, flags)
++
++    _check_rc(rc)
++    return msg.tracker
++
++
++cdef inline object _send_copy(void *handle, object msg, int flags=0):
++    """Send a message on this socket by copying its content."""
++    cdef int rc, rc2
++    cdef zmq_msg_t data
++    cdef char *msg_c
++    cdef Py_ssize_t msg_c_len=0
++
++    # copy to c array:
++    asbuffer_r(msg, <void **>&msg_c, &msg_c_len)
++
++    # Copy the msg before sending. This avoids any complications with
++    # the GIL, etc.
++    # If zmq_msg_init_* fails we must not call zmq_msg_close (Bus Error)
++    with nogil:
++        rc = zmq_msg_init_size(&data, msg_c_len)
++
++    _check_rc(rc)
++
++    with nogil:
++        memcpy(zmq_msg_data(&data), msg_c, zmq_msg_size(&data))
++        rc = zmq_msg_send(&data, handle, flags)
++        rc2 = zmq_msg_close(&data)
++    _check_rc(rc)
++    _check_rc(rc2)
++
++
++cdef class Socket:
++    """Socket(context, socket_type)
++
++    A 0MQ socket.
++
++    These objects will generally be constructed via the socket() method of a Context object.
++    
++    Note: 0MQ Sockets are *not* threadsafe. **DO NOT** share them across threads.
++    
++    Parameters
++    ----------
++    context : Context
++        The 0MQ Context this Socket belongs to.
++    socket_type : int
++        The socket type, which can be any of the 0MQ socket types: 
++        REQ, REP, PUB, SUB, PAIR, DEALER, ROUTER, PULL, PUSH, XPUB, XSUB.
++    
++    See Also
++    --------
++    .Context.socket : method for creating a socket bound to a Context.
++    """
++
++    def __cinit__(self, Context context, int socket_type, *args, **kwrags):
++        cdef Py_ssize_t c_handle
++        c_handle = context._handle
++
++        self.handle = NULL
++        self.context = context
++        self.socket_type = socket_type
++        with nogil:
++            self.handle = zmq_socket(<void *>c_handle, socket_type)
++        if self.handle == NULL:
++            raise ZMQError()
++        self._closed = False
++        self._pid = getpid()
++        context._add_socket(self.handle)
++
++    def __dealloc__(self):
++        """close *and* remove from context's list
++        
++        But be careful that context might not exist if called during gc
++        """
++        if self.handle != NULL and getpid() == self._pid:
++            rc = zmq_close(self.handle)
++            if rc != 0 and zmq_errno() != ENOTSOCK:
++                # ignore ENOTSOCK (closed by Context)
++                _check_rc(rc)
++            # during gc, self.context might be NULL
++            if self.context:
++                self.context._remove_socket(self.handle)
++    
++    def __init__(self, context, socket_type):
++        pass
++
++    @property
++    def closed(self):
++        return _check_closed(self, False)
++    
++    def close(self, linger=None):
++        """s.close(linger=None)
++
++        Close the socket.
++        
++        If linger is specified, LINGER sockopt will be set prior to closing.
++
++        This can be called to close the socket by hand. If this is not
++        called, the socket will automatically be closed when it is
++        garbage collected.
++        """
++        cdef int rc=0
++        cdef int linger_c
++        cdef bint setlinger=False
++        
++        if linger is not None:
++            linger_c = linger
++            setlinger=True
++        
++        if self.handle != NULL and not self._closed and getpid() == self._pid:
++            if setlinger:
++                zmq_setsockopt(self.handle, ZMQ_LINGER, &linger_c, sizeof(int))
++            rc = zmq_close(self.handle)
++            if rc != 0 and zmq_errno() != ENOTSOCK:
++                # ignore ENOTSOCK (closed by Context)
++                _check_rc(rc)
++            self._closed = True
++            # during gc, self.context might be NULL
++            if self.context:
++                self.context._remove_socket(self.handle)
++            self.handle = NULL
++
++    def set(self, int option, optval):
++        """s.set(option, optval)
++
++        Set socket options.
++
++        See the 0MQ API documentation for details on specific options.
++
++        Parameters
++        ----------
++        option : int
++            The option to set.  Available values will depend on your
++            version of libzmq.  Examples include::
++            
++                zmq.SUBSCRIBE, UNSUBSCRIBE, IDENTITY, HWM, LINGER, FD
++        
++        optval : int or bytes
++            The value of the option to set.
++        """
++        cdef int64_t optval_int64_c
++        cdef int optval_int_c
++        cdef int rc
++        cdef char* optval_c
++        cdef Py_ssize_t sz
++
++        _check_closed(self, True)
++        if isinstance(optval, unicode):
++            raise TypeError("unicode not allowed, use setsockopt_string")
++
++        if option in zmq.constants.bytes_sockopts:
++            if not isinstance(optval, bytes):
++                raise TypeError('expected bytes, got: %r' % optval)
++            optval_c = PyBytes_AsString(optval)
++            sz = PyBytes_Size(optval)
++            with nogil:
++                rc = zmq_setsockopt(
++                    self.handle, option,
++                    optval_c, sz
++                )
++        elif option in zmq.constants.int64_sockopts:
++            if not isinstance(optval, int):
++                raise TypeError('expected int, got: %r' % optval)
++            optval_int64_c = optval
++            with nogil:
++                rc = zmq_setsockopt(
++                    self.handle, option,
++                    &optval_int64_c, sizeof(int64_t)
++                )
++        else:
++            # default is to assume int, which is what most new sockopts will be
++            # this lets pyzmq work with newer libzmq which may add constants
++            # pyzmq has not yet added, rather than artificially raising. Invalid
++            # sockopts will still raise just the same, but it will be libzmq doing
++            # the raising.
++            if not isinstance(optval, int):
++                raise TypeError('expected int, got: %r' % optval)
++            optval_int_c = optval
++            with nogil:
++                rc = zmq_setsockopt(
++                    self.handle, option,
++                    &optval_int_c, sizeof(int)
++                )
++
++        _check_rc(rc)
++
++    def get(self, int option):
++        """s.get(option)
++
++        Get the value of a socket option.
++
++        See the 0MQ API documentation for details on specific options.
++
++        Parameters
++        ----------
++        option : int
++            The option to get.  Available values will depend on your
++            version of libzmq.  Examples include::
++            
++                zmq.IDENTITY, HWM, LINGER, FD, EVENTS
++
++        Returns
++        -------
++        optval : int or bytes
++            The value of the option as a bytestring or int.
++        """
++        cdef int64_t optval_int64_c
++        cdef int optval_int_c
++        cdef fd_t optval_fd_c
++        cdef char identity_str_c [255]
++        cdef size_t sz
++        cdef int rc
++
++        _check_closed(self, True)
++
++        if option in zmq.constants.bytes_sockopts:
++            sz = 255
++            with nogil:
++                rc = zmq_getsockopt(self.handle, option, <void *>identity_str_c, &sz)
++            _check_rc(rc)
++            result = PyBytes_FromStringAndSize(<char *>identity_str_c, sz)
++        elif option in zmq.constants.int64_sockopts:
++            sz = sizeof(int64_t)
++            with nogil:
++                rc = zmq_getsockopt(self.handle, option, <void *>&optval_int64_c, &sz)
++            _check_rc(rc)
++            result = optval_int64_c
++        elif option == ZMQ_FD:
++            sz = sizeof(fd_t)
++            with nogil:
++                rc = zmq_getsockopt(self.handle, option, <void *>&optval_fd_c, &sz)
++            _check_rc(rc)
++            result = optval_fd_c
++        else:
++            # default is to assume int, which is what most new sockopts will be
++            # this lets pyzmq work with newer libzmq which may add constants
++            # pyzmq has not yet added, rather than artificially raising. Invalid
++            # sockopts will still raise just the same, but it will be libzmq doing
++            # the raising.
++            sz = sizeof(int)
++            with nogil:
++                rc = zmq_getsockopt(self.handle, option, <void *>&optval_int_c, &sz)
++            _check_rc(rc)
++            result = optval_int_c
++
++        return result
++    
++    def bind(self, addr):
++        """s.bind(addr)
++
++        Bind the socket to an address.
++
++        This causes the socket to listen on a network port. Sockets on the
++        other side of this connection will use ``Socket.connect(addr)`` to
++        connect to this socket.
++
++        Parameters
++        ----------
++        addr : str
++            The address string. This has the form 'protocol://interface:port',
++            for example 'tcp://127.0.0.1:5555'. Protocols supported include
++            tcp, udp, pgm, epgm, inproc and ipc. If the address is unicode, it is
++            encoded to utf-8 first.
++        """
++        cdef int rc
++        cdef char* c_addr
++
++        _check_closed(self, True)
++        if isinstance(addr, unicode):
++            addr = addr.encode('utf-8')
++        if not isinstance(addr, bytes):
++            raise TypeError('expected str, got: %r' % addr)
++        c_addr = addr
++        rc = zmq_bind(self.handle, c_addr)
++        if rc != 0:
++            if IPC_PATH_MAX_LEN and zmq_errno() == ENAMETOOLONG:
++                # py3compat: addr is bytes, but msg wants str
++                if str is unicode:
++                    addr = addr.decode('utf-8', 'replace')
++                path = addr.split('://', 1)[-1]
++                msg = ('ipc path "{0}" is longer than {1} '
++                                'characters (sizeof(sockaddr_un.sun_path)). '
++                                'zmq.IPC_PATH_MAX_LEN constant can be used '
++                                'to check addr length (if it is defined).'
++                                .format(path, IPC_PATH_MAX_LEN))
++                raise ZMQError(msg=msg)
++        _check_rc(rc)
++
++    def connect(self, addr):
++        """s.connect(addr)
++
++        Connect to a remote 0MQ socket.
++
++        Parameters
++        ----------
++        addr : str
++            The address string. This has the form 'protocol://interface:port',
++            for example 'tcp://127.0.0.1:5555'. Protocols supported are
++            tcp, upd, pgm, inproc and ipc. If the address is unicode, it is
++            encoded to utf-8 first.
++        """
++        cdef int rc
++        cdef char* c_addr
++
++        _check_closed(self, True)
++        if isinstance(addr, unicode):
++            addr = addr.encode('utf-8')
++        if not isinstance(addr, bytes):
++            raise TypeError('expected str, got: %r' % addr)
++        c_addr = addr
++        
++        rc = zmq_connect(self.handle, c_addr)
++        if rc != 0:
++            raise ZMQError()
++
++    def unbind(self, addr):
++        """s.unbind(addr)
++        
++        Unbind from an address (undoes a call to bind).
++        
++        This feature requires libzmq-3
++
++        Parameters
++        ----------
++        addr : str
++            The address string. This has the form 'protocol://interface:port',
++            for example 'tcp://127.0.0.1:5555'. Protocols supported are
++            tcp, upd, pgm, inproc and ipc. If the address is unicode, it is
++            encoded to utf-8 first.
++        """
++        cdef int rc
++        cdef char* c_addr
++        
++        if ZMQ_VERSION_MAJOR < 3:
++            raise NotImplementedError("unbind requires libzmq >= 3.0, have %s" % zmq.zmq_version())
++        
++
++        _check_closed(self, True)
++        if isinstance(addr, unicode):
++            addr = addr.encode('utf-8')
++        if not isinstance(addr, bytes):
++            raise TypeError('expected str, got: %r' % addr)
++        c_addr = addr
++        
++        rc = zmq_unbind(self.handle, c_addr)
++        if rc != 0:
++            raise ZMQError()
++
++    def disconnect(self, addr):
++        """s.disconnect(addr)
++
++        Disconnect from a remote 0MQ socket (undoes a call to connect).
++        
++        This feature requires libzmq-3
++
++        Parameters
++        ----------
++        addr : str
++            The address string. This has the form 'protocol://interface:port',
++            for example 'tcp://127.0.0.1:5555'. Protocols supported are
++            tcp, upd, pgm, inproc and ipc. If the address is unicode, it is
++            encoded to utf-8 first.
++        """
++        cdef int rc
++        cdef char* c_addr
++        
++        if ZMQ_VERSION_MAJOR < 3:
++            raise NotImplementedError("disconnect requires libzmq >= 3.0, have %s" % zmq.zmq_version())
++
++        _check_closed(self, True)
++        if isinstance(addr, unicode):
++            addr = addr.encode('utf-8')
++        if not isinstance(addr, bytes):
++            raise TypeError('expected str, got: %r' % addr)
++        c_addr = addr
++        
++        rc = zmq_disconnect(self.handle, c_addr)
++        if rc != 0:
++            raise ZMQError()
++
++    #-------------------------------------------------------------------------
++    # Sending and receiving messages
++    #-------------------------------------------------------------------------
++
++    cpdef object send(self, object data, int flags=0, copy=True, track=False):
++        """s.send(data, flags=0, copy=True, track=False)
++
++        Send a message on this socket.
++
++        This queues the message to be sent by the IO thread at a later time.
++
++        Parameters
++        ----------
++        data : object, str, Frame
++            The content of the message.
++        flags : int
++            Any supported flag: NOBLOCK, SNDMORE.
++        copy : bool
++            Should the message be sent in a copying or non-copying manner.
++        track : bool
++            Should the message be tracked for notification that ZMQ has
++            finished with it? (ignored if copy=True)
++
++        Returns
++        -------
++        None : if `copy` or not track
++            None if message was sent, raises an exception otherwise.
++        MessageTracker : if track and not copy
++            a MessageTracker object, whose `pending` property will
++            be True until the send is completed.
++        
++        Raises
++        ------
++        TypeError
++            If a unicode object is passed
++        ValueError
++            If `track=True`, but an untracked Frame is passed.
++        ZMQError
++            If the send does not succeed for any reason.
++        
++        """
++        _check_closed(self, True)
++        
++        if isinstance(data, unicode):
++            raise TypeError("unicode not allowed, use send_unicode")
++        
++        if copy:
++            # msg.bytes never returns the input data object
++            # it is always a copy, but always the same copy
++            if isinstance(data, Frame):
++                data = data.buffer
++            return _send_copy(self.handle, data, flags)
++        else:
++            if isinstance(data, Frame):
++                if track and not data.tracker:
++                    raise ValueError('Not a tracked message')
++                msg = data
++            else:
++                msg = Frame(data, track=track)
++            return _send_frame(self.handle, msg, flags)
++
++    cpdef object recv(self, int flags=0, copy=True, track=False):
++        """s.recv(flags=0, copy=True, track=False)
++
++        Receive a message.
++
++        Parameters
++        ----------
++        flags : int
++            Any supported flag: NOBLOCK. If NOBLOCK is set, this method
++            will raise a ZMQError with EAGAIN if a message is not ready.
++            If NOBLOCK is not set, then this method will block until a
++            message arrives.
++        copy : bool
++            Should the message be received in a copying or non-copying manner?
++            If False a Frame object is returned, if True a string copy of
++            message is returned.
++        track : bool
++            Should the message be tracked for notification that ZMQ has
++            finished with it? (ignored if copy=True)
++
++        Returns
++        -------
++        msg : bytes, Frame
++            The received message frame.  If `copy` is False, then it will be a Frame,
++            otherwise it will be bytes.
++            
++        Raises
++        ------
++        ZMQError
++            for any of the reasons zmq_msg_recv might fail.
++        """
++        _check_closed(self, True)
++        
++        if copy:
++            return _recv_copy(self.handle, flags)
++        else:
++            frame = _recv_frame(self.handle, flags, track)
++            frame.more = self.getsockopt(zmq.RCVMORE)
++            return frame
++    
++
++__all__ = ['Socket', 'IPC_PATH_MAX_LEN']
+diff --git a/zmq/core/_zstopwatch.pxd b/zmq/core/_zstopwatch.pxd
+new file mode 100644
+index 0000000..5d56166
+--- /dev/null
++++ b/zmq/core/_zstopwatch.pxd
+@@ -0,0 +1,31 @@
++"""0MQ Stopwatch class declaration."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++
++cdef class Stopwatch:
++    """A simple stopwatch based on zmq_stopwatch_start/stop."""
++
++    cdef void *watch # The C handle for the underlying zmq object
++
+diff --git a/zmq/core/_zstopwatch.pyx b/zmq/core/_zstopwatch.pyx
+new file mode 100644
+index 0000000..6d2fd61
+--- /dev/null
++++ b/zmq/core/_zstopwatch.pyx
+@@ -0,0 +1,90 @@
++"""0MQ Stopwatch class."""
++
++#
++#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
++#
++#    This file is part of pyzmq.
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from libzmq cimport zmq_stopwatch_start, zmq_stopwatch_stop, zmq_sleep
++
++from zmq.error import ZMQError
++
++#-----------------------------------------------------------------------------
++# Code
++#-----------------------------------------------------------------------------
++
++cdef class Stopwatch:
++    """Stopwatch()
++
++    A simple stopwatch based on zmq_stopwatch_start/stop.
++
++    This class should be used for benchmarking and timing 0MQ code.
++    """
++
++    def __cinit__(self):
++        self.watch = NULL
++
++    def __dealloc__(self):
++        try:
++            self.stop()
++        except ZMQError:
++            pass
++
++    def start(self):
++        """s.start()
++
++        Start the stopwatch.
++        """
++        if self.watch == NULL:
++            with nogil:
++                self.watch = zmq_stopwatch_start()
++        else:
++            raise ZMQError('Stopwatch is already runing.')
++
++    def stop(self):
++        """s.stop()
++
++        Stop the stopwatch.
++        
++        Returns
++        -------
++        t : unsigned long int
++            the number of microseconds since ``start()`` was called.
++        """
++        cdef unsigned long time
++        if self.watch == NULL:
++            raise ZMQError('Must start the Stopwatch before calling stop.')
++        else:
++            with nogil:
++                time = zmq_stopwatch_stop(self.watch)
++            self.watch = NULL
++            return time
++
++    def sleep(self, int seconds):
++        """s.sleep(seconds)
++
++        Sleep for an integer number of seconds.
++        """
++        with nogil:
++            zmq_sleep(seconds)
++
++
++__all__ = ['Stopwatch']
+diff --git a/zmq/core/constants.pyx b/zmq/core/constants.pyx
+deleted file mode 100644
+index fa2695d..0000000
+--- a/zmq/core/constants.pyx
++++ /dev/null
+@@ -1,190 +0,0 @@
+-"""0MQ Constants."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from libzmq cimport *
+-
+-#-----------------------------------------------------------------------------
+-# Python module level constants
+-#-----------------------------------------------------------------------------
+-
+-_optionals = []
+-
+-if ZMQ_VERSION < 30000:
+-    # backport DONTWAIT as alias to NOBLOCK
+-    NOBLOCK = ZMQ_NOBLOCK
+-    DONTWAIT = ZMQ_NOBLOCK
+-else:
+-    # keep NOBLOCK as alias for new DONTWAIT
+-    NOBLOCK = ZMQ_DONTWAIT
+-    DONTWAIT = ZMQ_DONTWAIT
+-
+-VERSION = ZMQ_VERSION
+-
+-# socket types
+-PAIR = ZMQ_PAIR
+-PUB = ZMQ_PUB
+-SUB = ZMQ_SUB
+-REQ = ZMQ_REQ
+-REP = ZMQ_REP
+-DEALER = ZMQ_DEALER
+-ROUTER = ZMQ_ROUTER
+-PULL = ZMQ_PULL
+-PUSH = ZMQ_PUSH
+-XPUB = ZMQ_XPUB
+-XSUB = ZMQ_XSUB
+-
+-# keep deprecated aliases
+-XREQ = DEALER
+-XREP = ROUTER
+-UPSTREAM = PULL
+-DOWNSTREAM = PUSH
+-
+-
+-# socket options
+-AFFINITY = ZMQ_AFFINITY
+-IDENTITY = ZMQ_IDENTITY
+-SUBSCRIBE = ZMQ_SUBSCRIBE
+-UNSUBSCRIBE = ZMQ_UNSUBSCRIBE
+-RATE = ZMQ_RATE
+-RECOVERY_IVL = ZMQ_RECOVERY_IVL
+-RECONNECT_IVL_MAX = ZMQ_RECONNECT_IVL_MAX
+-SNDBUF = ZMQ_SNDBUF
+-RCVBUF = ZMQ_RCVBUF
+-RCVMORE = ZMQ_RCVMORE
+-SNDMORE = ZMQ_SNDMORE
+-POLLIN = ZMQ_POLLIN
+-POLLOUT = ZMQ_POLLOUT
+-POLLERR = ZMQ_POLLERR
+-
+-STREAMER = ZMQ_STREAMER
+-FORWARDER = ZMQ_FORWARDER
+-QUEUE = ZMQ_QUEUE
+-
+-# sockopts new in 2.2.0
+-SNDTIMEO = ZMQ_SNDTIMEO
+-RCVTIMEO = ZMQ_RCVTIMEO
+-
+-# sockopts removed in 3.0.0
+-HWM = ZMQ_HWM
+-SWAP = ZMQ_SWAP
+-MCAST_LOOP = ZMQ_MCAST_LOOP
+-RECOVERY_IVL_MSEC = ZMQ_RECOVERY_IVL_MSEC
+-
+-# new in 3.x
+-IO_THREADS = ZMQ_IO_THREADS
+-MAX_SOCKETS = ZMQ_MAX_SOCKETS
+-
+-MORE = ZMQ_MORE
+-    
+-MAXMSGSIZE = ZMQ_MAXMSGSIZE
+-SNDHWM = ZMQ_SNDHWM
+-RCVHWM = ZMQ_RCVHWM
+-MULTICAST_HOPS = ZMQ_MULTICAST_HOPS
+-IPV4ONLY = ZMQ_IPV4ONLY
+-LAST_ENDPOINT = ZMQ_LAST_ENDPOINT
+-
+-ROUTER_MANDATORY = ZMQ_ROUTER_MANDATORY
+-# aliases
+-ROUTER_BEHAVIOR = ROUTER_MANDATORY
+-FAIL_UNROUTABLE = ROUTER_MANDATORY
+-
+-TCP_KEEPALIVE = ZMQ_TCP_KEEPALIVE
+-TCP_KEEPALIVE_CNT = ZMQ_TCP_KEEPALIVE_CNT
+-TCP_KEEPALIVE_IDLE = ZMQ_TCP_KEEPALIVE_IDLE
+-TCP_KEEPALIVE_INTVL = ZMQ_TCP_KEEPALIVE_INTVL
+-TCP_ACCEPT_FILTER = ZMQ_TCP_ACCEPT_FILTER
+-DELAY_ATTACH_ON_CONNECT = ZMQ_DELAY_ATTACH_ON_CONNECT
+-XPUB_VERBOSE = ZMQ_XPUB_VERBOSE
+-ROUTER_RAW = ZMQ_ROUTER_RAW
+-
+-EVENT_CONNECTED = ZMQ_EVENT_CONNECTED
+-EVENT_CONNECT_DELAYED = ZMQ_EVENT_CONNECT_DELAYED
+-EVENT_CONNECT_RETRIED = ZMQ_EVENT_CONNECT_RETRIED
+-EVENT_LISTENING = ZMQ_EVENT_LISTENING
+-EVENT_BIND_FAILED = ZMQ_EVENT_BIND_FAILED
+-EVENT_ACCEPTED = ZMQ_EVENT_ACCEPTED
+-EVENT_ACCEPT_FAILED = ZMQ_EVENT_ACCEPT_FAILED
+-EVENT_CLOSED = ZMQ_EVENT_CLOSED
+-EVENT_CLOSE_FAILED = ZMQ_EVENT_CLOSE_FAILED
+-EVENT_DISCONNECTED = ZMQ_EVENT_DISCONNECTED
+-
+-FD = ZMQ_FD
+-EVENTS = ZMQ_EVENTS
+-TYPE = ZMQ_TYPE
+-LINGER = ZMQ_LINGER
+-RECONNECT_IVL = ZMQ_RECONNECT_IVL
+-BACKLOG = ZMQ_BACKLOG
+-
+-# As new constants are added in future versions, add a new block here
+-# like the two above, checking agains the relevant value for ZMQ_VERSION.
+-# The constants will need to be added to libzmq.pxd and utils/zmq_compat.h
+-# as well.
+-
+-#-----------------------------------------------------------------------------
+-# Error handling
+-#-----------------------------------------------------------------------------
+-
+-# Often used standard errnos
+-from errno import (
+-    EAGAIN,
+-    EINVAL,
+-    EFAULT,
+-    ENOMEM,
+-    ENODEV
+-)
+-
+-# For Windows compatability
+-ENOTSUP = ZMQ_ENOTSUP
+-EPROTONOSUPPORT = ZMQ_EPROTONOSUPPORT
+-ENOBUFS = ZMQ_ENOBUFS
+-ENETDOWN = ZMQ_ENETDOWN
+-EADDRINUSE = ZMQ_EADDRINUSE
+-EADDRNOTAVAIL = ZMQ_EADDRNOTAVAIL
+-ECONNREFUSED = ZMQ_ECONNREFUSED
+-EINPROGRESS = ZMQ_EINPROGRESS
+-ENOTSOCK = ZMQ_ENOTSOCK
+-
+-# new errnos in zmq3
+-EMSGSIZE = ZMQ_EMSGSIZE
+-EAFNOSUPPORT = ZMQ_EAFNOSUPPORT
+-ENETUNREACH = ZMQ_ENETUNREACH
+-ECONNABORTED = ZMQ_ECONNABORTED
+-ECONNRESET = ZMQ_ECONNRESET
+-ENOTCONN = ZMQ_ENOTCONN
+-ETIMEDOUT = ZMQ_ETIMEDOUT
+-EHOSTUNREACH = ZMQ_EHOSTUNREACH
+-ENETRESET = ZMQ_ENETRESET
+-
+-# 0MQ Native
+-EFSM = ZMQ_EFSM
+-ENOCOMPATPROTO = ZMQ_ENOCOMPATPROTO
+-ETERM = ZMQ_ETERM
+-EMTHREAD = ZMQ_EMTHREAD
+-
+-#-----------------------------------------------------------------------------
+-# Symbols to export
+-#-----------------------------------------------------------------------------
+-_names = list(locals().keys())
+-__all__ = [ key for key in _names if not key.startswith('_') ]
+diff --git a/zmq/core/context.pxd b/zmq/core/context.pxd
+deleted file mode 100644
+index e399de5..0000000
+--- a/zmq/core/context.pxd
++++ /dev/null
+@@ -1,40 +0,0 @@
+-"""0MQ Context class declaration."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-cdef class Context:
+-    """Manage the lifecycle of a 0MQ context."""
+-
+-    cdef object __weakref__     # enable weakref
+-    cdef void *handle           # The C handle for the underlying zmq object.
+-    cdef void **_sockets        # A C-array containg socket handles
+-    cdef size_t _n_sockets       # the number of sockets
+-    cdef size_t _max_sockets     # the size of the _sockets array
+-    cdef int _pid               # the pid of the process which created me (for fork safety)
+-
+-    cdef public object closed   # bool property for a closed context.
+-    # helpers for events on _sockets in Socket.__cinit__()/close()
+-    cdef inline void _add_socket(self, void* handle)
+-    cdef inline void _remove_socket(self, void* handle)
+-
+diff --git a/zmq/core/context.pyx b/zmq/core/context.pyx
+deleted file mode 100644
+index 0917c66..0000000
+--- a/zmq/core/context.pyx
++++ /dev/null
+@@ -1,254 +0,0 @@
+-"""0MQ Context class."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from libc.stdlib cimport free, malloc, realloc
+-
+-from libzmq cimport *
+-
+-cdef extern from "getpid_compat.h":
+-    int getpid()
+-
+-from zmq.error import ZMQError
+-from zmq.core.checkrc cimport _check_rc
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-_instance = None
+-
+-cdef class Context:
+-    """Context(io_threads=1)
+-
+-    Manage the lifecycle of a 0MQ context.
+-
+-    Parameters
+-    ----------
+-    io_threads : int
+-        The number of IO threads.
+-    """
+-    
+-    def __cinit__(self, int io_threads = 1, **kwargs):
+-        self.handle = NULL
+-        self._sockets = NULL
+-        
+-        if ZMQ_VERSION_MAJOR >= 3:
+-            self.handle = zmq_ctx_new()
+-        else:
+-            self.handle = zmq_init(io_threads)
+-        
+-        if self.handle == NULL:
+-            raise ZMQError()
+-        
+-        cdef int rc = 0
+-        if ZMQ_VERSION_MAJOR >= 3:
+-            rc = zmq_ctx_set(self.handle, ZMQ_IO_THREADS, io_threads)
+-            _check_rc(rc)
+-        
+-        self.closed = False
+-        self._n_sockets = 0
+-        self._max_sockets = 32
+-        
+-        self._sockets = <void **>malloc(self._max_sockets*sizeof(void *))
+-        if self._sockets == NULL:
+-            raise MemoryError("Could not allocate _sockets array")
+-        
+-        self._pid = getpid()
+-    
+-    def __init__(self, io_threads=1):
+-        # no-op
+-        pass
+-    
+-
+-    def __del__(self):
+-        """deleting a Context should terminate it, without trying non-threadsafe destroy"""
+-        self.term()
+-    
+-    def __dealloc__(self):
+-        """don't touch members in dealloc, just cleanup allocations"""
+-        cdef int rc
+-        if self._sockets != NULL:
+-            free(self._sockets)
+-            self._sockets = NULL
+-            self._n_sockets = 0
+-        self.term()
+-    
+-    cdef inline void _add_socket(self, void* handle):
+-        """Add a socket handle to be closed when Context terminates.
+-        
+-        This is to be called in the Socket constructor.
+-        """
+-        # print self._n_sockets, self._max_sockets
+-        if self._n_sockets >= self._max_sockets:
+-            self._max_sockets *= 2
+-            self._sockets = <void **>realloc(self._sockets, self._max_sockets*sizeof(void *))
+-            if self._sockets == NULL:
+-                raise MemoryError("Could not reallocate _sockets array")
+-        
+-        self._sockets[self._n_sockets] = handle
+-        self._n_sockets += 1
+-        # print self._n_sockets, self._max_sockets
+-
+-    cdef inline void _remove_socket(self, void* handle):
+-        """Remove a socket from the collected handles.
+-        
+-        This should be called by Socket.close, to prevent trying to
+-        close a socket a second time.
+-        """
+-        cdef bint found = False
+-        
+-        for idx in range(self._n_sockets):
+-            if self._sockets[idx] == handle:
+-                found=True
+-                break
+-        
+-        if found:
+-            self._n_sockets -= 1
+-            if self._n_sockets:
+-                # move last handle to closed socket's index
+-                self._sockets[idx] = self._sockets[self._n_sockets]
+-    
+-    @property
+-    def _handle(self):
+-        return <Py_ssize_t> self.handle
+-    
+-    def term(self):
+-        """ctx.term()
+-
+-        Close or terminate the context.
+-        
+-        This can be called to close the context by hand. If this is not called,
+-        the context will automatically be closed when it is garbage collected.
+-        """
+-        cdef int rc
+-        cdef int i=-1
+-
+-        if self.handle != NULL and not self.closed and getpid() == self._pid:
+-            with nogil:
+-                rc = zmq_ctx_destroy(self.handle)
+-            _check_rc(rc)
+-            self.handle = NULL
+-            self.closed = True
+-    
+-    def set(self, int option, optval):
+-        """ctx.set(option, optval)
+-
+-        Set context options.
+-
+-        See the 0MQ API documentation for zmq_ctx_set
+-        for details on specific options.
+-        
+-        New in libzmq-3.2
+-
+-        Parameters
+-        ----------
+-        option : int
+-            The option to set.  Available values will depend on your
+-            version of libzmq.  Examples include::
+-            
+-                zmq.IO_THREADS, zmq.MAX_SOCKETS
+-        
+-        optval : int
+-            The value of the option to set.
+-        """
+-        cdef int optval_int_c
+-        cdef int rc
+-        cdef char* optval_c
+-
+-        if self.closed:
+-            raise RuntimeError("Context has been destroyed")
+-        
+-        if not isinstance(optval, int):
+-            raise TypeError('expected int, got: %r' % optval)
+-        optval_int_c = optval
+-        rc = zmq_ctx_set(self.handle, option, optval_int_c)
+-        _check_rc(rc)
+-
+-    def get(self, int option):
+-        """ctx.get(option)
+-
+-        Get the value of a context option.
+-
+-        See the 0MQ API documentation for zmq_ctx_get
+-        for details on specific options.
+-        
+-        New in libzmq-3.2
+-
+-        Parameters
+-        ----------
+-        option : int
+-            The option to get.  Available values will depend on your
+-            version of libzmq.  Examples include::
+-            
+-                zmq.IO_THREADS, zmq.MAX_SOCKETS
+-            
+-        Returns
+-        -------
+-        optval : int
+-            The value of the option as an integer.
+-        """
+-        cdef int optval_int_c
+-        cdef size_t sz
+-        cdef int rc
+-
+-        if self.closed:
+-            raise RuntimeError("Context has been destroyed")
+-
+-        rc = zmq_ctx_get(self.handle, option)
+-        _check_rc(rc)
+-
+-        return rc
+-
+-    def destroy(self, linger=None):
+-        """ctx.destroy(linger=None)
+-        
+-        Close all sockets associated with this context, and then terminate
+-        the context. If linger is specified,
+-        the LINGER sockopt of the sockets will be set prior to closing.
+-        
+-        WARNING:
+-        
+-        destroy involves calling zmq_close(), which is *NOT* threadsafe.
+-        If there are active sockets in other threads, this must not be called.
+-        """
+-        
+-        cdef int linger_c
+-        cdef bint setlinger=False
+-        
+-        if linger is not None:
+-            linger_c = linger
+-            setlinger=True
+-        if self.handle != NULL and not self.closed and self._n_sockets:
+-            while self._n_sockets:
+-                if setlinger:
+-                    zmq_setsockopt(self._sockets[0], ZMQ_LINGER, &linger_c, sizeof(int))
+-                rc = zmq_close(self._sockets[0])
+-                if rc < 0 and zmq_errno() != ZMQ_ENOTSOCK:
+-                    raise ZMQError()
+-                self._n_sockets -= 1
+-                self._sockets[0] = self._sockets[self._n_sockets]
+-            self.term()
+-    
+-__all__ = ['Context']
+diff --git a/zmq/core/error.pyx b/zmq/core/error.pyx
+deleted file mode 100644
+index 85e785f..0000000
+--- a/zmq/core/error.pyx
++++ /dev/null
+@@ -1,56 +0,0 @@
+-"""0MQ Error classes and functions."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-# allow const char*
+-cdef extern from *:
+-    ctypedef char* const_char_ptr "const char*"
+-
+-from libzmq cimport zmq_strerror, zmq_errno as zmq_errno_c
+-
+-from zmq.utils.strtypes import bytes
+-
+-def strerror(int errno):
+-    """strerror(errno)
+-
+-    Return the error string given the error number.
+-    """
+-    cdef const_char_ptr str_e
+-    # char * will be a bytes object:
+-    str_e = zmq_strerror(errno)
+-    if str is bytes:
+-        # Python 2: str is bytes, so we already have the right type
+-        return str_e
+-    else:
+-        # Python 3: decode bytes to unicode str
+-        return str_e.decode()
+-
+-def zmq_errno():
+-    """zmq_errno()
+-    
+-    Return the integer errno of the most recent zmq error.
+-    """
+-    return zmq_errno_c()
+-
+-__all__ = ['strerror', 'zmq_errno']
+diff --git a/zmq/core/message.pxd b/zmq/core/message.pxd
+deleted file mode 100644
+index a86a8e0..0000000
+--- a/zmq/core/message.pxd
++++ /dev/null
+@@ -1,66 +0,0 @@
+-"""0MQ Message related class declarations."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from cpython cimport PyBytes_FromStringAndSize
+-
+-from libzmq cimport zmq_msg_t, zmq_msg_data, zmq_msg_size
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-cdef class MessageTracker(object):
+-    """A class for tracking if 0MQ is done using one or more messages."""
+-
+-    cdef set events  # Message Event objects to track.
+-    cdef set peers   # Other Message or MessageTracker objects.
+-
+-
+-cdef class Frame:
+-    """A Message Frame class for non-copy send/recvs."""
+-
+-    cdef zmq_msg_t zmq_msg
+-    cdef object _data      # The actual message data as a Python object.
+-    cdef object _buffer    # A Python Buffer/View of the message contents
+-    cdef object _bytes     # A bytes/str copy of the message.
+-    cdef bint _failed_init # Flag to handle failed zmq_msg_init
+-    cdef public object tracker_event  # Event for use with zmq_free_fn.
+-    cdef public object tracker        # MessageTracker object.
+-    cdef public bint more             # whether RCVMORE was set
+-
+-    cdef Frame fast_copy(self) # Create shallow copy of Message object.
+-    cdef object _getbuffer(self) # Construct self._buffer.
+-
+-
+-cdef inline object copy_zmq_msg_bytes(zmq_msg_t *zmq_msg):
+-    """ Copy the data from a zmq_msg_t """
+-    cdef char *data_c = NULL
+-    cdef Py_ssize_t data_len_c
+-    with nogil:
+-        data_c = <char *>zmq_msg_data(zmq_msg)
+-        data_len_c = zmq_msg_size(zmq_msg)
+-    return PyBytes_FromStringAndSize(data_c, data_len_c)
+-
+-
+diff --git a/zmq/core/message.pyx b/zmq/core/message.pyx
+deleted file mode 100644
+index 1d358ab..0000000
+--- a/zmq/core/message.pyx
++++ /dev/null
+@@ -1,297 +0,0 @@
+-"""0MQ Message related classes."""
+-
+-#
+-#    Copyright (c) 2013 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-# get version-independent aliases:
+-cdef extern from "pyversion_compat.h":
+-    pass
+-
+-from cpython cimport Py_DECREF, Py_INCREF
+-
+-from buffers cimport asbuffer_r, viewfromobject_r
+-
+-cdef extern from "Python.h":
+-    ctypedef int Py_ssize_t
+-
+-from libzmq cimport *
+-
+-import time
+-
+-try:
+-    # below 3.3
+-    from threading import _Event as Event
+-except (ImportError, AttributeError):
+-    # python throws ImportError, cython throws AttributeError
+-    from threading import Event
+-
+-import zmq
+-from zmq.core.checkrc cimport _check_rc
+-from zmq.utils.strtypes import bytes,unicode,basestring
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-
+-cdef void free_python_msg(void *data, void *hint) with gil:
+-    """A function for DECREF'ing Python based messages."""
+-    if hint != NULL:
+-        tracker_event = (<tuple>hint)[1]
+-        Py_DECREF(<object>hint)
+-        if isinstance(tracker_event, Event):
+-            # don't assert before DECREF:
+-            # assert tracker_queue.empty(), "somebody else wrote to my Queue!"
+-            tracker_event.set()
+-        tracker_event = None
+-
+-
+-cdef class Frame:
+-    """Frame(data=None, track=False)
+-
+-    A zmq message Frame class for non-copy send/recvs.
+-
+-    This class is only needed if you want to do non-copying send and recvs.
+-    When you pass a string to this class, like ``Frame(s)``, the 
+-    ref-count of `s` is increased by two: once because the Frame saves `s` as 
+-    an instance attribute and another because a ZMQ message is created that
+-    points to the buffer of `s`. This second ref-count increase makes sure
+-    that `s` lives until all messages that use it have been sent. Once 0MQ
+-    sends all the messages and it doesn't need the buffer of s, 0MQ will call
+-    ``Py_DECREF(s)``.
+-
+-    Parameters
+-    ----------
+-
+-    data : object, optional
+-        any object that provides the buffer interface will be used to
+-        construct the 0MQ message data.
+-    track : bool [default: False]
+-        whether a MessageTracker_ should be created to track this object.
+-        Tracking a message has a cost at creation, because it creates a threadsafe
+-        Event object.
+-    
+-    """
+-
+-    def __cinit__(self, object data=None, track=False, **kwargs):
+-        cdef int rc
+-        cdef char *data_c = NULL
+-        cdef Py_ssize_t data_len_c=0
+-        cdef object hint
+-
+-        # init more as False
+-        self.more = False
+-
+-        # Save the data object in case the user wants the the data as a str.
+-        self._data = data
+-        self._failed_init = True  # bool switch for dealloc
+-        self._buffer = None       # buffer view of data
+-        self._bytes = None        # bytes copy of data
+-
+-        # Event and MessageTracker for monitoring when zmq is done with data:
+-        if track:
+-            evt = Event()
+-            self.tracker_event = evt
+-            self.tracker = zmq.MessageTracker(evt)
+-        else:
+-            self.tracker_event = None
+-            self.tracker = None
+-
+-        if isinstance(data, unicode):
+-            raise TypeError("Unicode objects not allowed. Only: str/bytes, buffer interfaces.")
+-
+-        if data is None:
+-            with nogil:
+-                rc = zmq_msg_init(&self.zmq_msg)
+-            _check_rc(rc)
+-            self._failed_init = False
+-            return
+-        else:
+-            asbuffer_r(data, <void **>&data_c, &data_len_c)
+-        # We INCREF the *original* Python object (not self) and pass it
+-        # as the hint below. This allows other copies of this Frame
+-        # object to take over the ref counting of data properly.
+-        hint = (data, self.tracker_event)
+-        Py_INCREF(hint)
+-        with nogil:
+-            rc = zmq_msg_init_data(
+-                &self.zmq_msg, <void *>data_c, data_len_c, 
+-                <zmq_free_fn *>free_python_msg, <void *>hint
+-            )
+-        if rc != 0:
+-            Py_DECREF(hint)
+-            _check_rc(rc)
+-        self._failed_init = False
+-    
+-    def __init__(self, object data=None, track=False):
+-        """Enforce signature"""
+-        pass
+-
+-    def __dealloc__(self):
+-        cdef int rc
+-        if self._failed_init:
+-            return
+-        # This simply decreases the 0MQ ref-count of zmq_msg.
+-        with nogil:
+-            rc = zmq_msg_close(&self.zmq_msg)
+-        _check_rc(rc)
+-    
+-    # buffer interface code adapted from petsc4py by Lisandro Dalcin, a BSD project
+-    
+-    def __getbuffer__(self, Py_buffer* buffer, int flags):
+-        # new-style (memoryview) buffer interface
+-        with nogil:
+-            buffer.buf = zmq_msg_data(&self.zmq_msg)
+-            buffer.len = zmq_msg_size(&self.zmq_msg)
+-        
+-        buffer.obj = self
+-        buffer.readonly = 1
+-        buffer.format = "B"
+-        buffer.ndim = 0
+-        buffer.shape = NULL
+-        buffer.strides = NULL
+-        buffer.suboffsets = NULL
+-        buffer.itemsize = 1
+-        buffer.internal = NULL
+-    
+-    def __getsegcount__(self, Py_ssize_t *lenp):
+-        # required for getreadbuffer
+-        if lenp != NULL:
+-            with nogil:
+-                lenp[0] = zmq_msg_size(&self.zmq_msg)
+-        return 1
+-    
+-    def __getreadbuffer__(self, Py_ssize_t idx, void **p):
+-        # old-style (buffer) interface
+-        cdef char *data_c = NULL
+-        cdef Py_ssize_t data_len_c
+-        if idx != 0:
+-            raise SystemError("accessing non-existent buffer segment")
+-        # read-only, because we don't want to allow
+-        # editing of the message in-place
+-        with nogil:
+-            data_c = <char *>zmq_msg_data(&self.zmq_msg)
+-            data_len_c = zmq_msg_size(&self.zmq_msg)
+-        if p != NULL:
+-            p[0] = <void*>data_c
+-        return data_len_c
+-    
+-    # end buffer interface
+-    
+-    def __copy__(self):
+-        """Create a shallow copy of the message.
+-
+-        This does not copy the contents of the Frame, just the pointer.
+-        This will increment the 0MQ ref count of the message, but not
+-        the ref count of the Python object. That is only done once when
+-        the Python is first turned into a 0MQ message.
+-        """
+-        return self.fast_copy()
+-
+-    cdef Frame fast_copy(self):
+-        """Fast, cdef'd version of shallow copy of the Frame."""
+-        cdef Frame new_msg
+-        new_msg = Frame()
+-        # This does not copy the contents, but just increases the ref-count 
+-        # of the zmq_msg by one.
+-        with nogil:
+-            zmq_msg_copy(&new_msg.zmq_msg, &self.zmq_msg)
+-        # Copy the ref to data so the copy won't create a copy when str is
+-        # called.
+-        if self._data is not None:
+-            new_msg._data = self._data
+-        if self._buffer is not None:
+-            new_msg._buffer = self._buffer
+-        if self._bytes is not None:
+-            new_msg._bytes = self._bytes
+-
+-        # Frame copies share the tracker and tracker_event
+-        new_msg.tracker_event = self.tracker_event
+-        new_msg.tracker = self.tracker
+-
+-        return new_msg
+-
+-    def __len__(self):
+-        """Return the length of the message in bytes."""
+-        cdef size_t sz
+-        with nogil:
+-            sz = zmq_msg_size(&self.zmq_msg)
+-        return sz
+-        # return <int>zmq_msg_size(&self.zmq_msg)
+-
+-    def __str__(self):
+-        """Return the str form of the message."""
+-        if isinstance(self._data, bytes):
+-            b = self._data
+-        else:
+-            b = self.bytes
+-        if str is unicode:
+-            return b.decode()
+-        else:
+-            return b
+-
+-    cdef inline object _getbuffer(self):
+-        """Create a Python buffer/view of the message data.
+-
+-        This will be called only once, the first time the `buffer` property
+-        is accessed. Subsequent calls use a cached copy.
+-        """
+-        if self._data is None:
+-            return viewfromobject_r(self)
+-        else:
+-            return viewfromobject_r(self._data)
+-    
+-    @property
+-    def buffer(self):
+-        """Get a read-only buffer view of the message contents."""
+-        if self._buffer is None:
+-            self._buffer = self._getbuffer()
+-        return self._buffer
+-
+-    @property
+-    def bytes(self):
+-        """Get the message content as a Python str/bytes object.
+-
+-        The first time this property is accessed, a copy of the message 
+-        contents is made. From then on that same copy of the message is
+-        returned.
+-        """
+-        if self._bytes is None:
+-            self._bytes = copy_zmq_msg_bytes(&self.zmq_msg)
+-        return self._bytes
+-    
+-    def set(self, int option, int value):
+-        """Set a message property"""
+-        cdef int rc = zmq_msg_set(&self.zmq_msg, option, value)
+-        _check_rc(rc)
+-    
+-    def get(self, int option):
+-        """Get a message property"""
+-        cdef int rc = zmq_msg_get(&self.zmq_msg, option)
+-        _check_rc(rc)
+-        return rc
+-
+-# legacy Message name
+-Message = Frame
+-
+-__all__ = ['Frame', 'Message']
+diff --git a/zmq/core/socket.pxd b/zmq/core/socket.pxd
+deleted file mode 100644
+index 92253eb..0000000
+--- a/zmq/core/socket.pxd
++++ /dev/null
+@@ -1,48 +0,0 @@
+-"""0MQ Socket class declaration."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from context cimport Context
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-
+-cdef class Socket:
+-    """A 0MQ socket."""
+-
+-    cdef object __weakref__     # enable weakref
+-    cdef void *handle           # The C handle for the underlying zmq object.
+-    cdef public int socket_type # The 0MQ socket type - REQ,REP, etc.
+-    # Hold on to a reference to the context to make sure it is not garbage
+-    # collected until the socket it done with it.
+-    cdef public Context context # The zmq Context object that owns this.
+-    cdef public bint _closed    # bool property for a closed socket.
+-    cdef int _pid               # the pid of the process which created me (for fork safety)
+-
+-    # cpdef methods for direct-cython access:
+-    cpdef object send(self, object data, int flags=*, copy=*, track=*)
+-    cpdef object recv(self, int flags=*, copy=*, track=*)
+-
+diff --git a/zmq/core/socket.pyx b/zmq/core/socket.pyx
+deleted file mode 100644
+index 16fbf7f..0000000
+--- a/zmq/core/socket.pyx
++++ /dev/null
+@@ -1,628 +0,0 @@
+-"""0MQ Socket class."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Cython Imports
+-#-----------------------------------------------------------------------------
+-
+-# get version-independent aliases:
+-cdef extern from "pyversion_compat.h":
+-    pass
+-
+-from libc.errno cimport ENAMETOOLONG
+-from libc.string cimport memcpy
+-
+-from cpython cimport PyBytes_FromStringAndSize
+-from cpython cimport PyBytes_AsString, PyBytes_Size
+-from cpython cimport Py_DECREF, Py_INCREF
+-
+-from buffers cimport asbuffer_r, viewfromobject_r
+-
+-from libzmq cimport *
+-from message cimport Frame, copy_zmq_msg_bytes
+-
+-from context cimport Context
+-
+-cdef extern from "Python.h":
+-    ctypedef int Py_ssize_t
+-
+-cdef extern from "ipcmaxlen.h":
+-    int get_ipc_path_max_len()
+-
+-cdef extern from "getpid_compat.h":
+-    int getpid()
+-
+-
+-#-----------------------------------------------------------------------------
+-# Python Imports
+-#-----------------------------------------------------------------------------
+-
+-import copy as copy_mod
+-import time
+-import sys
+-import random
+-import struct
+-import codecs
+-
+-from zmq.utils import jsonapi
+-
+-try:
+-    import cPickle
+-    pickle = cPickle
+-except:
+-    cPickle = None
+-    import pickle
+-
+-import zmq
+-from zmq.core import constants
+-from zmq.core.constants import *
+-from zmq.core.checkrc cimport _check_rc
+-from zmq.error import ZMQError, ZMQBindError
+-from zmq.utils.strtypes import bytes,unicode,basestring
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-IPC_PATH_MAX_LEN = get_ipc_path_max_len()
+-
+-# inline some small socket submethods:
+-# true methods frequently cannot be inlined, acc. Cython docs
+-
+-cdef inline _check_closed(Socket s, bint raise_notsup):
+-    cdef int rc
+-    cdef int errno
+-    cdef int stype
+-    cdef size_t sz=sizeof(int)
+-    if s._closed:
+-        if raise_notsup:
+-            raise ZMQError(ENOTSUP)
+-        else:
+-            return True
+-    else:
+-        rc = zmq_getsockopt(s.handle, ZMQ_TYPE, <void *>&stype, &sz)
+-        if rc < 0 and zmq_errno() == ENOTSOCK:
+-            s._closed = True
+-            if raise_notsup:
+-                raise ZMQError(ENOTSUP)
+-            else:
+-                return True
+-        else:
+-            _check_rc(rc)
+-    return False
+-
+-cdef inline Frame _recv_frame(void *handle, int flags=0, track=False):
+-    """Receive a message in a non-copying manner and return a Frame."""
+-    cdef int rc
+-    cdef Frame msg
+-    msg = Frame(track=track)
+-
+-    with nogil:
+-        rc = zmq_msg_recv(&msg.zmq_msg, handle, flags)
+-    
+-    _check_rc(rc)
+-    return msg
+-
+-cdef inline object _recv_copy(void *handle, int flags=0):
+-    """Receive a message and return a copy"""
+-    cdef zmq_msg_t zmq_msg
+-    with nogil:
+-        zmq_msg_init (&zmq_msg)
+-        rc = zmq_msg_recv(&zmq_msg, handle, flags)
+-    _check_rc(rc)
+-    msg_bytes = copy_zmq_msg_bytes(&zmq_msg)
+-    with nogil:
+-        zmq_msg_close(&zmq_msg)
+-    return msg_bytes
+-
+-cdef inline object _send_frame(void *handle, Frame msg, int flags=0):
+-    """Send a Frame on this socket in a non-copy manner."""
+-    cdef int rc
+-    cdef Frame msg_copy
+-
+-    # Always copy so the original message isn't garbage collected.
+-    # This doesn't do a real copy, just a reference.
+-    msg_copy = msg.fast_copy()
+-
+-    with nogil:
+-        rc = zmq_msg_send(&msg_copy.zmq_msg, handle, flags)
+-
+-    _check_rc(rc)
+-    return msg.tracker
+-
+-
+-cdef inline object _send_copy(void *handle, object msg, int flags=0):
+-    """Send a message on this socket by copying its content."""
+-    cdef int rc, rc2
+-    cdef zmq_msg_t data
+-    cdef char *msg_c
+-    cdef Py_ssize_t msg_c_len=0
+-
+-    # copy to c array:
+-    asbuffer_r(msg, <void **>&msg_c, &msg_c_len)
+-
+-    # Copy the msg before sending. This avoids any complications with
+-    # the GIL, etc.
+-    # If zmq_msg_init_* fails we must not call zmq_msg_close (Bus Error)
+-    with nogil:
+-        rc = zmq_msg_init_size(&data, msg_c_len)
+-
+-    _check_rc(rc)
+-
+-    with nogil:
+-        memcpy(zmq_msg_data(&data), msg_c, zmq_msg_size(&data))
+-        rc = zmq_msg_send(&data, handle, flags)
+-        rc2 = zmq_msg_close(&data)
+-    _check_rc(rc)
+-    _check_rc(rc2)
+-
+-
+-cdef class Socket:
+-    """Socket(context, socket_type)
+-
+-    A 0MQ socket.
+-
+-    These objects will generally be constructed via the socket() method of a Context object.
+-    
+-    Note: 0MQ Sockets are *not* threadsafe. **DO NOT** share them across threads.
+-    
+-    Parameters
+-    ----------
+-    context : Context
+-        The 0MQ Context this Socket belongs to.
+-    socket_type : int
+-        The socket type, which can be any of the 0MQ socket types: 
+-        REQ, REP, PUB, SUB, PAIR, DEALER, ROUTER, PULL, PUSH, XPUB, XSUB.
+-    
+-    See Also
+-    --------
+-    .Context.socket : method for creating a socket bound to a Context.
+-    """
+-
+-    def __cinit__(self, Context context, int socket_type, *args, **kwrags):
+-        cdef Py_ssize_t c_handle
+-        c_handle = context._handle
+-
+-        self.handle = NULL
+-        self.context = context
+-        self.socket_type = socket_type
+-        with nogil:
+-            self.handle = zmq_socket(<void *>c_handle, socket_type)
+-        if self.handle == NULL:
+-            raise ZMQError()
+-        self._closed = False
+-        self._pid = getpid()
+-        context._add_socket(self.handle)
+-
+-    def __dealloc__(self):
+-        """close *and* remove from context's list
+-        
+-        But be careful that context might not exist if called during gc
+-        """
+-        if self.handle != NULL and getpid() == self._pid:
+-            rc = zmq_close(self.handle)
+-            if rc != 0 and zmq_errno() != ENOTSOCK:
+-                # ignore ENOTSOCK (closed by Context)
+-                _check_rc(rc)
+-            # during gc, self.context might be NULL
+-            if self.context:
+-                self.context._remove_socket(self.handle)
+-    
+-    def __init__(self, context, socket_type):
+-        pass
+-
+-    @property
+-    def closed(self):
+-        return _check_closed(self, False)
+-    
+-    def close(self, linger=None):
+-        """s.close(linger=None)
+-
+-        Close the socket.
+-        
+-        If linger is specified, LINGER sockopt will be set prior to closing.
+-
+-        This can be called to close the socket by hand. If this is not
+-        called, the socket will automatically be closed when it is
+-        garbage collected.
+-        """
+-        cdef int rc=0
+-        cdef int linger_c
+-        cdef bint setlinger=False
+-        
+-        if linger is not None:
+-            linger_c = linger
+-            setlinger=True
+-        
+-        if self.handle != NULL and not self._closed and getpid() == self._pid:
+-            if setlinger:
+-                zmq_setsockopt(self.handle, ZMQ_LINGER, &linger_c, sizeof(int))
+-            rc = zmq_close(self.handle)
+-            if rc != 0 and zmq_errno() != ENOTSOCK:
+-                # ignore ENOTSOCK (closed by Context)
+-                _check_rc(rc)
+-            self._closed = True
+-            # during gc, self.context might be NULL
+-            if self.context:
+-                self.context._remove_socket(self.handle)
+-            self.handle = NULL
+-
+-    def set(self, int option, optval):
+-        """s.set(option, optval)
+-
+-        Set socket options.
+-
+-        See the 0MQ API documentation for details on specific options.
+-
+-        Parameters
+-        ----------
+-        option : int
+-            The option to set.  Available values will depend on your
+-            version of libzmq.  Examples include::
+-            
+-                zmq.SUBSCRIBE, UNSUBSCRIBE, IDENTITY, HWM, LINGER, FD
+-        
+-        optval : int or bytes
+-            The value of the option to set.
+-        """
+-        cdef int64_t optval_int64_c
+-        cdef int optval_int_c
+-        cdef int rc
+-        cdef char* optval_c
+-        cdef Py_ssize_t sz
+-
+-        _check_closed(self, True)
+-        if isinstance(optval, unicode):
+-            raise TypeError("unicode not allowed, use setsockopt_string")
+-
+-        if option in zmq.constants.bytes_sockopts:
+-            if not isinstance(optval, bytes):
+-                raise TypeError('expected bytes, got: %r' % optval)
+-            optval_c = PyBytes_AsString(optval)
+-            sz = PyBytes_Size(optval)
+-            with nogil:
+-                rc = zmq_setsockopt(
+-                    self.handle, option,
+-                    optval_c, sz
+-                )
+-        elif option in zmq.constants.int64_sockopts:
+-            if not isinstance(optval, int):
+-                raise TypeError('expected int, got: %r' % optval)
+-            optval_int64_c = optval
+-            with nogil:
+-                rc = zmq_setsockopt(
+-                    self.handle, option,
+-                    &optval_int64_c, sizeof(int64_t)
+-                )
+-        else:
+-            # default is to assume int, which is what most new sockopts will be
+-            # this lets pyzmq work with newer libzmq which may add constants
+-            # pyzmq has not yet added, rather than artificially raising. Invalid
+-            # sockopts will still raise just the same, but it will be libzmq doing
+-            # the raising.
+-            if not isinstance(optval, int):
+-                raise TypeError('expected int, got: %r' % optval)
+-            optval_int_c = optval
+-            with nogil:
+-                rc = zmq_setsockopt(
+-                    self.handle, option,
+-                    &optval_int_c, sizeof(int)
+-                )
+-
+-        _check_rc(rc)
+-
+-    def get(self, int option):
+-        """s.get(option)
+-
+-        Get the value of a socket option.
+-
+-        See the 0MQ API documentation for details on specific options.
+-
+-        Parameters
+-        ----------
+-        option : int
+-            The option to get.  Available values will depend on your
+-            version of libzmq.  Examples include::
+-            
+-                zmq.IDENTITY, HWM, LINGER, FD, EVENTS
+-
+-        Returns
+-        -------
+-        optval : int or bytes
+-            The value of the option as a bytestring or int.
+-        """
+-        cdef int64_t optval_int64_c
+-        cdef int optval_int_c
+-        cdef fd_t optval_fd_c
+-        cdef char identity_str_c [255]
+-        cdef size_t sz
+-        cdef int rc
+-
+-        _check_closed(self, True)
+-
+-        if option in zmq.constants.bytes_sockopts:
+-            sz = 255
+-            with nogil:
+-                rc = zmq_getsockopt(self.handle, option, <void *>identity_str_c, &sz)
+-            _check_rc(rc)
+-            result = PyBytes_FromStringAndSize(<char *>identity_str_c, sz)
+-        elif option in zmq.constants.int64_sockopts:
+-            sz = sizeof(int64_t)
+-            with nogil:
+-                rc = zmq_getsockopt(self.handle, option, <void *>&optval_int64_c, &sz)
+-            _check_rc(rc)
+-            result = optval_int64_c
+-        elif option == ZMQ_FD:
+-            sz = sizeof(fd_t)
+-            with nogil:
+-                rc = zmq_getsockopt(self.handle, option, <void *>&optval_fd_c, &sz)
+-            _check_rc(rc)
+-            result = optval_fd_c
+-        else:
+-            # default is to assume int, which is what most new sockopts will be
+-            # this lets pyzmq work with newer libzmq which may add constants
+-            # pyzmq has not yet added, rather than artificially raising. Invalid
+-            # sockopts will still raise just the same, but it will be libzmq doing
+-            # the raising.
+-            sz = sizeof(int)
+-            with nogil:
+-                rc = zmq_getsockopt(self.handle, option, <void *>&optval_int_c, &sz)
+-            _check_rc(rc)
+-            result = optval_int_c
+-
+-        return result
+-    
+-    def bind(self, addr):
+-        """s.bind(addr)
+-
+-        Bind the socket to an address.
+-
+-        This causes the socket to listen on a network port. Sockets on the
+-        other side of this connection will use ``Socket.connect(addr)`` to
+-        connect to this socket.
+-
+-        Parameters
+-        ----------
+-        addr : str
+-            The address string. This has the form 'protocol://interface:port',
+-            for example 'tcp://127.0.0.1:5555'. Protocols supported include
+-            tcp, udp, pgm, epgm, inproc and ipc. If the address is unicode, it is
+-            encoded to utf-8 first.
+-        """
+-        cdef int rc
+-        cdef char* c_addr
+-
+-        _check_closed(self, True)
+-        if isinstance(addr, unicode):
+-            addr = addr.encode('utf-8')
+-        if not isinstance(addr, bytes):
+-            raise TypeError('expected str, got: %r' % addr)
+-        c_addr = addr
+-        rc = zmq_bind(self.handle, c_addr)
+-        if rc != 0:
+-            if IPC_PATH_MAX_LEN and zmq_errno() == ENAMETOOLONG:
+-                # py3compat: addr is bytes, but msg wants str
+-                if str is unicode:
+-                    addr = addr.decode('utf-8', 'replace')
+-                path = addr.split('://', 1)[-1]
+-                msg = ('ipc path "{0}" is longer than {1} '
+-                                'characters (sizeof(sockaddr_un.sun_path)). '
+-                                'zmq.IPC_PATH_MAX_LEN constant can be used '
+-                                'to check addr length (if it is defined).'
+-                                .format(path, IPC_PATH_MAX_LEN))
+-                raise ZMQError(msg=msg)
+-        _check_rc(rc)
+-
+-    def connect(self, addr):
+-        """s.connect(addr)
+-
+-        Connect to a remote 0MQ socket.
+-
+-        Parameters
+-        ----------
+-        addr : str
+-            The address string. This has the form 'protocol://interface:port',
+-            for example 'tcp://127.0.0.1:5555'. Protocols supported are
+-            tcp, upd, pgm, inproc and ipc. If the address is unicode, it is
+-            encoded to utf-8 first.
+-        """
+-        cdef int rc
+-        cdef char* c_addr
+-
+-        _check_closed(self, True)
+-        if isinstance(addr, unicode):
+-            addr = addr.encode('utf-8')
+-        if not isinstance(addr, bytes):
+-            raise TypeError('expected str, got: %r' % addr)
+-        c_addr = addr
+-        
+-        rc = zmq_connect(self.handle, c_addr)
+-        if rc != 0:
+-            raise ZMQError()
+-
+-    def unbind(self, addr):
+-        """s.unbind(addr)
+-        
+-        Unbind from an address (undoes a call to bind).
+-        
+-        This feature requires libzmq-3
+-
+-        Parameters
+-        ----------
+-        addr : str
+-            The address string. This has the form 'protocol://interface:port',
+-            for example 'tcp://127.0.0.1:5555'. Protocols supported are
+-            tcp, upd, pgm, inproc and ipc. If the address is unicode, it is
+-            encoded to utf-8 first.
+-        """
+-        cdef int rc
+-        cdef char* c_addr
+-        
+-        if ZMQ_VERSION_MAJOR < 3:
+-            raise NotImplementedError("unbind requires libzmq >= 3.0, have %s" % zmq.zmq_version())
+-        
+-
+-        _check_closed(self, True)
+-        if isinstance(addr, unicode):
+-            addr = addr.encode('utf-8')
+-        if not isinstance(addr, bytes):
+-            raise TypeError('expected str, got: %r' % addr)
+-        c_addr = addr
+-        
+-        rc = zmq_unbind(self.handle, c_addr)
+-        if rc != 0:
+-            raise ZMQError()
+-
+-    def disconnect(self, addr):
+-        """s.disconnect(addr)
+-
+-        Disconnect from a remote 0MQ socket (undoes a call to connect).
+-        
+-        This feature requires libzmq-3
+-
+-        Parameters
+-        ----------
+-        addr : str
+-            The address string. This has the form 'protocol://interface:port',
+-            for example 'tcp://127.0.0.1:5555'. Protocols supported are
+-            tcp, upd, pgm, inproc and ipc. If the address is unicode, it is
+-            encoded to utf-8 first.
+-        """
+-        cdef int rc
+-        cdef char* c_addr
+-        
+-        if ZMQ_VERSION_MAJOR < 3:
+-            raise NotImplementedError("disconnect requires libzmq >= 3.0, have %s" % zmq.zmq_version())
+-
+-        _check_closed(self, True)
+-        if isinstance(addr, unicode):
+-            addr = addr.encode('utf-8')
+-        if not isinstance(addr, bytes):
+-            raise TypeError('expected str, got: %r' % addr)
+-        c_addr = addr
+-        
+-        rc = zmq_disconnect(self.handle, c_addr)
+-        if rc != 0:
+-            raise ZMQError()
+-
+-    #-------------------------------------------------------------------------
+-    # Sending and receiving messages
+-    #-------------------------------------------------------------------------
+-
+-    cpdef object send(self, object data, int flags=0, copy=True, track=False):
+-        """s.send(data, flags=0, copy=True, track=False)
+-
+-        Send a message on this socket.
+-
+-        This queues the message to be sent by the IO thread at a later time.
+-
+-        Parameters
+-        ----------
+-        data : object, str, Frame
+-            The content of the message.
+-        flags : int
+-            Any supported flag: NOBLOCK, SNDMORE.
+-        copy : bool
+-            Should the message be sent in a copying or non-copying manner.
+-        track : bool
+-            Should the message be tracked for notification that ZMQ has
+-            finished with it? (ignored if copy=True)
+-
+-        Returns
+-        -------
+-        None : if `copy` or not track
+-            None if message was sent, raises an exception otherwise.
+-        MessageTracker : if track and not copy
+-            a MessageTracker object, whose `pending` property will
+-            be True until the send is completed.
+-        
+-        Raises
+-        ------
+-        TypeError
+-            If a unicode object is passed
+-        ValueError
+-            If `track=True`, but an untracked Frame is passed.
+-        ZMQError
+-            If the send does not succeed for any reason.
+-        
+-        """
+-        _check_closed(self, True)
+-        
+-        if isinstance(data, unicode):
+-            raise TypeError("unicode not allowed, use send_unicode")
+-        
+-        if copy:
+-            # msg.bytes never returns the input data object
+-            # it is always a copy, but always the same copy
+-            if isinstance(data, Frame):
+-                data = data.buffer
+-            return _send_copy(self.handle, data, flags)
+-        else:
+-            if isinstance(data, Frame):
+-                if track and not data.tracker:
+-                    raise ValueError('Not a tracked message')
+-                msg = data
+-            else:
+-                msg = Frame(data, track=track)
+-            return _send_frame(self.handle, msg, flags)
+-
+-    cpdef object recv(self, int flags=0, copy=True, track=False):
+-        """s.recv(flags=0, copy=True, track=False)
+-
+-        Receive a message.
+-
+-        Parameters
+-        ----------
+-        flags : int
+-            Any supported flag: NOBLOCK. If NOBLOCK is set, this method
+-            will raise a ZMQError with EAGAIN if a message is not ready.
+-            If NOBLOCK is not set, then this method will block until a
+-            message arrives.
+-        copy : bool
+-            Should the message be received in a copying or non-copying manner?
+-            If False a Frame object is returned, if True a string copy of
+-            message is returned.
+-        track : bool
+-            Should the message be tracked for notification that ZMQ has
+-            finished with it? (ignored if copy=True)
+-
+-        Returns
+-        -------
+-        msg : bytes, Frame
+-            The received message frame.  If `copy` is False, then it will be a Frame,
+-            otherwise it will be bytes.
+-            
+-        Raises
+-        ------
+-        ZMQError
+-            for any of the reasons zmq_msg_recv might fail.
+-        """
+-        _check_closed(self, True)
+-        
+-        if copy:
+-            return _recv_copy(self.handle, flags)
+-        else:
+-            frame = _recv_frame(self.handle, flags, track)
+-            frame.more = self.getsockopt(zmq.RCVMORE)
+-            return frame
+-    
+-
+-__all__ = ['Socket', 'IPC_PATH_MAX_LEN']
+diff --git a/zmq/core/stopwatch.pxd b/zmq/core/stopwatch.pxd
+deleted file mode 100644
+index 5d56166..0000000
+--- a/zmq/core/stopwatch.pxd
++++ /dev/null
+@@ -1,31 +0,0 @@
+-"""0MQ Stopwatch class declaration."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-
+-cdef class Stopwatch:
+-    """A simple stopwatch based on zmq_stopwatch_start/stop."""
+-
+-    cdef void *watch # The C handle for the underlying zmq object
+-
+diff --git a/zmq/core/stopwatch.pyx b/zmq/core/stopwatch.pyx
+deleted file mode 100644
+index 6d2fd61..0000000
+--- a/zmq/core/stopwatch.pyx
++++ /dev/null
+@@ -1,90 +0,0 @@
+-"""0MQ Stopwatch class."""
+-
+-#
+-#    Copyright (c) 2010-2011 Brian E. Granger & Min Ragan-Kelley
+-#
+-#    This file is part of pyzmq.
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from libzmq cimport zmq_stopwatch_start, zmq_stopwatch_stop, zmq_sleep
+-
+-from zmq.error import ZMQError
+-
+-#-----------------------------------------------------------------------------
+-# Code
+-#-----------------------------------------------------------------------------
+-
+-cdef class Stopwatch:
+-    """Stopwatch()
+-
+-    A simple stopwatch based on zmq_stopwatch_start/stop.
+-
+-    This class should be used for benchmarking and timing 0MQ code.
+-    """
+-
+-    def __cinit__(self):
+-        self.watch = NULL
+-
+-    def __dealloc__(self):
+-        try:
+-            self.stop()
+-        except ZMQError:
+-            pass
+-
+-    def start(self):
+-        """s.start()
+-
+-        Start the stopwatch.
+-        """
+-        if self.watch == NULL:
+-            with nogil:
+-                self.watch = zmq_stopwatch_start()
+-        else:
+-            raise ZMQError('Stopwatch is already runing.')
+-
+-    def stop(self):
+-        """s.stop()
+-
+-        Stop the stopwatch.
+-        
+-        Returns
+-        -------
+-        t : unsigned long int
+-            the number of microseconds since ``start()`` was called.
+-        """
+-        cdef unsigned long time
+-        if self.watch == NULL:
+-            raise ZMQError('Must start the Stopwatch before calling stop.')
+-        else:
+-            with nogil:
+-                time = zmq_stopwatch_stop(self.watch)
+-            self.watch = NULL
+-            return time
+-
+-    def sleep(self, int seconds):
+-        """s.sleep(seconds)
+-
+-        Sleep for an integer number of seconds.
+-        """
+-        with nogil:
+-            zmq_sleep(seconds)
+-
+-
+-__all__ = ['Stopwatch']
+diff --git a/zmq/devices/__init__.py b/zmq/devices/__init__.py
+index b5c8eb3..dcae13d 100644
+--- a/zmq/devices/__init__.py
++++ b/zmq/devices/__init__.py
+@@ -14,11 +14,12 @@
+ #-----------------------------------------------------------------------------
+ 
+ from zmq import device
+-from zmq.devices import basedevice, proxydevice, monitoredqueue, monitoredqueuedevice
++from zmq.devices import basedevice, proxydevice, monitoredqueuedevice
++from zmq.devices import _zmonitoredqueue as monitoredqueue
+ 
+ from zmq.devices.basedevice import *
+ from zmq.devices.proxydevice import *
+-from zmq.devices.monitoredqueue import *
++from zmq.devices._zmonitoredqueue import *
+ from zmq.devices.monitoredqueuedevice import *
+ 
+ __all__ = ['device']
+diff --git a/zmq/devices/_zmonitoredqueue.pxd b/zmq/devices/_zmonitoredqueue.pxd
+new file mode 100644
+index 0000000..e04354a
+--- /dev/null
++++ b/zmq/devices/_zmonitoredqueue.pxd
+@@ -0,0 +1,166 @@
++"""MonitoredQueue class declarations.
++
++Authors
++-------
++* MinRK
++* Brian Granger
++"""
++
++#
++#    Copyright (c) 2010 Min Ragan-Kelley, Brian Granger
++#
++#    This file is part of pyzmq, but is derived and adapted from zmq_queue.cpp
++#    originally from libzmq-2.1.6, used under LGPLv3
++#
++#    pyzmq 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.
++#
++#    pyzmq 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/>.
++#
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++from libzmq cimport *
++
++#-----------------------------------------------------------------------------
++# MonitoredQueue C functions
++#-----------------------------------------------------------------------------
++
++cdef inline int _relay(void *insocket_, void *outsocket_, void *sidesocket_, 
++                zmq_msg_t msg, zmq_msg_t side_msg, zmq_msg_t id_msg,
++                bint swap_ids) nogil:
++    cdef int rc
++    cdef int64_t flag_2
++    cdef int flag_3
++    cdef int flags
++    cdef bint more
++    cdef size_t flagsz
++    cdef void * flag_ptr
++    
++    if ZMQ_VERSION_MAJOR < 3:
++        flagsz = sizeof (int64_t)
++        flag_ptr = &flag_2
++    else:
++        flagsz = sizeof (int)
++        flag_ptr = &flag_3
++    
++    if swap_ids:# both router, must send second identity first
++        # recv two ids into msg, id_msg
++        rc = zmq_msg_recv(&msg, insocket_, 0)
++        rc = zmq_msg_recv(&id_msg, insocket_, 0)
++
++        # send second id (id_msg) first
++        #!!!! always send a copy before the original !!!!
++        rc = zmq_msg_copy(&side_msg, &id_msg)
++        rc = zmq_msg_send(&side_msg, outsocket_, ZMQ_SNDMORE)
++        rc = zmq_msg_send(&id_msg, sidesocket_, ZMQ_SNDMORE)
++        # send first id (msg) second
++        rc = zmq_msg_copy(&side_msg, &msg)
++        rc = zmq_msg_send(&side_msg, outsocket_, ZMQ_SNDMORE)
++        rc = zmq_msg_send(&msg, sidesocket_, ZMQ_SNDMORE)
++        if rc < 0:
++            return rc
++    while (True):
++        rc = zmq_msg_recv(&msg, insocket_, 0)
++        # assert (rc == 0)
++        rc = zmq_getsockopt (insocket_, ZMQ_RCVMORE, flag_ptr, &flagsz)
++        flags = 0
++        if ZMQ_VERSION_MAJOR < 3:
++            if flag_2:
++                flags |= ZMQ_SNDMORE
++        else:
++            if flag_3:
++                flags |= ZMQ_SNDMORE
++            # LABEL has been removed:
++            # rc = zmq_getsockopt (insocket_, ZMQ_RCVLABEL, flag_ptr, &flagsz)
++            # if flag_3:
++            #     flags |= ZMQ_SNDLABEL
++        # assert (rc == 0)
++
++        rc = zmq_msg_copy(&side_msg, &msg)
++        if flags:
++            rc = zmq_msg_send(&side_msg, outsocket_, flags)
++            # only SNDMORE for side-socket
++            rc = zmq_msg_send(&msg, sidesocket_, ZMQ_SNDMORE)
++        else:
++            rc = zmq_msg_send(&side_msg, outsocket_, 0)
++            rc = zmq_msg_send(&msg, sidesocket_, 0)
++            break
++    return rc
++
++# the MonitoredQueue C function, adapted from zmq::queue.cpp :
++cdef inline int c_monitored_queue (void *insocket_, void *outsocket_,
++                        void *sidesocket_, zmq_msg_t *in_msg_ptr, 
++                        zmq_msg_t *out_msg_ptr, int swap_ids) nogil:
++    """The actual C function for a monitored queue device. 
++
++    See ``monitored_queue()`` for details.
++    """
++    
++    cdef zmq_msg_t msg
++    cdef int rc = zmq_msg_init (&msg)
++    cdef zmq_msg_t id_msg
++    rc = zmq_msg_init (&id_msg)
++    cdef zmq_msg_t side_msg
++    rc = zmq_msg_init (&side_msg)
++    # assert (rc == 0)
++    
++    
++    cdef zmq_pollitem_t items [2]
++    items [0].socket = insocket_
++    items [0].fd = 0
++    items [0].events = ZMQ_POLLIN
++    items [0].revents = 0
++    items [1].socket = outsocket_
++    items [1].fd = 0
++    items [1].events = ZMQ_POLLIN
++    items [1].revents = 0
++    # I don't think sidesocket should be polled?
++    # items [2].socket = sidesocket_
++    # items [2].fd = 0
++    # items [2].events = ZMQ_POLLIN
++    # items [2].revents = 0
++    
++    while (True):
++    
++        # //  Wait while there are either requests or replies to process.
++        rc = zmq_poll (&items [0], 2, -1)
++        if rc < 0:
++            return rc
++        # //  The algorithm below asumes ratio of request and replies processed
++        # //  under full load to be 1:1. Although processing requests replies
++        # //  first is tempting it is suspectible to DoS attacks (overloading
++        # //  the system with unsolicited replies).
++        # 
++        # //  Process a request.
++        if (items [0].revents & ZMQ_POLLIN):
++            # send in_prefix to side socket
++            rc = zmq_msg_copy(&side_msg, in_msg_ptr)
++            rc = zmq_msg_send(&side_msg, sidesocket_, ZMQ_SNDMORE)
++            if rc < 0:
++                return rc
++            # relay the rest of the message
++            rc = _relay(insocket_, outsocket_, sidesocket_, msg, side_msg, id_msg, swap_ids)
++            if rc < 0:
++                return rc
++        if (items [1].revents & ZMQ_POLLIN):
++            # send out_prefix to side socket
++            rc = zmq_msg_copy(&side_msg, out_msg_ptr)
++            rc = zmq_msg_send(&side_msg, sidesocket_, ZMQ_SNDMORE)
++            if rc < 0:
++                return rc
++            # relay the rest of the message
++            rc = _relay(outsocket_, insocket_, sidesocket_, msg, side_msg, id_msg, swap_ids)
++            if rc < 0:
++                return rc
++    return 0
+diff --git a/zmq/devices/_zmonitoredqueue.pyx b/zmq/devices/_zmonitoredqueue.pyx
+new file mode 100644
+index 0000000..a74ae8e
+--- /dev/null
++++ b/zmq/devices/_zmonitoredqueue.pyx
+@@ -0,0 +1,108 @@
++"""MonitoredQueue classes and functions.
++
++Authors
++-------
++* MinRK
++* Brian Granger
++"""
++
++#-----------------------------------------------------------------------------
++#  Copyright (c) 2010-2012 Brian Granger, Min Ragan-Kelley
++#
++#  This file is part of pyzmq
++#
++#  Distributed under the terms of the New BSD License.  The full license is in
++#  the file COPYING.BSD, distributed as part of this software.
++#-----------------------------------------------------------------------------
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++cdef extern from "Python.h":
++    ctypedef int Py_ssize_t
++
++from libc.string cimport memcpy
++
++from buffers cimport asbuffer_r
++from libzmq cimport *
++
++from zmq.core._zsocket cimport Socket
++from zmq.core.checkrc cimport _check_rc
++
++from zmq import ROUTER, ZMQError
++
++#-----------------------------------------------------------------------------
++# MonitoredQueue functions
++#-----------------------------------------------------------------------------
++
++
++def monitored_queue(Socket in_socket, Socket out_socket, Socket mon_socket,
++                    bytes in_prefix=b'in', bytes out_prefix=b'out'):
++    """monitored_queue(in_socket, out_socket, mon_socket,
++                       in_prefix='in', out_prefix='out')
++
++    Start a monitored queue device.
++
++    A monitored queue behaves just like a zmq QUEUE device as far as in_socket
++    and out_socket are concerned, except that all messages *also* go out on
++    mon_socket. mon_socket also prefixes the messages coming from each with a
++    prefix, by default 'in' and 'out', so all messages sent by mon_socket are
++    multipart.
++    
++    The only difference between this and a QUEUE as far as in/out are
++    concerned is that it works with two ROUTER sockets by swapping the IDENT
++    prefixes.
++    
++    Parameters
++    ----------
++    in_socket : Socket
++        One of the sockets to the Queue. Its messages will be prefixed with
++        'in'.
++    out_socket : Socket
++        One of the sockets to the Queue. Its messages will be prefixed with
++        'out'. The only difference between in/out socket is this prefix.
++    mon_socket : Socket
++        This socket sends out every message received by each of the others
++        with an in/out prefix specifying which one it was.
++    in_prefix : str
++        Prefix added to broadcast messages from in_socket.
++    out_prefix : str
++        Prefix added to broadcast messages from out_socket.
++    """
++    
++    cdef void *ins=in_socket.handle
++    cdef void *outs=out_socket.handle
++    cdef void *mons=mon_socket.handle
++    cdef zmq_msg_t in_msg
++    cdef zmq_msg_t out_msg
++    cdef bint swap_ids
++    cdef char *msg_c = NULL
++    cdef Py_ssize_t msg_c_len
++    cdef int rc
++
++    # force swap_ids if both ROUTERs
++    swap_ids = (in_socket.socket_type == ROUTER and 
++                out_socket.socket_type == ROUTER)
++    
++    # build zmq_msg objects from str prefixes
++    asbuffer_r(in_prefix, <void **>&msg_c, &msg_c_len)
++    with nogil:
++        rc = zmq_msg_init_size(&in_msg, msg_c_len)
++    _check_rc(rc)
++    
++    with nogil:
++        memcpy(zmq_msg_data(&in_msg), msg_c, zmq_msg_size(&in_msg))
++    
++    asbuffer_r(out_prefix, <void **>&msg_c, &msg_c_len)
++    
++    with nogil:
++        rc = zmq_msg_init_size(&out_msg, msg_c_len)
++    _check_rc(rc)
++    
++    with nogil:
++        memcpy(zmq_msg_data(&out_msg), msg_c, zmq_msg_size(&out_msg))
++        rc = c_monitored_queue(ins, outs, mons, &in_msg, &out_msg, swap_ids)
++    return rc
++
++__all__ = ['monitored_queue']
+diff --git a/zmq/devices/basedevice.py b/zmq/devices/basedevice.py
+index f65ba1f..4b2c42b 100644
+--- a/zmq/devices/basedevice.py
++++ b/zmq/devices/basedevice.py
+@@ -20,8 +20,15 @@ Authors
+ #-----------------------------------------------------------------------------
+ 
+ import time
+-from threading import Thread
+-from multiprocessing import Process
++try:
++    from threading import Thread
++except ImportError:
++    Thread = None
++
++try:
++    from multiprocessing import Process
++except ImportError:
++    Process = None
+ 
+ from zmq import device, QUEUE, Context
+ 
+diff --git a/zmq/devices/monitoredqueue.pxd b/zmq/devices/monitoredqueue.pxd
+deleted file mode 100644
+index e04354a..0000000
+--- a/zmq/devices/monitoredqueue.pxd
++++ /dev/null
+@@ -1,166 +0,0 @@
+-"""MonitoredQueue class declarations.
+-
+-Authors
+--------
+-* MinRK
+-* Brian Granger
+-"""
+-
+-#
+-#    Copyright (c) 2010 Min Ragan-Kelley, Brian Granger
+-#
+-#    This file is part of pyzmq, but is derived and adapted from zmq_queue.cpp
+-#    originally from libzmq-2.1.6, used under LGPLv3
+-#
+-#    pyzmq 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.
+-#
+-#    pyzmq 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/>.
+-#
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-from libzmq cimport *
+-
+-#-----------------------------------------------------------------------------
+-# MonitoredQueue C functions
+-#-----------------------------------------------------------------------------
+-
+-cdef inline int _relay(void *insocket_, void *outsocket_, void *sidesocket_, 
+-                zmq_msg_t msg, zmq_msg_t side_msg, zmq_msg_t id_msg,
+-                bint swap_ids) nogil:
+-    cdef int rc
+-    cdef int64_t flag_2
+-    cdef int flag_3
+-    cdef int flags
+-    cdef bint more
+-    cdef size_t flagsz
+-    cdef void * flag_ptr
+-    
+-    if ZMQ_VERSION_MAJOR < 3:
+-        flagsz = sizeof (int64_t)
+-        flag_ptr = &flag_2
+-    else:
+-        flagsz = sizeof (int)
+-        flag_ptr = &flag_3
+-    
+-    if swap_ids:# both router, must send second identity first
+-        # recv two ids into msg, id_msg
+-        rc = zmq_msg_recv(&msg, insocket_, 0)
+-        rc = zmq_msg_recv(&id_msg, insocket_, 0)
+-
+-        # send second id (id_msg) first
+-        #!!!! always send a copy before the original !!!!
+-        rc = zmq_msg_copy(&side_msg, &id_msg)
+-        rc = zmq_msg_send(&side_msg, outsocket_, ZMQ_SNDMORE)
+-        rc = zmq_msg_send(&id_msg, sidesocket_, ZMQ_SNDMORE)
+-        # send first id (msg) second
+-        rc = zmq_msg_copy(&side_msg, &msg)
+-        rc = zmq_msg_send(&side_msg, outsocket_, ZMQ_SNDMORE)
+-        rc = zmq_msg_send(&msg, sidesocket_, ZMQ_SNDMORE)
+-        if rc < 0:
+-            return rc
+-    while (True):
+-        rc = zmq_msg_recv(&msg, insocket_, 0)
+-        # assert (rc == 0)
+-        rc = zmq_getsockopt (insocket_, ZMQ_RCVMORE, flag_ptr, &flagsz)
+-        flags = 0
+-        if ZMQ_VERSION_MAJOR < 3:
+-            if flag_2:
+-                flags |= ZMQ_SNDMORE
+-        else:
+-            if flag_3:
+-                flags |= ZMQ_SNDMORE
+-            # LABEL has been removed:
+-            # rc = zmq_getsockopt (insocket_, ZMQ_RCVLABEL, flag_ptr, &flagsz)
+-            # if flag_3:
+-            #     flags |= ZMQ_SNDLABEL
+-        # assert (rc == 0)
+-
+-        rc = zmq_msg_copy(&side_msg, &msg)
+-        if flags:
+-            rc = zmq_msg_send(&side_msg, outsocket_, flags)
+-            # only SNDMORE for side-socket
+-            rc = zmq_msg_send(&msg, sidesocket_, ZMQ_SNDMORE)
+-        else:
+-            rc = zmq_msg_send(&side_msg, outsocket_, 0)
+-            rc = zmq_msg_send(&msg, sidesocket_, 0)
+-            break
+-    return rc
+-
+-# the MonitoredQueue C function, adapted from zmq::queue.cpp :
+-cdef inline int c_monitored_queue (void *insocket_, void *outsocket_,
+-                        void *sidesocket_, zmq_msg_t *in_msg_ptr, 
+-                        zmq_msg_t *out_msg_ptr, int swap_ids) nogil:
+-    """The actual C function for a monitored queue device. 
+-
+-    See ``monitored_queue()`` for details.
+-    """
+-    
+-    cdef zmq_msg_t msg
+-    cdef int rc = zmq_msg_init (&msg)
+-    cdef zmq_msg_t id_msg
+-    rc = zmq_msg_init (&id_msg)
+-    cdef zmq_msg_t side_msg
+-    rc = zmq_msg_init (&side_msg)
+-    # assert (rc == 0)
+-    
+-    
+-    cdef zmq_pollitem_t items [2]
+-    items [0].socket = insocket_
+-    items [0].fd = 0
+-    items [0].events = ZMQ_POLLIN
+-    items [0].revents = 0
+-    items [1].socket = outsocket_
+-    items [1].fd = 0
+-    items [1].events = ZMQ_POLLIN
+-    items [1].revents = 0
+-    # I don't think sidesocket should be polled?
+-    # items [2].socket = sidesocket_
+-    # items [2].fd = 0
+-    # items [2].events = ZMQ_POLLIN
+-    # items [2].revents = 0
+-    
+-    while (True):
+-    
+-        # //  Wait while there are either requests or replies to process.
+-        rc = zmq_poll (&items [0], 2, -1)
+-        if rc < 0:
+-            return rc
+-        # //  The algorithm below asumes ratio of request and replies processed
+-        # //  under full load to be 1:1. Although processing requests replies
+-        # //  first is tempting it is suspectible to DoS attacks (overloading
+-        # //  the system with unsolicited replies).
+-        # 
+-        # //  Process a request.
+-        if (items [0].revents & ZMQ_POLLIN):
+-            # send in_prefix to side socket
+-            rc = zmq_msg_copy(&side_msg, in_msg_ptr)
+-            rc = zmq_msg_send(&side_msg, sidesocket_, ZMQ_SNDMORE)
+-            if rc < 0:
+-                return rc
+-            # relay the rest of the message
+-            rc = _relay(insocket_, outsocket_, sidesocket_, msg, side_msg, id_msg, swap_ids)
+-            if rc < 0:
+-                return rc
+-        if (items [1].revents & ZMQ_POLLIN):
+-            # send out_prefix to side socket
+-            rc = zmq_msg_copy(&side_msg, out_msg_ptr)
+-            rc = zmq_msg_send(&side_msg, sidesocket_, ZMQ_SNDMORE)
+-            if rc < 0:
+-                return rc
+-            # relay the rest of the message
+-            rc = _relay(outsocket_, insocket_, sidesocket_, msg, side_msg, id_msg, swap_ids)
+-            if rc < 0:
+-                return rc
+-    return 0
+diff --git a/zmq/devices/monitoredqueue.pyx b/zmq/devices/monitoredqueue.pyx
+deleted file mode 100644
+index 65db882..0000000
+--- a/zmq/devices/monitoredqueue.pyx
++++ /dev/null
+@@ -1,108 +0,0 @@
+-"""MonitoredQueue classes and functions.
+-
+-Authors
+--------
+-* MinRK
+-* Brian Granger
+-"""
+-
+-#-----------------------------------------------------------------------------
+-#  Copyright (c) 2010-2012 Brian Granger, Min Ragan-Kelley
+-#
+-#  This file is part of pyzmq
+-#
+-#  Distributed under the terms of the New BSD License.  The full license is in
+-#  the file COPYING.BSD, distributed as part of this software.
+-#-----------------------------------------------------------------------------
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-cdef extern from "Python.h":
+-    ctypedef int Py_ssize_t
+-
+-from libc.string cimport memcpy
+-
+-from buffers cimport asbuffer_r
+-from libzmq cimport *
+-
+-from zmq.core.socket cimport Socket
+-from zmq.core.checkrc cimport _check_rc
+-
+-from zmq import ROUTER, ZMQError
+-
+-#-----------------------------------------------------------------------------
+-# MonitoredQueue functions
+-#-----------------------------------------------------------------------------
+-
+-
+-def monitored_queue(Socket in_socket, Socket out_socket, Socket mon_socket,
+-                    bytes in_prefix=b'in', bytes out_prefix=b'out'):
+-    """monitored_queue(in_socket, out_socket, mon_socket,
+-                       in_prefix='in', out_prefix='out')
+-
+-    Start a monitored queue device.
+-
+-    A monitored queue behaves just like a zmq QUEUE device as far as in_socket
+-    and out_socket are concerned, except that all messages *also* go out on
+-    mon_socket. mon_socket also prefixes the messages coming from each with a
+-    prefix, by default 'in' and 'out', so all messages sent by mon_socket are
+-    multipart.
+-    
+-    The only difference between this and a QUEUE as far as in/out are
+-    concerned is that it works with two ROUTER sockets by swapping the IDENT
+-    prefixes.
+-    
+-    Parameters
+-    ----------
+-    in_socket : Socket
+-        One of the sockets to the Queue. Its messages will be prefixed with
+-        'in'.
+-    out_socket : Socket
+-        One of the sockets to the Queue. Its messages will be prefixed with
+-        'out'. The only difference between in/out socket is this prefix.
+-    mon_socket : Socket
+-        This socket sends out every message received by each of the others
+-        with an in/out prefix specifying which one it was.
+-    in_prefix : str
+-        Prefix added to broadcast messages from in_socket.
+-    out_prefix : str
+-        Prefix added to broadcast messages from out_socket.
+-    """
+-    
+-    cdef void *ins=in_socket.handle
+-    cdef void *outs=out_socket.handle
+-    cdef void *mons=mon_socket.handle
+-    cdef zmq_msg_t in_msg
+-    cdef zmq_msg_t out_msg
+-    cdef bint swap_ids
+-    cdef char *msg_c = NULL
+-    cdef Py_ssize_t msg_c_len
+-    cdef int rc
+-
+-    # force swap_ids if both ROUTERs
+-    swap_ids = (in_socket.socket_type == ROUTER and 
+-                out_socket.socket_type == ROUTER)
+-    
+-    # build zmq_msg objects from str prefixes
+-    asbuffer_r(in_prefix, <void **>&msg_c, &msg_c_len)
+-    with nogil:
+-        rc = zmq_msg_init_size(&in_msg, msg_c_len)
+-    _check_rc(rc)
+-    
+-    with nogil:
+-        memcpy(zmq_msg_data(&in_msg), msg_c, zmq_msg_size(&in_msg))
+-    
+-    asbuffer_r(out_prefix, <void **>&msg_c, &msg_c_len)
+-    
+-    with nogil:
+-        rc = zmq_msg_init_size(&out_msg, msg_c_len)
+-    _check_rc(rc)
+-    
+-    with nogil:
+-        memcpy(zmq_msg_data(&out_msg), msg_c, zmq_msg_size(&out_msg))
+-        rc = c_monitored_queue(ins, outs, mons, &in_msg, &out_msg, swap_ids)
+-    return rc
+-
+-__all__ = ['monitored_queue']
+diff --git a/zmq/devices/monitoredqueuedevice.py b/zmq/devices/monitoredqueuedevice.py
+index a9f5c3f..422715c 100644
+--- a/zmq/devices/monitoredqueuedevice.py
++++ b/zmq/devices/monitoredqueuedevice.py
+@@ -24,7 +24,7 @@ import time
+ 
+ from zmq import ZMQError, PUB
+ from zmq.devices.proxydevice import ProxyBase, Proxy, ThreadProxy, ProcessProxy
+-from zmq.devices.monitoredqueue import monitored_queue
++from zmq.devices._zmonitoredqueue import monitored_queue
+ 
+ #-----------------------------------------------------------------------------
+ # Classes
+diff --git a/zmq/sugar/backend.py b/zmq/sugar/backend.py
+index ad07379..6f87c1b 100644
+--- a/zmq/sugar/backend.py
++++ b/zmq/sugar/backend.py
+@@ -23,8 +23,9 @@ try:
+         strerror, zmq_errno,
+         zmq_poll,
+         zmq_version_info,
+-        constants,
++        _zconstants,
+     )
++    constants = _zconstants
+ except ImportError:
+     from zmq.cffi_core import (
+         Context,
+diff --git a/zmq/sugar/context.py b/zmq/sugar/context.py
+index bcc4686..f0f3325 100644
+--- a/zmq/sugar/context.py
++++ b/zmq/sugar/context.py
+@@ -128,4 +128,4 @@ class Context(ContextBase, AttributeSetter):
+             else:
+                 del self.sockopts[opt]
+ 
+-__all__ = ['Context']
+\ No newline at end of file
++__all__ = ['Context']
+diff --git a/zmq/utils/_zinitthreads.pyx b/zmq/utils/_zinitthreads.pyx
+new file mode 100644
+index 0000000..6c57c9f
+--- /dev/null
++++ b/zmq/utils/_zinitthreads.pyx
+@@ -0,0 +1,23 @@
++"""Utility to initialize threads."""
++
++#-----------------------------------------------------------------------------
++#  Copyright (c) 2010 Brian Granger, Min Ragan-Kelley
++#
++#  Distributed under the terms of the New BSD License.  The full license is in
++#  the file COPYING.BSD, distributed as part of this software.
++#-----------------------------------------------------------------------------
++
++#-----------------------------------------------------------------------------
++# Imports
++#-----------------------------------------------------------------------------
++
++cdef extern from "Python.h":
++    cdef void PyEval_InitThreads()
++
++# It seems that in only *some* version of Python/Cython we need to call this
++# by hand to get threads initialized. Not clear why this is the case though.
++# If we don't have this, pyzmq will segfault.
++def init_threads():
++    PyEval_InitThreads()
++
++__all__ = ['init_threads']
+diff --git a/zmq/utils/_zrebuffer.pyx b/zmq/utils/_zrebuffer.pyx
+new file mode 100644
+index 0000000..ca240d3
+--- /dev/null
++++ b/zmq/utils/_zrebuffer.pyx
+@@ -0,0 +1,104 @@
++"""
++Utility for changing itemsize of memoryviews, and getting
++numpy arrays from byte-arrays that should be interpreted with a different
++itemsize.
++
++Authors
++-------
++* MinRK
++"""
++
++#-----------------------------------------------------------------------------
++#  Copyright (c) 2010-2012 Brian Granger, Min Ragan-Kelley
++#
++#  This file is part of pyzmq
++#
++#  Distributed under the terms of the New BSD License.  The full license is in
++#  the file COPYING.BSD, distributed as part of this software.
++#-----------------------------------------------------------------------------
++
++from libc.stdlib cimport malloc
++from buffers cimport *
++
++cdef inline object _rebuffer(object obj, char * format, int itemsize):
++    """clobber the format & itemsize of a 1-D
++
++    This is the Python 3 model, but will work on Python >= 2.6. Currently,
++    we use it only on >= 3.0.
++    """
++    cdef Py_buffer view
++    cdef int flags = PyBUF_SIMPLE
++    cdef int mode = 0
++    # cdef Py_ssize_t *shape, *strides, *suboffsets
++    
++    mode = check_buffer(obj)
++    if mode == 0:
++        raise TypeError("%r does not provide a buffer interface."%obj)
++
++    if mode == 3:
++        flags = PyBUF_ANY_CONTIGUOUS
++        if format:
++            flags |= PyBUF_FORMAT
++        PyObject_GetBuffer(obj, &view, flags)
++        assert view.ndim <= 1, "Can only reinterpret 1-D memoryviews"
++        assert view.len % itemsize == 0, "Buffer of length %i not divisible into items of size %i"%(view.len, itemsize)
++        # hack the format
++        view.ndim = 1
++        view.format = format
++        view.itemsize = itemsize
++        view.strides = <Py_ssize_t *>malloc(sizeof(Py_ssize_t))
++        view.strides[0] = itemsize
++        view.shape = <Py_ssize_t *>malloc(sizeof(Py_ssize_t))
++        view.shape[0] = view.len/itemsize
++        view.suboffsets = <Py_ssize_t *>malloc(sizeof(Py_ssize_t))
++        view.suboffsets[0] = 0
++        # for debug: make buffer writable, for zero-copy testing
++        # view.readonly = 0
++        
++        return PyMemoryView_FromBuffer(&view)
++    else:
++        raise TypeError("This funciton is only for new-style buffer objects.")
++
++def rebuffer(obj, format, itemsize):
++    """Change the itemsize of a memoryview.
++    
++    Only for 1D contiguous buffers.
++    """
++    return _rebuffer(obj, format, itemsize)
++
++def array_from_buffer(view, dtype, shape):
++    """Get a numpy array from a memoryview, regardless of the itemsize of the original
++    memoryview.  This is important, because pyzmq does not send memoryview shape data
++    over the wire, so we need to change the memoryview itemsize before calling
++    asarray.
++    """
++    import numpy
++    A = numpy.array([],dtype=dtype)
++    ref = viewfromobject(A,0)
++    fmt = ref.format.encode()
++    buf = viewfromobject(view, 0)
++    buf = _rebuffer(view, fmt, ref.itemsize)
++    return numpy.asarray(buf, dtype=dtype).reshape(shape)
++
++def print_view_info(obj):
++    """simple utility for printing info on a new-style buffer object"""
++    cdef Py_buffer view
++    cdef int flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT
++    cdef int mode = 0
++    
++    mode = check_buffer(obj)
++    if mode == 0:
++        raise TypeError("%r does not provide a buffer interface."%obj)
++
++    if mode == 3:
++        PyObject_GetBuffer(obj, &view, flags)
++        print <Py_ssize_t>view.buf, view.len, view.format, view.ndim,
++        if view.ndim:
++            if view.shape:
++                print view.shape[0],
++            if view.strides:
++                print view.strides[0],
++            if view.suboffsets:
++                print view.suboffsets[0],
++        print
++    
+\ No newline at end of file
+diff --git a/zmq/utils/initthreads.pyx b/zmq/utils/initthreads.pyx
+deleted file mode 100644
+index 6c57c9f..0000000
+--- a/zmq/utils/initthreads.pyx
++++ /dev/null
+@@ -1,23 +0,0 @@
+-"""Utility to initialize threads."""
+-
+-#-----------------------------------------------------------------------------
+-#  Copyright (c) 2010 Brian Granger, Min Ragan-Kelley
+-#
+-#  Distributed under the terms of the New BSD License.  The full license is in
+-#  the file COPYING.BSD, distributed as part of this software.
+-#-----------------------------------------------------------------------------
+-
+-#-----------------------------------------------------------------------------
+-# Imports
+-#-----------------------------------------------------------------------------
+-
+-cdef extern from "Python.h":
+-    cdef void PyEval_InitThreads()
+-
+-# It seems that in only *some* version of Python/Cython we need to call this
+-# by hand to get threads initialized. Not clear why this is the case though.
+-# If we don't have this, pyzmq will segfault.
+-def init_threads():
+-    PyEval_InitThreads()
+-
+-__all__ = ['init_threads']
+diff --git a/zmq/utils/rebuffer.pyx b/zmq/utils/rebuffer.pyx
+deleted file mode 100644
+index ca240d3..0000000
+--- a/zmq/utils/rebuffer.pyx
++++ /dev/null
+@@ -1,104 +0,0 @@
+-"""
+-Utility for changing itemsize of memoryviews, and getting
+-numpy arrays from byte-arrays that should be interpreted with a different
+-itemsize.
+-
+-Authors
+--------
+-* MinRK
+-"""
+-
+-#-----------------------------------------------------------------------------
+-#  Copyright (c) 2010-2012 Brian Granger, Min Ragan-Kelley
+-#
+-#  This file is part of pyzmq
+-#
+-#  Distributed under the terms of the New BSD License.  The full license is in
+-#  the file COPYING.BSD, distributed as part of this software.
+-#-----------------------------------------------------------------------------
+-
+-from libc.stdlib cimport malloc
+-from buffers cimport *
+-
+-cdef inline object _rebuffer(object obj, char * format, int itemsize):
+-    """clobber the format & itemsize of a 1-D
+-
+-    This is the Python 3 model, but will work on Python >= 2.6. Currently,
+-    we use it only on >= 3.0.
+-    """
+-    cdef Py_buffer view
+-    cdef int flags = PyBUF_SIMPLE
+-    cdef int mode = 0
+-    # cdef Py_ssize_t *shape, *strides, *suboffsets
+-    
+-    mode = check_buffer(obj)
+-    if mode == 0:
+-        raise TypeError("%r does not provide a buffer interface."%obj)
+-
+-    if mode == 3:
+-        flags = PyBUF_ANY_CONTIGUOUS
+-        if format:
+-            flags |= PyBUF_FORMAT
+-        PyObject_GetBuffer(obj, &view, flags)
+-        assert view.ndim <= 1, "Can only reinterpret 1-D memoryviews"
+-        assert view.len % itemsize == 0, "Buffer of length %i not divisible into items of size %i"%(view.len, itemsize)
+-        # hack the format
+-        view.ndim = 1
+-        view.format = format
+-        view.itemsize = itemsize
+-        view.strides = <Py_ssize_t *>malloc(sizeof(Py_ssize_t))
+-        view.strides[0] = itemsize
+-        view.shape = <Py_ssize_t *>malloc(sizeof(Py_ssize_t))
+-        view.shape[0] = view.len/itemsize
+-        view.suboffsets = <Py_ssize_t *>malloc(sizeof(Py_ssize_t))
+-        view.suboffsets[0] = 0
+-        # for debug: make buffer writable, for zero-copy testing
+-        # view.readonly = 0
+-        
+-        return PyMemoryView_FromBuffer(&view)
+-    else:
+-        raise TypeError("This funciton is only for new-style buffer objects.")
+-
+-def rebuffer(obj, format, itemsize):
+-    """Change the itemsize of a memoryview.
+-    
+-    Only for 1D contiguous buffers.
+-    """
+-    return _rebuffer(obj, format, itemsize)
+-
+-def array_from_buffer(view, dtype, shape):
+-    """Get a numpy array from a memoryview, regardless of the itemsize of the original
+-    memoryview.  This is important, because pyzmq does not send memoryview shape data
+-    over the wire, so we need to change the memoryview itemsize before calling
+-    asarray.
+-    """
+-    import numpy
+-    A = numpy.array([],dtype=dtype)
+-    ref = viewfromobject(A,0)
+-    fmt = ref.format.encode()
+-    buf = viewfromobject(view, 0)
+-    buf = _rebuffer(view, fmt, ref.itemsize)
+-    return numpy.asarray(buf, dtype=dtype).reshape(shape)
+-
+-def print_view_info(obj):
+-    """simple utility for printing info on a new-style buffer object"""
+-    cdef Py_buffer view
+-    cdef int flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT
+-    cdef int mode = 0
+-    
+-    mode = check_buffer(obj)
+-    if mode == 0:
+-        raise TypeError("%r does not provide a buffer interface."%obj)
+-
+-    if mode == 3:
+-        PyObject_GetBuffer(obj, &view, flags)
+-        print <Py_ssize_t>view.buf, view.len, view.format, view.ndim,
+-        if view.ndim:
+-            if view.shape:
+-                print view.shape[0],
+-            if view.strides:
+-                print view.strides[0],
+-            if view.suboffsets:
+-                print view.suboffsets[0],
+-        print
+-    
+\ No newline at end of file