amqp-client-python 0.2.0.post1__tar.gz → 0.2.1__tar.gz

amqp_client_python-0.2.1/.github/workflows/publish.yml

@@ -0,0 +1,22 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Build and publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          uv build
+          uv publish

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: amqp-client-python
-Version: 0.2.0.post1
+Version: 0.2.1
 Summary: Python AMQP Client Library
 Project-URL: Homepage, https://github.com/nutes-uepb/amqp-client-python
 Project-URL: Repository, https://github.com/nutes-uepb/amqp-client-python
@@ -17,7 +17,6 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -81,19 +80,22 @@ pip install amqp-rs
 ### Table of Compatibility
 | version  | compatible with |
 | ---- | ---- |
+| 0.2.1 | ~0.2.0 |
 | 0.2.0 | 0.2.0 |
 | 0.1.14 | ~0.1.12 |
 
 ### Installation
 
-You can install `amqp-client-python` using pip:
+You can install `amqp-client-python` using uv or pip:
 ```bash
+uv add amqp-client-python
+# or
 pip install amqp-client-python
 ```
 
 ### Prerequisites
 
-*   Python 3.7+
+*   Python 3.9+
 *   A running RabbitMQ instance.
 
 ### Examples:
@@ -110,15 +112,18 @@ from amqp_client_python import (
 )
 config = Config(Options("queue", "rpc_queue", "rpc_exchange"))
 eventbus = AsyncEventbusRabbitMQ(config)
-# publish
+# publish (supports dict/str with auto-JSON, or raw bytes/bytearray without overhead)
+await eventbus.publish("rpc_exchange", "routing.key", {"message": "content"})
+await eventbus.publish("rpc_exchange", "routing.key", b"raw_binary_payload")
 
-eventbus.publish("rpc_exchange", "routing.key", "message_content")
-# subscribe
+# subscribe (auto_decode=True delivers parsed JSON dict; auto_decode=False delivers raw bytes)
 async def subscribe_handler(body) -> None:
     print(body, type(body), flush=True) # handle messages
 await eventbus.subscribe("rpc_exchange", "routing.key", subscribe_handler)
+
 # rpc_publish
-response = await eventbus.rpc_client("rpc_exchange", "user.find", "message_content")
+response = await eventbus.rpc_client("rpc_exchange", "user.find", {"name": "alice"})
+
 # provider
 async def rpc_provider_handler(body) -> bytes:
     print(f"body: {body}")

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/README.md

@@ -46,19 +46,22 @@ pip install amqp-rs
 ### Table of Compatibility
 | version  | compatible with |
 | ---- | ---- |
+| 0.2.1 | ~0.2.0 |
 | 0.2.0 | 0.2.0 |
 | 0.1.14 | ~0.1.12 |
 
 ### Installation
 
-You can install `amqp-client-python` using pip:
+You can install `amqp-client-python` using uv or pip:
 ```bash
+uv add amqp-client-python
+# or
 pip install amqp-client-python
 ```
 
 ### Prerequisites
 
-*   Python 3.7+
+*   Python 3.9+
 *   A running RabbitMQ instance.
 
 ### Examples:
@@ -75,15 +78,18 @@ from amqp_client_python import (
 )
 config = Config(Options("queue", "rpc_queue", "rpc_exchange"))
 eventbus = AsyncEventbusRabbitMQ(config)
-# publish
+# publish (supports dict/str with auto-JSON, or raw bytes/bytearray without overhead)
+await eventbus.publish("rpc_exchange", "routing.key", {"message": "content"})
+await eventbus.publish("rpc_exchange", "routing.key", b"raw_binary_payload")
 
-eventbus.publish("rpc_exchange", "routing.key", "message_content")
-# subscribe
+# subscribe (auto_decode=True delivers parsed JSON dict; auto_decode=False delivers raw bytes)
 async def subscribe_handler(body) -> None:
     print(body, type(body), flush=True) # handle messages
 await eventbus.subscribe("rpc_exchange", "routing.key", subscribe_handler)
+
 # rpc_publish
-response = await eventbus.rpc_client("rpc_exchange", "user.find", "message_content")
+response = await eventbus.rpc_client("rpc_exchange", "user.find", {"name": "alice"})
+
 # provider
 async def rpc_provider_handler(body) -> bytes:
     print(f"body: {body}")

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/__init__.py

@@ -2,3 +2,14 @@ from .rabbitmq import EventbusRabbitMQ, AsyncEventbusRabbitMQ, EventbusWrapperRa
 from .domain.models import Config, Options, SSLOptions
 from .domain.utils import ConnectionType
 from pika import DeliveryMode
+
+__all__ = [
+    "EventbusRabbitMQ",
+    "AsyncEventbusRabbitMQ",
+    "EventbusWrapperRabbitMQ",
+    "Config",
+    "Options",
+    "SSLOptions",
+    "ConnectionType",
+    "DeliveryMode",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/domain/models/__init__.py

@@ -1,3 +1,9 @@
 from .config import Config
 from .options import Options
 from .ssl_options import SSLOptions
+
+__all__ = [
+    "Config",
+    "Options",
+    "SSLOptions",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/domain/utils/__init__.py

@@ -1,2 +1,7 @@
 from .connection_type import ConnectionType
 from .types import HandlerType
+
+__all__ = [
+    "ConnectionType",
+    "HandlerType",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/event/__init__.py

@@ -4,3 +4,12 @@ from .async_provider_handler import AsyncProviderHandler
 from .async_subscriber_handler import AsyncSubscriberHandler
 from .provider_handler import ProviderHandler
 from .subscriber_handler import SubscriberHandler
+
+__all__ = [
+    "IntegrationEvent",
+    "IntegrationEventHandler",
+    "AsyncProviderHandler",
+    "AsyncSubscriberHandler",
+    "ProviderHandler",
+    "SubscriberHandler",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/exceptions/__init__.py

@@ -7,3 +7,15 @@ from .publish_timeout_exception import PublishTimeoutException
 from .auto_reconnect_exception import AutoReconnectException
 from .blocking_exception import BlockingException
 from .thread_unsafe_exception import ThreadUnsafeException
+
+__all__ = [
+    "EventBusException",
+    "NackException",
+    "RpcProviderException",
+    "TimeoutException",
+    "ResponseTimeoutException",
+    "PublishTimeoutException",
+    "AutoReconnectException",
+    "BlockingException",
+    "ThreadUnsafeException",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/rabbitmq/__init__.py

@@ -1,6 +1,6 @@
 from .async_eventbus_rabbitmq import AsyncEventbusRabbitMQ
 from .async_connection_factory import AsyncConnectionFactoryRabbitMQ
-from .async_connection import AsyncConnection, ConnectionType
+from .async_connection import AsyncConnection
 from .async_channel_factory import AsyncChannelFactoryRabbitMQ
 from .async_channel import AsyncChannel
 from .eventbus_rabbitmq import EventbusRabbitMQ
@@ -9,3 +9,17 @@ from .connection_rabbitmq import ConnectionRabbitMQ
 from .channel_factory_rabbitmq import ChannelFactoryRabbitMQ
 from .channel_rabbitmq import ChannelRabbitMQ
 from .eventbus_wrapper_rabbitmq import EventbusWrapperRabbitMQ
+
+__all__ = [
+    "AsyncEventbusRabbitMQ",
+    "AsyncConnectionFactoryRabbitMQ",
+    "AsyncConnection",
+    "AsyncChannelFactoryRabbitMQ",
+    "AsyncChannel",
+    "EventbusRabbitMQ",
+    "ConnectionFactoryRabbitMQ",
+    "ConnectionRabbitMQ",
+    "ChannelFactoryRabbitMQ",
+    "ChannelRabbitMQ",
+    "EventbusWrapperRabbitMQ",
+]

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/rabbitmq/async_channel.py

@@ -1,3 +1,4 @@
+from collections import deque
 from typing import MutableMapping, Mapping, Optional, Union, Dict, List
 from .async_channel_factory import AsyncChannelFactoryRabbitMQ
 from amqp_client_python.exceptions import (
@@ -59,13 +60,19 @@ class AsyncChannel:
         self._deliveries: MutableMapping[int, Future] = {}
         self.response_timeout = 60
 
+    @staticmethod
+    def _serialize_payload(body, content_type: str = "application/json"):
+        if isinstance(body, (bytes, bytearray, memoryview)):
+            return body
+        return dumps(body)
+
     @property
     def is_open(self) -> Optional[bool]:
         return self._channel and self._channel.is_open
 
-    def open(self, connection: AsyncioConnection, callbacks=[]):
+    def open(self, connection: AsyncioConnection, callbacks=None):
         if not self.is_open:
-            self.callbacks = callbacks
+            self.callbacks = callbacks if callbacks is not None else deque()
             self._connection = connection
             self.ioloop = connection.ioloop
             self._channel = self.channel_factory.create_channel(
@@ -87,10 +94,15 @@ class AsyncChannel:
         self.ioloop.create_task(self.process_callbacks())  # type: ignore
 
     async def process_callbacks(self):
-        for callback, future in self.callbacks:
-            result = await callback()
-            if not future.done():
-                future.set_result(result)
+        while self.callbacks:
+            callback, future = self.callbacks.popleft()
+            try:
+                result = await callback()
+                if not future.done():
+                    future.set_result(result)
+            except Exception as exc:
+                if not future.done():
+                    future.set_exception(exc)
 
     def add_on_channel_close_callback(self):
         """This method tells pika to call the on_channel_closed method if
@@ -302,7 +314,7 @@ class AsyncChannel:
         if self.rpc_publisher_started:
             return True
         if self.rpc_publisher_starting:
-            return await self.rpc_consumer_future
+            return await self.rpc_publisher_future
         self.rpc_publisher_starting = True
         self.rpc_publisher_future = self.ioloop.create_future()
 
@@ -355,7 +367,7 @@ class AsyncChannel:
         self._channel.basic_publish(
             exchange_name,
             routing_key,
-            dumps(body),  # Serialize payload to JSON
+            self._serialize_payload(body, content_type),
             properties=BasicProperties(
                 reply_to=self._callback_queue,  # Response queue address
                 correlation_id=corr_id,  # Request/response matching ID
@@ -430,7 +442,7 @@ class AsyncChannel:
         self._channel.basic_publish(
             exchange_name,
             routing_key,
-            dumps(body),
+            self._serialize_payload(body, content_type),
             properties=BasicProperties(
                 reply_to=self._callback_queue,
                 content_type=content_type,
@@ -485,13 +497,14 @@ class AsyncChannel:
         exchange_type="topic",
         durable=True,
         auto_delete=False,
+        auto_decode=True,
     ):
         await self.start_rpc_publisher()
         self.register_queue(
             exchange_name, queue_name, exchange_type, durable, auto_delete
         )
         self.register_handler(
-            queue_name, routing_key, callback, content_type, timeout
+            queue_name, routing_key, callback, content_type, timeout, auto_decode=auto_decode
         )
 
         self.queue_bind(queue_name, exchange_name, routing_key)
@@ -526,13 +539,14 @@ class AsyncChannel:
             self.consumers[queue_name] = False
 
     def register_handler(
-        self, queue_name, routing_key, callback, content_type, response_timeout
+        self, queue_name, routing_key, callback, content_type, response_timeout, auto_decode=True
     ):
         if routing_key not in self.subscribes[queue_name]:
             self.subscribes[queue_name][routing_key] = {
                 "handle": callback,
                 "content_type": content_type,
                 "response_timeout": response_timeout or self.response_timeout,
+                "auto_decode": auto_decode,
             }
             if "*" in routing_key and routing_key not in self.re_subscribes:
                 self.re_subscribes.append(routing_key)
@@ -548,12 +562,13 @@ class AsyncChannel:
         exchange_type: str = "topic",
         durable: bool = True,
         auto_delete: bool = False,
+        auto_decode: bool = True,
     ) -> None:
         self.register_queue(
             exchange_name, queue_name, exchange_type, durable, auto_delete
         )
         self.register_handler(
-            queue_name, routing_key, callback, content_type, timeout
+            queue_name, routing_key, callback, content_type, timeout, auto_decode=auto_decode
         )
 
         self.queue_bind(queue_name, exchange_name, routing_key)
@@ -581,7 +596,11 @@ class AsyncChannel:
 
         async def process_message(handler: HandlerType):
             nonlocal body
-            body = loads(body)
+            if handler.get("auto_decode", True) and handler.get("content_type") == "application/json":
+                try:
+                    body = loads(body)
+                except Exception:
+                    pass
             response = await wait_for(
                 handler["handle"](body),
                 timeout=handler["response_timeout"],

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/rabbitmq/async_connection.py

@@ -1,4 +1,6 @@
-from typing import Optional, Callable, Awaitable, Tuple, Dict, List, Any
+from collections import deque
+from typing import Optional, Callable, Awaitable, Tuple, Dict, Any
+
 from .async_connection_factory import AsyncConnectionFactoryRabbitMQ, AsyncioConnection
 from .async_channel import AsyncChannel
 from ..exceptions import AutoReconnectException
@@ -60,7 +62,7 @@ class AsyncConnection:
         self.openning = False
         self.reconnecting = False
         self.reconnect_delay = 1
-        self.callbacks: List[Tuple[Callable, Future]] = []
+        self.callbacks: deque[Tuple[Callable, Future]] = deque()
         self.type = connection_type
         self.backup: Dict[str, Dict[str, Any]] = {
             "exchange": {},
@@ -87,6 +89,7 @@ class AsyncConnection:
             if not self.ioloop:
                 self.ioloop = get_event_loop()
             self.openning = True
+            self._closing = False
             self._connection = self.connection_factory.create_connection(
                 uri=uri,
                 on_connection_open=self.on_connection_open,
@@ -129,6 +132,37 @@ class AsyncConnection:
             signal=self.signal,
         )
         self._channel.publisher_confirms = self.publisher_confirms
+
+        if self.reconnecting or self.backup["subscribe"] or self.backup["rpc_subscribe"]:
+            async def recorvery():
+                for routing_key in list(self.backup["subscribe"].keys()):
+                    params = self.backup["subscribe"][routing_key]
+                    await self.subscribe(
+                        params["queue_name"],
+                        params["exchange_name"],
+                        routing_key,
+                        params["callback"],
+                        params["timeout"],
+                        content_type=params.get("content_type", "application/json"),
+                        auto_decode=params.get("auto_decode", True),
+                    )
+                for routing_key in list(self.backup["rpc_subscribe"].keys()):
+                    params = self.backup["rpc_subscribe"][routing_key]
+                    await self.rpc_subscribe(
+                        params["queue_name"],
+                        params["exchange_name"],
+                        routing_key,
+                        params["callback"],
+                        params["timeout"],
+                        content_type=params.get("content_type", "application/json"),
+                        auto_decode=params.get("auto_decode", True),
+                    )
+
+            future: Future = Future(loop=self.ioloop)
+            self.callbacks.append((recorvery, future))
+            self.reconnect_delay = 1
+            self.reconnecting = False
+
         self._channel.open(self._connection, self.callbacks)
 
     def on_connection_open_error(self, _unused_connection, err):
@@ -193,30 +227,34 @@ class AsyncConnection:
             )
             self.reconnect_delay += 1
         else:
-
-            async def recorvery():
-                for routing_key in self.backup["subscribe"]:
-                    params = self.backup["subscribe"][routing_key]
-                    await self.subscribe(
-                        params["queue_name"],
-                        params["exchange_name"],
-                        routing_key,
-                        params["callback"],
-                        params["timeout"],
-                    )
-                for routing_key in self.backup["rpc_subscribe"]:
-                    params = self.backup["rpc_subscribe"][routing_key]
-                    await self.rpc_subscribe(
-                        params["queue_name"],
-                        params["exchange_name"],
-                        routing_key,
-                        params["callback"],
-                        params["timeout"],
-                    )
-
-            self.ioloop.create_task(self.add_callback(recorvery))  # type: ignore
-            self.reconnect_delay = 1
-            self.reconnecting = False
+            if self.reconnecting:
+                async def recorvery():
+                    for routing_key in list(self.backup["subscribe"].keys()):
+                        params = self.backup["subscribe"][routing_key]
+                        await self.subscribe(
+                            params["queue_name"],
+                            params["exchange_name"],
+                            routing_key,
+                            params["callback"],
+                            params["timeout"],
+                            content_type=params.get("content_type", "application/json"),
+                            auto_decode=params.get("auto_decode", True),
+                        )
+                    for routing_key in list(self.backup["rpc_subscribe"].keys()):
+                        params = self.backup["rpc_subscribe"][routing_key]
+                        await self.rpc_subscribe(
+                            params["queue_name"],
+                            params["exchange_name"],
+                            routing_key,
+                            params["callback"],
+                            params["timeout"],
+                            content_type=params.get("content_type", "application/json"),
+                            auto_decode=params.get("auto_decode", True),
+                        )
+
+                self.reconnect_delay = 1
+                self.reconnecting = False
+                self.ioloop.create_task(self.add_callback(recorvery))  # type: ignore
 
     @property
     def is_open(self) -> Optional[bool]:
@@ -356,7 +394,14 @@ class AsyncConnection:
         )
 
     async def rpc_subscribe(
-        self, queue_name, exchange_name, routing_key, callback, timeout
+        self,
+        queue_name,
+        exchange_name,
+        routing_key,
+        callback,
+        timeout,
+        content_type="application/json",
+        auto_decode=True,
     ):
         """
         Registers an RPC handler for a specific routing key.
@@ -367,24 +412,16 @@ class AsyncConnection:
             routing_key: The routing key to subscribe to
             callback: The function to call when a message is received
             timeout: Timeout in seconds for processing the received message
-
-        Examples:
-            >>> async def handle_rpc(body):
-                    result = process_request(body)
-                    return json.dumps(result).encode()
-            >>> await connection.rpc_subscribe(
-                    "rpc_queue",
-                    "rpc_exchange",
-                    "user.find",
-                    handle_rpc,
-                    10.0
-                )
+            content_type: Content type of expected message
+            auto_decode: Whether to auto-decode JSON payload
         """
         self.backup["rpc_subscribe"][routing_key] = {
             "queue_name": queue_name,
             "exchange_name": exchange_name,
             "callback": callback,
             "timeout": timeout,
+            "content_type": content_type,
+            "auto_decode": auto_decode,
         }
         await self._channel.rpc_subscribe(
             queue_name=queue_name,
@@ -392,6 +429,8 @@ class AsyncConnection:
             routing_key=routing_key,
             callback=callback,
             timeout=timeout,
+            content_type=content_type,
+            auto_decode=auto_decode,
         )
 
     async def subscribe(
@@ -401,6 +440,8 @@ class AsyncConnection:
         routing_key: str,
         callback: Callable[[Any], Awaitable[None]],
         timeout: Optional[float],
+        content_type: str = "application/json",
+        auto_decode: bool = True,
     ):
         """
         Subscribes to messages with a specific routing key.
@@ -411,23 +452,16 @@ class AsyncConnection:
             routing_key: The routing key to subscribe to
             callback: The function to call when a message is received
             timeout: Timeout in seconds for processing the received message
-
-        Examples:
-            >>> async def handle_message(body):
-                    print(f"Received: {body}")
-            >>> await connection.subscribe(
-                    "notifications_queue",
-                    "notifications",
-                    "email.send",
-                    handle_message,
-                    5.0
-                )
+            content_type: Content type of expected message
+            auto_decode: Whether to auto-decode JSON payload
         """
         self.backup["subscribe"][routing_key] = {
             "queue_name": queue_name,
             "exchange_name": exchange_name,
             "callback": callback,
             "timeout": timeout,
+            "content_type": content_type,
+            "auto_decode": auto_decode,
         }
         await self._channel.subscribe(
             exchange_name=exchange_name,
@@ -435,6 +469,8 @@ class AsyncConnection:
             routing_key=routing_key,
             callback=callback,
             timeout=timeout,
+            content_type=content_type,
+            auto_decode=auto_decode,
         )
 
     async def add_callback(
@@ -464,7 +500,7 @@ class AsyncConnection:
             >>> result = await connection.add_callback(my_operation, 10.0)
         """
         try:
-            if self.is_open and self._channel.is_open:
+            if self.is_open and self._channel and self._channel.is_open:
                 return await callback()
             else:
                 future: Future = Future(loop=self.ioloop)

{amqp_client_python-0.2.0.post1 → amqp_client_python-0.2.1}/amqp_client_python/rabbitmq/async_eventbus_rabbitmq.py

@@ -212,6 +212,8 @@ class AsyncEventbusRabbitMQ:
         handler: Callable[[Any], Awaitable[Union[bytes, str]]],
         timeout: Optional[int] = None,
         connection_timeout: int = 16,
+        content_type: str = "application/json",
+        auto_decode: bool = True,
     ) -> None:
         """
         Register a provider to listen on RPC request queue
@@ -221,6 +223,8 @@ class AsyncEventbusRabbitMQ:
             handler: message handler, it will be called when a message is received
             timeout: timeout in seconds for waiting for process the received message
             connection_timeout: timeout for waiting for connection restabilishment
+            content_type: Content type of expected message
+            auto_decode: Whether to auto-decode JSON payload (default True)
 
         Raises:
             AutoReconnectException: when cannout reconnect on the gived timeout
@@ -233,12 +237,18 @@ class AsyncEventbusRabbitMQ:
         """
 
         async def add_resource():
+            extra_kwargs = {}
+            if content_type != "application/json":
+                extra_kwargs["content_type"] = content_type
+            if not auto_decode:
+                extra_kwargs["auto_decode"] = auto_decode
             await self._rpc_server_connection.rpc_subscribe(
                 self.config.options.rpc_queue_name,
                 self.config.options.rpc_exchange_name,
                 name,
                 handler,
                 timeout,
+                **extra_kwargs,
             )
 
         if self._rpc_server_connection.open(self.config.url):
@@ -252,6 +262,8 @@ class AsyncEventbusRabbitMQ:
         handler: Callable[[Any], Awaitable[None]],
         timeout: Optional[float] = None,
         connection_timeout: int = 16,
+        content_type: str = "application/json",
+        auto_decode: bool = True,
     ) -> None:
         """
         Register a provider to listen on queue of bus
@@ -262,6 +274,8 @@ class AsyncEventbusRabbitMQ:
             handler: message handler, it will be called when a message is received
             timeout: timeout in seconds for waiting for process the received message
             connection_timeout: timeout for waiting for connection restabilishment
+            content_type: Content type of expected message
+            auto_decode: Whether to auto-decode JSON payload (default True)
 
         Raises:
             AutoReconnectException: when cannout reconnect on the gived timeout
@@ -277,12 +291,18 @@ class AsyncEventbusRabbitMQ:
         """
 
         async def add_subscribe():
+            extra_kwargs = {}
+            if content_type != "application/json":
+                extra_kwargs["content_type"] = content_type
+            if not auto_decode:
+                extra_kwargs["auto_decode"] = auto_decode
             await self._sub_connection.subscribe(
                 self.config.options.queue_name,
                 exchange_name,
                 routing_key,
                 handler,
                 timeout,
+                **extra_kwargs,
             )
 
         if self._sub_connection.open(self.config.url):