workerlib 0.3.1__py3-none-any.whl

workerlib/__init__.py

@@ -0,0 +1,22 @@
+from src.workerlib.connection import RabbitMQConnection, ConnectionParams, ConnectionError
+from src.workerlib.mq_queue import RabbitMQQueue, QueueConfig
+from src.workerlib.consumer import RabbitMQConsumer, ErrorHandlingStrategy
+from src.workerlib.pool import WorkerPool
+from src.workerlib.producer import RabbitMQProducer
+from src.workerlib.retry import RetryConfig, retry_on_failure
+
+__version__ = "0.3.1"
+
+__all__ = [
+    'WorkerPool',
+    'RabbitMQConnection',
+    'ConnectionParams',
+    'ConnectionError',
+    'RabbitMQQueue',
+    'QueueConfig',
+    'RabbitMQConsumer',
+    'ErrorHandlingStrategy',
+    'RabbitMQProducer',
+    'RetryConfig',
+    'retry_on_failure'
+]

workerlib/connection.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass
+from typing import Optional
+import aio_pika
+import logging
+
+
+@dataclass
+class ConnectionParams:
+    host: str = "127.0.0.1"
+    port: int = 5672
+    virtual_host: str = "/"
+    username: str = "guest"
+    password: str = "guest"
+    heartbeat: int = 60
+    timeout: int = 10
+
+
+class ConnectionError(Exception):
+    pass
+
+
+logger = logging.getLogger(__name__)
+
+
+class RabbitMQConnection:
+    def __init__(self, params: ConnectionParams = None):
+        self.params = params or ConnectionParams()
+        self._connection: Optional[aio_pika.abc.AbstractRobustConnection] = None
+        self._channel: Optional[aio_pika.Channel] = None
+
+    @property
+    def channel(self) -> aio_pika.Channel:
+        if not self._channel or self._channel.is_closed:
+            raise ConnectionError("Channel not available. Call connect() first.")
+        return self._channel
+
+    def _get_url(self) -> str:
+        return (f"amqp://{self.params.username}:{self.params.password}"
+                f"@{self.params.host}:{self.params.port}"
+                f"/{self.params.virtual_host}")
+
+    async def is_healthy(self) -> bool:
+        return self._connection and not self._connection.is_closed
+
+    async def connect(self) -> None:
+        if self._connection and not self._connection.is_closed:
+            logger.info("Connection is already open.")
+            return
+        try:
+            self._connection = await aio_pika.connect_robust(
+                self._get_url(),
+                heartbeat=self.params.heartbeat,
+                timeout=self.params.timeout
+            )
+            self._channel = await self._connection.channel()
+            logger.info(f"Connected to RabbitMQ at {self.params.host}:{self.params.port}")
+        except Exception as e:
+            logger.error(f"Error connecting to RabbitMQ: {e}")
+            raise ConnectionError(f"Error connecting to RabbitMQ: {e}")
+
+    async def reconnect(self) -> None:
+        await self.close()
+        await self.connect()
+
+    async def close(self) -> None:
+        if self._connection and not self._connection.is_closed:
+            await self._connection.close()
+            self._connection = None
+            self._channel = None
+            logger.info("Connection to RabbitMQ closed.")
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

workerlib/consumer.py

