rabbitmq-amqp-python-client 0.3.0__tar.gz → 0.4.1__tar.gz

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rabbitmq-amqp-python-client
-Version: 0.3.0
+Version: 0.4.1
 Summary: Python RabbitMQ client for AMQP 1.0 protocol
 License: Apache-2.0 license
 License-File: LICENSE
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: packaging (>=23.0,<24.0)
-Requires-Dist: python-qpid-proton (>=0.39.0,<0.40.0)
+Requires-Dist: python-qpid-proton (>=0.40.0,<0.41.0)
 Requires-Dist: typing-extensions (>=4.13.0,<5.0.0)
 Description-Content-Type: text/markdown
 

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rabbitmq-amqp-python-client"
-version = "0.3.0"
+version = "0.4.1"
 description = "Python RabbitMQ client for AMQP 1.0 protocol"
 authors = ["RabbitMQ team"]
 license = "Apache-2.0 license"
@@ -8,7 +8,7 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.9"
-python-qpid-proton = "^0.39.0"
+python-qpid-proton = "^0.40.0"
 typing-extensions = "^4.13.0"
 packaging = "^23.0"
 
@@ -21,7 +21,7 @@ isort = "^5.9.3"
 mypy = "^0.910"
 pytest = "^8.3.4"
 black = "^24.3.0"
-python-qpid-proton = "^0.39.0"
+python-qpid-proton = "^0.40.0"
 requests = "^2.31.0"
 pytest-asyncio = "^1.2.0"
 

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/rabbitmq_amqp_python_client/__init__.py

