rabbitmq-amqp-python-client 0.4.0__tar.gz → 0.5.0__tar.gz

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rabbitmq-amqp-python-client
-Version: 0.4.0
+Version: 0.5.0
 Summary: Python RabbitMQ client for AMQP 1.0 protocol
 License: Apache-2.0 license
 License-File: LICENSE

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rabbitmq-amqp-python-client"
-version = "0.4.0"
+version = "0.5.0"
 description = "Python RabbitMQ client for AMQP 1.0 protocol"
 authors = ["RabbitMQ team"]
 license = "Apache-2.0 license"

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/__init__.py

@@ -13,8 +13,9 @@ from .common import ExchangeType, QueueType
 from .connection import Connection
 from .consumer import Consumer
 from .entities import (
+    AbcConsumerOptions,
     ConsumerOptions,
-    DirectReplyToConsumerOptions,
+    ConsumerSettleStrategy,
     ExchangeCustomSpecification,
     ExchangeSpecification,
     ExchangeToExchangeBindingSpecification,
@@ -29,6 +30,7 @@ from .entities import (
 from .environment import Environment
 from .exceptions import (
     ArgumentOutOfRangeException,
+    InvalidOperationException,
     ValidationCodeException,
 )
 from .management import Management
@@ -72,8 +74,8 @@ __all__ = [
     "ExchangeSpecification",
     "QuorumQueueSpecification",
     "ClassicQueueSpecification",
+    "ConsumerSettleStrategy",
     "StreamSpecification",
-    "DirectReplyToConsumerOptions",
     "ExchangeToQueueBindingSpecification",
     "ExchangeToExchangeBindingSpecification",
     "QueueType",
@@ -99,6 +101,7 @@ __all__ = [
     "ConnectionClosed",
     "StreamConsumerOptions",
     "StreamFilterOptions",
+    "AbcConsumerOptions",
     "ConsumerOptions",
     "MessageProperties",
     "OffsetSpecification",
@@ -113,4 +116,5 @@ __all__ = [
     "AsyncPublisher",
     "AsyncManagement",
     "AsyncEnvironment",
+    "InvalidOperationException",
 ]

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/amqp_consumer_handler.py

@@ -1,11 +1,14 @@
-from .delivery_context import DeliveryContext
+from .delivery_context import (
+    AbcDeliveryContext,
+    DeliveryContext,
+)
 from .qpid.proton._events import Event
 from .qpid.proton.handlers import MessagingHandler
 
 """
 AMQPMessagingHandler extends the QPID MessagingHandler.
 It is an helper to set the default values needed for manually accepting and settling messages.
-self.delivery_context is an instance of DeliveryContext, which is used to accept, reject,
+self.delivery_context is an instance of IDeliveryContext (defaults to DeliveryContext), which is used to accept, reject,
 requeue or requeue with annotations a message.
 It is not mandatory to use this class, but it is a good practice to use it.
 """
@@ -20,7 +23,7 @@ class AMQPMessagingHandler(MessagingHandler):  # type: ignore
         different methods of the delivery_context what to do with the message
         """
         super().__init__(auto_accept=auto_accept, auto_settle=auto_settle)
-        self.delivery_context: DeliveryContext = DeliveryContext()
+        self.delivery_context: AbcDeliveryContext = DeliveryContext()
         self._offset = 0
 
     def on_amqp_message(self, event: Event) -> None:

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/asyncio/connection.py

@@ -8,7 +8,7 @@ from ..address_helper import validate_address
 from ..connection import Connection
 from ..consumer import Consumer
 from ..entities import (
-    ConsumerOptions,
+    AbcConsumerOptions,
     OAuth2Options,
     RecoveryConfiguration,
 )
@@ -228,7 +228,7 @@ class AsyncConnection:
         self,
         destination: str,
         message_handler: Optional[MessagingHandler] = None,
-        consumer_options: Optional[ConsumerOptions] = None,
+        consumer_options: Optional[AbcConsumerOptions] = None,
         credit: Optional[int] = None,
     ) -> AsyncConsumer:
         """

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/asyncio/consumer.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import threading
+import warnings
 from types import TracebackType
 from typing import (
     Any,
@@ -15,7 +16,7 @@ from typing import (
 
 from ..amqp_consumer_handler import AMQPMessagingHandler
 from ..consumer import Consumer
-from ..entities import ConsumerOptions
+from ..entities import AbcConsumerOptions
 from ..qpid.proton._exceptions import Timeout
 from ..qpid.proton._message import Message
 from ..qpid.proton.utils import BlockingConnection
@@ -39,7 +40,7 @@ class AsyncConsumer:
         _conn (BlockingConnection): The shared blocking connection
         _addr (str): The address to consume from
         _handler (Optional[AMQPMessagingHandler]): Optional message handling callback
-        _stream_options (Optional[ConsumerOptions]): Configuration for stream consumption
+        _stream_options (Optional[AbcConsumerOptions]): Configuration for stream consumption
         _credit (Optional[int]): Flow control credit value
         _connection_lock (asyncio.Lock): Lock for coordinating access to the shared connection
         _remove_callback (Optional[Callable[[AsyncConsumer], None]]): Callback on close
@@ -56,7 +57,7 @@ class AsyncConsumer:
         conn: BlockingConnection,
         addr: str,
         handler: Optional[AMQPMessagingHandler] = None,
-        stream_options: Optional[ConsumerOptions] = None,
+        stream_options: Optional[AbcConsumerOptions] = None,
         credit: Optional[int] = None,
         *,
         connection_lock: asyncio.Lock,
@@ -69,7 +70,7 @@ class AsyncConsumer:
             conn (BlockingConnection): The blocking connection to use
             addr (str): The address to consume from
             handler (Optional[AMQPMessagingHandler]): Optional message handler for processing received messages
-            stream_options (Optional[ConsumerOptions]): Optional configuration for stream-based consumption
+            stream_options (Optional[AbcConsumerOptions]): Optional configuration for stream-based consumption
             credit (Optional[int]): Optional credit value for flow control
             connection_lock (asyncio.Lock): Lock for coordinating access to the shared connection.
                             Must be created by the caller (AsyncConnection).
@@ -124,6 +125,11 @@ class AsyncConsumer:
         """
         Consume a message from the queue.
 
+        .. deprecated::
+            Use the ``message_handler`` parameter when creating the consumer via
+            :meth:`AsyncConnection.consumer` instead. The message handler processes
+            messages as they arrive without polling.
+
         Args:
             timeout: The time to wait for a message.
                     None: Defaults to 60s
@@ -139,6 +145,12 @@ class AsyncConsumer:
             The return type might be None if no message is available and timeout occurs,
             but this is handled by the cast to Message.
         """
+        warnings.warn(
+            "consume() is deprecated; pass message_handler when creating the consumer "
+            "via connection.consumer() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         if not self._opened or self._consumer is None:
             raise RuntimeError(
                 "Consumer is not opened. Call open() or use async context manager."

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/connection.py

@@ -16,7 +16,7 @@ from packaging import version
 from .address_helper import validate_address
 from .consumer import Consumer
 from .entities import (
-    ConsumerOptions,
+    AbcConsumerOptions,
     OAuth2Options,
     RecoveryConfiguration,
 )
@@ -381,7 +381,7 @@ class Connection:
         self,
         destination: Optional[str] = None,
         message_handler: Optional[MessagingHandler] = None,
-        consumer_options: Optional[ConsumerOptions] = None,
+        consumer_options: Optional[AbcConsumerOptions] = None,
         credit: Optional[int] = None,
     ) -> Consumer:
         """

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/consumer.py

@@ -1,13 +1,16 @@
 import logging
+import warnings
 from typing import Literal, Optional, Union, cast
 
 from .amqp_consumer_handler import AMQPMessagingHandler
 from .entities import (
+    AbcConsumerOptions,
     ConsumerOptions,
-    DirectReplyToConsumerOptions,
     StreamConsumerOptions,
 )
 from .options import (
+    DynamicReceiverOption,
+    ReceiverOptionPreSettled,
     ReceiverOptionUnsettled,
     ReceiverOptionUnsettledWithFilters,
 )
@@ -42,7 +45,7 @@ class Consumer:
         conn: BlockingConnection,
         addr: Optional[str] = None,
         handler: Optional[AMQPMessagingHandler] = None,
-        consumer_options: Optional[ConsumerOptions] = None,
+        consumer_options: Optional[AbcConsumerOptions] = None,
         credit: Optional[int] = None,
     ):
         """
@@ -73,16 +76,22 @@ class Consumer:
         addr = ""
         if self._addr is not None:
             addr = self._addr
+        credit = 10
+        if self._credit is not None:
+            credit = self._credit
 
         self._conn = conn
+        self._receiver = self._create_receiver(addr)
         if self._consumer_options is None:
             logger.debug("creating new receiver without stream")
+
             self._receiver = self._conn.create_receiver(
                 addr,
                 options=ReceiverOptionUnsettled(addr),
                 handler=self._handler,
+                credit=self._credit,
             )
-        else:
+        elif isinstance(self._consumer_options, StreamConsumerOptions):
             logger.debug("creating new stream receiver")
             self._consumer_options.offset(self._handler.offset - 1)  # type: ignore
             self._receiver = self._conn.create_receiver(
@@ -92,6 +101,10 @@ class Consumer:
                 ),
                 handler=self._handler,
             )
+        elif isinstance(self._consumer_options, ConsumerOptions):
+            self._receiver = self._create_receiver_from_cq_consumer_options(
+                addr, credit
+            )
 
     def _set_consumers_list(self, consumers: []) -> None:  # type: ignore
         self._consumers = consumers
@@ -100,6 +113,11 @@ class Consumer:
         """
         Consume a message from the queue.
 
+        .. deprecated::
+            Use the ``message_handler`` parameter when creating the consumer via
+            :meth:`Connection.consumer` instead. The message handler processes
+            messages as they arrive without polling.
+
         Args:
             timeout: The time to wait for a message.
                     None: Defaults to 60s
@@ -112,9 +130,17 @@ class Consumer:
             The return type might be None if no message is available and timeout occurs,
             but this is handled by the cast to Message.
         """
+        warnings.warn(
+            "consume() is deprecated; pass message_handler when creating the consumer "
+            "via connection.consumer() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         if self._receiver is not None:
-            message = self._receiver.receive(timeout=timeout)
-            return cast(Message, message)
+            message_original = self._receiver.receive(timeout=timeout)
+            message = cast(Message, message_original)
+            return message
+        raise Exception("Receiver is not initialized")
 
     def close(self) -> None:
         """
@@ -163,6 +189,8 @@ class Consumer:
         else:
             logger.debug("Creating the receiver, without options")
 
+        # we assume the default is for quorum and classic queues with
+        # Unsettled mode
         if self._consumer_options is None:
             return self._conn.create_receiver(
                 addr,
@@ -171,14 +199,6 @@ class Consumer:
                 credit=credit,
             )
 
-        if isinstance(self._consumer_options, DirectReplyToConsumerOptions):
-            logger.debug("Creating dynamic receiver for direct reply-to")
-            dynamic_receiver = self._conn.create_dynamic_receiver(
-                credit, handler=self._handler
-            )
-            dynamic_receiver.credit = credit
-            return dynamic_receiver
-
         if isinstance(self._consumer_options, StreamConsumerOptions):
             return self._conn.create_receiver(
                 addr,
@@ -188,10 +208,48 @@ class Consumer:
                 handler=self._handler,
             )
 
+        if isinstance(self._consumer_options, ConsumerOptions):
+            return self._create_receiver_from_cq_consumer_options(addr, credit)
+
         raise Exception(
             "Receiver is not initialized. No valid consumer options provided."
         )
 
+    def _create_receiver_from_cq_consumer_options(
+        self, addr: Optional[str], credit: int
+    ) -> BlockingReceiver:
+
+        if self._consumer_options is None:
+            raise Exception(
+                "Consumer options must be provided for CQ receiver creation."
+            )
+
+        if self._consumer_options.pre_settled():
+            logger.debug("Creating receiver with pre-settled deliveries")
+            return self._conn.create_receiver(
+                addr,
+                options=ReceiverOptionPreSettled(addr),
+                handler=self._handler,
+                credit=credit,
+            )
+
+        if self._consumer_options.direct_reply_to():
+            logger.debug("Creating receiver for direct-reply-to queue")
+            return self._conn.create_receiver(
+                addr,
+                options=DynamicReceiverOption(),
+                handler=self._handler,
+                credit=credit,
+            )
+
+        logger.debug("Creating receiver for CQ queue with default unsettled deliveries")
+        return self._conn.create_receiver(
+            addr,
+            options=ReceiverOptionUnsettled(addr),
+            handler=self._handler,
+            credit=credit,
+        )
+
     @property
     def address(self) -> Optional[str]:
         if self._receiver is not None:

rabbitmq_amqp_python_client-0.5.0/rabbitmq_amqp_python_client/delivery_context.py

@@ -0,0 +1,219 @@
+from abc import ABC, abstractmethod
+from typing import Dict
+
+from .exceptions import (
+    ArgumentOutOfRangeException,
+    InvalidOperationException,
+)
+from .qpid.proton._data import PythonAMQPData
+from .qpid.proton._delivery import Delivery
+from .qpid.proton._events import Event
+from .utils import validate_annotations
+
+"""
+DeliveryContext is a class that is used to accept, reject, requeue or requeue with annotations a message.
+It is an helper to set the default values needed for manually accepting and settling messages.
+"""
+
+
+class AbcDeliveryContext(ABC):
+    """
+    Abstract interface for delivery context operations.
+    Provides methods to accept, reject, requeue or requeue with annotations a message.
+    """
+
+    @abstractmethod
+    def accept(self, event: Event) -> None:
+        """
+        Accept the message (AMQP 1.0 <code>accepted</code> outcome).
+
+        This means the message has been processed and the broker can delete it.
+        """
+        pass
+
+    @abstractmethod
+    def discard(self, event: Event) -> None:
+        """
+        Reject the message (AMQP 1.0 <code>rejected</code> outcome).
+        This means the message cannot be processed because it is invalid, the broker can drop it
+        or dead-letter it if it is configured.
+        """
+        pass
+
+    @abstractmethod
+    def discard_with_annotations(
+        self, event: Event, annotations: Dict[str, "PythonAMQPData"]
+    ) -> None:
+        """
+        Discard the message with annotations to combine with the existing message annotations.
+        This means the message cannot be processed because it is invalid, the broker can drop it
+        or dead-letter it if it is configured.
+        Application-specific annotation keys must start with the <code>x-opt-</code> prefix.
+        Annotation keys the broker understands starts with <code>x-</code>, but not with <code>x-opt-
+        This maps to the AMQP 1.0
+        modified{delivery-failed = true, undeliverable-here = true}</code> outcome.
+         <param name="annotations"> annotations message annotations to combine with existing ones </param>
+        <a
+            href="https://docs.oasis-open.org/amqp/core/v1.0/os/amqp-core-messaging-v1.0-os.html#type-modified">AMQP
+                    1.0 <code>modified</code> outcome</a>
+         The annotations can be used only with Quorum queues, see https://www.rabbitmq.com/docs/amqp#modified-outcome
+        """
+        pass
+
+    @abstractmethod
+    def requeue(self, event: Event) -> None:
+        """
+        Requeue the message (AMQP 1.0 <code>released</code> outcome).
+        This means the message has not been processed and the broker can requeue it and deliver it
+        to the same or a different consumer.
+        """
+        pass
+
+    @abstractmethod
+    def requeue_with_annotations(
+        self, event: Event, annotations: Dict[str, "PythonAMQPData"]
+    ) -> None:
+        """
+         Requeue the message with annotations to combine with the existing message annotations.
+        This means the message has not been processed and the broker can requeue it and deliver it
+         to the same or a different consumer.
+         Application-specific annotation keys must start with the <code>x-opt-</code> prefix.
+         Annotation keys the broker understands starts with <code>x-</code>, but not with <code>x-opt-
+         </code>.
+         This maps to the AMQP 1.0 <code>
+         modified{delivery-failed = false, undeliverable-here = false}</code> outcome.
+         <param name="annotations"> annotations message annotations to combine with existing ones </param>
+        <a
+             href="https://docs.oasis-open.org/amqp/core/v1.0/os/amqp-core-messaging-v1.0-os.html#type-modified">AMQP
+             1.0 <code>modified</code> outcome</a>
+        The annotations can be used only with Quorum queues, see https://www.rabbitmq.com/docs/amqp#modified-outcome
+        """
+        pass
+
+
+class DeliveryContext(AbcDeliveryContext):
+    """
+    Default implementation of IDeliveryContext.
+    Used to accept, reject, requeue or requeue with annotations a message.
+    It is an helper to set the default values needed for manually accepting and settling messages.
+    """
+
+    def accept(self, event: Event) -> None:
+        """
+        Accept the message (AMQP 1.0 <code>accepted</code> outcome).
+
+        This means the message has been processed and the broker can delete it.
+        """
+        dlv = event.delivery
+        if dlv.settled:
+            # like the other clients, it has to raise an exception if trying to accept an already settled delivery
+            raise InvalidOperationException(
+                "auto-settle on, message is already disposed"
+            )
+        dlv.update(Delivery.ACCEPTED)
+        dlv.settle()
+
+    def discard(self, event: Event) -> None:
+        """
+        Reject the message (AMQP 1.0 <code>rejected</code> outcome).
+        This means the message cannot be processed because it is invalid, the broker can drop it
+        or dead-letter it if it is configured.
+        """
+        dlv = event.delivery
+        if dlv.settled:
+            # like the other clients, it has to raise an exception if trying to discard an already settled delivery
+            raise InvalidOperationException(
+                "auto-settle on, message is already disposed"
+            )
+        dlv.update(Delivery.REJECTED)
+        dlv.settle()
+
+    def discard_with_annotations(
+        self, event: Event, annotations: Dict[str, "PythonAMQPData"]
+    ) -> None:
+        """
+        Discard the message with annotations to combine with the existing message annotations.
+        This means the message cannot be processed because it is invalid, the broker can drop it
+        or dead-letter it if it is configured.
+        Application-specific annotation keys must start with the <code>x-opt-</code> prefix.
+        Annotation keys the broker understands starts with <code>x-</code>, but not with <code>x-opt-
+        This maps to the AMQP 1.0
+        modified{delivery-failed = true, undeliverable-here = true}</code> outcome.
+         <param name="annotations"> annotations message annotations to combine with existing ones </param>
+        <a
+            href="https://docs.oasis-open.org/amqp/core/v1.0/os/amqp-core-messaging-v1.0-os.html#type-modified">AMQP
+                    1.0 <code>modified</code> outcome</a>
+         The annotations can be used only with Quorum queues, see https://www.rabbitmq.com/docs/amqp#modified-outcome
+        """
+        dlv = event.delivery
+        if dlv.settled:
+            # like the other clients, it has to raise an exception if trying to discard an already settled delivery
+            raise InvalidOperationException(
+                "auto-settle on, message is already disposed"
+            )
+        dlv.local.annotations = annotations
+        dlv.local.failed = True
+        dlv.local.undeliverable = True
+
+        validated = validate_annotations(annotations.keys())
+
+        if validated is False:
+            raise ArgumentOutOfRangeException(
+                "Message annotation key must start with 'x-'"
+            )
+
+        dlv.update(Delivery.MODIFIED)
+        dlv.settle()
+
+    def requeue(self, event: Event) -> None:
+        """
+        Requeue the message (AMQP 1.0 <code>released</code> outcome).
+        This means the message has not been processed and the broker can requeue it and deliver it
+        to the same or a different consumer.
+        """
+        dlv = event.delivery
+        if dlv.settled:
+            # like the other clients, it has to raise an exception if trying to requeue an already settled delivery
+            raise InvalidOperationException(
+                "auto-settle on, message is already disposed"
+            )
+        dlv.update(Delivery.RELEASED)
+        dlv.settle()
+
+    def requeue_with_annotations(
+        self, event: Event, annotations: Dict[str, "PythonAMQPData"]
+    ) -> None:
+        """
+         Requeue the message with annotations to combine with the existing message annotations.
+        This means the message has not been processed and the broker can requeue it and deliver it
+         to the same or a different consumer.
+         Application-specific annotation keys must start with the <code>x-opt-</code> prefix.
+         Annotation keys the broker understands starts with <code>x-</code>, but not with <code>x-opt-
+         </code>.
+         This maps to the AMQP 1.0 <code>
+         modified{delivery-failed = false, undeliverable-here = false}</code> outcome.
+         <param name="annotations"> annotations message annotations to combine with existing ones </param>
+        <a
+             href="https://docs.oasis-open.org/amqp/core/v1.0/os/amqp-core-messaging-v1.0-os.html#type-modified">AMQP
+             1.0 <code>modified</code> outcome</a>
+        The annotations can be used only with Quorum queues, see https://www.rabbitmq.com/docs/amqp#modified-outcome
+        """
+        dlv = event.delivery
+        if dlv.settled:
+            # like the other clients, it has to raise an exception if trying to requeue an already settled delivery
+            raise InvalidOperationException(
+                "auto-settle on, message is already disposed"
+            )
+        dlv.local.annotations = annotations
+        dlv.local.failed = False
+        dlv.local.undeliverable = False
+
+        validated = validate_annotations(annotations.keys())
+
+        if validated is False:
+            raise ArgumentOutOfRangeException(
+                "Message annotation key must start with 'x-'"
+            )
+
+        dlv.update(Delivery.MODIFIED)
+        dlv.settle()

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/entities.py

@@ -1,11 +1,12 @@
+from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
-from enum import Enum
+from enum import Enum, auto
 from typing import Any, Dict, Optional, Union
 
 from .common import ExchangeType, QueueType
 from .exceptions import ValidationCodeException
-from .qpid.proton._data import Described, symbol
+from .qpid.proton._data import Described, symbol, timestamp
 
 SQL_FILTER = "sql-filter"
 AMQP_SQL_FILTER = "amqp:sql-filter"
@@ -109,11 +110,13 @@ class OffsetSpecification(Enum):
         first: Start from the first message in the stream
         next: Start from the next message to arrive
         last: Start from the last message in the stream
+        timestamp: Start from a specific timestamp
     """
 
     first = ("first",)
     next = ("next",)
     last = ("last",)
+    timestamp = ("timestamp",)
 
 
 @dataclass
@@ -153,16 +156,27 @@ class ExchangeToExchangeBindingSpecification:
     binding_key: Optional[str] = None
 
 
-class ConsumerOptions:
+class AbcConsumerOptions(ABC):
+    """
+    Abstract base class for consumer configuration options.
+    This class defines the interface for consumer options, including validation
+    and filter set retrieval.
+    """
+
+    @abstractmethod
     def validate(self, versions: Dict[str, bool]) -> None:
         raise NotImplementedError("Subclasses should implement this method")
 
+    @abstractmethod
     def filter_set(self) -> Dict[symbol, Described]:
         raise NotImplementedError("Subclasses should implement this method")
 
     def direct_reply_to(self) -> bool:
         return False
 
+    def pre_settled(self) -> bool:
+        return False
+
 
 @dataclass
 class MessageProperties:
@@ -198,13 +212,12 @@ class MessageProperties:
     reply_to_group_id: Optional[str] = None
 
 
-"""
-  StreamFilterOptions defines the filtering options for a stream consumer.
-  for values and match_unfiltered see: https://www.rabbitmq.com/blog/2023/10/16/stream-filtering
-"""
-
-
 class StreamFilterOptions:
+    """
+    StreamFilterOptions defines the filtering options for a stream consumer.
+    for values and match_unfiltered see: https://www.rabbitmq.com/blog/2023/10/16/stream-filtering
+    """
+
     values: Optional[list[str]] = None
     match_unfiltered: bool = False
     application_properties: Optional[dict[str, Any]] = None
@@ -226,7 +239,7 @@ class StreamFilterOptions:
         self.sql = sql
 
 
-class StreamConsumerOptions(ConsumerOptions):
+class StreamConsumerOptions(AbcConsumerOptions):
     """
     Configuration options for stream queues.
 
@@ -243,7 +256,9 @@ class StreamConsumerOptions(ConsumerOptions):
 
     def __init__(
         self,
-        offset_specification: Optional[Union[OffsetSpecification, int]] = None,
+        offset_specification: Optional[
+            Union[OffsetSpecification, int, datetime]
+        ] = None,
         filter_options: Optional[StreamFilterOptions] = None,
     ):
 
@@ -275,7 +290,9 @@ class StreamConsumerOptions(ConsumerOptions):
         if filter_options.sql is not None and filter_options.sql != "":
             self._filter_sql(filter_options.sql)
 
-    def _offset(self, offset_specification: Union[OffsetSpecification, int]) -> None:
+    def _offset(
+        self, offset_specification: Union[OffsetSpecification, int, datetime]
+    ) -> None:
         """
         Set the offset specification for the stream.
 
@@ -287,11 +304,20 @@ class StreamConsumerOptions(ConsumerOptions):
             self._filter_set[symbol(STREAM_OFFSET_SPEC)] = Described(
                 symbol(STREAM_OFFSET_SPEC), offset_specification
             )
-        else:
+        if isinstance(offset_specification, OffsetSpecification):
             self._filter_set[symbol(STREAM_OFFSET_SPEC)] = Described(
                 symbol(STREAM_OFFSET_SPEC), offset_specification.name
             )
 
+        if isinstance(offset_specification, datetime):
+            # convert datetime to milliseconds since epoch
+            milliseconds_since_epoch = int(offset_specification.timestamp() * 1000)
+            # Create a timestamp instance
+            ts = timestamp(milliseconds_since_epoch)
+            self._filter_set[symbol(STREAM_OFFSET_SPEC)] = Described(
+                symbol(STREAM_OFFSET_SPEC), ts
+            )
+
     def _filter_values(self, filters: list[str]) -> None:
         """
         Set the filter values for the stream.
@@ -403,19 +429,92 @@ class StreamConsumerOptions(ConsumerOptions):
             )
 
 
-class DirectReplyToConsumerOptions(ConsumerOptions):
+class ConsumerSettleStrategy(Enum):
+    """
+    ConsumerSettleStrategy defines the settle strategy for Classic and Quorum queue consumers.
+    Uniform with the AMQP 1.0 clients interface (e.g. .NET client SettleStrategy).
+
+    Attributes:
+        ExplicitSettle: Consumer uses explicit settle (default). Message settle mode
+                        is the default one (explicit settle).
+        DirectReplyTo: Enables Direct Reply-To consumer behavior.
+                       Feature in RabbitMQ, allowing for simplified request-reply messaging patterns.
+                       Docs: https://www.rabbitmq.com/docs/direct-reply-to#usage-amqp
+        PreSettled: Deliveries are pre-settled (at-most-once semantics).
+                    When enabled, messages are automatically settled when received,
+                    meaning they cannot be redelivered if processing fails.
+    """
+
+    ExplicitSettle = auto()
+    DirectReplyTo = auto()
+    PreSettled = auto()
+
+
+@dataclass
+class ConsumerOptions(AbcConsumerOptions):
+    """
+    Configuration options for FIFO (Classic and Quorum) queue consumers.
+    Not valid for Stream queues.
+
+    This class provides options for consuming from FIFO queues, including
+    support for pre-settled deliveries. Uses a single settle_strategy to
+    align with the uniform AMQP 1.0 clients interface.
+
+    Attributes:
+        see ConsumerSettleStrategy enum for available strategies.
+    """
+
+    def __init__(
+        self,
+        settle_strategy: ConsumerSettleStrategy = ConsumerSettleStrategy.ExplicitSettle,
+    ):
+        super().__init__()
+        self._settle_strategy = settle_strategy
 
     def validate(self, versions: Dict[str, bool]) -> None:
-        if not versions.get("4.2.0", False):
-            raise ValidationCodeException(
-                "Direct Reply-To requires RabbitMQ 4.2.0 or higher"
-            )
+        """
+        Validates Classic/Quorum consumer options against supported RabbitMQ server versions.
+
+        Args:
+            versions: Dictionary mapping version strings to boolean indicating support.
+
+        Raises:
+            ValidationCodeException: If a feature requires a higher RabbitMQ version.
+        """
+        # Classic/Quorum queues and pre-settled deliveries are supported in RabbitMQ 4.x
+        # No specific version validation needed at this time
+        if self._settle_strategy == ConsumerSettleStrategy.DirectReplyTo:
+            if not versions.get("4.2.0", False):
+                raise ValidationCodeException(
+                    "Direct Reply-To requires RabbitMQ 4.2.0 or higher"
+                )
 
     def filter_set(self) -> Dict[symbol, Described]:
+        """
+        Get the filter set configuration (empty for FIFO consumers).
+
+        Returns:
+            Dict[symbol, Described]: Empty dictionary as FIFO consumers don't use filters.
+        """
         return {}
 
     def direct_reply_to(self) -> bool:
-        return True
+        """
+        Indicates if this is a direct reply-to consumer.
+
+        Returns:
+            bool: True if DirectReplyTo settle strategy is used, False otherwise.
+        """
+        return self._settle_strategy is ConsumerSettleStrategy.DirectReplyTo
+
+    def pre_settled(self) -> bool:
+        """
+        Indicates if deliveries are pre-settled.
+
+        Returns:
+            bool: True if deliveries are pre-settled, False otherwise.
+        """
+        return self._settle_strategy is ConsumerSettleStrategy.PreSettled
 
 
 @dataclass

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/exceptions.py

@@ -14,3 +14,12 @@ class ArgumentOutOfRangeException(BaseException):
 
     def __str__(self) -> str:
         return repr(self.msg)
+
+
+class InvalidOperationException(Exception):
+    # Constructor or Initializer
+    def __init__(self, msg: str):
+        self.msg = msg
+
+    def __str__(self) -> str:
+        return repr(self.msg)

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/options.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from .entities import ConsumerOptions
+from .entities import AbcConsumerOptions
 from .qpid.proton._data import (  # noqa: E402
     Data,
     PropertyDict,
@@ -89,7 +89,7 @@ class ReceiverOptionUnsettled(LinkOption):  # type: ignore
 
 
 class ReceiverOptionUnsettledWithFilters(Filter):  # type: ignore
-    def __init__(self, addr: Optional[str], consumer_options: ConsumerOptions):
+    def __init__(self, addr: Optional[str], consumer_options: AbcConsumerOptions):
         super().__init__(consumer_options.filter_set())
         self._addr = addr
 
@@ -103,3 +103,26 @@ class ReceiverOptionUnsettledWithFilters(Filter):  # type: ignore
 
     def test(self, link: Link) -> bool:
         return bool(link.is_receiver)
+
+
+class ReceiverOptionPreSettled(LinkOption):  # type: ignore
+    """
+    Receiver option for pre-settled deliveries (at-most-once semantics).
+
+    When pre-settled is enabled, deliveries are automatically settled when received,
+    meaning they cannot be redelivered if processing fails. This uses RCV_FIRST
+    which causes the receiver to settle deliveries immediately upon receiving them.
+    """
+
+    def __init__(self, addr: Optional[str]):
+        self._addr = addr
+
+    def apply(self, link: Link) -> None:
+        link.target.address = self._addr
+        link.snd_settle_mode = Link.SND_SETTLED
+        link.rcv_settle_mode = Link.RCV_FIRST
+        link.properties = PropertyDict({symbol("paired"): True})
+        link.source.dynamic = False
+
+    def test(self, link: Link) -> bool:
+        return bool(link.is_receiver)

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/qpid/proton/_data.py

@@ -18,6 +18,7 @@
 #
 
 import uuid
+from datetime import datetime
 from typing import (
     Any,
     Callable,

{rabbitmq_amqp_python_client-0.4.0 → rabbitmq_amqp_python_client-0.5.0}/rabbitmq_amqp_python_client/qpid/proton/_reactor.py

@@ -1039,7 +1039,7 @@ class Backoff(object):
 
 
 def make_backoff_wrapper(
-    backoff: Optional[Union[List[Union[float, int]], bool, Backoff]]
+    backoff: Optional[Union[List[Union[float, int]], bool, Backoff]],
 ) -> Optional[Union[List[Union[float, int]], bool, Backoff]]:
     """
     Make a wrapper for a backoff object:

rabbitmq_amqp_python_client-0.4.0/rabbitmq_amqp_python_client/delivery_context.py

@@ -1,114 +0,0 @@
-from typing import Dict
-
-from .exceptions import ArgumentOutOfRangeException
-from .qpid.proton._data import PythonAMQPData
-from .qpid.proton._delivery import Delivery
-from .qpid.proton._events import Event
-from .utils import validate_annotations
-
-"""
-DeliveryContext is a class that is used to accept, reject, requeue or requeue with annotations a message.
-It is an helper to set the default values needed for manually accepting and settling messages.
-"""
-
-
-class DeliveryContext:
-    """
-    Accept the message (AMQP 1.0 <code>accepted</code> outcome).
-
-    This means the message has been processed and the broker can delete it.
-    """
-
-    def accept(self, event: Event) -> None:
-        dlv = event.delivery
-        dlv.update(Delivery.ACCEPTED)
-        dlv.settle()
-
-    """
-    Reject the message (AMQP 1.0 <code>rejected</code> outcome).
-    This means the message cannot be processed because it is invalid, the broker can drop it
-    or dead-letter it if it is configured.
-    """
-
-    def discard(self, event: Event) -> None:
-        dlv = event.delivery
-        dlv.update(Delivery.REJECTED)
-        dlv.settle()
-
-    """
-    Discard the message with annotations to combine with the existing message annotations.
-    This means the message cannot be processed because it is invalid, the broker can drop it
-    or dead-letter it if it is configured.
-    Application-specific annotation keys must start with the <code>x-opt-</code> prefix.
-    Annotation keys the broker understands starts with <code>x-</code>, but not with <code>x-opt-
-        This maps to the AMQP 1.0
-        modified{delivery-failed = true, undeliverable-here = true}</code> outcome.
-         <param name="annotations"> annotations message annotations to combine with existing ones </param>
-        <a
-            href="https://docs.oasis-open.org/amqp/core/v1.0/os/amqp-core-messaging-v1.0-os.html#type-modified">AMQP
-                        1.0 <code>modified</code> outcome</a>
-         The annotations can be used only with Quorum queues, see https://www.rabbitmq.com/docs/amqp#modified-outcome
-    """
-
-    def discard_with_annotations(
-        self, event: Event, annotations: Dict[str, "PythonAMQPData"]
-    ) -> None:
-        dlv = event.delivery
-        dlv.local.annotations = annotations
-        dlv.local.failed = True
-        dlv.local.undeliverable = True
-
-        validated = validate_annotations(annotations.keys())
-
-        if validated is False:
-            raise ArgumentOutOfRangeException(
-                "Message annotation key must start with 'x-'"
-            )
-
-        dlv.update(Delivery.MODIFIED)
-        dlv.settle()
-
-    """
-    Requeue the message (AMQP 1.0 <code>released</code> outcome).
-    This means the message has not been processed and the broker can requeue it and deliver it
-    to the same or a different consumer.
-    """
-
-    def requeue(self, event: Event) -> None:
-        dlv = event.delivery
-        dlv.update(Delivery.RELEASED)
-        dlv.settle()
-
-    """
-     Requeue the message with annotations to combine with the existing message annotations.
-        This means the message has not been processed and the broker can requeue it and deliver it
-         to the same or a different consumer.
-         Application-specific annotation keys must start with the <code>x-opt-</code> prefix.
-         Annotation keys the broker understands starts with <code>x-</code>, but not with <code>x-opt-
-         </code>.
-         This maps to the AMQP 1.0 <code>
-         modified{delivery-failed = false, undeliverable-here = false}</code> outcome.
-         <param name="annotations"> annotations message annotations to combine with existing ones </param>
-        <a
-             href="https://docs.oasis-open.org/amqp/core/v1.0/os/amqp-core-messaging-v1.0-os.html#type-modified">AMQP
-             1.0 <code>modified</code> outcome</a>
-        The annotations can be used only with Quorum queues, see https://www.rabbitmq.com/docs/amqp#modified-outcome
-    """
-
-    def requeue_with_annotations(
-        self, event: Event, annotations: Dict[str, "PythonAMQPData"]
-    ) -> None:
-        dlv = event.delivery
-        dlv.local.annotations = annotations
-        dlv.local.failed = False
-        dlv.local.undeliverable = False
-
-        validated = validate_annotations(annotations.keys())
-
-        if validated is False:
-            raise ArgumentOutOfRangeException(
-                "Message annotation key must start with 'x-'"
-            )
-
-        dlv.update(Delivery.MODIFIED)
-        dlv.settle()