@@ -0,0 +1,217 @@
+import asyncio
+import json
+import logging
+import time
+from enum import Enum
+from typing import Callable, Awaitable, Optional, Dict, Any
+
+import aio_pika
+
+from .mq_queue import RabbitMQQueue
+from .retry import retry_on_failure, RetryConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ErrorHandlingStrategy(Enum):
+    IGNORE = "ignore"
+    REQUEUE_END = "requeue_end"
+    REQUEUE_FRONT = "requeue_front"
+    DLQ = "dlq"
+    RETRY_THEN_DLQ = "retry_then_dlq"
+
+
+class RabbitMQConsumer:
+    def __init__(
+            self,
+            queue: RabbitMQQueue,
+            handler: Callable[[Dict[str, Any]], Awaitable[bool]],
+            error_strategy: ErrorHandlingStrategy = ErrorHandlingStrategy.RETRY_THEN_DLQ,
+            retry_config: Optional[RetryConfig] = None,
+            dlq_enabled: bool = True,
+            requeue_delay: float = 5.0
+    ) -> None:
+        self.queue = queue
+        self.handler = handler
+        self.error_strategy = error_strategy
+        self.retry_config = retry_config or RetryConfig()
+        self.dlq_enabled = dlq_enabled
+        self.requeue_delay = requeue_delay
+
+        self.metrics = {
+            "processed": 0,
+            "failed": 0,
+            "requeued": 0,
+            "dlq_moved": 0,
+            "ignored": 0
+        }
+
+    async def _requeue_with_delay(self, message: aio_pika.abc.AbstractIncomingMessage):
+        try:
+            channel = message.channel
+            delay_queue_name = f"{self.queue.config.name}.delayed"
+
+            await channel.declare_queue(
+                delay_queue_name,
+                durable=True,
+                arguments={
+                    "x-dead-letter-exchange": "",
+                    "x-dead-letter-routing-key": self.queue.config.name,
+                    "x-message-ttl": int(self.requeue_delay * 1000)
+                }
+            )
+
+            await channel.publish(
+                aio_pika.Message(
+                    body=message.body,
+                    headers=message.headers,
+                    delivery_mode=message.delivery_mode
+                ),
+                exchange='',
+                routing_key=delay_queue_name
+            )
+
+            self.metrics["requeued"] += 1
+            logger.info(f"Message requeued with {self.requeue_delay}s delay")
+
+        except Exception as e:
+            logger.error(f"Failed to requeue message: {e}")
+            await message.nack(requeue=True)
+
+    async def _move_to_dlq(self, message: aio_pika.abc.AbstractIncomingMessage, error_msg: str = None):
+        if not self.dlq_enabled:
+            return False
+
+        try:
+            dlq_name = f"{self.queue.config.name}.dlq"
+
+            channel = self.queue.connection.channel
+
+            await channel.declare_queue(
+                dlq_name,
+                durable=True,
+                arguments={"x-queue-mode": "lazy"}
+            )
+
+            headers = message.headers or {}
+            headers.update({
+                "x-failure-reason": error_msg or "Unknown error",
+                "x-original-queue": self.queue.config.name,
+                "x-failed-at": time.time()
+            })
+
+            exchange = channel.default_exchange
+            await exchange.publish(
+                aio_pika.Message(
+                    body=message.body,
+                    headers=headers,
+                    delivery_mode=message.delivery_mode,
+                    content_type=message.content_type
+                ),
+                routing_key=dlq_name
+            )
+
+            self.metrics["dlq_moved"] += 1
+            logger.info(f"Message moved to DLQ: {dlq_name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to move message to DLQ: {e}")
+            return False
+
+    async def _handle_with_retry(self, data: Dict[str, Any]) -> bool:
+
+        async def attempt_handler():
+            return await self.handler(data)
+
+        try:
+            if self.retry_config.max_attempts > 1:
+                return await retry_on_failure(attempt_handler, config=self.retry_config)
+            else:
+                return await self.handler(data)
+        except Exception as e:
+            logger.error(f"Handler failed after retries: {e}")
+            return False
+
+    async def _handle_error(self, message: aio_pika.abc.AbstractIncomingMessage,
+                            data: Optional[Dict[str, Any]] = None,
+                            error_msg: str = None):
+
+        if self.error_strategy == ErrorHandlingStrategy.IGNORE:
+            await message.ack()
+            self.metrics["ignored"] += 1
+            logger.warning(f"Ignored failed message: {error_msg}")
+
+        elif self.error_strategy == ErrorHandlingStrategy.REQUEUE_END:
+            await self._requeue_with_delay(message)
+            await message.ack()
+            self.metrics["failed"] += 1
+
+        elif self.error_strategy == ErrorHandlingStrategy.REQUEUE_FRONT:
+            await message.nack(requeue=True)
+            self.metrics["failed"] += 1
+            logger.info("Message requeued to front")
+
+        elif self.error_strategy == ErrorHandlingStrategy.DLQ:
+            moved = await self._move_to_dlq(message, error_msg)
+            await message.ack()
+            self.metrics["failed"] += 1
+            if not moved:
+                logger.error("Failed to move to DLQ, message acknowledged anyway")
+
+        elif self.error_strategy == ErrorHandlingStrategy.RETRY_THEN_DLQ:
+            if data and await self._handle_with_retry(data):
+                await message.ack()
+                self.metrics["processed"] += 1
+                logger.info("Message processed successfully after retry")
+            else:
+                moved = await self._move_to_dlq(message, error_msg)
+                await message.ack()
+                self.metrics["failed"] += 1
+                if not moved:
+                    logger.error("Failed to move to DLQ after retry")
+
+    async def process_message(self, message: aio_pika.abc.AbstractIncomingMessage):
+        try:
+            data = json.loads(message.body.decode())
+
+            if self.error_strategy == ErrorHandlingStrategy.RETRY_THEN_DLQ:
+                success = await self._handle_with_retry(data)
+                if success:
+                    await message.ack()
+                    self.metrics["processed"] += 1
+                    logger.info("Message processed successfully")
+                else:
+                    await self._handle_error(message, data, "Retry failed")
+            else:
+                success = await self.handler(data)
+                if success:
+                    await message.ack()
+                    self.metrics["processed"] += 1
+                    logger.info("Message processed successfully")
+                else:
+                    await self._handle_error(message, data, "Handler returned False")
+
+        except json.JSONDecodeError as e:
+            error_msg = f"Invalid JSON: {e}"
+            logger.error(error_msg)
+            await self._handle_error(message, None, error_msg)
+
+        except Exception as e:
+            error_msg = f"Unexpected error: {e}"
+            logger.error(error_msg)
+            await self._handle_error(message, None, error_msg)
+
+    async def consume(self, stop_event: Optional[asyncio.Event] = None) -> None:
+        queue = await self.queue.get_queue()
+
+        async with queue.iterator() as queue_iter:
+            async for message in queue_iter:
+                if stop_event and stop_event.is_set():
+                    logger.info("Stop event received, stopping consumer")
+                    break
+
+                logger.debug(f"Received message: {message.message_id}")
+                await self.process_message(message)
+
+        logger.info("Consumer stopped")

workerlib/mq_queue.py

@@ -0,0 +1,46 @@
+import logging
+from dataclasses import dataclass
+from typing import Optional
+
+import aio_pika
+
+from .connection import RabbitMQConnection
+
+
+@dataclass
+class QueueConfig:
+    name: str
+    durable: bool = True
+    exclusive: bool = False
+    auto_delete: bool = False
+    arguments: Optional[dict] = None
+    prefetch_count: int = 1
+
+
+logger = logging.getLogger(__name__)
+
+
+class RabbitMQQueue:
+    def __init__(self, connection: RabbitMQConnection, config: QueueConfig):
+        self.connection = connection
+        self.config = config
+        self._queue = None
+
+    @property
+    def queue_name(self) -> str:
+        return self.config.name
+
+    async def get_queue(self) -> aio_pika.Queue:
+        if not self._queue:
+            await self.connection.connect()
+            channel = self.connection.channel
+            await channel.set_qos(prefetch_count=self.config.prefetch_count)
+            self._queue = await channel.declare_queue(
+                self.config.name,
+                durable=self.config.durable,
+                exclusive=self.config.exclusive,
+                auto_delete=self.config.auto_delete,
+                arguments=self.config.arguments or {}
+            )
+            logger.info(f"Queue declared: {self.config.name}")
+        return self._queue

workerlib/pool.py

@@ -0,0 +1,172 @@
+import asyncio
+import logging
+from asyncio import Task
+from typing import Optional, Dict, Callable, Any, Awaitable
+
+from .connection import RabbitMQConnection, ConnectionParams
+from .mq_queue import RabbitMQQueue, QueueConfig
+from .consumer import RabbitMQConsumer, ErrorHandlingStrategy
+from .producer import RabbitMQProducer
+from .retry import RetryConfig
+
+logger = logging.getLogger(__name__)
+
+
+class WorkerPool:
+    def __init__(
+            self,
+            connection_params: Optional[ConnectionParams] = None,
+            auto_start: bool = True
+    ):
+        self.connection_params = connection_params or ConnectionParams()
+        self.connection: Optional[RabbitMQConnection] = None
+        self.workers: Dict[str, RabbitMQConsumer] = {}
+        self.producers: Dict[str, RabbitMQProducer] = {}
+        self.tasks: Dict[str, Task] = {}
+        self._auto_start = auto_start
+
+    async def __aenter__(self):
+        if self._auto_start:
+            await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.stop()
+
+    async def start(self):
+        if self.connection and await self.connection.is_healthy():
+            logger.info("WorkerPool already started")
+            return
+
+        self.connection = RabbitMQConnection(self.connection_params)
+        await self.connection.connect()
+        logger.info("WorkerPool started")
+
+    async def stop(self):
+        for task_name, task in self.tasks.items():
+            task.cancel()
+            logger.debug(f"Cancelled task: {task_name}")
+
+        if self.tasks:
+            await asyncio.gather(*self.tasks.values(), return_exceptions=True)
+            self.tasks.clear()
+
+        if self.connection:
+            await self.connection.close()
+            self.connection = None
+
+        self.workers.clear()
+        self.producers.clear()
+        logger.info("WorkerPool stopped")
+
+    def add_worker(
+            self,
+            queue_name: str,
+            handler: Callable[[Dict[str, Any]], Awaitable[bool]],
+            prefetch_count: int = 1,
+            error_strategy: ErrorHandlingStrategy = ErrorHandlingStrategy.RETRY_THEN_DLQ,
+            retry_config: Optional[RetryConfig] = None,
+            dlq_enabled: bool = True,
+            auto_start: bool = True
+    ):
+        if queue_name in self.workers:
+            raise KeyError(f"Worker for queue '{queue_name}' already exists")
+
+        if not self.connection:
+            raise RuntimeError("Connection not established. Call start() first or set auto_start=True")
+
+        queue_config = QueueConfig(
+            name=queue_name,
+            prefetch_count=prefetch_count
+        )
+
+        queue = RabbitMQQueue(self.connection, queue_config)
+
+        consumer = RabbitMQConsumer(
+            queue=queue,
+            handler=handler,
+            error_strategy=error_strategy,
+            retry_config=retry_config,
+            dlq_enabled=dlq_enabled
+        )
+
+        producer = RabbitMQProducer(
+            connection=self.connection,
+            queue=queue,
+            send_retries=3
+        )
+
+        self.workers[queue_name] = consumer
+        self.producers[queue_name] = producer
+
+        if auto_start:
+            task = asyncio.create_task(consumer.consume())
+            self.tasks[queue_name] = task
+            logger.info(f"Worker for queue '{queue_name}' started")
+        else:
+            logger.info(f"Worker for queue '{queue_name}' added (not started)")
+
+    async def send(
+            self,
+            queue_name: str,
+            data: Dict[str, Any],
+            with_retry: bool = True,
+            **kwargs
+    ):
+        if queue_name not in self.producers:
+            raise ValueError(f"No producer for queue '{queue_name}'")
+
+        producer = self.producers[queue_name]
+
+        if with_retry:
+            await producer.send_with_retry(data, **kwargs)
+        else:
+            await producer.send(data, **kwargs)
+
+    async def send_raw(self, queue_name: str, body: bytes, **kwargs):
+        if queue_name not in self.producers:
+            raise ValueError(f"No producer for queue '{queue_name}'")
+
+        producer = self.producers[queue_name]
+        await producer.send_raw(body, **kwargs)
+
+    def get_metrics(self, queue_name: Optional[str] = None) -> Dict[str, Any]:
+        if queue_name:
+            if queue_name not in self.workers:
+                raise ValueError(f"No worker for queue '{queue_name}'")
+
+            consumer_metrics = self.workers[queue_name].metrics.copy()
+            producer_metrics = self.producers[queue_name].metrics.copy()
+
+            return {
+                "consumer": consumer_metrics,
+                "producer": producer_metrics,
+                "queue": queue_name
+            }
+        else:
+            all_metrics = {
+                "total_queues": len(self.workers),
+                "queues": {}
+            }
+
+            for q_name in self.workers:
+                all_metrics["queues"][q_name] = self.get_metrics(q_name)
+
+            return all_metrics
+
+    async def restart_worker(self, queue_name: str):
+        if queue_name not in self.tasks:
+            raise ValueError(f"No running worker for queue '{queue_name}'")
+
+        old_task = self.tasks[queue_name]
+        old_task.cancel()
+        try:
+            await old_task
+        except asyncio.CancelledError:
+            pass
+
+        consumer = self.workers[queue_name]
+        new_task = asyncio.create_task(consumer.consume())
+        self.tasks[queue_name] = new_task
+
+        logger.info(f"Worker for queue '{queue_name}' restarted")