@@ -14,6 +14,7 @@ from .connection import Connection
 from .consumer import Consumer
 from .entities import (
     ConsumerOptions,
+    DirectReplyToConsumerOptions,
     ExchangeCustomSpecification,
     ExchangeSpecification,
     ExchangeToExchangeBindingSpecification,
@@ -72,6 +73,7 @@ __all__ = [
     "QuorumQueueSpecification",
     "ClassicQueueSpecification",
     "StreamSpecification",
+    "DirectReplyToConsumerOptions",
     "ExchangeToQueueBindingSpecification",
     "ExchangeToExchangeBindingSpecification",
     "QueueType",

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/rabbitmq_amqp_python_client/connection.py

@@ -379,7 +379,7 @@ class Connection:
 
     def consumer(
         self,
-        destination: str,
+        destination: Optional[str] = None,
         message_handler: Optional[MessagingHandler] = None,
         consumer_options: Optional[ConsumerOptions] = None,
         credit: Optional[int] = None,
@@ -388,7 +388,7 @@ class Connection:
         Create a new consumer instance.
 
         Args:
-            destination: The address to consume from
+            destination: Optional The address to consume from
             message_handler: Optional handler for processing messages
             consumer_options: Optional configuration for queue consumption. Each queue has its own consumer options.
             credit: Optional credit value for flow control
@@ -397,9 +397,11 @@ class Connection:
             Consumer: A new consumer instance
 
         Raises:
-            ArgumentOutOfRangeException: If destination address format is invalid
+            ArgumentOutOfRangeException: If destination address format is invalid.
+            Only applies if not using Direct Reply-to.
+            The server will provide the queue name in that case.
         """
-        if not validate_address(destination):
+        if destination is not None and not validate_address(destination):
             raise ArgumentOutOfRangeException(
                 "destination address must start with /queues or /exchanges"
             )
@@ -438,9 +440,7 @@ class Connection:
             time.sleep(delay.total_seconds())
 
             try:
-
                 self._open_connections(reconnect_handlers=True)
-
                 self._connections.append(self)
 
             except ConnectionException as e:

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/rabbitmq_amqp_python_client/consumer.py

@@ -2,7 +2,11 @@ import logging
 from typing import Literal, Optional, Union, cast
 
 from .amqp_consumer_handler import AMQPMessagingHandler
-from .entities import ConsumerOptions
+from .entities import (
+    ConsumerOptions,
+    DirectReplyToConsumerOptions,
+    StreamConsumerOptions,
+)
 from .options import (
     ReceiverOptionUnsettled,
     ReceiverOptionUnsettledWithFilters,
@@ -29,16 +33,16 @@ class Consumer:
         _conn (BlockingConnection): The underlying connection to RabbitMQ
         _addr (str): The address to consume from
         _handler (Optional[MessagingHandler]): Optional message handling callback
-        _stream_options (Optional[StreamConsumerOptions]): Configuration for stream consumption
+        _consumer_options (Optional[StreamConsumerOptions]): Configuration for stream consumption
         _credit (Optional[int]): Flow control credit value
     """
 
     def __init__(
         self,
         conn: BlockingConnection,
-        addr: str,
+        addr: Optional[str] = None,
         handler: Optional[AMQPMessagingHandler] = None,
-        stream_options: Optional[ConsumerOptions] = None,
+        consumer_options: Optional[ConsumerOptions] = None,
         credit: Optional[int] = None,
     ):
         """
@@ -48,14 +52,14 @@ class Consumer:
             conn: The blocking connection to use for consuming
             addr: The address to consume from
             handler: Optional message handler for processing received messages
-            stream_options: Optional configuration for stream-based consumption
+            consumer_options: Optional configuration for stream-based consumption
             credit: Optional credit value for flow control
         """
         self._receiver: Optional[BlockingReceiver] = None
         self._conn = conn
         self._addr = addr
         self._handler = handler
-        self._stream_options = stream_options
+        self._consumer_options = consumer_options
         self._credit = credit
         self._consumers: list[Consumer] = []
         self._open()
@@ -66,21 +70,25 @@ class Consumer:
             self._receiver = self._create_receiver(self._addr)
 
     def _update_connection(self, conn: BlockingConnection) -> None:
+        addr = ""
+        if self._addr is not None:
+            addr = self._addr
+
         self._conn = conn
-        if self._stream_options is None:
+        if self._consumer_options is None:
             logger.debug("creating new receiver without stream")
             self._receiver = self._conn.create_receiver(
-                self._addr,
-                options=ReceiverOptionUnsettled(self._addr),
+                addr,
+                options=ReceiverOptionUnsettled(addr),
                 handler=self._handler,
             )
         else:
             logger.debug("creating new stream receiver")
-            self._stream_options.offset(self._handler.offset - 1)  # type: ignore
+            self._consumer_options.offset(self._handler.offset - 1)  # type: ignore
             self._receiver = self._conn.create_receiver(
-                self._addr,
+                addr,
                 options=ReceiverOptionUnsettledWithFilters(
-                    self._addr, self._stream_options
+                    addr, self._consumer_options
                 ),
                 handler=self._handler,
             )
@@ -142,29 +150,54 @@ class Consumer:
             self._receiver.container.stop_events()
             self._receiver.container.stop()
 
-    def _create_receiver(self, addr: str) -> BlockingReceiver:
-        logger.debug("Creating the receiver")
-        if self._stream_options is None:
-            receiver = self._conn.create_receiver(
-                addr, options=ReceiverOptionUnsettled(addr), handler=self._handler
-            )
+    def _create_receiver(self, addr: Optional[str] = None) -> BlockingReceiver:
+        credit = 10
+        if self._credit is not None:
+            credit = self._credit
 
+        if self._consumer_options is not None:
+            logger.debug(
+                "Creating the receiver, with options: %s",
+                type(self._consumer_options).__name__,
+            )
         else:
-            receiver = self._conn.create_receiver(
+            logger.debug("Creating the receiver, without options")
+
+        if self._consumer_options is None:
+            return self._conn.create_receiver(
                 addr,
-                options=ReceiverOptionUnsettledWithFilters(addr, self._stream_options),
+                options=ReceiverOptionUnsettled(addr),
                 handler=self._handler,
+                credit=credit,
             )
 
-        if self._credit is not None:
-            receiver.credit = self._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
 
-        return receiver
+        if isinstance(self._consumer_options, StreamConsumerOptions):
+            return self._conn.create_receiver(
+                addr,
+                options=ReceiverOptionUnsettledWithFilters(
+                    addr, self._consumer_options
+                ),
+                handler=self._handler,
+            )
+
+        raise Exception(
+            "Receiver is not initialized. No valid consumer options provided."
+        )
 
     @property
-    def address(self) -> str:
-        """Get the current publisher address."""
-        return self._addr
+    def address(self) -> Optional[str]:
+        if self._receiver is not None:
+            return cast(Optional[str], self._receiver.link.remote_source.address)
+        else:
+            raise Exception("Receiver is not initialized")
 
     @property
     def handler(self) -> Optional[AMQPMessagingHandler]:

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/rabbitmq_amqp_python_client/entities.py

@@ -5,7 +5,7 @@ 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 +109,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
@@ -160,6 +162,9 @@ class ConsumerOptions:
     def filter_set(self) -> Dict[symbol, Described]:
         raise NotImplementedError("Subclasses should implement this method")
 
+    def direct_reply_to(self) -> bool:
+        return False
+
 
 @dataclass
 class MessageProperties:
@@ -240,7 +245,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,
     ):
 
@@ -272,7 +279,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.
 
@@ -284,11 +293,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.
@@ -400,6 +418,21 @@ class StreamConsumerOptions(ConsumerOptions):
             )
 
 
+class DirectReplyToConsumerOptions(ConsumerOptions):
+
+    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"
+            )
+
+    def filter_set(self) -> Dict[symbol, Described]:
+        return {}
+
+    def direct_reply_to(self) -> bool:
+        return True
+
+
 @dataclass
 class RecoveryConfiguration:
     """

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/rabbitmq_amqp_python_client/options.py

@@ -1,9 +1,15 @@
+from typing import Optional
+
 from .entities import ConsumerOptions
 from .qpid.proton._data import (  # noqa: E402
+    Data,
     PropertyDict,
     symbol,
 )
-from .qpid.proton._endpoints import Link  # noqa: E402
+from .qpid.proton._endpoints import (  # noqa: E402
+    Link,
+    Terminus,
+)
 from .qpid.proton.reactor import (  # noqa: E402
     Filter,
     LinkOption,
@@ -52,8 +58,23 @@ class ReceiverOption(LinkOption):  # type: ignore
         link.source.dynamic = False
 
 
+class DynamicReceiverOption(LinkOption):  # type: ignore
+
+    def apply(self, link: Link) -> None:
+        link.snd_settle_mode = Link.SND_SETTLED
+        # link.rcv_settle_mode = Link.RCV_FIRST
+        link.source.expiry_policy = Terminus.EXPIRE_WITH_LINK
+        link.properties = PropertyDict({symbol("paired"): True})
+        link.source.dynamic = True
+        data = link.source.capabilities
+        data.put_array(False, Data.SYMBOL)
+        data.enter()
+        data.put_string("rabbitmq:volatile-queue")
+        data.exit()
+
+
 class ReceiverOptionUnsettled(LinkOption):  # type: ignore
-    def __init__(self, addr: str):
+    def __init__(self, addr: Optional[str]):
         self._addr = addr
 
     def apply(self, link: Link) -> None:
@@ -68,7 +89,7 @@ class ReceiverOptionUnsettled(LinkOption):  # type: ignore
 
 
 class ReceiverOptionUnsettledWithFilters(Filter):  # type: ignore
-    def __init__(self, addr: str, consumer_options: ConsumerOptions):
+    def __init__(self, addr: Optional[str], consumer_options: ConsumerOptions):
         super().__init__(consumer_options.filter_set())
         self._addr = addr
 

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/rabbitmq_amqp_python_client/publisher.py

@@ -94,7 +94,7 @@ class Publisher:
                 return self._sender.send(message)
         else:
             if message.address != "":
-                if validate_address(message.address) is False:
+                if not validate_address(message.address):
                     raise ArgumentOutOfRangeException(
                         "destination address must start with /queues or /exchanges"
                     )

{rabbitmq_amqp_python_client-0.3.0 → rabbitmq_amqp_python_client-0.4.1}/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.3.0 → rabbitmq_amqp_python_client-0.4.1}/rabbitmq_amqp_python_client/qpid/proton/_utils.py

@@ -44,6 +44,7 @@ from ._handlers import (
 )
 from ._reactor import Container
 from ._url import Url
+from ...options import DynamicReceiverOption
 
 try:
     from typing import Literal
@@ -505,6 +506,17 @@ class BlockingConnection(Handler):
             ),
         )
 
+    def create_dynamic_receiver(
+        self, credit: Optional[int] = None, handler: Optional[Handler] = None
+    ):
+        return self.create_receiver(
+            credit=credit,
+            dynamic=True,
+            options=DynamicReceiverOption(),
+            handler=handler,
+            name="dynamic-receiver_" + str(id(self)),
+        )
+
     def create_receiver(
         self,
         address: Optional[str] = None,
@@ -514,6 +526,8 @@ class BlockingConnection(Handler):
         name: Optional[str] = None,
         options: Optional[
             Union[
+                "DynamicReceiverOption",
+                List["DynamicReceiverOption"],
                 "ReceiverOption",
                 List["ReceiverOption"],
                 "LinkOption",