rabbitmq-amqp-python-client 0.6.0__tar.gz → 0.7.0__tar.gz

{rabbitmq_amqp_python_client-0.6.0 → rabbitmq_amqp_python_client-0.7.0}/PKG-INFO

@@ -1,22 +1,21 @@
 Metadata-Version: 2.4
 Name: rabbitmq-amqp-python-client
-Version: 0.6.0
+Version: 0.7.0
 Summary: Python RabbitMQ client for AMQP 1.0 protocol
 License: Apache-2.0 license
 License-File: LICENSE
 Author: RabbitMQ team
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: packaging (>=24.0,<25.0)
+Requires-Dist: packaging (>=26.0,<27.0)
 Requires-Dist: python-qpid-proton (>=0.40.0,<0.41.0)
-Requires-Dist: typing-extensions (>=4.13.0,<5.0.0)
+Requires-Dist: typing-extensions (>=4.15.0,<5.0.0)
 Description-Content-Type: text/markdown
 
 ## RabbitMQ AMQP 1.0 Python Client
@@ -72,7 +71,7 @@ export LDFLAGS="-L/usr/lib/x86_64-linux-gnu"
 pip install "python-qpid-proton>=0.39.0,<0.40.0" --no-binary python-qpid-proton --verbose --no-cache-dir
 ```
 
-### Async Interface (Experimental)
+### Async Interface
 
 The client provides an async interface via the `rabbitmq_amqp_python_client.asyncio` module. The async classes act as facades that:
 
@@ -101,4 +100,10 @@ Additional async examples are available in the [examples](./examples) folder:
 - TLS: [examples/tls/tls_example_async.py](./examples/tls/tls_example_async.py)
 
 
+### Thread Safety
+
+The TCP connection is not thread safe. 
+If you want to use the client in a multithreaded environment, you should create a connection per thread. 
+
+
 

{rabbitmq_amqp_python_client-0.6.0 → rabbitmq_amqp_python_client-0.7.0}/README.md

@@ -51,7 +51,7 @@ export LDFLAGS="-L/usr/lib/x86_64-linux-gnu"
 pip install "python-qpid-proton>=0.39.0,<0.40.0" --no-binary python-qpid-proton --verbose --no-cache-dir
 ```
 
-### Async Interface (Experimental)
+### Async Interface
 
 The client provides an async interface via the `rabbitmq_amqp_python_client.asyncio` module. The async classes act as facades that:
 
@@ -80,3 +80,9 @@ Additional async examples are available in the [examples](./examples) folder:
 - TLS: [examples/tls/tls_example_async.py](./examples/tls/tls_example_async.py)
 
 
+### Thread Safety
+
+The TCP connection is not thread safe. 
+If you want to use the client in a multithreaded environment, you should create a connection per thread. 
+
+

{rabbitmq_amqp_python_client-0.6.0 → rabbitmq_amqp_python_client-0.7.0}/pyproject.toml

@@ -1,33 +1,37 @@
 [tool.poetry]
 name = "rabbitmq-amqp-python-client"
-version = "0.6.0"
+version = "0.7.0"
 description = "Python RabbitMQ client for AMQP 1.0 protocol"
 authors = ["RabbitMQ team"]
 license = "Apache-2.0 license"
 readme = "README.md"
 
 [tool.poetry.dependencies]
-python = "^3.9"
+python = "^3.10"
 python-qpid-proton = "^0.40.0"
-typing-extensions = "^4.13.0"
-packaging = "^24.0"
+typing-extensions = "^4.15.0"
+packaging = "^26.0"
 
 
 [tool.poetry.group.dev.dependencies]