workerlib/producer.py

@@ -0,0 +1,161 @@
+import json
+import logging
+import asyncio
+from typing import Any, Dict, List, Optional
+
+import aio_pika
+from aio_pika.exceptions import AMQPConnectionError
+
+from .connection import RabbitMQConnection
+from .mq_queue import RabbitMQQueue
+
+logger = logging.getLogger(__name__)
+
+
+class RabbitMQProducer:
+    def __init__(
+            self,
+            connection: RabbitMQConnection,
+            queue: RabbitMQQueue,
+            send_retries: int = 3,
+            retry_delay: float = 1.0,
+            enable_auto_reconnect: bool = True
+    ) -> None:
+        self.connection = connection
+        self.queue = queue
+        self.send_retries = send_retries
+        self.retry_delay = retry_delay
+        self.enable_auto_reconnect = enable_auto_reconnect
+        self.metrics = {
+            "sent": 0,
+            "failed": 0,
+            "retried": 0
+        }
+
+    async def _ensure_connection(self) -> None:
+        if not await self.connection.is_healthy():
+            if self.enable_auto_reconnect:
+                logger.warning("Connection lost, attempting to reconnect...")
+                await self.connection.reconnect()
+            else:
+                raise ConnectionError("Connection is not available")
+
+    async def send_with_retry(
+            self,
+            data: Dict[str, Any],
+            max_retries: Optional[int] = None,
+            retry_delay: Optional[float] = None,
+            **kwargs
+    ) -> bool:
+        max_retries = max_retries or self.send_retries
+        retry_delay = retry_delay or self.retry_delay
+        last_exception = None
+
+        for attempt in range(max_retries):
+            try:
+                await self.send(data, **kwargs)
+                return True
+
+            except (AMQPConnectionError, ConnectionError) as e:
+                last_exception = e
+                self.metrics["retried"] += 1
+
+                if attempt == max_retries - 1:
+                    logger.error(f"Failed to send after {max_retries} attempts: {e}")
+                    break
+
+                logger.warning(
+                    f"Connection error on send attempt {attempt + 1}/{max_retries}. "
+                    f"Retrying in {retry_delay}s... Error: {e}"
+                )
+
+                await asyncio.sleep(retry_delay)
+
+                if self.enable_auto_reconnect:
+                    try:
+                        await self.connection.reconnect()
+                        logger.info("Reconnected successfully")
+                    except Exception as reconnect_error:
+                        logger.error(f"Failed to reconnect: {reconnect_error}")
+
+        self.metrics["failed"] += 1
+        if last_exception:
+            raise last_exception
+        return False
+
+    async def send(self, data: Dict[str, Any], **kwargs) -> None:
+        await self._ensure_connection()
+
+        try:
+            queue_obj = await self.queue.get_queue()
+            body = json.dumps(data).encode()
+
+            message = aio_pika.Message(
+                body=body,
+                delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
+                content_type="application/json",
+                **kwargs
+            )
+
+            channel = self.connection.channel
+            exchange = channel.default_exchange
+
+            await exchange.publish(
+                message,
+                routing_key=queue_obj.name
+            )
+
+            self.metrics["sent"] += 1
+            logger.debug(f"Message sent to queue {queue_obj.name}")
+
+        except Exception as e:
+            self.metrics["failed"] += 1
+            logger.error(f"Failed to send message: {e}")
+            raise
+
+    async def send_raw(self, body: bytes, **kwargs) -> None:
+        await self._ensure_connection()
+
+        try:
+            queue_obj = await self.queue.get_queue()
+            message = aio_pika.Message(body=body, **kwargs)
+
+            channel = self.connection.channel
+            exchange = channel.default_exchange
+            await exchange.publish(
+                message,
+                routing_key=queue_obj.name
+            )
+
+            self.metrics["sent"] += 1
+            logger.debug(f"Raw message sent to queue {queue_obj.name}")
+
+        except Exception as e:
+            self.metrics["failed"] += 1
+            logger.error(f"Failed to send raw message: {e}")
+            raise
+
+    async def send_batch(self, messages: List[Dict[str, Any]]) -> None:
+        await self._ensure_connection()
+
+        queue_obj = await self.queue.get_queue()
+        channel = self.connection.channel
+        exchange = channel.default_exchange
+        sent_count = 0
+
+        for data in messages:
+            try:
+                body = json.dumps(data).encode()
+                message = aio_pika.Message(
+                    body=body,
+                    delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
+                    content_type="application/json"
+                )
+                await exchange.publish(message, routing_key=queue_obj.name)
+                sent_count += 1
+
+            except Exception as e:
+                logger.error(f"Failed to send message in batch: {e}")
+
+        self.metrics["sent"] += sent_count
+        logger.info(f"Sent {sent_count}/{len(messages)} messages to queue {queue_obj.name}")

