redqueue 0.11.0__tar.gz → 0.11.1__tar.gz

{redqueue-0.11.0 → redqueue-0.11.1}/CHANGELOG.md

@@ -4,10 +4,27 @@ All notable public release changes are documented here.
 
 所有公开发布版本的重要变更都会记录在此文件中。
 
-Development versions are tracked separately from formal release versions.
-开发版本与正式版本分开管理。
-
-## [0.11.0] - 2026-06-21
+Development versions are tracked separately from formal release versions.
+开发版本与正式版本分开管理。
+
+## [0.11.1] - 2026-06-21
+
+### Fixed
+
+- Fixed resource cleanup in sync and async `from_url()` when Redis capability
+  detection, configuration validation, or backend initialization fails after the
+  client created an owned Redis connection.
+- Added explicit `owns_redis` override support to sync and async `from_url()`
+  for advanced ownership control.
+
+### 修复
+
+- 修复同步和异步 `from_url()` 在自动创建 Redis 连接后，如果 Redis 能力探测、
+  配置校验或后端初始化失败，已创建连接未释放的问题。
+- 同步和异步 `from_url()` 新增显式 `owns_redis` 覆盖支持，用于高级资源所有权
+  控制。
+
+## [0.11.0] - 2026-06-21
 
 ### Added
 

