async-task-kit 0.1.1__tar.gz → 0.1.13__tar.gz

{async_task_kit-0.1.1 → async_task_kit-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-task-kit
-Version: 0.1.1
+Version: 0.1.13
 Summary: A powerful async task processing kit based on RabbitMQ with Coroutine, Thread, and Process support.
 Author-email: realwrtoff <realwrtoff@gmail.com>
 Classifier: Programming Language :: Python :: 3
@@ -10,6 +10,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aio-pika>=9.4.0
+Requires-Dist: asyncpg>=0.31.0
 Requires-Dist: python-dotenv>=1.0.0
 Dynamic: license-file
 
@@ -174,6 +175,54 @@ if __name__ == "__main__":
     asyncio.run(publish())
 ```
 
+### 5. RabbitMQ Client API
+
+`RabbitMQ` 提供连接池、`push` / `pop`、延迟重试队列，以及 `queue_length` 查询队列深度。
+
+#### `queue_length`
+
+```python
+from async_task_kit import RabbitMQ
+
+rmq = RabbitMQ("amqp://guest:guest@localhost/")
+await rmq.init()
+
+length = await rmq.queue_length("my_demo_queue")
+if length == RabbitMQ.QUEUE_LENGTH_UNAVAILABLE:
+    # -1：连不上或队列不存在，稍后重试
+    ...
+elif length == 0:
+    # 队列存在且为空
+    ...
+else:
+    # 当前消息数
+    ...
+
+await rmq.close()
+```
+
+| 返回值 | 含义 |
+|--------|------|
+| `>= 0` | 队列真实消息数（`0` = 空队列） |
+| `-1` (`QUEUE_LENGTH_UNAVAILABLE`) | 连接失败、队列不存在或其它异常，应重试 |
+
+实现要点：
+
+- 使用 **`passive=True`** 声明：只查询已存在的队列，**不会**自动创建空队列。
+- 断连时会关闭旧连接池并自动重建（与 `push` / `pop` 一致）。
+
+#### `pop` 的 `durable` 参数
+
+`pop` 在取消息前会 `declare_queue`。`push` 默认以 **`durable=True`** 创建队列（重启后队列仍在），因此 `pop` 默认同样传 `durable=True`，保证声明参数与已有队列一致，避免 RabbitMQ 返回 `PRECONDITION_FAILED`。
+
+若你的队列是非持久化的，调用时需显式传入：
+
+```python
+await rmq.pop("my_queue", durable=False)
+```
+
+`queue_length` 使用 passive 模式，无需传 `durable`。
+
 ## License
 
 MIT

{async_task_kit-0.1.1 → async_task_kit-0.1.13}/README.md

@@ -159,6 +159,54 @@ if __name__ == "__main__":
     asyncio.run(publish())
 ```
 
+### 5. RabbitMQ Client API
+
+`RabbitMQ` 提供连接池、`push` / `pop`、延迟重试队列，以及 `queue_length` 查询队列深度。
+
+#### `queue_length`
+
+```python
+from async_task_kit import RabbitMQ
+
+rmq = RabbitMQ("amqp://guest:guest@localhost/")
+await rmq.init()
+
+length = await rmq.queue_length("my_demo_queue")
+if length == RabbitMQ.QUEUE_LENGTH_UNAVAILABLE:
+    # -1：连不上或队列不存在，稍后重试
+    ...
+elif length == 0:
+    # 队列存在且为空
+    ...
+else:
+    # 当前消息数
+    ...
+
+await rmq.close()
+```
+
+| 返回值 | 含义 |
+|--------|------|
+| `>= 0` | 队列真实消息数（`0` = 空队列） |
+| `-1` (`QUEUE_LENGTH_UNAVAILABLE`) | 连接失败、队列不存在或其它异常，应重试 |
+
+实现要点：
+
+- 使用 **`passive=True`** 声明：只查询已存在的队列，**不会**自动创建空队列。
+- 断连时会关闭旧连接池并自动重建（与 `push` / `pop` 一致）。
+
+#### `pop` 的 `durable` 参数
+
+`pop` 在取消息前会 `declare_queue`。`push` 默认以 **`durable=True`** 创建队列（重启后队列仍在），因此 `pop` 默认同样传 `durable=True`，保证声明参数与已有队列一致，避免 RabbitMQ 返回 `PRECONDITION_FAILED`。
+
+若你的队列是非持久化的，调用时需显式传入：
+
+```python
+await rmq.pop("my_queue", durable=False)
+```
+
+`queue_length` 使用 passive 模式，无需传 `durable`。
+
 ## License
 
 MIT

{async_task_kit-0.1.1 → async_task_kit-0.1.13}/async_task_kit/core/rabbitmq.py

@@ -29,7 +29,11 @@ class BasicQueue(ABC):
     @abstractmethod
     async def pop(self, queue_name: str,** kwargs: Any) -> Any:
         raise NotImplementedError
-
+    
+    @abstractmethod
+    async def queue_length(self, queue_name: str) -> int:
+        raise NotImplementedError
+    
     @abstractmethod
     async def ack(self, message: Any) -> None:
         raise NotImplementedError
@@ -50,6 +54,7 @@ class RabbitMQ(BasicQueue):
     DEFAULT_DEAD_LETTER_DAYS = 7
     DEFAULT_DELAY_SECONDS = 30
     DEFAULT_POP_TIMEOUT = 1.0
+    QUEUE_LENGTH_UNAVAILABLE = -1
 
     def __init__(
         self,
@@ -92,6 +97,23 @@ class RabbitMQ(BasicQueue):
                 logger.error(f"[RabbitMQ] 初始化失败: {e}", exc_info=True)
                 raise
 
+    async def _invalidate_pools(self) -> None:
+        """断连或 close 时关闭 pool，下次 init() 会重建。"""
+        async with self._init_lock:
+            self._ready.clear()
+            channel_pool = self._channel_pool
+            connection_pool = self._connection_pool
+            self._channel_pool = None
+            self._connection_pool = None
+
+        for pool, label in ((channel_pool, "channel"), (connection_pool, "connection")):
+            if pool is None:
+                continue
+            try:
+                await pool.close()
+            except Exception as e:
+                logger.warning(f"[RabbitMQ] 关闭旧 {label} pool 失败: {e}")
+
     async def _get_connection(self) -> aio_pika.abc.AbstractRobustConnection:
         try:
             return await aio_pika.connect_robust(
@@ -118,24 +140,33 @@ class RabbitMQ(BasicQueue):
         count = int(kwargs.get("count", 0))
         durable = kwargs.get("durable", True)
 
-        async with self._channel_pool.acquire() as channel:
-            if 0 < count < self.max_retry_count:
-                rk = await self._setup_delay_queue(channel, queue_name,** kwargs)
-            elif count >= self.max_retry_count:
-                rk = await self._setup_dead_letter_queue(channel, queue_name, **kwargs)
-            else:
-                rk = await self._setup_normal_queue(channel, queue_name, durable)
-
-            msg = self._create_message(data, count)
-            await channel.default_exchange.publish(msg, routing_key=rk)
-            logger.debug(f"[PUSH] queue={queue_name} count={count}")
-            return msg
+        try:
+            async with self._channel_pool.acquire() as channel:
+                if 0 < count < self.max_retry_count:
+                    rk = await self._setup_delay_queue(channel, queue_name,** kwargs)
+                elif count >= self.max_retry_count:
+                    rk = await self._setup_dead_letter_queue(channel, queue_name, **kwargs)
+                else:
+                    rk = await self._setup_normal_queue(channel, queue_name, durable)
+
+                msg = self._create_message(data, count)
+                await channel.default_exchange.publish(msg, routing_key=rk)
+                logger.debug(f"[PUSH] queue={queue_name} count={count}")
+                return msg
+        except (ConnectionClosed, ChannelClosed):
+            logger.warning("[PUSH] 连接断开，准备重连")
+            await self._invalidate_pools()
+            return None
+        except Exception as e:
+            logger.error(f"[PUSH] 异常 queue={queue_name}: {e}", exc_info=True)
+            return None
 
     async def pop(self, queue_name: str,** kwargs: Any) -> Optional[aio_pika.abc.AbstractIncomingMessage]:
         if self._closed:
             return None
 
         await self.init()
+        # durable 须与 push 声明队列时一致（默认 True），否则 re-declare 可能 PRECONDITION_FAILED
         durable = kwargs.get("durable", True)
 
         try:
@@ -148,11 +179,31 @@ class RabbitMQ(BasicQueue):
             return None
         except (ConnectionClosed, ChannelClosed):
             logger.warning("[POP] 连接断开，准备重连")
-            self._ready.clear()
+            await self._invalidate_pools()
             return None
         except Exception as e:
             logger.error(f"[POP] 异常 queue={queue_name}: {e}", exc_info=True)
             return None
+    
+    async def queue_length(self, queue_name: str) -> int:
+        """Return queue message count, or QUEUE_LENGTH_UNAVAILABLE (-1) on failure."""
+        if self._closed:
+            return self.QUEUE_LENGTH_UNAVAILABLE
+
+        try:
+            await self.init()
+            async with self._channel_pool.acquire() as channel:
+                # passive：只查询已存在队列，不创建；队列不存在则 ChannelClosed → -1
+                queue = await channel.declare_queue(queue_name, passive=True)
+                count = queue.declaration_result.message_count
+                return count if count is not None else 0
+        except (ConnectionClosed, ChannelClosed):
+            logger.warning("[QUEUE_LENGTH] 连接断开，准备重连")
+            await self._invalidate_pools()
+            return self.QUEUE_LENGTH_UNAVAILABLE
+        except Exception as e:
+            logger.error(f"[QUEUE_LENGTH] 异常 queue={queue_name}: {e}", exc_info=True)
+            return self.QUEUE_LENGTH_UNAVAILABLE
 
     async def ack(self, message: aio_pika.abc.AbstractIncomingMessage) -> None:
         try:
@@ -217,13 +268,5 @@ class RabbitMQ(BasicQueue):
         if self._closed:
             return
         self._closed = True
-        self._ready.clear()
-
-        try:
-            if self._channel_pool:
-                await self._channel_pool.close()
-            if self._connection_pool:
-                await self._connection_pool.close()
-            logger.info("[RabbitMQ] 已关闭")
-        except Exception as e:
-            logger.error(f"[关闭失败] {e}")
+        await self._invalidate_pools()
+        logger.info("[RabbitMQ] 已关闭")

async_task_kit-0.1.13/async_task_kit/utils/env_loader.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class EnvLoader:
+    def __init__(self, task_id: str | None = None):
+        self.prefix = f"{task_id.upper()}_" if task_id else ""
+
+    def _candidate_keys(self, key: str) -> list[str]:
+        uk = key.upper()
+        if self.prefix:
+            # 有任务前缀：优先前缀变量，其次全局公共变量
+            return [self.prefix + uk, uk]
+        # 无task_id，只查全局公共变量
+        return [uk]
+
+    def get(self, key: str, default: str | None = None) -> str | None:
+        for k in self._candidate_keys(key):
+            val = os.getenv(k)
+            if val is not None:
+                return val.strip()
+        return default
+
+    def get_int(self, key: str, default: int | None = None) -> int | None:
+        raw_val = None
+        for k in self._candidate_keys(key):
+            raw_val = os.getenv(k)
+            if raw_val is not None:
+                break
+        if raw_val is None:
+            return default
+        try:
+            return int(raw_val.strip())
+        except (ValueError, TypeError):
+            return default
+
+    def get_bool(self, key: str, default: bool = False) -> bool:
+        raw_val = None
+        for k in self._candidate_keys(key):
+            raw_val = os.getenv(k)
+            if raw_val is not None:
+                break
+        if raw_val is None:
+            return default
+        v = raw_val.strip().lower()
+        true_set = {"1", "true", "yes", "on", "y"}
+        false_set = {"0", "false", "no", "off", "n"}
+        if v in true_set:
+            return True
+        if v in false_set:
+            return False
+        return default

{async_task_kit-0.1.1 → async_task_kit-0.1.13}/async_task_kit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-task-kit
-Version: 0.1.1
+Version: 0.1.13
 Summary: A powerful async task processing kit based on RabbitMQ with Coroutine, Thread, and Process support.
 Author-email: realwrtoff <realwrtoff@gmail.com>
 Classifier: Programming Language :: Python :: 3
@@ -10,6 +10,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aio-pika>=9.4.0
+Requires-Dist: asyncpg>=0.31.0
 Requires-Dist: python-dotenv>=1.0.0
 Dynamic: license-file
 
@@ -174,6 +175,54 @@ if __name__ == "__main__":
     asyncio.run(publish())
 ```
 
+### 5. RabbitMQ Client API
+
+`RabbitMQ` 提供连接池、`push` / `pop`、延迟重试队列，以及 `queue_length` 查询队列深度。
+
+#### `queue_length`
+
+```python
+from async_task_kit import RabbitMQ
+
+rmq = RabbitMQ("amqp://guest:guest@localhost/")
+await rmq.init()
+
+length = await rmq.queue_length("my_demo_queue")
+if length == RabbitMQ.QUEUE_LENGTH_UNAVAILABLE:
+    # -1：连不上或队列不存在，稍后重试
+    ...
+elif length == 0:
+    # 队列存在且为空
+    ...
+else:
+    # 当前消息数
+    ...
+
+await rmq.close()
+```
+
+| 返回值 | 含义 |
+|--------|------|
+| `>= 0` | 队列真实消息数（`0` = 空队列） |
+| `-1` (`QUEUE_LENGTH_UNAVAILABLE`) | 连接失败、队列不存在或其它异常，应重试 |
+
+实现要点：
+
+- 使用 **`passive=True`** 声明：只查询已存在的队列，**不会**自动创建空队列。
+- 断连时会关闭旧连接池并自动重建（与 `push` / `pop` 一致）。
+
+#### `pop` 的 `durable` 参数
+
+`pop` 在取消息前会 `declare_queue`。`push` 默认以 **`durable=True`** 创建队列（重启后队列仍在），因此 `pop` 默认同样传 `durable=True`，保证声明参数与已有队列一致，避免 RabbitMQ 返回 `PRECONDITION_FAILED`。
+
+若你的队列是非持久化的，调用时需显式传入：
+
+```python
+await rmq.pop("my_queue", durable=False)
+```
+
+`queue_length` 使用 passive 模式，无需传 `durable`。
+
 ## License
 
 MIT

{async_task_kit-0.1.1 → async_task_kit-0.1.13}/async_task_kit.egg-info/requires.txt

@@ -1,2 +1,3 @@
 aio-pika>=9.4.0
+asyncpg>=0.31.0
 python-dotenv>=1.0.0

{async_task_kit-0.1.1 → async_task_kit-0.1.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "async-task-kit"
-version = "0.1.1"
+version = "0.1.13"
 description = "A powerful async task processing kit based on RabbitMQ with Coroutine, Thread, and Process support."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -13,7 +13,8 @@ authors = [
 ]
 dependencies = [
   "aio-pika>=9.4.0",
-  "python-dotenv>=1.0.0"
+  "asyncpg>=0.31.0",
+  "python-dotenv>=1.0.0",
 ]
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -21,6 +22,9 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 
+[dependency-groups]
+dev = ["build", "twine"]
+
 [tool.setuptools.packages.find]
 where = ["."]
-include = ["async_task_kit*"]
+include = ["async_task_kit*"]

async_task_kit-0.1.1/async_task_kit/utils/env_loader.py

@@ -1,16 +0,0 @@
-import os
-from dotenv import load_dotenv
-load_dotenv()
-
-class EnvLoader:
-    def __init__(self, task_id=None):
-        self.prefix = f"{task_id}_".upper() if task_id else ""
-
-    def get(self, key, default=None):
-        return os.getenv(f"{self.prefix}{key}", default)
-
-    def get_int(self, key, default=1):
-        try:
-            return int(os.getenv(f"{self.prefix}{key}", default))
-        except:
-            return default