-pyjwt = "^2.10.1"
-pika = "^1.3.2"
-flake8 = "^7.1.1"
-isort = "^5.9.3"
-mypy = "^0.910"
-pytest = "^8.3.4"
-black = "^24.3.0"
-python-qpid-proton = "^0.40.0"
-requests = "^2.31.0"
-pytest-asyncio = "^1.2.0"
+pyjwt = "^2.12.1"
+pika = "^1.4.0"
+flake8 = "^7.3.0"
+isort = "^8.0.1"
+mypy = "^1.20.1"
+pytest = "^9.0.3"
+black = "^26.3.1"
+requests = "^2.33.1"
+pytest-asyncio = "^1.3.0"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
+[tool.black]
+extend-exclude = "rabbitmq_amqp_python_client/qpid"
+
 [tool.pytest.ini_options]
-asyncio_mode = "auto"
+asyncio_mode = "auto"
+addopts = "-v"
+console_output_style = "count"

{rabbitmq_amqp_python_client-0.6.0 → rabbitmq_amqp_python_client-0.7.0}/rabbitmq_amqp_python_client/__init__.py

@@ -1,4 +1,5 @@
 from importlib import metadata
+from typing import Optional
 
 from .address_helper import AddressHelper
 from .amqp_consumer_handler import AMQPMessagingHandler
@@ -23,12 +24,14 @@ from .entities import (
     MessageProperties,
     OAuth2Options,
     OffsetSpecification,
+    QuorumConsumerOptions,
     RecoveryConfiguration,
     StreamConsumerOptions,
     StreamFilterOptions,
 )
 from .environment import Environment
 from .exceptions import (
+    AmqpMessageRejectedException,
     ArgumentOutOfRangeException,
     InvalidOperationException,
     ValidationCodeException,
@@ -57,6 +60,7 @@ from .ssl_configuration import (
 )
 from .utils import Converter
 
+__license__: Optional[str]
 try:
     __version__ = metadata.version(__package__)
     __license__ = metadata.metadata(__package__)["license"]
@@ -91,6 +95,7 @@ __all__ = [
     "AMQPMessagingHandler",
     "ArgumentOutOfRangeException",
     "ValidationCodeException",
+    "AmqpMessageRejectedException",
     "PosixSslConfigurationContext",
     "WinSslConfigurationContext",
     "PosixClientCert",
@@ -103,6 +108,7 @@ __all__ = [
     "StreamFilterOptions",
     "AbcConsumerOptions",
     "ConsumerOptions",
+    "QuorumConsumerOptions",
     "MessageProperties",
     "OffsetSpecification",
     "OutcomeState",

rabbitmq_amqp_python_client-0.7.0/rabbitmq_amqp_python_client/amqp_consumer_handler.py

@@ -0,0 +1,94 @@
+from typing import Union
+
+from .delivery_context import (
+    AbcDeliveryContext,
+    DeliveryContext,
+)
+from .qpid.proton._endpoints import Link
+from .qpid.proton._events import Event
+from .qpid.proton._handler import Handler
+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 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.
+"""
+
+
+class _DeferredFlowController(Handler):
+    """
+    A flow controller that intentionally omits on_link_local_open.
+
+    The standard FlowController grants receiver credit in both on_link_local_open
+    and on_link_remote_open. Granting credit during on_link_local_open causes the
+    server to start delivering messages while BlockingLink.__init__() is still
+    running its wait() loop (i.e. before consumer.run() is ever called), because:
+
+      1. The FLOW frame carrying that credit is flushed to the server in the same
+         selector.select() call that performs the ATTACH handshake.
+      2. The server immediately sends stream messages back.
+      3. Those messages arrive in the same t.push() read as the ATTACH response
+         and are dispatched in the same process() iteration — inside wait() —
+         so on_amqp_message fires before consumer.run() returns.
+
+    By omitting on_link_local_open the FLOW frame is only queued (in
+    on_link_remote_open) after the remote ATTACH is received, at which point the
+    wait() loop has already exited. The queued FLOW is sent only when
+    consumer.run() drives the first process() cycle, ensuring messages start
+    arriving only after run() is called.
+
+    Credit replenishment (on_link_flow / on_delivery) works exactly as before.
+    """
+
+    def __init__(self, window: int = 10) -> None:
+        self._window = window
+        self._drained = 0
+
+    def on_link_remote_open(self, event: Event) -> None:
+        self._flow(event.link)
+
+    def on_link_flow(self, event: Event) -> None:
+        self._flow(event.link)
+
+    def on_delivery(self, event: Event) -> None:
+        self._flow(event.link)
+
+    def _flow(self, link: Union["Link", object]) -> None:
+        if link.is_receiver:  # type: ignore[union-attr]
+            self._drained += link.drained()  # type: ignore[union-attr]
+            if self._drained == 0:
+                delta = self._window - link.credit  # type: ignore[union-attr]
+                link.flow(delta)  # type: ignore[union-attr]
+
+
+class AMQPMessagingHandler(MessagingHandler):
+
+    def __init__(self, auto_accept: bool = False, auto_settle: bool = True):
+        """
+        :param auto_accept: if True, the message is automatically accepted
+        by default is false, so the user has to manually accept the message and decide with the
+        different methods of the delivery_context what to do with the message
+        """
+        # prefetch=0 disables the built-in FlowController so it cannot grant
+        # credit during link setup (which would make messages arrive before
+        # consumer.run() is called).  _DeferredFlowController is added instead;
+        # it behaves identically except it does not implement on_link_local_open.
+        super().__init__(prefetch=0, auto_accept=auto_accept, auto_settle=auto_settle)
+        self.handlers.append(_DeferredFlowController())
+        self.delivery_context: AbcDeliveryContext = DeliveryContext()
+        self._offset = 0
+
+    def on_amqp_message(self, event: Event) -> None:
+        pass
+
+    def on_message(self, event: Event) -> None:
+        if "x-stream-offset" in event.message.annotations:
+            self._offset = int(event.message.annotations["x-stream-offset"])
+        self.on_amqp_message(event)
+
+    @property
+    def offset(self) -> int:
+        return self._offset

{rabbitmq_amqp_python_client-0.6.0 → rabbitmq_amqp_python_client-0.7.0}/rabbitmq_amqp_python_client/asyncio/connection.py

@@ -5,6 +5,7 @@ import logging
 from typing import Callable, Optional, Union
 
 from ..address_helper import validate_address
+from ..amqp_consumer_handler import AMQPMessagingHandler
 from ..connection import Connection
 from ..consumer import Consumer
 from ..entities import (
@@ -15,7 +16,6 @@ from ..entities import (
 from ..exceptions import ArgumentOutOfRangeException
 from ..management import Management
 from ..publisher import Publisher
-from ..qpid.proton._handlers import MessagingHandler
 from ..ssl_configuration import (
     PosixSslConfigurationContext,
     WinSslConfigurationContext,
@@ -226,8 +226,8 @@ class AsyncConnection:
 
     async def consumer(
         self,
-        destination: str,
-        message_handler: Optional[MessagingHandler] = None,
+        destination: Optional[str] = None,
+        message_handler: Optional[AMQPMessagingHandler] = None,
         consumer_options: Optional[AbcConsumerOptions] = None,
         credit: Optional[int] = None,
     ) -> AsyncConsumer:
@@ -235,7 +235,8 @@ class AsyncConnection:
         Create a new consumer instance.
 
         Args:
-            destination: The address to consume from
+            destination: The address to consume from. Use ``None`` only with
+                options such as Direct Reply-To where the broker supplies the address.
             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
@@ -247,7 +248,7 @@ class AsyncConnection:
             RuntimeError: If consumer creation fails
             ArgumentOutOfRangeException: If destination address format is invalid
         """
-        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"
             )
@@ -264,7 +265,7 @@ class AsyncConnection:
             async_consumer = AsyncConsumer(
                 self._connection._conn,
                 destination,
-                message_handler,  # pyright: ignore[reportArgumentType]
+                message_handler,
                 consumer_options,
                 credit,
                 connection_lock=self._connection_lock,

{rabbitmq_amqp_python_client-0.6.0 → rabbitmq_amqp_python_client-0.7.0}/rabbitmq_amqp_python_client/asyncio/consumer.py

@@ -3,22 +3,13 @@ from __future__ import annotations
 import asyncio
 import logging
 import threading
-import warnings
 from types import TracebackType
-from typing import (
-    Any,
-    Callable,
-    Literal,
-    Optional,
-    Type,
-    Union,
-)
+from typing import Any, Callable, Optional, Type
 
 from ..amqp_consumer_handler import AMQPMessagingHandler
 from ..consumer import Consumer
 from ..entities import AbcConsumerOptions
 from ..qpid.proton._exceptions import Timeout
-from ..qpid.proton._message import Message
 from ..qpid.proton.utils import BlockingConnection
 
 logger = logging.getLogger(__name__)
@@ -38,7 +29,7 @@ class AsyncConsumer:
     Attributes:
         _consumer (Optional[Consumer]): The underlying synchronous Consumer
         _conn (BlockingConnection): The shared blocking connection
-        _addr (str): The address to consume from
+        _addr (Optional[str]): The address to consume from
         _handler (Optional[AMQPMessagingHandler]): Optional message handling callback
         _stream_options (Optional[AbcConsumerOptions]): Configuration for stream consumption
         _credit (Optional[int]): Flow control credit value
@@ -55,7 +46,7 @@ class AsyncConsumer:
     def __init__(
         self,
         conn: BlockingConnection,
-        addr: str,
+        addr: Optional[str] = None,
         handler: Optional[AMQPMessagingHandler] = None,
         stream_options: Optional[AbcConsumerOptions] = None,
         credit: Optional[int] = None,
@@ -68,7 +59,7 @@ class AsyncConsumer:
 
         Args:
             conn (BlockingConnection): The blocking connection to use
-            addr (str): The address to consume from
+            addr (Optional[str]): The address to consume from; ``None`` for Direct Reply-To
             handler (Optional[AMQPMessagingHandler]): Optional message handler for processing received messages
             stream_options (Optional[AbcConsumerOptions]): Optional configuration for stream-based consumption
             credit (Optional[int]): Optional credit value for flow control
@@ -119,46 +110,6 @@ class AsyncConsumer:
         self._stop_event.clear()
         logger.debug(f"AsyncConsumer opened for address: {self._addr}")
 
-    async def consume(
-        self, timeout: Union[None, Literal[False], float] = False
-    ) -> Message:
-        """
-        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
-                    float: Wait for specified number of seconds
-
-        Returns:
-            Message: The received message
-
-        Raises:
-            RuntimeError: If consumer is not opened
-
-        Note:
-            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."
-            )
-
-        async with self._connection_lock:
-            return await asyncio.to_thread(self._consumer.consume, timeout)
-
     async def close(self) -> None:
         """
         Close the consumer connection.
@@ -336,8 +287,10 @@ class AsyncConsumer:
         await self.close()
 
     @property
-    def address(self) -> str:
-        """Get the current consumer address."""
+    def address(self) -> Optional[str]:
+        """Get the current consumer address (from the link when the receiver is open)."""
+        if self._opened and self._consumer is not None:
+            return self._consumer.address
         return self._addr
 
     @property

{rabbitmq_amqp_python_client-0.6.0 → rabbitmq_amqp_python_client-0.7.0}/rabbitmq_amqp_python_client/connection.py

@@ -4,16 +4,20 @@ import time
 from datetime import timedelta
 from typing import (
     Annotated,
+    Any,
     Callable,
+    Mapping,
     Optional,
     TypeVar,
     Union,
+    cast,
 )
 
 import typing_extensions
 from packaging import version
 
 from .address_helper import validate_address
+from .amqp_consumer_handler import AMQPMessagingHandler
 from .consumer import Consumer
 from .entities import (
     AbcConsumerOptions,
@@ -27,7 +31,6 @@ from .exceptions import (
 from .management import Management
 from .publisher import Publisher
 from .qpid.proton._exceptions import ConnectionException
-from .qpid.proton._handlers import MessagingHandler
 from .qpid.proton._transport import SSLDomain
 from .qpid.proton.utils import BlockingConnection
 from .ssl_configuration import (
@@ -94,7 +97,7 @@ class Connection:
         ] = ssl_context
         self._managements: list[Management] = []
         self._recovery_configuration: RecoveryConfiguration = recovery_configuration
-        self._ssl_domain = None
+        self._ssl_domain: Optional[SSLDomain] = None
         self._connections = []  # type: ignore
         self._index: int = -1
         self._publishers: list[Publisher] = []
@@ -185,8 +188,9 @@ class Connection:
         if remote_props is None:
             raise ValidationCodeException("No remote properties received from server")
 
+        props = cast(Mapping[str, Any], remote_props)
         # Check if server is RabbitMQ
-        product = remote_props.get("product")
+        product = props.get("product")
         if product != "RabbitMQ":
             raise ValidationCodeException(
                 f"Connection to non-RabbitMQ server detected. "
@@ -194,7 +198,7 @@ class Connection:
             )
 
         # Check server version is >= 4.0.0
-        server_version = remote_props.get("version")
+        server_version = props.get("version")
         if server_version is None:
             raise ValidationCodeException("Server version not provided")
 
@@ -232,7 +236,8 @@ class Connection:
         if remote_props is None:
             raise ValidationCodeException("No remote properties received from server")
 
-        server_version = remote_props.get("version")
+        props = cast(Mapping[str, Any], remote_props)
+        server_version = props.get("version")
         if server_version is None:
             raise ValidationCodeException("Server version not provided")
 
@@ -298,7 +303,7 @@ class Connection:
 
                 self._ssl_domain.set_credentials(
                     client_cert,
-                    client_key,
+                    client_key or "",
                     password,
                 )
 
@@ -380,7 +385,7 @@ class Connection:
     def consumer(
         self,
         destination: Optional[str] = None,
-        message_handler: Optional[MessagingHandler] = None,
+        message_handler: Optional[AMQPMessagingHandler] = None,
         consumer_options: Optional[AbcConsumerOptions] = None,
         credit: Optional[int] = None,
     ) -> Consumer:
@@ -411,6 +416,7 @@ class Connection:
                     "4.0.0": self._is_server_version_gte("4.0.0"),
                     "4.1.0": self._is_server_version_gte("4.1.0"),
                     "4.2.0": self._is_server_version_gte("4.2.0"),
+                    "4.3.0": self._is_server_version_gte("4.3.0"),
                 }
             )
         consumer = Consumer(
@@ -419,7 +425,7 @@ class Connection:
         self._consumers.append(consumer)
         return consumer
 
-    def _on_disconnection(self) -> None:
+    def _on_disconnection(self, *_args: Any) -> None:
 
         logger.debug("_on_disconnection: disconnection detected")
         if self in self._connections:

{rabbitmq_amqp_python_client-0.6.0 → rabbitmq_amqp_python_client-0.7.0}/rabbitmq_amqp_python_client/consumer.py

@@ -1,11 +1,11 @@
 import logging
-import warnings
-from typing import Literal, Optional, Union, cast
+from typing import Optional
 
 from .amqp_consumer_handler import AMQPMessagingHandler
 from .entities import (
     AbcConsumerOptions,
     ConsumerOptions,
+    QuorumConsumerOptions,
     StreamConsumerOptions,
 )
 from .options import (
@@ -14,7 +14,7 @@ from .options import (
     ReceiverOptionUnsettled,
     ReceiverOptionUnsettledWithFilters,
 )
-from .qpid.proton._message import Message
+from .qpid.proton._flow_properties import SAC_CALLBACK_KEY
 from .qpid.proton.utils import (
     BlockingConnection,
     BlockingReceiver,
@@ -70,6 +70,7 @@ class Consumer:
     def _open(self) -> None:
         if self._receiver is None:
             logger.debug("Creating Receiver")
+            self._register_sac_callback()
             self._receiver = self._create_receiver(self._addr)
 
     def _update_connection(self, conn: BlockingConnection) -> None:
@@ -101,7 +102,10 @@ class Consumer:
                 ),
                 handler=self._handler,
             )
-        elif isinstance(self._consumer_options, ConsumerOptions):
+        elif isinstance(
+            self._consumer_options, (QuorumConsumerOptions, ConsumerOptions)
+        ):
+            self._register_sac_callback()
             self._receiver = self._create_receiver_from_cq_consumer_options(
                 addr, credit
             )
@@ -109,39 +113,6 @@ class Consumer:
     def _set_consumers_list(self, consumers: []) -> None:  # type: ignore
         self._consumers = consumers
 
-    def consume(self, timeout: Union[None, Literal[False], float] = False) -> Message:
-        """
-        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
-                    float: Wait for specified number of seconds
-
-        Returns:
-            Message: The received message
-
-        Note:
-            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_original = self._receiver.receive(timeout=timeout)
-            message = cast(Message, message_original)
-            return message
-        raise Exception("Receiver is not initialized")
-
     def close(self) -> None:
         """
         Close the consumer connection.
@@ -149,11 +120,43 @@ class Consumer:
         Closes the receiver if it exists and cleans up resources.
         """
         logger.debug("Closing the receiver")
+        self._unregister_sac_callback()
         if self._receiver is not None:
-            self._receiver.close()
+            self._receiver.close()  # type: ignore[no-untyped-call]
             if self in self._consumers:
                 self._consumers.remove(self)
 
+    def _register_sac_callback(self) -> None:
+        """Register the SAC callback on the transport for QuorumConsumerOptions."""
+        if not isinstance(self._consumer_options, QuorumConsumerOptions):
+            return
+        cb = self._consumer_options.sac_state_handler
+        if cb is None:
+            return
+        try:
+            conn = self._conn.conn
+            if conn is None:
+                return
+            transport = conn.transport
+            if transport is not None:
+                setattr(transport, SAC_CALLBACK_KEY, cb)
+                logger.debug("Registered SAC callback on transport")
+        except Exception as exc:
+            logger.debug("Could not register SAC callback: %s", exc)
+
+    def _unregister_sac_callback(self) -> None:
+        """Remove the SAC callback from the transport, if one was registered."""
+        try:
+            conn = self._conn.conn
+            if conn is None:
+                return
+            transport = conn.transport
+            if transport is not None and hasattr(transport, SAC_CALLBACK_KEY):
+                delattr(transport, SAC_CALLBACK_KEY)
+                logger.debug("Unregistered SAC callback from transport")
+        except Exception as exc:
+            logger.debug("Could not unregister SAC callback: %s", exc)
+
     def run(self) -> None:
         """
         Run the consumer in continuous mode.
@@ -208,6 +211,9 @@ class Consumer:
                 handler=self._handler,
             )
 
+        if isinstance(self._consumer_options, QuorumConsumerOptions):
+            return self._create_receiver_from_cq_consumer_options(addr, credit)
+
         if isinstance(self._consumer_options, ConsumerOptions):
             return self._create_receiver_from_cq_consumer_options(addr, credit)
 
@@ -253,7 +259,7 @@ class Consumer:
     @property
     def address(self) -> Optional[str]:
         if self._receiver is not None:
-            return cast(Optional[str], self._receiver.link.remote_source.address)
+            return self._receiver.link.remote_source.address
         else:
             raise Exception("Receiver is not initialized")