gh-rabbit-hole 1.6.0

Basic Setup

First, import the necessary classes:

from asyncio_rabbit_manager import AsyncioRabbitManagerFactory, AsyncioRabbitManager

Creating a Manager

Use the factory to create an instance of AsyncioRabbitManager:

factory = AsyncioRabbitManagerFactory()
rabbit_manager = factory.create('<config_file_name>')

Sending Messages

Send messages to a specified queue:

rabbit_manager.send_message('Hello, World!', 'my_queue')

Receiving Messages

Define a callback for incoming messages and start listening:

async def handle_message(channel, method, properties, body):
    print("Received message:", body)

rabbit_manager.on_message_callback = handle_message
await rabbit_manager.connect()

Closing Connection

Properly close the connection when done:

await rabbit_manager.close_connection()

Features

• Asynchronous Connection: Establishes non-blocking connections to RabbitMQ, allowing the rest of the application to continue executing while managing network operations in the background.

• Channel Management: Opens and configures RabbitMQ channels to send and receive messages.

• Message Sending and Receiving: Supports sending messages to queues or exchanges and configuring asynchronous callbacks for incoming message handling.

• Asyncio Integration: Built around asyncio primitives for easy integration with other asynchronous operations and the event loop.

• Advanced Logging: Utilizes a customizable logging system to monitor activities and quickly diagnose issues.

Usage

Ideal for asyncio-based applications that require efficient and asynchronous communication with RabbitMQ. Especially useful in contexts where performance and responsiveness are critical, such as in microservices, bots, or real-time data processing systems.

import logging
from your_module import AsyncioRabbitManager  # Replace with the actual module name

logger = logging.getLogger(__name__)

rabbit_manager = AsyncioRabbitManager(
    amqp_url="your_amqp_url",
    sending_queue="your_sending_queue",
    listening_queue="your_listening_queue",
    sending_exchange="your_sending_exchange",
    logger=logger,
    on_message_callback=your_message_callback_function  # Replace with your callback
)

import asyncio

async def main():
    await rabbit_manager.connect()

asyncio.run(main())

message = {"key": "value"}  # Your message content
routing_key = "your_routing_key"  # Optional
to_exchange = False  # Set to True if sending to an exchange

rabbit_manager.send_message(message, routing_key, to_exchange)

async def message_handler(channel, method, properties, body):
    print("Received message:", body)

# Set this as your callback
rabbit_manager.on_message_callback = message_handler

async def close():
    await rabbit_manager.close_connection()

asyncio.run(close())