amqp-client-python 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

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/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/domain/models/config.py

@@ -10,15 +10,11 @@ class Config:
         self, options: Options, ssl_options: Optional[SSLOptions] = None
     ) -> None:
         """
-        Create an Config object thats hold and mount the connection information.
+        Create a Config object that holds and manages the connection information.
 
         Args:
-            options: hold information for estabilish connection
-            ssl_options: hold information for estabilish SSL connections
-
-        Returns:
-
-        Raises:
+            options: holds information for establishing connection
+            ssl_options: holds information for establishing SSL connections
 
         Examples:
             >>> Config(
@@ -32,16 +28,13 @@ class Config:
 
     def build(self) -> "Config":
         """
-        Create an Config object thats hold and mount the connection information.
-
-        Args:
+        Create a Config object that holds and manages the connection information.
 
         Returns:
             Config object
 
-        Raises:
-
         Examples:
+            >>> # config = Config(...)
             >>> config.build()
         """
         opt = {

amqp_client_python/domain/models/options.py

@@ -18,7 +18,7 @@ class Options:
         **kwargs: Dict[str, Any]
     ) -> None:
         """
-        Create an Options object that hold the credentials and configs options.
+        Create an Options object that holds the credentials and configuration options.
 
         Args:
             queue_name: name of queue that will be used for subscriptions
@@ -34,10 +34,6 @@ class Options:
             publisher_confirms: wait for publisher confirmations
             **kwargs: pika options
 
-        Returns:
-
-        Raises:
-
         Examples:
             >>> Options("example", "example.rpc", "example.rpc", "amqp://admin:admin@localhost:5672/")
 

amqp_client_python/domain/models/ssl_options.py

@@ -3,18 +3,13 @@ class SSLOptions:
         self, certfile_path: str, keyfile_path: str, ca_certs_path: str
     ) -> None:
         """
-        Create an SslOptions object that hold the certs paths.
+        Create an SslOptions object that holds the cert paths.
 
         Args:
             certfile_path: cert file path string
             keyfile_path: private key file path string
             ca_certs_path: ca file path string
 
-        Returns:
-            Um dicionário com as notas da escala e os graus.
-
-        Raises:
-
         Examples:
             >>> SSLOptions("./.certs/cert.pem", "./.certs/privkey.pem", "./.certs/ca.pem")
         """

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/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/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/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/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
@@ -108,7 +120,6 @@ class AsyncChannel:
         :param pika.channel.Channel: The closed channel
         :param Exception reason: why the channel was closed
         """
-        print("channel closed:", reason, flush=True)
         LOGGER.info(f"Channel {channel} was closed: {reason}")
         self._consuming = False
         if self._connection.is_closing or self._connection.is_closed:
@@ -238,10 +249,10 @@ class AsyncChannel:
                     )
                 else:
                     future.set_result(body)
-            return not self.auto_ack and self._channel_rpc.basic_ack(
+            return not self.auto_ack and self._channel_rpc.is_open and self._channel_rpc.basic_ack(
                 basic_deliver.delivery_tag
             )
-        not self.auto_ack and self._channel_rpc.basic_nack(
+        not self.auto_ack and self._channel_rpc.is_open and self._channel_rpc.basic_nack(
             basic_deliver.delivery_tag, requeue=False
         )
 
@@ -303,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()
 
@@ -334,34 +345,41 @@ class AsyncChannel:
         routing_key: str,
         body,
         content_type,
-        timeout,
+        response_timeout,
         delivery_mode=DeliveryMode.Transient,
         expiration: Optional[Union[str, None]] = None,
         **key_args,
     ):
+        # Create future to track RPC response
         future = self.ioloop.create_future()  # type: ignore
+        # Generate unique correlation ID for RPC matching
         corr_id = str(uuid4())
+        # Store future in tracking dictionary
         self.rpc_futures[corr_id] = {"response": future}
+        # Setup cleanup callback for completed RPC
         clean_response = partial(self.clean_rpc_response, corr_id)
         future.add_done_callback(clean_response)
 
+        # Ensure RPC response consumer is operational
         await self.start_rpc_consumer()
 
+        # Publish RPC request with metadata headers
         self._channel.basic_publish(
             exchange_name,
             routing_key,
-            dumps(body),
+            self._serialize_payload(body, content_type),
             properties=BasicProperties(
-                reply_to=self._callback_queue,
-                correlation_id=corr_id,
-                content_type=content_type,
-                delivery_mode=delivery_mode,
-                expiration=expiration,
+                reply_to=self._callback_queue,  # Response queue address
+                correlation_id=corr_id,  # Request/response matching ID
+                content_type=content_type,  # Payload format descriptor
+                delivery_mode=delivery_mode,  # Persistent/Transient delivery
+                expiration=expiration,  # Message TTL control
                 **key_args,
             ),
             mandatory=False,
         )
 
+        # Setup timeout handler for unfulfilled requests
         def not_arrived(id: str):
             if id in self.rpc_futures:
                 future = self.rpc_futures[id]
@@ -375,27 +393,40 @@ class AsyncChannel:
                     )
 
         func = partial(not_arrived, corr_id)
-        self.ioloop.call_later(timeout, func)  # type: ignore
+        # Schedule timeout check using event loop
+        self.ioloop.call_later(response_timeout, func)  # type: ignore
 
+        # Handle publisher confirms if enabled
         if self.publisher_confirms:
             return await self.handle_publish(future, corr_id)
+        # Return final response or exception
         return await future
 
     async def handle_publish(self, future, corr_id):
+        """Manages dual confirmation flow (publish + response)"""
+
+        # Create separate tracking for publish confirmation
         publish_future = self.ioloop.create_future()
+        # Store both futures in tracking system
         self.rpc_futures[corr_id]["published"] = publish_future
+        # Initiate confirmation tracking
         self.publish_confirmation(publish_future)
+        # Concurrently wait for first completed operation:
+        # - Publisher confirmation (ACK/NACK)
+        # - RPC response arrival
         done_all, pending_all = await wait(
             [publish_future, future], return_when=FIRST_COMPLETED
         )
+        # Extract potential exception from completed operation
         exception = done_all.pop().exception()
         if exception:
+            # Cancel remaining operations
             [undone.cancel() for undone in pending_all]
             raise exception
-        elif len(pending_all):
+        elif len(pending_all):  # Response still pending after confirmation
             return await future
         else:
-            return future.result()
+            return future.result()  # Return final result directly
 
     async def publish(
         self,
@@ -411,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,
@@ -436,9 +467,15 @@ class AsyncChannel:
             return await publish_future
 
     def publish_confirmation(self, future: Future):
+        """Tracks message publishes requiring confirmation"""
+
+        # Increment sequence counter for message tracking
         self._message_number += 1
+        # Store future reference for confirmation handling
         self.futures[self._message_number] = future
+        # Link to delivery tracking system
         self._deliveries[self._message_number] = future
+        # Register cleanup callback using partial binding
         clean = partial(self.clean_publish_confirmation, self._message_number)
         future.add_done_callback(clean)
 
@@ -455,18 +492,19 @@ class AsyncChannel:
         routing_key: str,
         queue_name: str,
         callback,
-        response_timeout,
+        timeout,
         content_type="application/json",
         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, response_timeout
+            queue_name, routing_key, callback, content_type, timeout, auto_decode=auto_decode
         )
 
         self.queue_bind(queue_name, exchange_name, routing_key)
@@ -501,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)
@@ -518,17 +557,18 @@ class AsyncChannel:
         routing_key: str,
         queue_name: str,
         callback,
-        response_timeout: Optional[int],
+        timeout: Optional[int],
         content_type: str = "application/json",
         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, response_timeout
+            queue_name, routing_key, callback, content_type, timeout, auto_decode=auto_decode
         )
 
         self.queue_bind(queue_name, exchange_name, routing_key)
@@ -556,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"],
@@ -572,7 +616,7 @@ class AsyncChannel:
                         type="normal",
                     ),
                 )
-            not self.auto_ack and not self._channel.basic_ack(
+            not self.auto_ack and self._channel.is_open and not self._channel.basic_ack(
                 basic_deliver.delivery_tag
             )
 
@@ -599,7 +643,7 @@ class AsyncChannel:
                                 type="error",
                             ),
                         )
-                    return not self.auto_ack and self._channel.basic_nack(
+                    return not self.auto_ack and self._channel.is_open and self._channel.basic_nack(
                         basic_deliver.delivery_tag, requeue=False
                     )
 
@@ -615,7 +659,7 @@ class AsyncChannel:
                             type="error",
                         ),
                     )
-                not self.auto_ack and self._channel.basic_nack(
+                not self.auto_ack and self._channel.is_open and self._channel.basic_nack(
                     basic_deliver.delivery_tag, requeue=False
                 )