remove some dead code checks for unsupported libzmq

Author: minrk

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)
@@ -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:

zmq/backend/cffi/utils.py

@@ -31,7 +31,6 @@ def curve_keypair():
     (public, secret) : two bytestrings
         The public and private key pair as 40 byte z85-encoded bytestrings.
     """
-    _check_version((3, 2), "curve_keypair")
     public = ffi.new('char[64]')
     private = ffi.new('char[64]')
     rc = C.zmq_curve_keypair(public, private)

zmq/backend/cython/_zmq.py

@@ -92,7 +92,6 @@
     ZMQ_ROUTER,
     ZMQ_SNDMORE,
     ZMQ_TYPE,
-    ZMQ_VERSION_MAJOR,
     _zmq_version,
     fd_t,
     int64_t,
@@ -109,7 +108,6 @@
     zmq_free_fn,
     zmq_getsockopt,
     zmq_has,
-    zmq_init,
     zmq_join,
     zmq_leave,
     zmq_msg_close,
@@ -534,16 +532,13 @@ def __init__(self, io_threads: C.int = 1, shadow: size_t = 0):
             self._shadow = True
         else:
             self._shadow = False
-            if ZMQ_VERSION_MAJOR >= 3:
-                self.handle = zmq_ctx_new()
-            else:
-                self.handle = zmq_init(io_threads)
+            self.handle = zmq_ctx_new()
 
         if self.handle == NULL:
             raise ZMQError()
 
         rc: C.int = 0
-        if ZMQ_VERSION_MAJOR >= 3 and not self._shadow:
+        if not self._shadow:
             rc = zmq_ctx_set(self.handle, ZMQ_IO_THREADS, io_threads)
             _check_rc(rc)
 
@@ -984,7 +979,6 @@ def unbind(self, addr):
         rc: C.int
         c_addr: p_char
 
-        _check_version((3, 2), "unbind")
         _check_closed(self)
         if isinstance(addr, str):
             addr = addr.encode('utf-8')
@@ -1014,7 +1008,6 @@ def disconnect(self, addr):
         rc: C.int
         c_addr: p_char
 
-        _check_version((3, 2), "disconnect")
         _check_closed(self)
         if isinstance(addr, str):
             addr = addr.encode('utf-8')
@@ -1047,7 +1040,6 @@ def monitor(self, addr, events: C.int = ZMQ_EVENT_ALL):
             default: zmq.EVENT_ALL
             The zmq event bitmask for which events will be sent to the monitor.
         """
-        _check_version((3, 2), "monitor")
 
         if isinstance(addr, str):
             # cast str to utf8 bytes
@@ -1595,11 +1587,6 @@ def zmq_poll(sockets, timeout: C.int = -1):
     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, events = sockets[i]
         if isinstance(s, Socket):

zmq/sugar/socket.py

@@ -498,11 +498,7 @@ def bind_to_random_port(
         ZMQBindError
             if `max_tries` reached before successful bind
         """
-        if (
-            (zmq.zmq_version_info() >= (3, 2))
-            and min_port == 49152
-            and max_port == 65536
-        ):
+        if min_port == 49152 and max_port == 65536:
             # if LAST_ENDPOINT is supported, and min_port / max_port weren't specified,
             # we can bind to port 0 and let the OS do the work
             self.bind(f"{addr}:*")
@@ -531,17 +527,13 @@ def get_hwm(self) -> int:
 
         On libzmq ≥ 3, this gets SNDHWM if available, otherwise RCVHWM
         """
-        major = zmq.zmq_version_info()[0]
-        if major >= 3:
-            # return sndhwm, fallback on rcvhwm
-            try:
-                return cast(int, self.get(zmq.SNDHWM))
-            except zmq.ZMQError:
-                pass
+        # return sndhwm, fallback on rcvhwm
+        try:
+            return cast(int, self.get(zmq.SNDHWM))
+        except zmq.ZMQError:
+            pass
 
-            return cast(int, self.get(zmq.RCVHWM))
-        else:
-            return cast(int, self.get(zmq.HWM))
+        return cast(int, self.get(zmq.RCVHWM))
 
     def set_hwm(self, value: int) -> None:
         """Set the High Water Mark.
@@ -554,22 +546,18 @@ def set_hwm(self, value: int) -> None:
             New values only take effect for subsequent socket
             bind/connects.
         """
-        major = zmq.zmq_version_info()[0]
-        if major >= 3:
-            raised = None
-            try:
-                self.sndhwm = value
-            except Exception as e:
-                raised = e
-            try:
-                self.rcvhwm = value
-            except Exception as e:
-                raised = e
+        raised = None
+        try:
+            self.sndhwm = value
+        except Exception as e:
+            raised = e
+        try:
+            self.rcvhwm = value
+        except Exception as e:
+            raised = e
 
-            if raised:
-                raise raised
-        else:
-            self.set(zmq.HWM, value)
+        if raised:
+            raise raised
 
     hwm = property(
         get_hwm,

zmq/tests/__init__.py

@@ -181,11 +181,10 @@ def assertRaisesErrno(self, errno, func, *args, **kwargs):
 
     def _select_recv(self, multipart, socket, **kwargs):
         """call recv[_multipart] in a way that raises if there is nothing to receive"""
-        if zmq.zmq_version_info() >= (3, 1, 0):
-            # zmq 3.1 has a bug, where poll can return false positives,
-            # so we wait a little bit just in case
-            # See LIBZMQ-280 on JIRA
-            time.sleep(0.1)
+        # zmq 3.1 has a bug, where poll can return false positives,
+        # so we wait a little bit just in case
+        # See LIBZMQ-280 on JIRA
+        time.sleep(0.1)
 
         r, w, x = zmq.select([socket], [], [], timeout=kwargs.pop('timeout', 5))
         assert len(r) > 0, "Should have received a message"