amqp-client-python 0.2.1.dev1__py3-none-any.whl → 0.2.2.dev1__py3-none-any.whl

amqp_client_python/domain/models/options.py

@@ -15,6 +15,12 @@ class Options:
         vhost: str = "/",
         heartbeat: Optional[int] = 60,
         publisher_confirms: bool = False,
+        rpc_exchange_type: str = "topic",
+        rpc_queue_durable: bool = True,
+        rpc_queue_auto_delete: bool = False,
+        exchange_type: str = "topic",
+        queue_durable: bool = True,
+        queue_auto_delete: bool = False,
         **kwargs: Dict[str, Any]
     ) -> None:
         """
@@ -32,6 +38,12 @@ class Options:
             vhost: vhost information
             heartbeat: interval between heartbeat
             publisher_confirms: wait for publisher confirmations
+            rpc_exchange_type: exchange type for RPC server (default 'topic')
+            rpc_queue_durable: durability for RPC server queue (default True)
+            rpc_queue_auto_delete: auto_delete for RPC server queue (default False)
+            exchange_type: exchange type for pub/sub subscriptions (default 'topic')
+            queue_durable: durability for pub/sub subscriptions queue (default True)
+            queue_auto_delete: auto_delete for pub/sub subscriptions queue (default False)
             **kwargs: pika options
 
         Examples:
@@ -56,4 +68,10 @@ class Options:
         self.vhost = vhost
         self.heartbeat = heartbeat
         self.publisher_confirms = publisher_confirms
+        self.rpc_exchange_type = kwargs.pop("rpc_exchange_type", rpc_exchange_type)
+        self.rpc_queue_durable = kwargs.pop("rpc_queue_durable", rpc_queue_durable)
+        self.rpc_queue_auto_delete = kwargs.pop("rpc_queue_auto_delete", rpc_queue_auto_delete)
+        self.exchange_type = kwargs.pop("exchange_type", exchange_type)
+        self.queue_durable = kwargs.pop("queue_durable", queue_durable)
+        self.queue_auto_delete = kwargs.pop("queue_auto_delete", queue_auto_delete)
         self.kwargs = kwargs

amqp_client_python/rabbitmq/async_channel.py

@@ -1,5 +1,5 @@
 from collections import deque
-from typing import MutableMapping, Mapping, Optional, Union, Dict, List
+from typing import MutableMapping, Mapping, Optional, Union, Dict, List, Tuple, Any
 from .async_channel_factory import AsyncChannelFactoryRabbitMQ
 from amqp_client_python.exceptions import (
     NackException,
@@ -54,11 +54,20 @@ class AsyncChannel:
         self.auto_ack = auto_ack
         self.subscribes: Dict[str, Dict[str, HandlerType]] = {}
         self.re_subscribes: List[str] = []
+        self._compiled_patterns: Dict[str, List[Tuple[str, Any]]] = {}
+        self._queue_exchange_type: Dict[str, str] = {}
         self.consumers: Dict[str, bool] = {}
         self.publisher_confirms = False
         self._message_number = 0
         self._deliveries: MutableMapping[int, Future] = {}
         self.response_timeout = 60
+        self._declared_exchanges: Dict[str, Tuple[str, bool]] = {}
+
+    @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]:
@@ -81,6 +90,7 @@ class AsyncChannel:
         """
         LOGGER.info("Channel opened")
         self._channel = channel
+        self._declared_exchanges.clear()
         self.add_on_channel_close_callback()
         self.publisher_confirms and self.add_publish_confirms()
         self._prefetch_count and self.set_qos(self._prefetch_count)