workerlib/retry.py

@@ -0,0 +1,49 @@
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Optional, Any, Callable, Awaitable
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class RetryConfig:
+    max_attempts: int = 3
+    initial_delay: float = 1.0
+    backoff_factor: float = 2.0
+    max_delay: float = 60.0
+
+    def get_delay(self, attempt: int) -> float:
+        delay = self.initial_delay * (self.backoff_factor ** (attempt - 1))
+        return min(delay, self.max_delay)
+
+
+async def retry_on_failure(
+        func: Callable[..., Awaitable[Any]],
+        *args,
+        config: Optional[RetryConfig] = None,
+        **kwargs
+) -> Any:
+    retry_config = config or RetryConfig()
+    last_error: Optional[Exception] = None
+
+    for attempt in range(1, retry_config.max_attempts + 1):
+        try:
+            result = await func(*args, **kwargs)
+            if attempt > 1:
+                logger.info(f"Success after {attempt} attempts")
+            return result
+        except Exception as e:
+            last_error = e
+            if attempt == retry_config.max_attempts:
+                logger.error(f"Max retries exceeded: {attempt}")
+                break
+
+            delay = retry_config.get_delay(attempt)
+            logger.warning(
+                f"Attempt {attempt}/{retry_config.max_attempts} failed. "
+                f"Retrying in {delay:.1f}s. Error: {e}"
+            )
+            await asyncio.sleep(delay)
+
+    raise last_error or Exception("Unknown error")

workerlib-0.3.1.dist-info/METADATA

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: workerlib
+Version: 0.3.1
+Summary: Async RabbitMQ worker utilities
+Author-email: YOUR_NAME <your.email@example.com>
+Maintainer-email: YOUR_NAME <your.email@example.com>
+Project-URL: Homepage, https://github.com/ametist-dev/workerlib
+Project-URL: Repository, https://github.com/ametist-dev/workerlib
+Project-URL: Issues, https://github.com/ametist-dev/workerlib/issues
+Keywords: async,rabbitmq,aio-pika,workers
+Classifier: Programming Language :: Python :: 3
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aio-pika<10,>=9.0.0
+
+# WorkerLib - асинхронная работа с RabbitMQ
+## Быстрый старт
+```python
+import asyncio
+from workerlib import WorkerPool
+
+async def task_handler(data: dict) -> bool:
+    print(f"Обработка: {data}")
+    return True
+
+async def main():
+    async with WorkerPool() as pool:
+        pool.add_worker("tasks", task_handler)
+        await pool.send("tasks", {"id": 1, "cmd": "start"})
+        await asyncio.sleep(2)
+
+asyncio.run(main())
+```
+## Формат сообщений
+**JSON сообщение**
+Библиотека автоматически сериализует dict в JSON при отправке:
+```python
+# Отправка простого сообщения
+await pool.send("queue", {
+    "event": "user_created",
+    "user_id": 123,
+    "email": "user@example.com",
+    "timestamp": "2024-01-15T10:30:00Z"
+})
+
+# Отправка вложенных структур
+await pool.send("queue", {
+    "type": "order",
+    "data": {
+        "order_id": "ORD-12345",
+        "items": [
+            {"id": 1, "quantity": 2},
+            {"id": 2, "quantity": 1}
+        ],
+        "total": 299.99
+    },
+    "metadata": {
+        "source": "api",
+        "version": "1.0"
+    }
+})
+```
+## Основные примеры
+1. Пул с несколькими воркерами
+```python
+from workerlib import WorkerPool, ErrorHandlingStrategy
+
+async def main():
+    async with WorkerPool() as pool:
+        # Email воркер с DLQ
+        pool.add_worker(
+            queue_name="emails",
+            handler=email_handler,
+            error_strategy=ErrorHandlingStrategy.RETRY_THEN_DLQ,
+            prefetch_count=5
+        )
+        
+        # Обработчик платежей
+        pool.add_worker(
+            queue_name="payments",
+            handler=payment_handler,
+            error_strategy=ErrorHandlingStrategy.REQUEUE_END
+        )
+        
+        # Отправка задач
+        await pool.send("emails", {"to": "user@test.com"})
+        await pool.send("payments", {"amount": 100})
+```
+2. Кастомное подключение и retry
+```python
+from workerlib import ConnectionParams, RetryConfig
+
+params = ConnectionParams(
+    host="rabbit.local",
+    username="admin",
+    password="secret"
+)
+
+retry_config = RetryConfig(
+    max_attempts=3,
+    initial_delay=1.0,
+    backoff_factor=2.0
+)
+
+async with WorkerPool(connection_params=params) as pool:
+    pool.add_worker(
+        queue_name="critical",
+        handler=critical_handler,
+        retry_config=retry_config
+    )
+```
+3. Обработка ошибок
+```python
+from workerlib import ErrorHandlingStrategy
+
+# Варианты:
+# IGNORE - проигнорировать ошибку
+# REQUEUE_END - в конец очереди с задержкой
+# REQUEUE_FRONT - в начало очереди
+# DLQ - в Dead Letter Queue
+# RETRY_THEN_DLQ - повторить, затем в DLQ
+
+pool.add_worker(
+    queue_name="tasks",
+    handler=my_handler,
+    error_strategy=ErrorHandlingStrategy.RETRY_THEN_DLQ,
+    dlq_enabled=True,
+    requeue_delay=5.0  # задержка повторной обработки
+)
+```
+4. Отдельные компоненты
+```python
+from workerlib import (
+    RabbitMQConnection,
+    RabbitMQQueue,
+    RabbitMQConsumer,
+    RabbitMQProducer
+)
+
+# Создание вручную
+connection = RabbitMQConnection()
+await connection.connect()
+
+queue = RabbitMQQueue(connection, QueueConfig(name="my_queue"))
+
+producer = RabbitMQProducer(connection, queue)
+await producer.send({"test": "data"})
+
+consumer = RabbitMQConsumer(queue, my_handler)
+await consumer.consume()
+```
+5. Batch отправка
+```python
+async with WorkerPool() as pool:
+    messages = [
+        {"id": i, "data": f"item_{i}"}
+        for i in range(100)
+    ]
+    
+    tasks = [
+        pool.send("batch_queue", msg)
+        for msg in messages
+    ]
+    
+    await asyncio.gather(*tasks)
+```
+6. Метрики
+```python
+async with WorkerPool() as pool:
+    pool.add_worker("monitored", handler)
+    
+    # Отправляем задачи
+    for i in range(10):
+        await pool.send("monitored", {"task": i})
+    
+    # Получаем метрики
+    metrics = pool.get_metrics("monitored")
+    print(f"Обработано: {metrics['consumer']['processed']}")
+    print(f"Ошибок: {metrics['consumer']['failed']}")
+```
+7. FastAPI интеграция
+```python
+from fastapi import FastAPI
+from workerlib import WorkerPool
+
+app = FastAPI()
+worker_pool = WorkerPool(auto_start=False)
+
+@app.on_event("startup")
+async def startup():
+    await worker_pool.start()
+    worker_pool.add_worker("api_tasks", task_handler)
+
+@app.on_event("shutdown")
+async def shutdown():
+    await worker_pool.stop()
+
+@app.post("/task")
+async def create_task(data: dict):
+    await worker_pool.send("api_tasks", data)
+    return {"status": "queued"}
+```
+## Конфигурация
+ConnectionParams
+```python
+ConnectionParams(
+    host="127.0.0.1",
+    port=5672,
+    username="guest",
+    password="guest",
+    heartbeat=60,
+    timeout=10
+)
+```
+QueueConfig
+```python
+QueueConfig(
+    name="queue_name",
+    durable=True,
+    prefetch_count=1
+)
+```
+RetryConfig
+```python
+RetryConfig(
+    max_attempts=3,
+    initial_delay=1.0,
+    backoff_factor=2.0,
+    max_delay=60.0
+)
+```
+## Установка
+```bash
+pip install workerlib
+```
+Требования: Python 3.8+, aio_pika

workerlib-0.3.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+workerlib/__init__.py,sha256=-Kf1M5qJ-QOaNtMv1XUzFM3-IShzjIYbE-TQpkcvl-I,692
+workerlib/connection.py,sha256=pJGTnxOORPGCRnMezpbo2JDZ7EVWSGGm2-joDLw1EaQ,2531
+workerlib/consumer.py,sha256=xPpQxvnBoLaBB3nZH-P7PyAFzxyehD6ruvGQ0gPGj_I,7979
+workerlib/mq_queue.py,sha256=yBsW7rVeNwWjzkYnBYO46kzJTttacrPrzGgwFaS-580,1329
+workerlib/pool.py,sha256=_7lFiYp-b0Xj3E6iSFWLFt7t9jdyWrsZYxXBiSu6HCw,5765
+workerlib/producer.py,sha256=L1iw2IHWOnRRZZOiFu3LzetIx5OnaEUyqP1AhcOCcf8,5421
+workerlib/retry.py,sha256=3wIK3hqQ09A3q54k6kkpNZL6pBSSQGfvHaWCQ0XPwDA,1526
+workerlib-0.3.1.dist-info/METADATA,sha256=kxfOazgUvEUb6BmmOLDJWoTdvbBTMnNvH76gAGQI44c,6689
+workerlib-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+workerlib-0.3.1.dist-info/top_level.txt,sha256=CrIpxje3R-70l5ttCsQ7A-tjg6_oJU1tMC02RKkCl3Y,10
+workerlib-0.3.1.dist-info/RECORD,,

workerlib-0.3.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

workerlib-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+workerlib