{redqueue-0.11.0 → redqueue-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redqueue
-Version: 0.11.0
+Version: 0.11.1
 Summary: Redis-backed Python message queue library with List, Streams, delayed tasks, and monitoring.
 Project-URL: Homepage, https://github.com/SpringMirror-pear/redqueue
 Project-URL: Repository, https://github.com/SpringMirror-pear/redqueue.git

{redqueue-0.11.0 → redqueue-0.11.1}/docs/API.md

@@ -1,8 +1,8 @@
 # RedQueue API / RedQueue API 文档
 
-This document describes the public API available in RedQueue `0.11.0`.
-
-本文档描述 RedQueue `0.11.0` 的公开 API。
+This document describes the public API available in RedQueue `0.11.1`.
+
+本文档描述 RedQueue `0.11.1` 的公开 API。
 
 ## Clients / 客户端
 

{redqueue-0.11.0 → redqueue-0.11.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "redqueue"
-version = "0.11.0"
+version = "0.11.1"
 description = "Redis-backed Python message queue library with List, Streams, delayed tasks, and monitoring."
 readme = "README.md"
 requires-python = ">=3.9"

{redqueue-0.11.0 → redqueue-0.11.1}/src/redqueue/_version.py

@@ -3,4 +3,4 @@
 
 """Package version."""
 
-__version__ = "0.11.0"
+__version__ = "0.11.1"

{redqueue-0.11.0 → redqueue-0.11.1}/src/redqueue/async_client.py

@@ -99,28 +99,50 @@ class AsyncQueueClient:
             QueueConfigError: If configuration values are invalid.
         """
 
-        redis = options.pop("redis", None)
-        pool_options = options.pop("pool_options", None) or {}
-        owns_redis = False
-        if redis is None:
-            if connection_manager is not None:
-                redis = connection_manager.redis()
-            else:
-                redis = Redis.from_url(url, **pool_options)
-                owns_redis = True
-        capabilities = options.pop(
-            "capabilities",
-            None,
-        ) or await detect_capabilities_async(cast(AsyncRedisInfoClient, redis))
-        config = QueueConfig(queue=queue, backend=backend, **options)
-        client = cls(
-            config=config,
-            redis=redis,
-            capabilities=capabilities,
-            owns_redis=owns_redis,
-        )
-        await client._ensure_backend()
-        return client
+        redis = options.pop("redis", None)
+        pool_options = options.pop("pool_options", None) or {}
+        explicit_owns_redis = options.pop("owns_redis", None)
+        owns_redis = (
+            bool(explicit_owns_redis)
+            if explicit_owns_redis is not None
+            else False
+        )
+        if redis is None:
+            if connection_manager is not None:
+                redis = connection_manager.redis()
+            else:
+                redis = Redis.from_url(url, **pool_options)
+                owns_redis = (
+                    True
+                    if explicit_owns_redis is None
+                    else bool(explicit_owns_redis)
+                )
+        try:
+            capabilities = options.pop(
+                "capabilities",
+                None,
+            ) or await detect_capabilities_async(cast(AsyncRedisInfoClient, redis))
+            config = QueueConfig(queue=queue, backend=backend, **options)
+            client = cls(
+                config=config,
+                redis=redis,
+                capabilities=capabilities,
+                owns_redis=owns_redis,
+            )
+            await client._ensure_backend()
+            return client
+        except Exception:
+            if owns_redis:
+                close = getattr(redis, "aclose", None) or getattr(
+                    redis,
+                    "close",
+                    None,
+                )
+                if close is not None:
+                    result = close()
+                    if hasattr(result, "__await__"):
+                        await result
+            raise
 
     async def publish(
         self,

{redqueue-0.11.0 → redqueue-0.11.1}/src/redqueue/client.py

@@ -107,25 +107,41 @@ class QueueClient:
             QueueConfigError: If configuration values are invalid.
         """
 
-        redis = options.pop("redis", None)
-        pool_options = options.pop("pool_options", None) or {}
-        owns_redis = False
-        if redis is None:
-            if connection_manager is not None:
-                redis = connection_manager.redis()
-            else:
-                redis = Redis.from_url(url, **pool_options)
-                owns_redis = True
-        capabilities = options.pop("capabilities", None) or detect_capabilities(
-            cast(RedisInfoClient, redis)
-        )
-        config = QueueConfig(queue=queue, backend=backend, **options)
-        return cls(
-            config=config,
-            redis=redis,
-            capabilities=capabilities,
-            owns_redis=owns_redis,
-        )
+        redis = options.pop("redis", None)
+        pool_options = options.pop("pool_options", None) or {}
+        explicit_owns_redis = options.pop("owns_redis", None)
+        owns_redis = (
+            bool(explicit_owns_redis)
+            if explicit_owns_redis is not None
+            else False
+        )
+        if redis is None:
+            if connection_manager is not None:
+                redis = connection_manager.redis()
+            else:
+                redis = Redis.from_url(url, **pool_options)
+                owns_redis = (
+                    True
+                    if explicit_owns_redis is None
+                    else bool(explicit_owns_redis)
+                )
+        try:
+            capabilities = options.pop("capabilities", None) or detect_capabilities(
+                cast(RedisInfoClient, redis)
+            )
+            config = QueueConfig(queue=queue, backend=backend, **options)
+            return cls(
+                config=config,
+                redis=redis,
+                capabilities=capabilities,
+                owns_redis=owns_redis,
+            )
+        except Exception:
+            if owns_redis:
+                close = getattr(redis, "close", None)
+                if close is not None:
+                    close()
+            raise
 
     def publish(
         self,

{redqueue-0.11.0 → redqueue-0.11.1}/tests/test_project_skeleton.py

@@ -50,7 +50,7 @@ from tests.fakes import (
 
 class ProjectSkeletonTests(unittest.TestCase):
     def test_version_is_current_dev_version(self) -> None:
-        self.assertEqual(__version__, "0.11.0")
+        self.assertEqual(__version__, "0.11.1")
 
     def test_queue_config_accepts_and_normalizes_backend(self) -> None:
         config = QueueConfig(queue=" emails ", backend="stream")
@@ -653,7 +653,7 @@ class ProjectSkeletonTests(unittest.TestCase):
         with self.assertRaises(RuntimeError):
             manager.redis()
 
-    def test_sync_from_url_accepts_connection_manager_and_pool_options(self) -> None:
+    def test_sync_from_url_accepts_connection_manager_and_pool_options(self) -> None:
         redis = FakeListRedis()
         client = QueueClient.from_url(
             "redis://127.0.0.1:6379/0",
@@ -682,8 +682,58 @@ class ProjectSkeletonTests(unittest.TestCase):
             self.assertIs(managed_client.redis.connection_pool, manager.pool)
             managed_client.close()
             self.assertIs(manager.redis().connection_pool, manager.pool)
-        finally:
-            manager.close()
+        finally:
+            manager.close()
+
+    def test_sync_from_url_closes_owned_redis_when_initialization_fails(self) -> None:
+        class OwnedRedis(FakeListRedis):
+            def info(self, section: str | None = None) -> dict[str, str]:
+                return {"redis_version": "7.0.0"}
+
+        redis = OwnedRedis()
+
+        with self.assertRaises(QueueConfigError):
+            QueueClient.from_url(
+                "redis://127.0.0.1:6379/0",
+                queue="bad queue",
+                redis=redis,
+                owns_redis=True,
+            )
+
+        self.assertIn("close", redis.commands)
+
+    def test_sync_from_url_leaves_injected_redis_open_when_init_fails(self) -> None:
+        class InjectedRedis(FakeListRedis):
+            def info(self, section: str | None = None) -> dict[str, str]:
+                return {"redis_version": "7.0.0"}
+
+        redis = InjectedRedis()
+
+        with self.assertRaises(QueueConfigError):
+            QueueClient.from_url(
+                "redis://127.0.0.1:6379/0",
+                queue="bad queue",
+                redis=redis,
+            )
+
+        self.assertNotIn("close", redis.commands)
+
+    def test_sync_from_url_closes_owned_redis_when_capability_probe_fails(self) -> None:
+        class BrokenInfoRedis(FakeListRedis):
+            def info(self, section: str | None = None) -> dict[str, str]:
+                raise TimeoutError("redis unavailable")
+
+        redis = BrokenInfoRedis()
+
+        with self.assertRaises(BackendUnavailableError):
+            QueueClient.from_url(
+                "redis://127.0.0.1:6379/0",
+                queue="emails",
+                redis=redis,
+                owns_redis=True,
+            )
+
+        self.assertIn("close", redis.commands)
 
     def test_async_connection_manager_creates_pooled_clients(self) -> None:
         async def run() -> None:
@@ -705,7 +755,7 @@ class ProjectSkeletonTests(unittest.TestCase):
 
         asyncio.run(run())
 
-    def test_async_from_url_accepts_connection_manager_and_pool_options(self) -> None:
+    def test_async_from_url_accepts_connection_manager_and_pool_options(self) -> None:
         async def run() -> None:
             redis = FakeAsyncListRedis()
             client = await AsyncQueueClient.from_url(
@@ -737,8 +787,67 @@ class ProjectSkeletonTests(unittest.TestCase):
                 self.assertIs(manager.redis().connection_pool, manager.pool)
             finally:
                 await manager.close()
-
-        asyncio.run(run())
+
+        asyncio.run(run())
+
+    def test_async_from_url_closes_owned_redis_when_initialization_fails(self) -> None:
+        class OwnedAsyncRedis(FakeAsyncListRedis):
+            async def info(self, section: str | None = None) -> dict[str, str]:
+                return {"redis_version": "7.0.0"}
+
+        async def run() -> FakeAsyncListRedis:
+            redis = OwnedAsyncRedis()
+            with self.assertRaises(QueueConfigError):
+                await AsyncQueueClient.from_url(
+                    "redis://127.0.0.1:6379/0",
+                    queue="bad queue",
+                    redis=redis,
+                    owns_redis=True,
+                )
+            return redis
+
+        redis = asyncio.run(run())
+
+        self.assertIn("aclose", redis.commands)
+
+    def test_async_from_url_leaves_injected_redis_open_when_init_fails(self) -> None:
+        class InjectedAsyncRedis(FakeAsyncListRedis):
+            async def info(self, section: str | None = None) -> dict[str, str]:
+                return {"redis_version": "7.0.0"}
+
+        async def run() -> FakeAsyncListRedis:
+            redis = InjectedAsyncRedis()
+            with self.assertRaises(QueueConfigError):
+                await AsyncQueueClient.from_url(
+                    "redis://127.0.0.1:6379/0",
+                    queue="bad queue",
+                    redis=redis,
+                )
+            return redis
+
+        redis = asyncio.run(run())
+
+        self.assertNotIn("aclose", redis.commands)
+
+    def test_async_from_url_closes_owned_redis_on_probe_failure(self) -> None:
+        class BrokenInfoAsyncRedis(FakeAsyncListRedis):
+            async def info(self, section: str | None = None) -> dict[str, str]:
+                raise TimeoutError("redis unavailable")
+
+        async def run() -> FakeAsyncListRedis:
+            redis = BrokenInfoAsyncRedis()
+            with self.assertRaises(BackendUnavailableError):
+                await AsyncQueueClient.from_url(
+                    "redis://127.0.0.1:6379/0",
+                    queue="jobs",
+                    redis=redis,
+                    owns_redis=True,
+                )
+            return redis
+
+        redis = asyncio.run(run())
+
+        self.assertIn("aclose", redis.commands)
 
     def test_async_list_backend_ack_uses_original_serialized_payload(self) -> None:
         class NonDeterministicSerializer: