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

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/rabbitmq/async_channel.py

@@ -108,7 +108,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 +237,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
         )
 
@@ -334,34 +333,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),
+            dumps(body),  # Serialize payload to JSON
             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 +381,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,
@@ -436,9 +455,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,7 +480,7 @@ class AsyncChannel:
         routing_key: str,
         queue_name: str,
         callback,
-        response_timeout,
+        timeout,
         content_type="application/json",
         exchange_type="topic",
         durable=True,
@@ -466,7 +491,7 @@ class AsyncChannel:
             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
         )
 
         self.queue_bind(queue_name, exchange_name, routing_key)
@@ -518,7 +543,7 @@ 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,
@@ -528,7 +553,7 @@ class AsyncChannel:
             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
         )
 
         self.queue_bind(queue_name, exchange_name, routing_key)
@@ -572,7 +597,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 +624,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 +640,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
                 )
 

amqp_client_python/rabbitmq/async_connection.py

@@ -21,6 +21,33 @@ class AsyncConnection:
         connection_type: Optional[ConnectionType] = None,
         signal=Signal(),
     ) -> None:
+        """
+        Manages asynchronous connections to RabbitMQ with automatic reconnection capabilities.
+
+        This class handles connection lifecycle, channel management, and provides methods for
+        publishing messages, subscribing to queues, and implementing RPC patterns.
+
+        Args:
+            ioloop: The asyncio event loop to use for async operations
+            publisher_confirms: Whether to enable publisher confirmations for this connection
+            prefetch_count: Maximum number of unacknowledged messages to prefetch
+            auto_ack: Whether to automatically acknowledge messages
+            connection_type: Type of connection (PUBLISH, SUBSCRIBE, RPC_CLIENT, RPC_SERVER)
+            signal: Signal object for event handling
+
+        Returns:
+            None: None
+
+        Examples:
+            >>> connection = AsyncConnection(
+                    get_event_loop(),
+                    publisher_confirms=True,
+                    prefetch_count=10,
+                    auto_ack=False,
+                    connection_type=ConnectionType.PUBLISH
+                )
+            >>> connection.open("amqp://guest:guest@localhost:5672/%2F")
+        """
         self.ioloop = ioloop
         self.publisher_confirms = publisher_confirms
         self.connection_factory = AsyncConnectionFactoryRabbitMQ()
@@ -43,6 +70,18 @@ class AsyncConnection:
         }
 
     def open(self, uri):
+        """
+        Opens a connection to RabbitMQ using the provided URI.
+
+        If the connection is not already open and not in the process of opening,
+        this method will initiate a new connection.
+
+        Args:
+            uri: The AMQP URI to connect to (e.g., "amqp://guest:guest@localhost:5672/")
+
+        Examples:
+            >>> connection.open("amqp://guest:guest@localhost:5672/")
+        """
         self.url = uri
         if not self.is_open and not self.openning:
             if not self.ioloop:
@@ -55,13 +94,31 @@ class AsyncConnection:
                 on_connection_closed=self.on_connection_closed,
                 custum_ioloop=self.ioloop,
             )
+            return True
+        return False
 
     async def close(self):
+        """
+        Closes the connection to RabbitMQ gracefully.
+
+        This method will only close the connection if it is currently open.
+
+        Examples:
+            >>> await connection.close()
+        """
         if self.is_open:
             self._closing = True
             self._connection.close()
 
     def on_connection_open(self, _unused_connection):
+        """
+        Callback invoked when the connection to RabbitMQ is established.
+
+        This method creates a channel and emits a connection event.
+
+        Args:
+            _unused_connection: The connection object (not used)
+        """
         LOGGER.info(f"connection openned {_unused_connection}, {self._connection}")
         self.signal.emmit(Event.CONNECTED, condiction=self.type, loop=self.ioloop)
         self.openning = False
@@ -75,17 +132,29 @@ class AsyncConnection:
         self._channel.open(self._connection, self.callbacks)
 
     def on_connection_open_error(self, _unused_connection, err):
+        """
+        Callback invoked when the connection to RabbitMQ is established.
+
+        This method creates a channel and emits a connection event.
+
+        Args:
+            _unused_connection: The connection object (not used)
+        """
         LOGGER.info(f"connection open error: {err}, will attempt a connection")
         self.openning = False
         self.reconnect()
 
     def on_connection_closed(self, _unused_connection, reason):
-        """This method is invoked by pika when the connection to RabbitMQ is
+        """
+        Callback invoked when the connection to RabbitMQ is closed unexpectedly.
+
+        This method is invoked by pika when the connection to RabbitMQ is
         closed unexpectedly. Since it is unexpected, we will reconnect to
         RabbitMQ if it disconnects.
-        :param pika.connection.Connection connection: The closed connection obj
-        :param Exception reason: exception representing reason for loss of
-            connection.
+
+        Args:
+            _unused_connection: The closed connection object
+            reason: Exception representing reason for loss of connection
         """
         self._channel = None
         if self._closing:
@@ -98,15 +167,23 @@ class AsyncConnection:
             self.reconnect()
 
     def reconnect(self):
-        """Will be invoked if the connection can't be opened or is
-        closed. Indicates that a reconnect is necessary then stops the
-        ioloop.
+        """
+        Initiates the reconnection process.
+
+        Will be invoked if the connection can't be opened or is closed.
+        Indicates that a reconnect is necessary.
         """
         if not self.reconnecting:
             self.reconnecting = True
             self.retry_connection()
 
     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:
                 self.reconnect_delay = 30
@@ -125,7 +202,7 @@ class AsyncConnection:
                         params["exchange_name"],
                         routing_key,
                         params["callback"],
-                        params["response_timeout"],
+                        params["timeout"],
                     )
                 for routing_key in self.backup["rpc_subscribe"]:
                     params = self.backup["rpc_subscribe"][routing_key]
@@ -134,7 +211,7 @@ class AsyncConnection:
                         params["exchange_name"],
                         routing_key,
                         params["callback"],
-                        params["response_timeout"],
+                        params["timeout"],
                     )
 
             self.ioloop.create_task(self.add_callback(recorvery))  # type: ignore
@@ -143,6 +220,12 @@ class AsyncConnection:
 
     @property
     def is_open(self) -> Optional[bool]:
+        """
+        Checks if the connection is currently open.
+
+        Returns:
+            Optional[bool]: True if the connection is open, False otherwise, or None if no connection exists
+        """
         return self._connection and self._connection.is_open
 
     def stop(self) -> None:
@@ -170,17 +253,49 @@ class AsyncConnection:
         routing_key: str,
         body: Any,
         content_type: str,
-        timeout,
+        response_timeout,
         delivery_mode,
         expiration,
         **kwargs,
     ):
+        """
+        Sends an RPC request and waits for a response.
+
+        Args:
+            exchange_name: The exchange to publish to
+            routing_key: The routing key for the message
+            body: The message body to send
+            content_type: Content type of the message
+            response_timeout: Timeout in seconds for waiting for a response
+            delivery_mode: Delivery mode (persistent or transient)
+            expiration: Maximum lifetime of the message in the queue
+            **kwargs: Additional message properties
+
+        Returns:
+            Any: The response from the RPC server
+
+        Raises:
+            PublishTimeoutException: If publisher confirmation times out
+            NackException: If the message is rejected by the broker
+            ResponseTimeoutException: If no response is received within the response_timeout
+
+        Examples:
+            >>> response = await connection.rpc_client(
+                    "rpc_exchange",
+                    "user.find",
+                    {"id": 123},
+                    "application/json",
+                    5.0,
+                    DeliveryMode.Transient,
+                    "60000"
+                )
+        """
         return await self._channel.rpc_client(
             exchange_name,
             routing_key,
             body,
             content_type,
-            timeout,
+            response_timeout,
             delivery_mode,
             expiration,
             **kwargs,
@@ -197,6 +312,38 @@ class AsyncConnection:
         expiration,
         **kwargs,
     ):
+        """
+        Publishes a message to RabbitMQ.
+
+        Args:
+            exchange_name: The exchange to publish to
+            routing_key: The routing key for the message
+            body: The message body to send
+            content_type: Content type of the message
+            timeout: Timeout in seconds for publisher confirmation
+            delivery_mode: Delivery mode (persistent or transient)
+            expiration: Maximum lifetime of the message in the queue
+            **kwargs: Additional message properties
+
+        Returns:
+            Optional[bool]: True if publisher confirms enabled and message was confirmed,
+                           None if publisher confirms disabled
+
+        Raises:
+            PublishTimeoutException: If publisher confirmation times out
+            NackException: If the message is rejected by the broker
+
+        Examples:
+            >>> result = await connection.publish(
+                    "notifications",
+                    "email.send",
+                    {"to": "user@example.com", "subject": "Hello"},
+                    "application/json",
+                    5.0,
+                    DeliveryMode.Persistent,
+                    "60000"
+                )
+        """
         return await self._channel.publish(
             exchange_name,
             routing_key,
@@ -209,37 +356,85 @@ class AsyncConnection:
         )
 
     async def rpc_subscribe(
-        self, queue_name, exchange_name, routing_key, callback, response_timeout
+        self, queue_name, exchange_name, routing_key, callback, timeout
     ):
+        """
+        Registers an RPC handler for a specific routing key.
+
+        Args:
+            queue_name: The queue to consume from
+            exchange_name: The exchange to bind to
+            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
+                )
+        """
         self.backup["rpc_subscribe"][routing_key] = {
             "queue_name": queue_name,
             "exchange_name": exchange_name,
             "callback": callback,
-            "response_timeout": response_timeout,
+            "timeout": timeout,
         }
         await self._channel.rpc_subscribe(
             queue_name=queue_name,
             exchange_name=exchange_name,
             routing_key=routing_key,
             callback=callback,
-            response_timeout=response_timeout,
+            timeout=timeout,
         )
 
     async def subscribe(
-        self, queue_name, exchange_name, routing_key, callback, response_timeout
+        self,
+        queue_name: str,
+        exchange_name: str,
+        routing_key: str,
+        callback: Callable[[Any], Awaitable[None]],
+        timeout: Optional[float],
     ):
+        """
+        Subscribes to messages with a specific routing key.
+
+        Args:
+            queue_name: The queue to consume from
+            exchange_name: The exchange to bind to
+            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
+                )
+        """
         self.backup["subscribe"][routing_key] = {
             "queue_name": queue_name,
             "exchange_name": exchange_name,
             "callback": callback,
-            "response_timeout": response_timeout,
+            "timeout": timeout,
         }
         await self._channel.subscribe(
             exchange_name=exchange_name,
             queue_name=queue_name,
             routing_key=routing_key,
             callback=callback,
-            response_timeout=response_timeout,
+            timeout=timeout,
         )
 
     async def add_callback(
@@ -247,6 +442,27 @@ class AsyncConnection:
         callback: Callable[..., Awaitable[Any]],
         connection_timeout: Optional[float] = None,
     ):
+        """
+        Executes a callback when the connection is ready or queues it for later execution.
+
+        If the connection and channel are open, executes the callback immediately.
+        Otherwise, queues the callback to be executed when the connection is established.
+
+        Args:
+            callback: The async function to call
+            connection_timeout: Maximum time to wait for the connection to be established
+
+        Returns:
+            Any: The result of the callback
+
+        Raises:
+            AutoReconnectException: When the connection cannot be established within the timeout
+
+        Examples:
+            >>> async def my_operation():
+                    return await connection.publish(...)
+            >>> result = await connection.add_callback(my_operation, 10.0)
+        """
         try:
             if self.is_open and self._channel.is_open:
                 return await callback()

amqp_client_python/rabbitmq/async_eventbus_rabbitmq.py

@@ -23,8 +23,8 @@ class AsyncEventbusRabbitMQ:
         rpc_server_auto_ack: bool = False,
     ) -> None:
         """
-        Create an AsyncEventbusRabbitMQ object thats interacts with Bus
-        thats provides some connection management abstractions.
+        Create an AsyncEventbusRabbitMQ object that interacts with Bus that provides
+        some connection management abstractions
 
         Args:
             config: the Config object
@@ -40,27 +40,25 @@ class AsyncEventbusRabbitMQ:
             rpc_server_auto_ack: set to True to ack messages before processing on rpc server connection
 
         Returns:
-            AsyncEventbusRabbitMQ object
-
-        Raises:
+            None: None
 
         Examples:
             >>> async_eventbus = AsyncEventbusRabbitMQ(
                 config, loop, rpc_client_publisher_confirms=True,
                 rpc_server_publisher_confirms=False, rpc_server_auto_ack=False)
             ### register subscribe
-            >>> def handler(*body):
+            >>> def subscribe_handler(body):
                     print(f"do something with: {body}")
-            >>> subscribe_event = ExampleEvent("rpc_exchange")
-            >>> await eventbus.subscribe(subscribe_event, handler, "user.find")
+            >>> await eventbus.subscribe("rpc_exchange", "user.find", subscribe_handler)
             ### provide resource
-            >>> def handler2(*body):
+            >>> def rpc_provider_handler(body) -> Union[str, bytes]:
                     print(f"do something with: {body}")
-                    return "response"
-            >>> await eventbus.provide_resource("user.find2", handle2)
+                    return b"response"
+            >>> await eventbus.provide_resource("user.find2", rpc_provider_handler)
         """
         self._loop: Optional[AbstractEventLoop] = loop
         self._signal = Signal()
