ServiceBusReceiver Class

Abandon the message.

This message will be returned to the queue and made available to be received again.

abandon_message(message: ServiceBusReceivedMessage) -> None

Parameters

Returns

Exceptions

Examples

Abandon a received message.

       messages_abandon = servicebus_receiver.receive_messages(max_wait_time=5)
       for message in messages_abandon:
           servicebus_receiver.abandon_message(message)

close() -> None

Exceptions

Complete the message.

This removes the message from the queue.

complete_message(message: ServiceBusReceivedMessage) -> None

Parameters

Returns

Exceptions

Examples

Complete a received message.

       messages_complete = servicebus_receiver.receive_messages(max_wait_time=5)
       for message in messages_complete:
           servicebus_receiver.complete_message(message)

Move the message to the Dead Letter queue.

The Dead Letter queue is a sub-queue that can be used to store messages that failed to process correctly, or otherwise require further inspection or processing. The queue can also be configured to send expired messages to the Dead Letter queue.

dead_letter_message(message: ServiceBusReceivedMessage, reason: str | None = None, error_description: str | None = None) -> None

Parameters

Returns

Exceptions

Examples

Dead letter a received message.

       messages_dead_letter = servicebus_receiver.receive_messages(max_wait_time=5)
       for message in messages_dead_letter:
           servicebus_receiver.dead_letter_message(message)

Defers the message.

This message will remain in the queue but must be requested specifically by its sequence number in order to be received.

defer_message(message: ServiceBusReceivedMessage) -> None

Parameters

Returns

Exceptions

Examples

Defer a received message.

       messages_defer = servicebus_receiver.receive_messages(max_wait_time=5)
       for message in messages_defer:
           servicebus_receiver.defer_message(message)

next() -> ServiceBusReceivedMessage

Exceptions

Browse messages currently pending in the queue.

Peeked messages are not removed from queue, nor are they locked. They cannot be completed, deferred or dead-lettered.

peek_messages(max_message_count: int = 1, *, sequence_number: int = 0, timeout: float | None = None, **kwargs: Any) -> List[ServiceBusReceivedMessage]

Parameters

Keyword-Only Parameters

Returns

Exceptions

Examples

Look at pending messages in the queue.

   with servicebus_receiver:
       messages_peek = servicebus_receiver.peek_messages()
       for message in messages_peek:
           print(str(message))

Receive messages that have previously been deferred.

When receiving deferred messages from a partitioned entity, all of the supplied sequence numbers must be messages from the same partition.

receive_deferred_messages(sequence_numbers: int | List[int], *, timeout: float | None = None, **kwargs: Any) -> List[ServiceBusReceivedMessage]

Parameters

Keyword-Only Parameters

Returns

Exceptions

Examples

Receive deferred messages from ServiceBus.

   with servicebus_receiver:
       deferred_sequenced_numbers = []
       messages_defer = servicebus_receiver.receive_messages(max_wait_time=5)
       for message in messages_defer:
           deferred_sequenced_numbers.append(message.sequence_number)
           print(str(message))
           servicebus_receiver.defer_message(message)

       received_deferred_msg = servicebus_receiver.receive_deferred_messages(
           sequence_numbers=deferred_sequenced_numbers
       )

       for msg in received_deferred_msg:
           servicebus_receiver.complete_message(msg)

Receive a batch of messages at once.

This approach is optimal if you wish to process multiple messages simultaneously, or perform an ad-hoc receive as a single call.

Note that the number of messages retrieved in a single batch will be dependent on whether prefetch_count was set for the receiver. If prefetch_count is not set for the receiver, the receiver would try to cache max_message_count (if provided) messages within the request to the service.

This call will prioritize returning quickly over meeting a specified batch size, and so will return as soon as at least one message is received and there is a gap in incoming messages regardless of the specified batch size.

receive_messages(max_message_count: int | None = 1, max_wait_time: float | None = None) -> List[ServiceBusReceivedMessage]

Parameters

Returns

Exceptions

Examples

Receive messages from ServiceBus.

   with servicebus_receiver:
       messages_sync = servicebus_receiver.receive_messages(max_wait_time=5)
       for message in messages_sync:
           print(str(message))
           servicebus_receiver.complete_message(message)

Renew the message lock.

This will maintain the lock on the message to ensure it is not returned to the queue to be reprocessed.

In order to complete (or otherwise settle) the message, the lock must be maintained, and cannot already have expired; an expired lock cannot be renewed.

Messages received via RECEIVE_AND_DELETE mode are not locked, and therefore cannot be renewed. This operation is only available for non-sessionful messages as well.

renew_message_lock(message: ServiceBusReceivedMessage, *, timeout: float | None = None, **kwargs: Any) -> datetime

Parameters

Keyword-Only Parameters

Returns

Exceptions

Examples

Renew the lock on a received message.

       messages_lock = servicebus_receiver.receive_messages(max_wait_time=5)
       for message in messages_lock:
           servicebus_receiver.renew_message_lock(message)

Get the ServiceBusReceiver client_identifier associated with the receiver instance.

Returns

Get the ServiceBusSession object linked with the receiver. Session is only available to session-enabled entities, it would return None if called on a non-sessionful receiver.

Returns

Examples

Get session from a receiver

       with servicebus_client.get_queue_receiver(queue_name=queue_name, session_id=session_id) as receiver:
           session = receiver.session