Merge pull request #2082 from minrk/rm-dead-libzmq2

remove some dead code for libzmq2 support, add some Cython type annotations

Author: minrk

CMakeLists.txt

@@ -411,7 +411,6 @@ elseif(PYZMQ_BACKEND STREQUAL "cython")
     VERBATIM
     COMMAND "${Python_EXECUTABLE}"
             -mcython
-            --3str
             --output-file ${ZMQ_C}
             --module-name "zmq.backend.cython._zmq"
             ${ZMQ_PYX}

README.md

@@ -4,21 +4,18 @@ This package contains Python bindings for [ZeroMQ](https://zeromq.org).
 ØMQ is a lightweight and fast messaging implementation.
 
 PyZMQ should work with any reasonable version of Python (≥ 3.8), as well as PyPy.
-The Cython backend used by CPython supports libzmq ≥ 2.1.4 (including 3.2.x and 4.x),
-but the CFFI backend used by PyPy only supports libzmq ≥ 3.2.2 (including 4.x).
+PyZMQ supports libzmq ≥ 3.2.2 (including 4.x).
 
 For a summary of changes to pyzmq, see our
 [changelog](https://pyzmq.readthedocs.io/en/latest/changelog.html).
 
 ### ØMQ 3.x, 4.x
 
-PyZMQ fully supports the 3.x and 4.x APIs of libzmq,
+PyZMQ fully supports the stable (not DRAFT) 3.x and 4.x APIs of libzmq,
 developed at [zeromq/libzmq](https://github.com/zeromq/libzmq).
 No code to change, no flags to pass,
 just build pyzmq against the latest and it should work.
 
-PyZMQ does not support the old libzmq 2 API on PyPy.
-
 ## Documentation
 
 See PyZMQ's Sphinx-generated

tests/test_message.py

@@ -15,6 +15,8 @@
 
 import time
 
+import pytest
+
 import zmq
 from zmq_test_utils import PYPY, BaseZMQTestCase, SkipTest, skip_cpython_cffi, skip_pypy
 
@@ -215,11 +217,18 @@ def test_buffer_in(self):
         """test using a buffer as input"""
         ins = "§§¶•ªº˜µ¬˚…∆˙åß∂©œ∑´†≈ç√".encode()
         zmq.Frame(memoryview(ins))
+        zmq.Frame(bytearray(5))
 
     def test_bad_buffer_in(self):
         """test using a bad object"""
-        self.assertRaises(TypeError, zmq.Frame, 5)
-        self.assertRaises(TypeError, zmq.Frame, object())
+        with pytest.raises(TypeError):
+            zmq.Frame(5)
+        with pytest.raises(TypeError):
+            zmq.Frame(object())
+        with pytest.raises(TypeError):
+            zmq.Frame("str")
+        with pytest.raises(BufferError):
+            zmq.Frame(memoryview(bytearray(10))[::2])
 
     def test_buffer_out(self):
         """receiving buffered output"""

tests/test_socket.py

@@ -513,11 +513,11 @@ def test_recv_into_bad(self):
             b.recv_into(buf, nbytes=-1)
         # not contiguous
         buf = memoryview(bytearray(10))[::2]
-        with pytest.raises(ValueError):
+        with pytest.raises(BufferError):
             b.recv_into(buf)
         # readonly
         buf = memoryview(b"readonly")
-        with pytest.raises(ValueError):
+        with pytest.raises(BufferError):
             b.recv_into(buf)
         # too big
         buf = bytearray(10)

zmq/__init__.pyi

@@ -14,7 +14,6 @@ __version__: str
 from .backend import IPC_PATH_MAX_LEN as IPC_PATH_MAX_LEN
 from .backend import curve_keypair as curve_keypair
 from .backend import curve_public as curve_public
-from .backend import device as device
 from .backend import has as has
 from .backend import proxy as proxy
 from .backend import proxy_steerable as proxy_steerable

zmq/backend/__init__.pyi

@@ -111,7 +111,6 @@ def zmq_version_info() -> tuple[int, int, int]: ...
 def zmq_poll(
     sockets: list[Any], timeout: int | None = ...
 ) -> list[tuple[Socket, int]]: ...
-def device(device_type: int, frontend: Socket, backend: Socket | None = ...) -> int: ...
 def proxy(frontend: Socket, backend: Socket, capture: Socket | None = None) -> int: ...
 def proxy_steerable(
     frontend: Socket,

zmq/backend/cffi/_cdefs.h

@@ -9,8 +9,6 @@ int zmq_connect(void *socket, const char *endpoint);
 int zmq_errno(void);
 const char * zmq_strerror(int errnum);
 
-int zmq_device(int device, void *frontend, void *backend);
-
 int zmq_unbind(void *socket, const char *endpoint);
 int zmq_disconnect(void *socket, const char *endpoint);
 void* zmq_ctx_new();

zmq/backend/cffi/devices.py

@@ -9,10 +9,6 @@
 from .utils import _retry_sys_call
 
 
-def device(device_type, frontend, backend):
-    return proxy(frontend, backend)
-
-
 def proxy(frontend, backend, capture=None):
     if isinstance(capture, Socket):
         capture = capture._zmq_socket
@@ -60,4 +56,4 @@ def proxy_steerable(frontend, backend, capture=None, control=None):
     )
 
 
-__all__ = ['device', 'proxy', 'proxy_steerable']
+__all__ = ['proxy', 'proxy_steerable']

zmq/backend/cffi/message.py

@@ -82,6 +82,9 @@ def __init__(self, data=None, track=False, copy=None, copy_threshold=None):
             self._bytes = data
 
         self._buffer = memoryview(data)
+        if not self._buffer.contiguous:
+            raise BufferError("memoryview: underlying buffer is not contiguous")
+        # from_buffer silently copies if memory is not contiguous
         c_data = ffi.from_buffer(self._buffer)
         data_len_c = self._buffer.nbytes
 

zmq/backend/cffi/socket.py

@@ -7,7 +7,7 @@
 
 import zmq
 from zmq.constants import SocketOption, _OptType
-from zmq.error import ZMQError, _check_rc, _check_version
+from zmq.error import ZMQError, _check_rc
 
 from ._cffi import ffi
 from ._cffi import lib as C
@@ -184,7 +184,6 @@ def bind(self, address):
                 _check_rc(rc)
 
     def unbind(self, address):
-        _check_version((3, 2), "unbind")
         if isinstance(address, str):
             address = address.encode('utf8')
         rc = C.zmq_unbind(self._zmq_socket, address)
@@ -197,7 +196,6 @@ def connect(self, address):
         _check_rc(rc)
 
     def disconnect(self, address):
-        _check_version((3, 2), "disconnect")
         if isinstance(address, str):
             address = address.encode('utf8')
         rc = C.zmq_disconnect(self._zmq_socket, address)
@@ -340,9 +338,9 @@ def recv(self, flags=0, copy=True, track=False):
     def recv_into(self, buffer, /, *, nbytes: int = 0, flags: int = 0) -> int:
         view = memoryview(buffer)
         if not view.contiguous:
-            raise ValueError("Can only recv_into contiguous buffers")
+            raise BufferError("Can only recv_into contiguous buffers")
         if view.readonly:
-            raise ValueError("Cannot recv_into readonly buffer")
+            raise BufferError("Cannot recv_into readonly buffer")
         if nbytes < 0:
             raise ValueError(f"{nbytes=} must be non-negative")
         view_bytes = view.nbytes
@@ -372,8 +370,6 @@ def monitor(self, addr, events=-1):
         events : int [default: zmq.EVENT_ALL]
             The zmq event bitmask for which events will be sent to the monitor.
         """
-
-        _check_version((3, 2), "monitor")
         if events < 0:
             events = zmq.EVENT_ALL
         if addr is None: