PyZMQ: Python bindings for ZeroMQ

Warnings

• breaking In `pyzmq` 27.1.0, the behavior of `zmq.DRAFT_API` was restored to its pre-pyzmq 23 state. It now reflects if *both* `libzmq` and `pyzmq` were built with draft APIs, not just `zmq.has("draft")`.
  Fix: If relying on draft APIs, ensure both `libzmq` and `pyzmq` are built with draft API support. Review code that checked `zmq.DRAFT_API` if it was intended to merely check `zmq.has("draft")`.
• gotcha Blocking operations like `socket.send()` and `socket.recv()` can cause your program to hang indefinitely if a message is not available or cannot be sent immediately.
  Fix: Use the `zmq.NOBLOCK` flag with `send()`/`recv()`, or employ `zmq.Poller` to check socket readiness before attempting I/O operations. Example: `socket.recv(flags=zmq.NOBLOCK)` or `poller.poll(timeout=...)`.
• gotcha Improper termination of ZeroMQ contexts and sockets can lead to resource leaks, preventing programs from exiting cleanly or appearing 'stuck'.
  Fix: Always call `socket.close()` for all sockets and `context.term()` for the ZeroMQ context when they are no longer needed. It is highly recommended to use Python's `with` statement with `zmq.Context()` and `ctx.socket()` for automatic resource management.
• gotcha ZeroMQ sockets are NOT thread-safe. While a `zmq.Context` can be shared across threads, individual `zmq.Socket` instances should not be shared or accessed concurrently from multiple threads without external synchronization, which is generally discouraged.
  Fix: Create a separate `zmq.Socket` instance for each thread that needs to perform I/O, even if all threads share the same `zmq.Context`.
• deprecated The `zmq.utils.jsonapi` module is being deprecated, and `send_json`/`recv_json` methods will eventually only support the standard library's `json` module. This change is already present in development versions (e.g., 27.2.0.dev).
  Fix: Avoid using `zmq.utils.jsonapi` for custom serialization. Ensure that any custom JSON serialization or deserialization used with `send_json`/`recv_json` is compatible with Python's standard `json` library.
• breaking On Windows, `pyzmq` wheels no longer bundle `libzmq` with `AF_UNIX` (IPC) support enabled due to upstream `libzmq` bugs causing crashes. This was re-disabled in `pyzmq` 26.2 after an unintentional re-introduction in 26.0.
  Fix: If IPC communication is strictly required on Windows, users must build `pyzmq` from source and link against a compatible `libzmq` that enables `AF_UNIX` without exhibiting the crashing behavior. For most users, using TCP is the recommended alternative.

Install

• pip install pyzmq Latest stable version
• pip install 'pyzmq==27.1.0' Specific version

Imports

• zmq

  import zmq

  The primary import is the `zmq` module itself, not submodules directly.

Quickstart

This quickstart demonstrates a basic Request-Reply pattern using PyZMQ. A server binds to a port, waiting for requests, and sends replies. A client connects to the server, sends requests, and receives replies. The example uses `threading` to run both client and server in the same script for convenience; in a real application, they would typically be separate processes or even on different machines.

import zmq
import time
import threading

def run_server():
    context = zmq.Context()
    socket = context.socket(zmq.REP) # Reply socket
    socket.bind("tcp://*:5555")
    print("Server: Binding to port 5555...")

    try:
        while True:
            message = socket.recv_string()
            print(f"Server: Received request: {message}")
            time.sleep(1) # Simulate some work
            socket.send_string("World")
    except KeyboardInterrupt:
        print("\nServer: Shutting down.")
    finally:
        socket.close()
        context.term()

def run_client():
    context = zmq.Context()
    socket = context.socket(zmq.REQ) # Request socket
    socket.connect("tcp://localhost:5555")
    print("Client: Connecting to server...")

    try:
        for request_num in range(3):
            print(f"Client: Sending Hello {request_num}...")
            socket.send_string(f"Hello {request_num}")
            message = socket.recv_string()
            print(f"Client: Received reply: {message}")
            time.sleep(0.5)
    except KeyboardInterrupt:
        print("\nClient: Shutting down.")
    finally:
        socket.close()
        context.term()

if __name__ == "__main__":
    # Run server in a separate thread for demonstration
    server_thread = threading.Thread(target=run_server)
    server_thread.start()
    time.sleep(0.5) # Give server a moment to bind
    run_client()
    server_thread.join()