# Blocking I/O

This is a good option for simple scripts, where you don’t need to do anything else while waiting for a D-Bus reply. If you will use D-Bus for multiple threads, or you want a nicer way to wait for signals, see Blocking I/O with threads.

jeepney.io.blocking.open_dbus_connection(bus='SESSION', enable_fds=False, auth_timeout=1.0) → DBusConnection

  Connect to a D-Bus message bus

  Pass `enable_fds=True` to allow sending & receiving file descriptors. An error will be raised if the bus does not allow this. For simplicity, it’s advisable to leave this disabled unless you need it.

  D-Bus has an authentication step before sending or receiving messages. This takes < 1 ms in normal operation, but there is a timeout so that client code won’t get stuck if the server doesn’t reply. auth_timeout configures this timeout in seconds.

class jeepney.io.blocking.DBusConnection(sock: socket, enable_fds=False)
  send(message: Message, serial=None)

    Serialise and send a `Message` object

  receive(*, timeout=None) → Message

    Return the next available message from the connection

    If the data is ready, this will return immediately, even if timeout<=0. Otherwise, it will wait for up to timeout seconds, or indefinitely if timeout is None. If no message comes in time, it raises TimeoutError.

  send_and_get_reply(message, *, timeout=None)

    Send a message, wait for the reply and return it

    Filters are applied to other messages received before the reply - see `add_filter()`.

  recv_messages(*, timeout=None)

    Receive one message and apply filters

    See `filter()`. Returns nothing.

  filter(rule, *, queue: deque | None = None, bufsize=1)

    Create a filter for incoming messages

    Usage:

        with conn.filter(rule) as matches:
            # matches is a deque containing matched messages
            matching_msg = conn.recv_until_filtered(matches)

    Parameters:

      - rule (jeepney.MatchRule) – Catch messages matching this rule

      - queue (collections.deque) – Matched messages will be added to this

      - bufsize (int) – If no deque is passed in, create one with this size

  recv_until_filtered(queue, *, timeout=None) → Message

    Process incoming messages until one is filtered into queue

    Pops the message from queue and returns it, or raises TimeoutError if the optional timeout expires. Without a timeout, this is equivalent to:

        while len(queue) == 0:
            conn.recv_messages()
        return queue.popleft()

    In the other I/O modules, there is no need for this, because messages are placed in queues by a separate task.

    Parameters:

      - queue (collections.deque) – A deque connected by `filter()`

      - timeout (float) – Maximum time to wait in seconds

  close()

    Close the connection

    Using `with open_dbus_connection()` will also close the connection on exiting the block.

class jeepney.io.blocking.Proxy(msggen, connection, *, timeout=None)

  A blocking proxy for calling D-Bus methods

  You can call methods on the proxy object, such as `bus_proxy.Hello()` to make a method call over D-Bus and wait for a reply. It will either return a tuple of returned data, or raise `DBusErrorResponse`. The methods available are defined by the message generator you wrap.

  You can set a time limit on a call by passing `_timeout=` in the method call, or set a default when creating the proxy. The `_timeout` argument is not passed to the message generator. All timeouts are in seconds, and `TimeoutErrror` is raised if it expires before a reply arrives.

  Parameters:

    - msggen – A message generator object

    - connection (DBusConnection) – Connection to send and receive messages

    - timeout (float) – Default seconds to wait for a reply, or None for no limit

  See also

  Message generators and proxies