+        self._used_connections: List[AsyncConnection] = []
         self._pub_connection = AsyncConnection(
             self._loop,
             pub_publisher_confirms,
@@ -108,7 +106,7 @@ class AsyncEventbusRabbitMQ:
         **kwargs
     ) -> bytes:
         """
-        Sends a publish message to queue of the bus and waits for a response
+        Sends a publish message to a queue of the bus and waits for a response
 
         Args:
             exchange: exchange name
@@ -125,14 +123,14 @@ class AsyncEventbusRabbitMQ:
 
         Raises:
             AutoReconnectException: when cannout reconnect on the gived timeout
-            PublishTimeoutException: if publish confirmation is setted to True and \
+            PublishTimeoutException: if publish confirmation is set to True and \
             does not receive confirmation on the gived timeout
-            NackException: if publish confirmation is setted to True and receives a nack
+            NackException: if publish confirmation is set to True and receives a nack
             ResponseTimeoutException: if response timeout is reached
             RpcProviderException: if the rpc provider responded with an error
 
         Examples:
-            >>> await eventbus.rpc_client("example.rpc", "user.find", [{"name": "example"}], "application/json")
+            >>> await eventbus.rpc_client("example.rpc", "user.find", {"name": "example"}, "application/json")
         """
 
         async def add_rpc_client():
@@ -165,10 +163,10 @@ class AsyncEventbusRabbitMQ:
         **kwargs
     ) -> Optional[bool]:
         """
-        Sends a publish message to the bus following parameters passed
+        Sends a publish message to the bus following the parameters passed
 
         Args:
-            exchange: exchange name
+            exchange_name: exchange name
             routing_key:  routing key name
             body: body that will be sent
             content_type: content type of message
@@ -178,15 +176,14 @@ class AsyncEventbusRabbitMQ:
             expiration: maximum lifetime of message to stay on the queue
 
         Returns:
-            None: if publish confirmation is setted to False
-            True: if successful when publish confirmation is setted to True
+            None: if publish confirmation is set to False
+            True: if successful when publish confirmation is set to True
 
         Raises:
             AutoReconnectException: when cannout reconnect on the gived timeout
-            PublishTimeoutException: if publish confirmation is setted to True and \
+            PublishTimeoutException: if publish confirmation is set to True and \
             does not receive confirmation on the gived timeout
-            NackException: if publish confirmation is setted to True and receives a nack
-
+            NackException: if publish confirmation is set to True and receives a nack
 
         Examples:
             >>> exchange_name = "example.rpc"
@@ -212,30 +209,27 @@ class AsyncEventbusRabbitMQ:
     async def provide_resource(
         self,
         name: str,
-        handler: Callable[[List[Any]], Awaitable[Union[bytes, str]]],
-        response_timeout: Optional[int] = None,
+        handler: Callable[[Any], Awaitable[Union[bytes, str]]],
+        timeout: Optional[int] = None,
         connection_timeout: int = 16,
     ) -> None:
         """
-        Register a provider to listen on queue of bus
+        Register a provider to listen on RPC request queue
 
         Args:
             name: routing_key name
             handler: message handler, it will be called when a message is received
-            response_timeout: timeout in seconds for waiting for process the received message
+            timeout: timeout in seconds for waiting for process the received message
             connection_timeout: timeout for waiting for connection restabilishment
 
-        Returns:
-            None: None
-
         Raises:
             AutoReconnectException: when cannout reconnect on the gived timeout
 
         Examples:
-            >>> async def handle(body) -> Union[bytes, str]:
+            >>> async def handler(body) -> Union[bytes, str]:
                     print(f"received message: {body}")
                     return b"[]"
-            >>> await eventbus.provide_resource("user.find", handle)
+            >>> await eventbus.provide_resource("user.find", handler)
         """
 
         async def add_resource():
@@ -244,10 +238,11 @@ class AsyncEventbusRabbitMQ:
                 self.config.options.rpc_exchange_name,
                 name,
                 handler,
-                response_timeout,
+                timeout,
             )
 
-        self._rpc_server_connection.open(self.config.url)
+        if self._rpc_server_connection.open(self.config.url):
+            self._used_connections.append(self._rpc_server_connection)
         await self._rpc_server_connection.add_callback(add_resource, connection_timeout)
 
     async def subscribe(
@@ -255,7 +250,7 @@ class AsyncEventbusRabbitMQ:
         exchange_name: str,
         routing_key: str,
         handler: Callable[[Any], Awaitable[None]],
-        response_timeout: Optional[float] = None,
+        timeout: Optional[float] = None,
         connection_timeout: int = 16,
     ) -> None:
         """
@@ -265,12 +260,9 @@ class AsyncEventbusRabbitMQ:
             exchange_name: exchange name
             routing_key: routing_key name
             handler: message handler, it will be called when a message is received
-            response_timeout: timeout in seconds for waiting for process the received message
+            timeout: timeout in seconds for waiting for process the received message
             connection_timeout: timeout for waiting for connection restabilishment
 
-        Returns:
-            None: None
-
         Raises:
             AutoReconnectException: when cannout reconnect on the gived timeout
 
@@ -279,9 +271,9 @@ class AsyncEventbusRabbitMQ:
                     print(f"received message: {body}")
             >>> exchange_name = "example"
             >>> routing_key = "user.find3"
-            >>> response_timeout = 20
+            >>> timeout = 20
             >>> connection_timeout = 16
-            >>> await eventbus.subscribe(exchange_name, routing_key, handle, response_timeout, connection_timeout)
+            >>> await eventbus.subscribe(exchange_name, routing_key, handle, timeout, connection_timeout)
         """
 
         async def add_subscribe():
@@ -290,13 +282,45 @@ class AsyncEventbusRabbitMQ:
                 exchange_name,
                 routing_key,
                 handler,
-                response_timeout,
+                timeout,
             )
 
-        self._sub_connection.open(self.config.url)
+        if self._sub_connection.open(self.config.url):
+            self._used_connections.append(self._sub_connection)
         await self._sub_connection.add_callback(add_subscribe, connection_timeout)
 
-    async def dispose(self, stop_event_loop=True) -> None:
+    async def restore(self) -> None:
+        """
+        Restores connections and subscriptions after a disconnection.
+
+        This method attempts to reopen connections that were closed and
+        re-establishes any previously registered subscriptions and RPC providers.
+
+        Examples:
+            >>> # After a dispose, call restore to re-establish connections
+            >>> await eventbus.restore()
+        """
+        for connection in self._used_connections:
+            if not connection.is_open:
+                connection.open(self.config.url)
+
+    async def dispose(self, stop_event_loop: bool = True) -> None:
+        """
+        Closes all connections and optionally stops the event loop.
+
+        This method properly disposes of all resources used by the event bus,
+        including publisher, subscriber, RPC client, and RPC server connections.
+
+        Args:
+            stop_event_loop: Whether to stop the event loop after closing connections.
+
+        Examples:
+            >>> # Close all connections and stop the event loop
+            >>> await eventbus.dispose()
+
+            >>> # Close all connections but keep the event loop running
+            >>> await eventbus.dispose(stop_event_loop=False)
+        """
         await self._pub_connection.close()
         await self._sub_connection.close()
         await self._rpc_client_connection.close()

amqp_client_python/rabbitmq/channel_rabbitmq.py

@@ -127,7 +127,7 @@ class ChannelRabbitMQ:
         self.rpc_publisher = False
         self.rpc_consumer = False
         if not self._stopping:
-            if not self._connection.is_open():
+            if not self._connection.is_open:
                 if self._connection.ioloop_is_open:
                     self._connection.ioloop.call_later(5, self.reconnect)
                 # self._connection._connection.ioloop.call_later(5, self._connection.pause)
@@ -146,7 +146,7 @@ class ChannelRabbitMQ:
             LOGGER.debug("Closing the channel")
             self._channel.close()
 
-    def start_rpc_consumer(self):
+    def start_rpc_consumer(self, exchange, routing_key, message, content_type, correlation_id):
         self.rpc_consumer = True
         LOGGER.info("Starting rpc consumer")
 
@@ -162,6 +162,17 @@ class ChannelRabbitMQ:
                     consumer_tag=None,
                 )
 
+                self._channel.basic_publish(
+                    exchange,
+                    routing_key,
+                    message,
+                    properties=BasicProperties(
+                        reply_to=self._callback_queue,
+                        correlation_id=correlation_id,
+                        content_type=content_type,
+                    ),
+                )
+
             LOGGER.info(f"Declaring queue {self._callback_queue}")
             self._channel_rpc.queue_declare(
                 queue=self._callback_queue,
@@ -189,18 +200,19 @@ class ChannelRabbitMQ:
         last_id = str(uuid4())
         self.futures[last_id] = future
         self.response = None
-        self._channel.basic_publish(
-            exchange,
-            routing_key,
-            message,
-            properties=BasicProperties(
-                reply_to=self._callback_queue,
-                correlation_id=last_id,
-                content_type=content_type,
-            ),
-        )
         if not self.rpc_consumer:
-            self.start_rpc_consumer()
+            self.start_rpc_consumer(exchange, routing_key, message, content_type, last_id)
+        else:
+            self._channel.basic_publish(
+                exchange,
+                routing_key,
+                message,
+                properties=BasicProperties(
+                    reply_to=self._callback_queue,
+                    correlation_id=last_id,
+                    content_type=content_type,
+                ),
+            )
 
         def prevent_infinite_loop(last_id):
             if last_id in self.futures:
@@ -332,5 +344,5 @@ class ChannelRabbitMQ:
             future.set_result(body)
 
     def close(self):
-        if self.is_open():
+        if self.is_open:
             self._channel.close()

amqp_client_python/rabbitmq/connection_rabbitmq.py

@@ -56,7 +56,7 @@ class ConnectionRabbitMQ:
 
     def reconnect(self):
         LOGGER.debug("reconnect %s", self.ioloop_is_open)
-        if not self.is_open():
+        if not self.is_open:
             self._connection = self._connectionFactory.create_connection(
                 self._uri,
                 self.on_connection_open,
@@ -119,7 +119,7 @@ class ConnectionRabbitMQ:
             "durable": durable,
             "callback": callback,
         }
-        if self.is_open():
+        if self.is_open:
             self._channel.declare_exchange(
                 exchange=exchange,
                 durable=durable,
@@ -190,7 +190,7 @@ class ConnectionRabbitMQ:
             self.ioloop.add_callback_threadsafe(channel_openned)
 
     def channel_open(self, callback=lambda x: x):
-        if not self.is_open():
+        if not self.is_open:
             raise EventBusException("No connection open!")
         if not self.channel_is_open():
             self._channel.open(self, callback)
@@ -200,7 +200,7 @@ class ConnectionRabbitMQ:
         return self._connection and self._connection.is_open
 
     def channel_is_open(self):
-        return self._channel and self._channel.is_open()
+        return self._channel and self._channel.is_open
 
     def publish(self, exchange_name: str, routing_key: str, message: str):
         if not self.ioloop_is_open:
@@ -271,5 +271,5 @@ class ConnectionRabbitMQ:
 
     def close(self):
         self._channel.close()
-        if self.is_open():
+        if self.is_open:
             self._connection.close()

amqp_client_python/rabbitmq/eventbus_rabbitmq.py

@@ -185,13 +185,13 @@ class EventbusRabbitMQ:
             self.event_loop.add_callback_threadsafe(rpc_server_setup)
 
     def dispose(self, stop_event_loop=True):
-        if self.pub_connection.is_open():
+        if self.pub_connection.is_open:
             self.pub_connection.close()
-        if self.sub_connection.is_open():
+        if self.sub_connection.is_open:
             self.sub_connection.close()
-        if self.rpc_client_connection.is_open():
+        if self.rpc_client_connection.is_open:
             self.rpc_client_connection.close()
-        if self.rpc_server_connection.is_open():
+        if self.rpc_server_connection.is_open:
             self.rpc_server_connection.close()
         if stop_event_loop:
             self.event_loop.add_callback_threadsafe(self.event_loop.stop)

{amqp_client_python-0.2.0.dist-info → amqp_client_python-0.2.0.post1.dist-info}/METADATA

@@ -1,38 +1,41 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: amqp-client-python
-Version: 0.2.0
+Version: 0.2.0.post1
 Summary: Python AMQP Client Library
-Home-page: https://github.com/nutes-uepb/amqp-client-python
+Project-URL: Homepage, https://github.com/nutes-uepb/amqp-client-python
+Project-URL: Repository, https://github.com/nutes-uepb/amqp-client-python
+Project-URL: Bug Tracker, https://github.com/nutes-uepb/amqp-client-python/issues
+Project-URL: Source, https://github.com/nutes-uepb/amqp-client-python
+Author-email: NUTES UEPB <dev.seniorsaudemovel@gmail.com>
+Maintainer-email: "João Pedro Miranda C. Hluchan" <berrytern@gmail.com>
 License: Apache-2.0
-Keywords: packaging,dependency,amqp-client-python
-Author: NUTES UEPB
-Author-email: dev.seniorsaudemovel@gmail.com
-Requires-Python: >=3.7,<4.0
+License-File: LICENSE
+Keywords: amqp-client-python,dependency,packaging
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 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.7
 Classifier: Programming Language :: Python :: 3.8
 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
 Classifier: Topic :: Communications
 Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Networking
-Requires-Dist: pika (>=1.3.0,<2.0.0)
-Project-URL: Bug Tracker, https://github.com/nutes-uepb/amqp-client-python/issues
-Project-URL: Repository, https://github.com/nutes-uepb/amqp-client-python
+Requires-Python: <4.0,>=3.9
+Requires-Dist: pika<2.0.0,>=1.3.0
 Description-Content-Type: text/markdown
 
 # AMQP Client Python
 
-Client with high level of abstraction for manipulation of messages in the event bus RabbitMQ.
+A Python client providing a high-level abstraction for interacting with RabbitMQ, simplifying message publishing, subscribing, and RPC patterns.
 
 --------
 
@@ -53,6 +56,18 @@ Client with high level of abstraction for manipulation of messages in the event
 
 **Source Code**: <a href="https://github.com/nutes-uepb/amqp-client-python" target="_blank">https://github.com/nutes-uepb/amqp-client-python</a>
 
+**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;
@@ -69,6 +84,18 @@ Client with high level of abstraction for manipulation of messages in the event
 | 0.2.0 | 0.2.0 |
 | 0.1.14 | ~0.1.12 |
 
+### Installation
+
+You can install `amqp-client-python` using pip:
+```bash
+pip install amqp-client-python
+```
+
+### Prerequisites
+
+*   Python 3.7+
+*   A running RabbitMQ instance.
+
 ### Examples:
 #### you can use [sync](https://github.com/nutes-uepb/amqp-client-python/blob/develop/amqp_client_python/rabbitmq/eventbus_rabbitmq.py) , [async eventbus](https://github.com/nutes-uepb/amqp-client-python/blob/develop/amqp_client_python/rabbitmq/async_eventbus_rabbitmq.py) and [sync wrapper](https://github.com/nutes-uepb/amqp-client-python/blob/develop/amqp_client_python/rabbitmq/eventbus_wrapper_rabbitmq.py) of async eventbus
 <details><summary>async usage </summary>
@@ -229,4 +256,4 @@ When using [**EventbusRabbitMQ**](https://github.com/nutes-uepb/amqp-client-pyth
 [known-vulnerabilities-image]: https://snyk.io/test/github/nutes-uepb/amqp-client-python/badge.svg?targetFile=requirements.txt
 [known-vulnerabilities-url]: https://snyk.io/test/github/nutes-uepb/amqp-client-python?targetFile=requirements.txt
 [releases-image]: https://img.shields.io/github/release-date/nutes-uepb/amqp-client-python.svg
-[releases-url]: https://github.com/nutes-uepb/amqp-client-python/releases
+[releases-url]: https://github.com/nutes-uepb/amqp-client-python/releases

{amqp_client_python-0.2.0.dist-info → amqp_client_python-0.2.0.post1.dist-info}/RECORD

@@ -1,8 +1,10 @@
 amqp_client_python/__init__.py,sha256=6kv8G2KlcvbSVIE8Inxb3ugMNSTjg7KK9_HvyDprfb8,213
+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=T57j9Sr5Z0pWyGT598CpAx_KhoV-MVpgHTvfESZAa90,92
-amqp_client_python/domain/models/config.py,sha256=5uoSMpNWYQuJqE1QwVIA52nrKpcsetfOkzvVTtmZsNU,2288
-amqp_client_python/domain/models/options.py,sha256=jFHdoUjyi2v8xQD9W6koCr8icdyHVaKjdD_KYdPlsqE,2169
-amqp_client_python/domain/models/ssl_options.py,sha256=NADGDjxNBfd0QcBY3GSOhoffYmcLYURgzEYIj3ct3xQ,710
+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/ssl_options.py,sha256=xOTSIKfbNZbYepY6o3SxuZvLPX3J5pvRoJXIJlyBsrI,613
 amqp_client_python/domain/utils/__init__.py,sha256=ppob9KPfzq9K3Fd2-RJr6CnwmPDOdgaAzPqOV0Q17P0,75
 amqp_client_python/domain/utils/connection_type.py,sha256=AnEF8Nd3cQBCGX8rPKwEkKts8kwnGUAVr0nxnbpynLE,164
 amqp_client_python/domain/utils/types.py,sha256=veT5lgZhUxophpmWItYaz56XxJTXGJ2L6J6oG_TbSWs,160
@@ -24,22 +26,20 @@ amqp_client_python/exceptions/response_timeout_exception.py,sha256=us_PiJPSk1pnz
 amqp_client_python/exceptions/rpc_provider_exception.py,sha256=_1Ytb8BOUT_9xEtG_ibGx3cEMMM4kUVtduEVtXn-d6M,280
 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/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 amqp_client_python/rabbitmq/__init__.py,sha256=ZFaBSr8TDzZlHwaT344ao20W2FD5c3RI2sa5kiEeKeI,630
-amqp_client_python/rabbitmq/async_channel.py,sha256=xljTUf2XLTpGkLgHM5APNOcC7MGv8Ib68R4UKZHNfvo,25105
+amqp_client_python/rabbitmq/async_channel.py,sha256=OtW0agoSMG-v38lKJsFNRMaFoqubEauQCmLaLN7bQek,26667
 amqp_client_python/rabbitmq/async_channel_factory.py,sha256=ec_5B3Sgazi_ncIG5lI5nnmkH3NprwvyjMhvgpG1BWA,371
-amqp_client_python/rabbitmq/async_connection.py,sha256=U651qEYQUO7DBf33iuztYWRh1TiDJ1t-OPdMxmqZaqg,9225
+amqp_client_python/rabbitmq/async_connection.py,sha256=lWArTU5lXKMrKnnTivhrWs8c9PJnUNMAD5_QI3FZu-s,16906
 amqp_client_python/rabbitmq/async_connection_factory.py,sha256=3N5MM1fPUdodAFLh58rf6vvwN9OAclDVzmG85Qve-Ss,849
-amqp_client_python/rabbitmq/async_eventbus_rabbitmq.py,sha256=d_jcoF3KL4LVyVGoxoEjsuKHPfPXE7ErUlvGP4hw7y0,11766
+amqp_client_python/rabbitmq/async_eventbus_rabbitmq.py,sha256=4PCtqhVNT3cq-d0anfdKPzhmmETD-HMqIu-MVuZmZZA,12950
 amqp_client_python/rabbitmq/channel_factory_rabbitmq.py,sha256=h_vGqHgL0DOtXC0tmVd5gzXVlNKL48rxpKpwaN3AlOM,310
-amqp_client_python/rabbitmq/channel_rabbitmq.py,sha256=HSE3rqFxFrQVpVrs-PhW_2xc8onKFwQNsoXcmmJH1IY,13184
+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=7bv7ci1u0tQK74OvggRRoMfG2oABCnDO3cXoDsm7bdM,9782
-amqp_client_python/rabbitmq/eventbus_rabbitmq.py,sha256=HyfkeIRi4T3mP3XNAHfirr_Pxy2rhMBiE0W2EPsDnlM,6988
+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/ioloop_factory.py,sha256=vfgndKLcazQU0a4elI5RNHnQCTEua--Jjo99bzX8iHo,856
-amqp_client_python/signals.py,sha256=6mW4oWBQnbJwuKox6ceeDbxTM8v9aCDEb0o2zyhpb5g,1263
-amqp_client_python-0.2.0.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-amqp_client_python-0.2.0.dist-info/METADATA,sha256=K-H7fvA9N-ayfq9OVhPAlAbOW6g7zxk2ekqmOPz-SF8,9117
-amqp_client_python-0.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-amqp_client_python-0.2.0.dist-info/RECORD,,
+amqp_client_python-0.2.0.post1.dist-info/METADATA,sha256=w5Hdo9NIX282a9bOtOVK-AIJvvRLU0aUBjr4LPxr2ys,10206
+amqp_client_python-0.2.0.post1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+amqp_client_python-0.2.0.post1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+amqp_client_python-0.2.0.post1.dist-info/RECORD,,

{amqp_client_python-0.2.0.dist-info → amqp_client_python-0.2.0.post1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any