@@ -114,12 +124,14 @@ class AsyncChannel:
         :param pika.channel.Channel: The closed channel
         :param Exception reason: why the channel was closed
         """
-        LOGGER.info(f"Channel {channel} was closed: {reason}")
+        LOGGER.warning(f"Channel {channel} was closed by RabbitMQ: {reason}")
         self._consuming = False
+        if hasattr(self, "_declared_exchanges"):
+            self._declared_exchanges.clear()
         if self._connection.is_closing or self._connection.is_closed:
             LOGGER.info("Connection is closing or already closed")
         else:
-            LOGGER.info("Closing connection")
+            LOGGER.info(f"Closing connection due to channel closure: {reason}")
             self._connection.close()
 
     def add_publish_confirms(self):
@@ -154,14 +166,36 @@ class AsyncChannel:
         be invoked by pika.
         :param str|unicode exchange_name: The name of the exchange to declare
         """
-        LOGGER.info(f"Declaring exchange: {exchange_name}")
+        if not exchange_name:
+            return
+
+        exchange_type_str = str(getattr(exchange_type, "value", exchange_type))
+        durable_bool = bool(durable)
+
+        if not hasattr(self, "_declared_exchanges"):
+            self._declared_exchanges = {}
+
+        if exchange_name in self._declared_exchanges:
+            prev_type, prev_durable = self._declared_exchanges[exchange_name]
+            if (prev_type, prev_durable) == (exchange_type_str, durable_bool):
+                return
+            LOGGER.warning(
+                f"Exchange '{exchange_name}' was already declared as type='{prev_type}', durable={prev_durable}. "
+                f"Re-declaring with type='{exchange_type_str}', durable={durable_bool} on the same channel may "
+                f"trigger PRECONDITION_FAILED."
+            )
+
+        self._declared_exchanges[exchange_name] = (exchange_type_str, durable_bool)
+        LOGGER.info(
+            f"Declaring exchange: {exchange_name} (type={exchange_type_str}, durable={durable_bool})"
+        )
         # Note: using functools.partial is not required, it is demonstrating
         # how arbitrary data can be passed to the callback when it is called
         cb = partial(self.on_exchange_declareok, userdata=exchange_name)
         self._channel.exchange_declare(
             exchange=exchange_name,
-            exchange_type=exchange_type,
-            durable=durable,
+            exchange_type=exchange_type_str,
+            durable=durable_bool,
             callback=cb,
         )
 
@@ -361,7 +395,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
@@ -436,7 +470,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,
@@ -491,13 +525,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)
@@ -518,30 +553,52 @@ class AsyncChannel:
         self,
         exchange_name,
         queue_name: str,
-        exchange_type="direct",
+        exchange_type="topic",
         durable=True,
         auto_delete=False,
     ):
         if queue_name not in self.subscribes:
-            if not len(self.subscribes):
-                self.subscribes[queue_name] = {}
-        self.setup_exchange(exchange_name, exchange_type)
+            self.subscribes[queue_name] = {}
+        exchange_type_str = str(getattr(exchange_type, "value", exchange_type))
+        if not hasattr(self, "_queue_exchange_type"):
+            self._queue_exchange_type = {}
+        self._queue_exchange_type[queue_name] = exchange_type_str
+
+        self.setup_exchange(exchange_name, exchange_type, durable=durable)
         self.queue_declare(queue_name, durable=durable, auto_delete=auto_delete)
 
         if queue_name not in self.consumers:
             self.consumers[queue_name] = False
 
+    def _compile_routing_pattern(self, queue_name: str, routing_key: str):
+        if not hasattr(self, "_compiled_patterns"):
+            self._compiled_patterns = {}
+        if queue_name not in self._compiled_patterns:
+            self._compiled_patterns[queue_name] = []
+
+        if "*" in routing_key or "#" in routing_key:
+            # AMQP topic wildcard pattern (* = single word [^.]+, # = zero or more words .*)
+            amqp_regex = "^" + re.escape(routing_key).replace(r"\*", r"[^.]+").replace(r"\#", r".*") + "$"
+            try:
+                self._compiled_patterns[queue_name].append((routing_key, re.compile(amqp_regex)))
+            except re.error:
+                pass
+
     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 queue_name not in self.subscribes:
+            self.subscribes[queue_name] = {}
         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)
+            self._compile_routing_pattern(queue_name, routing_key)
 
     async def subscribe(
         self,
@@ -554,12 +611,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)
@@ -587,7 +645,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"],
@@ -609,30 +671,39 @@ class AsyncChannel:
 
         async def handle_message(queue_name, basic_deliver, props):
             try:
-                if basic_deliver.routing_key in self.subscribes[queue_name]:
-                    await process_message(
-                        self.subscribes[queue_name][basic_deliver.routing_key]
-                    )
-                else:
-                    for routing_key in self.re_subscribes:
-                        if re.match(routing_key, basic_deliver.routing_key):
-                            return await process_message(
-                                self.subscribes[queue_name][routing_key]
-                            )
-                    if self.rpc_publisher_started and props.reply_to:
-                        self._channel_rpc.basic_publish(
-                            "",
-                            props.reply_to,
-                            "Provider Error: routing_key not binded",
-                            properties=BasicProperties(
-                                correlation_id=props.correlation_id,
-                                content_type="text/plain",
-                                type="error",
-                            ),
-                        )
-                    return not self.auto_ack and self._channel.is_open and self._channel.basic_nack(
-                        basic_deliver.delivery_tag, requeue=False
+                handlers = self.subscribes.get(queue_name, {})
+                handler = handlers.get(basic_deliver.routing_key)
+                if handler:
+                    return await process_message(handler)
+
+                queue_type = getattr(self, "_queue_exchange_type", {}).get(queue_name, "topic")
+                if queue_type != "direct":
+                    patterns = getattr(self, "_compiled_patterns", {}).get(queue_name)
+                    if patterns:
+                        for pattern_key, pattern in patterns:
+                            if pattern.match(basic_deliver.routing_key):
+                                pattern_handler = handlers.get(pattern_key)
+                                if pattern_handler:
+                                    return await process_message(pattern_handler)
+                    elif self.re_subscribes:
+                        for routing_key in self.re_subscribes:
+                            if routing_key in handlers and re.match(routing_key, basic_deliver.routing_key):
+                                return await process_message(handlers[routing_key])
+
+                if self.rpc_publisher_started and props.reply_to:
+                    self._channel_rpc.basic_publish(
+                        "",
+                        props.reply_to,
+                        "Provider Error: routing_key not binded",
+                        properties=BasicProperties(
+                            correlation_id=props.correlation_id,
+                            content_type="text/plain",
+                            type="error",
+                        ),
                     )
+                return not self.auto_ack and self._channel.is_open and self._channel.basic_nack(
+                    basic_deliver.delivery_tag, requeue=False
+                )
 
             except BaseException as err:
                 if self.rpc_publisher_started and props.reply_to:

amqp_client_python/rabbitmq/async_connection.py

@@ -1,5 +1,5 @@
 from collections import deque
-from typing import Optional, Callable, Awaitable, Tuple, Dict, Any
+from typing import Optional, Callable, Awaitable, Tuple, Dict, Any, Union
 
 from .async_connection_factory import AsyncConnectionFactoryRabbitMQ, AsyncioConnection
 from .async_channel import AsyncChannel
@@ -64,7 +64,7 @@ class AsyncConnection:
         self.reconnect_delay = 1
         self.callbacks: deque[Tuple[Callable, Future]] = deque()
         self.type = connection_type
-        self.backup: Dict[str, Dict[str, Any]] = {
+        self.backup: Dict[str, Dict[Union[str, Tuple[str, str]], Any]] = {
             "exchange": {},
             "queue": {},
             "subscribe": {},
@@ -134,28 +134,8 @@ class AsyncConnection:
         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"],
-                    )
-                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"],
-                    )
-
             future: Future = Future(loop=self.ioloop)
-            self.callbacks.append((recorvery, future))
+            self.callbacks.append((self._recover_subscriptions, future))
             self.reconnect_delay = 1
             self.reconnecting = False
 
@@ -207,12 +187,39 @@ class AsyncConnection:
             self.reconnecting = True
             self.retry_connection()
 
+    async def _recover_subscriptions(self):
+        for key, params in list(self.backup["subscribe"].items()):
+            routing_key = params.get("routing_key") or (key[1] if isinstance(key, tuple) else 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),
+                exchange_type=params.get("exchange_type", "topic"),
+                durable=params.get("durable", True),
+                auto_delete=params.get("auto_delete", False),
+            )
+        for key, params in list(self.backup["rpc_subscribe"].items()):
+            routing_key = params.get("routing_key") or (key[1] if isinstance(key, tuple) else 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),
+                exchange_type=params.get("exchange_type", "topic"),
+                durable=params.get("durable", True),
+                auto_delete=params.get("auto_delete", False),
+            )
+
     def retry_connection(self):
         """
         Attempts to reconnect to RabbitMQ with exponential backoff.
-
-        If reconnection is successful, this method will recover previous subscriptions
-        and RPC handlers.
         """
         if not self.is_open:
             if self.reconnect_delay > 30:
@@ -224,29 +231,9 @@ class AsyncConnection:
             self.reconnect_delay += 1
         else:
             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"],
-                        )
-                    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"],
-                        )
-
                 self.reconnect_delay = 1
                 self.reconnecting = False
-                self.ioloop.create_task(self.add_callback(recorvery))  # type: ignore
+                self.ioloop.create_task(self.add_callback(self._recover_subscriptions))  # type: ignore
 
     @property
     def is_open(self) -> Optional[bool]:
@@ -386,7 +373,17 @@ 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,
+        exchange_type="topic",
+        durable=True,
+        auto_delete=False,
     ):
         """
         Registers an RPC handler for a specific routing key.
@@ -397,24 +394,24 @@ 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
+            exchange_type: Exchange type for RPC server (default 'topic')
+            durable: Durability of queue (default True)
+            auto_delete: Auto delete flag for queue (default False)
         """
-        self.backup["rpc_subscribe"][routing_key] = {
+        sub_key = (queue_name, routing_key)
+        self.backup["rpc_subscribe"][sub_key] = {
             "queue_name": queue_name,
             "exchange_name": exchange_name,
+            "routing_key": routing_key,
             "callback": callback,
             "timeout": timeout,
+            "content_type": content_type,
+            "auto_decode": auto_decode,
+            "exchange_type": exchange_type,
+            "durable": durable,
+            "auto_delete": auto_delete,
         }
         await self._channel.rpc_subscribe(
             queue_name=queue_name,
@@ -422,6 +419,11 @@ class AsyncConnection:
             routing_key=routing_key,
             callback=callback,
             timeout=timeout,
+            content_type=content_type,
+            auto_decode=auto_decode,
+            exchange_type=exchange_type,
+            durable=durable,
+            auto_delete=auto_delete,
         )
 
     async def subscribe(
@@ -431,6 +433,11 @@ class AsyncConnection:
         routing_key: str,
         callback: Callable[[Any], Awaitable[None]],
         timeout: Optional[float],
+        content_type: str = "application/json",
+        auto_decode: bool = True,
+        exchange_type: str = "topic",
+        durable: bool = True,
+        auto_delete: bool = False,
     ):
         """
         Subscribes to messages with a specific routing key.
@@ -441,23 +448,24 @@ 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
+            exchange_type: Exchange type for subscription (default 'topic')
+            durable: Durability of queue (default True)
+            auto_delete: Auto delete flag for queue (default False)
         """
-        self.backup["subscribe"][routing_key] = {
+        sub_key = (queue_name, routing_key)
+        self.backup["subscribe"][sub_key] = {
             "queue_name": queue_name,
             "exchange_name": exchange_name,
+            "routing_key": routing_key,
             "callback": callback,
             "timeout": timeout,
+            "content_type": content_type,
+            "auto_decode": auto_decode,
+            "exchange_type": exchange_type,
+            "durable": durable,
+            "auto_delete": auto_delete,
         }
         await self._channel.subscribe(
             exchange_name=exchange_name,
@@ -465,6 +473,11 @@ class AsyncConnection:
             routing_key=routing_key,
             callback=callback,
             timeout=timeout,
+            content_type=content_type,
+            auto_decode=auto_decode,
+            exchange_type=exchange_type,
+            durable=durable,
+            auto_delete=auto_delete,
         )
 
     async def add_callback(

amqp_client_python/rabbitmq/async_eventbus_rabbitmq.py

@@ -1,7 +1,7 @@
 from typing import Callable, Awaitable, Optional, Union, Any, List
 from .async_connection import AsyncConnection
 from ..domain.utils import ConnectionType
-from amqp_client_python.domain.models import Config
+from amqp_client_python.domain.models import Config, Options
 from asyncio import AbstractEventLoop, get_event_loop
 from pika import DeliveryMode
 from amqp_client_python.signals import Signal
@@ -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,23 @@ 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
+            options = getattr(self.config, "options", None)
+            if isinstance(options, Options):
+                extra_kwargs["exchange_type"] = options.rpc_exchange_type
+                extra_kwargs["durable"] = options.rpc_queue_durable
+                extra_kwargs["auto_delete"] = options.rpc_queue_auto_delete
             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 +267,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 +279,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 +296,23 @@ 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
+            options = getattr(self.config, "options", None)
+            if isinstance(options, Options):
+                extra_kwargs["exchange_type"] = options.exchange_type
+                extra_kwargs["durable"] = options.queue_durable
+                extra_kwargs["auto_delete"] = options.queue_auto_delete
             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):

amqp_client_python/rabbitmq/eventbus_wrapper_rabbitmq.py

@@ -142,6 +142,8 @@ class EventbusWrapperRabbitMQ:
         handler: Callable[[Any], Awaitable[None]],
         response_timeout: Optional[int] = None,
         connection_timeout: int = 16,
+        content_type: str = "application/json",
+        auto_decode: bool = True,
     ) -> Future:
         if self._thread.ident == current_thread().ident:
             raise BlockingException(
@@ -154,6 +156,8 @@ class EventbusWrapperRabbitMQ:
                 handler,
                 response_timeout,
                 connection_timeout,
+                content_type=content_type,
+                auto_decode=auto_decode,
             ),
             self._loop,
         )
@@ -165,13 +169,21 @@ class EventbusWrapperRabbitMQ:
         handler: Callable[[Any], Awaitable[None]],
         response_timeout: Optional[int] = None,
         connection_timeout: int = 16,
+        content_type: str = "application/json",
+        auto_decode: bool = True,
     ):
         if self._thread.ident != current_thread().ident:
             raise ThreadUnsafeException(
                 "Cannot run async call on this thread, try to use sync thread safe methods"
             )
         await self._async_eventbus.subscribe(
-            exchange_name, routing_key, handler, response_timeout, connection_timeout
+            exchange_name,
+            routing_key,
+            handler,
+            response_timeout,
+            connection_timeout,
+            content_type=content_type,
+            auto_decode=auto_decode,
         )
 
     def provide_resource(
@@ -180,6 +192,8 @@ class EventbusWrapperRabbitMQ:
         callback: Callable[[List[Any]], Awaitable[Union[bytes, str]]],
         response_timeout: Optional[int] = None,
         connection_timeout: int = 16,
+        content_type: str = "application/json",
+        auto_decode: bool = True,
     ) -> Future:
         if self._thread.ident == current_thread().ident:
             raise BlockingException(
@@ -187,7 +201,12 @@ class EventbusWrapperRabbitMQ:
             )
         return run_coroutine_threadsafe(
             self._async_eventbus.provide_resource(
-                name, callback, response_timeout, connection_timeout
+                name,
+                callback,
+                response_timeout,
+                connection_timeout,
+                content_type=content_type,
+                auto_decode=auto_decode,
             ),
             self._loop,
         )
@@ -198,13 +217,20 @@ class EventbusWrapperRabbitMQ:
         callback: Callable[[List[Any]], Awaitable[Union[bytes, str]]],
         response_timeout: Optional[int] = None,
         connection_timeout: int = 16,
+        content_type: str = "application/json",
+        auto_decode: bool = True,
     ):
         if self._thread.ident != current_thread().ident:
             raise ThreadUnsafeException(
                 "Cannot run async call on this thread, try to use sync thread safe methods"
             )
         await self._async_eventbus.provide_resource(
-            name, callback, response_timeout, connection_timeout
+            name,
+            callback,
+            response_timeout,
+            connection_timeout,
+            content_type=content_type,
+            auto_decode=auto_decode,
         )
 
     def dispose(self):

{amqp_client_python-0.2.1.dev1.dist-info → amqp_client_python-0.2.2.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: amqp-client-python
-Version: 0.2.1.dev1
+Version: 0.2.2.dev1
 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.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -28,7 +27,7 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Networking
-Requires-Python: <4.0,>=3.9
+Requires-Python: <4.0,>=3.10
 Requires-Dist: pika<2.0.0,>=1.3.0
 Description-Content-Type: text/markdown
 
@@ -57,16 +56,6 @@ A Python client providing a high-level abstraction for interacting with RabbitMQ
 
 **Discord Server**: <a href="https://discord.gg/RkXNeZpNZk" target="_blank">https://discord.gg/RkXNeZpNZk</a>
 
-### 🦀 Looking for higher performance? Try `amqp-rs`!
-If you need higher throughput, thread safety, and built-in compression, check out [**amqp-rs**](https://pypi.org/project/amqp-rs/).
-
-It is a high-performance Python extension developed in Rust using PyO3 and `tokio`. It shares a similar API and design philosophy with this library, but adds native thread safety, `zstd`/`zlib`/`lz4` compression, robust TLS/SSL support, and graceful shutdowns. 
-
-You can install it via `pip` or `uv`:
-```bash
-pip install amqp-rs
-```
-
 ---
 ### Features:
 - Automatic creation and management of queues, exchanges and channels;
@@ -80,19 +69,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:
@@ -109,15 +101,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.1.dev1.dist-info → amqp_client_python-0.2.2.dev1.dist-info}/RECORD

@@ -3,7 +3,7 @@ amqp_client_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 amqp_client_python/signals.py,sha256=6mW4oWBQnbJwuKox6ceeDbxTM8v9aCDEb0o2zyhpb5g,1263
 amqp_client_python/domain/models/__init__.py,sha256=EgEV-FeMUVMj_7RvhPbnZaqnJaNqTYnIAiEiqSy0ies,154
 amqp_client_python/domain/models/config.py,sha256=g2AWrlEvHCS1h2zlny29phREyG9GmD0rtGQHS3C7LVU,2268
-amqp_client_python/domain/models/options.py,sha256=lx-x4uyMpyjelZjMuyUxLsORz1ro1vDjD33j0EGYD-o,2141
+amqp_client_python/domain/models/options.py,sha256=uCApGDYfwKUVytoQ-g81mbHoEWvVp5kVObUlYpWBD1c,3376
 amqp_client_python/domain/models/ssl_options.py,sha256=xOTSIKfbNZbYepY6o3SxuZvLPX3J5pvRoJXIJlyBsrI,613
 amqp_client_python/domain/utils/__init__.py,sha256=lZL3bwchrTiiKx5d1RSVUJACAuPb7zOnoH9tZ65t_Ok,131
 amqp_client_python/domain/utils/connection_type.py,sha256=AnEF8Nd3cQBCGX8rPKwEkKts8kwnGUAVr0nxnbpynLE,164
@@ -27,19 +27,19 @@ amqp_client_python/exceptions/rpc_provider_exception.py,sha256=_1Ytb8BOUT_9xEtG_
 amqp_client_python/exceptions/thread_unsafe_exception.py,sha256=zcC4VyuxXWo66Tts1AQtkg07GK3OjXu3LEtt1AUj4jk,281
 amqp_client_python/exceptions/timeout_exception.py,sha256=0YT-vivS44mHF4Jc3o2rlZFc6l_zzNjcxCHPS9ArgN0,271
 amqp_client_python/rabbitmq/__init__.py,sha256=4N-j8rbrJj0kOOSIhSWJenj6JOJbzFNnW3bxwPGTyuM,941
-amqp_client_python/rabbitmq/async_channel.py,sha256=7QQTKqqe5uFBr9TqUOS0X0tMEMNJavstRnQ9RHWl2wA,26926
+amqp_client_python/rabbitmq/async_channel.py,sha256=cAis6UoMlmhb1HtMavnb36KC-AkK7c-aVc1GufO6bUs,30495
 amqp_client_python/rabbitmq/async_channel_factory.py,sha256=ec_5B3Sgazi_ncIG5lI5nnmkH3NprwvyjMhvgpG1BWA,371
-amqp_client_python/rabbitmq/async_connection.py,sha256=p05Y_1iXcytROZuaPqmodlKxsdxU50ALhEDjN7WqEhw,18308
+amqp_client_python/rabbitmq/async_connection.py,sha256=kq0jjXsuivmi101gj809ME_-LcrLYbey9rO9k0h-d0g,19063
 amqp_client_python/rabbitmq/async_connection_factory.py,sha256=3N5MM1fPUdodAFLh58rf6vvwN9OAclDVzmG85Qve-Ss,849
-amqp_client_python/rabbitmq/async_eventbus_rabbitmq.py,sha256=4PCtqhVNT3cq-d0anfdKPzhmmETD-HMqIu-MVuZmZZA,12950
+amqp_client_python/rabbitmq/async_eventbus_rabbitmq.py,sha256=mjMtdm6hmony1PXZqOc9molVZ2GRT9wrwRvFRd4AQBs,14553
 amqp_client_python/rabbitmq/channel_factory_rabbitmq.py,sha256=h_vGqHgL0DOtXC0tmVd5gzXVlNKL48rxpKpwaN3AlOM,310
 amqp_client_python/rabbitmq/channel_rabbitmq.py,sha256=S3SqGCfVRoIuPyZW40bQZBpWEgbe5YlvZ8ei23a2VVw,13737
 amqp_client_python/rabbitmq/connection_factory_rabbitmq.py,sha256=EKPG5gEsGwtpSKOhoPI5vK1sJOUARbOflOug6VREIrk,1022
 amqp_client_python/rabbitmq/connection_rabbitmq.py,sha256=9A8NAPAB3i-5E43SV5sxjKFFoRb4pIhzAAUHrvOvOng,9772
 amqp_client_python/rabbitmq/eventbus_rabbitmq.py,sha256=GZoJGVeBkMTPrQ5dIJqad-MdGmuuJsxGaXV1YGLdk5o,6980
-amqp_client_python/rabbitmq/eventbus_wrapper_rabbitmq.py,sha256=i3C-sZO9EifanfRXReiib56fxxzjV3Cx71rdbJORg78,7442
+amqp_client_python/rabbitmq/eventbus_wrapper_rabbitmq.py,sha256=ee1tWk2_sQ3tRlvItZCqZtqfDLrjn-K4NCQKw7hNiwg,8225
 amqp_client_python/rabbitmq/ioloop_factory.py,sha256=vfgndKLcazQU0a4elI5RNHnQCTEua--Jjo99bzX8iHo,856
-amqp_client_python-0.2.1.dev1.dist-info/METADATA,sha256=1PF9aIMEadkewz66TXxQLkFKeYKU6UtEzrbE6VHHRAw,10155
-amqp_client_python-0.2.1.dev1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-amqp_client_python-0.2.1.dev1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-amqp_client_python-0.2.1.dev1.dist-info/RECORD,,
+amqp_client_python-0.2.2.dev1.dist-info/METADATA,sha256=JuldbMrR7B8K4abQT-WwYksmSKoBEY0ApFNYdBhtCd0,9888
+amqp_client_python-0.2.2.dev1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+amqp_client_python-0.2.2.dev1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+amqp_client_python-0.2.2.dev1.dist-info/RECORD,,

{amqp_client_python-0.2.1.dev1.dist-info → amqp_client_python-0.2.2.dev1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.31.0
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any