redis-message-queue 3.1.0__tar.gz → 3.1.1__tar.gz

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/PKG-INFO

@@ -1,22 +1,32 @@
 Metadata-Version: 2.4
 Name: redis-message-queue
-Version: 3.1.0
+Version: 3.1.1
 Summary: Python message queuing with Redis and message deduplication
+License: MIT
 License-File: LICENSE
+Keywords: redis,message-queue,deduplication,task-queue
 Author: Elijas
 Author-email: 4084885+Elijas@users.noreply.github.com
 Requires-Python: >=3.12,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Distributed Computing
 Requires-Dist: redis (>=5.0.0)
 Requires-Dist: tenacity (>=8.1.0)
+Project-URL: Homepage, https://github.com/Elijas/redis-message-queue
+Project-URL: Issues, https://github.com/Elijas/redis-message-queue/issues
+Project-URL: Repository, https://github.com/Elijas/redis-message-queue
 Description-Content-Type: text/markdown
 
 # redis-message-queue
 
-[![PyPI Version](https://img.shields.io/badge/v3.1.0-version?color=43cd0f&style=flat&label=pypi)](https://pypi.org/project/redis-message-queue)
+[![PyPI Version](https://img.shields.io/badge/v3.1.1-version?color=43cd0f&style=flat&label=pypi)](https://pypi.org/project/redis-message-queue)
 [![PyPI Downloads](https://img.shields.io/pypi/dm/redis-message-queue?color=43cd0f&style=flat&label=downloads)](https://pypistats.org/packages/redis-message-queue)
 [![License: MIT](https://img.shields.io/badge/License-MIT-43cd0f.svg?style=flat&label=license)](LICENSE)
 [![Maintained: yes](https://img.shields.io/badge/yes-43cd0f.svg?style=flat&label=maintained)](https://github.com/Elijas/redis-message-queue/issues)
@@ -150,7 +160,7 @@ This enables lease-based redelivery for messages left in `processing` by a crash
 Tradeoffs:
 - delivery becomes at-least-once after lease expiry
 - the timeout must be longer than your normal processing time if you do not use heartbeats
-- if you do use heartbeats, the heartbeat interval must be no more than half of the visibility timeout
+- if you do use heartbeats, the heartbeat interval must be less than half of the visibility timeout
 - recovery happens on consumer polling cadence rather than instantly
 - heartbeats add background renewal work for active messages
 - if a heartbeat fails (network error or stale lease), the heartbeat stops silently; the consumer continues processing but may find at ack time that the message was reclaimed by another consumer
@@ -239,7 +249,7 @@ entirely (single attempt; exceptions propagate). The library uses
 `retry_budget_seconds` to size the operation-result cache TTL automatically,
 so the previous footgun of an over-long retry budget out-living the cache
 and producing misleading "cleanup was a no-op" warnings is now structurally
-impossible.
+impossible. Note: tenacity may allow one additional attempt beyond the budget if the budget check passes at attempt start — total wall-clock time can exceed `retry_budget_seconds` by the duration of that final attempt.
 
 To plug in a different retry library (`backoff`, `asyncstdlib.retry`, or your
 own logic) or fundamentally different semantics, subclass
@@ -300,6 +310,7 @@ await client.aclose()
 - **Redis Lua is atomic, not rollback-transactional.** The built-in scripts now preflight queue key types and fail closed on `WRONGTYPE` before mutating queue state, but Redis does not undo earlier writes if a later script command fails for another reason (for example `OOM` under severe memory pressure).
 - **Batch reclaim limit of 100.** The visibility-timeout reclaim Lua script processes at most 100 expired messages per consumer poll. Under extreme backlog this may delay recovery, but prevents any single poll from blocking Redis.
 - **Claim-attempt loop limit of 100 per poll.** The VT claim Lua script attempts at most 100 LMOVE+delivery-count checks per invocation. Under pathological conditions (>100 consecutive poison messages in pending), a single poll returns no message even though non-poison messages exist deeper in the queue. Subsequent polls drain the poison batch 100 at a time.
+- **Cluster detection uses `isinstance(client, RedisCluster)`.** Wrapped or instrumented cluster clients that delegate without inheriting will bypass hash-tag validation. Custom gateways should set `is_redis_cluster = True` explicitly.
 - **Redis Cluster requires hash tags.** The built-in queue uses multiple Redis keys per operation. Wrap the queue name in hash tags (for example `{myqueue}`) so every generated key lands in the same slot. When you pass a Redis Cluster client to the built-in queue/gateway path, incompatible names are rejected early.
 - **Client-side `Retry` can duplicate non-deduplicated publishes.** If you construct your `redis.Redis` client with `retry=Retry(...)`, redis-py retries `ConnectionError` / `TimeoutError` at the connection layer — *below* this library. Idempotent operations (deduplicated `publish()`, lease-scoped cleanup) are safe because their Lua scripts replay the original result. `add_message()` (used by `publish()` when `deduplication=False`) is a bare `LPUSH`: this library deliberately does not retry it, but a client-level `Retry` will, and if the server executed the command before the response was lost the message is enqueued twice. Leave `retry=None` (the default) if you need strict at-most-once semantics for non-deduplicated publishes, or accept the duplication risk. More broadly, any non-idempotent `LPUSH` path is vulnerable if the connection drops after server execution but before the client receives the response; all other built-in operations (deduplicated publish, lease-scoped ack/move, lease renewal) use replay markers and are safe under client-level `Retry`.
 

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/README.md

@@ -1,6 +1,6 @@
 # redis-message-queue
 
-[![PyPI Version](https://img.shields.io/badge/v3.1.0-version?color=43cd0f&style=flat&label=pypi)](https://pypi.org/project/redis-message-queue)
+[![PyPI Version](https://img.shields.io/badge/v3.1.1-version?color=43cd0f&style=flat&label=pypi)](https://pypi.org/project/redis-message-queue)
 [![PyPI Downloads](https://img.shields.io/pypi/dm/redis-message-queue?color=43cd0f&style=flat&label=downloads)](https://pypistats.org/packages/redis-message-queue)
 [![License: MIT](https://img.shields.io/badge/License-MIT-43cd0f.svg?style=flat&label=license)](LICENSE)
 [![Maintained: yes](https://img.shields.io/badge/yes-43cd0f.svg?style=flat&label=maintained)](https://github.com/Elijas/redis-message-queue/issues)
@@ -134,7 +134,7 @@ This enables lease-based redelivery for messages left in `processing` by a crash
 Tradeoffs:
 - delivery becomes at-least-once after lease expiry
 - the timeout must be longer than your normal processing time if you do not use heartbeats
-- if you do use heartbeats, the heartbeat interval must be no more than half of the visibility timeout
+- if you do use heartbeats, the heartbeat interval must be less than half of the visibility timeout
 - recovery happens on consumer polling cadence rather than instantly
 - heartbeats add background renewal work for active messages
 - if a heartbeat fails (network error or stale lease), the heartbeat stops silently; the consumer continues processing but may find at ack time that the message was reclaimed by another consumer
@@ -223,7 +223,7 @@ entirely (single attempt; exceptions propagate). The library uses
 `retry_budget_seconds` to size the operation-result cache TTL automatically,
 so the previous footgun of an over-long retry budget out-living the cache
 and producing misleading "cleanup was a no-op" warnings is now structurally
-impossible.
+impossible. Note: tenacity may allow one additional attempt beyond the budget if the budget check passes at attempt start — total wall-clock time can exceed `retry_budget_seconds` by the duration of that final attempt.
 
 To plug in a different retry library (`backoff`, `asyncstdlib.retry`, or your
 own logic) or fundamentally different semantics, subclass
@@ -284,6 +284,7 @@ await client.aclose()
 - **Redis Lua is atomic, not rollback-transactional.** The built-in scripts now preflight queue key types and fail closed on `WRONGTYPE` before mutating queue state, but Redis does not undo earlier writes if a later script command fails for another reason (for example `OOM` under severe memory pressure).
 - **Batch reclaim limit of 100.** The visibility-timeout reclaim Lua script processes at most 100 expired messages per consumer poll. Under extreme backlog this may delay recovery, but prevents any single poll from blocking Redis.
 - **Claim-attempt loop limit of 100 per poll.** The VT claim Lua script attempts at most 100 LMOVE+delivery-count checks per invocation. Under pathological conditions (>100 consecutive poison messages in pending), a single poll returns no message even though non-poison messages exist deeper in the queue. Subsequent polls drain the poison batch 100 at a time.
+- **Cluster detection uses `isinstance(client, RedisCluster)`.** Wrapped or instrumented cluster clients that delegate without inheriting will bypass hash-tag validation. Custom gateways should set `is_redis_cluster = True` explicitly.
 - **Redis Cluster requires hash tags.** The built-in queue uses multiple Redis keys per operation. Wrap the queue name in hash tags (for example `{myqueue}`) so every generated key lands in the same slot. When you pass a Redis Cluster client to the built-in queue/gateway path, incompatible names are rejected early.
 - **Client-side `Retry` can duplicate non-deduplicated publishes.** If you construct your `redis.Redis` client with `retry=Retry(...)`, redis-py retries `ConnectionError` / `TimeoutError` at the connection layer — *below* this library. Idempotent operations (deduplicated `publish()`, lease-scoped cleanup) are safe because their Lua scripts replay the original result. `add_message()` (used by `publish()` when `deduplication=False`) is a bare `LPUSH`: this library deliberately does not retry it, but a client-level `Retry` will, and if the server executed the command before the response was lost the message is enqueued twice. Leave `retry=None` (the default) if you need strict at-most-once semantics for non-deduplicated publishes, or accept the duplication risk. More broadly, any non-idempotent `LPUSH` path is vulnerable if the connection drops after server execution but before the client receives the response; all other built-in operations (deduplicated publish, lease-scoped ack/move, lease renewal) use replay markers and are safe under client-level `Retry`.
 

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/pyproject.toml

@@ -1,9 +1,25 @@
 [tool.poetry]
 name = "redis-message-queue"
-version = "3.1.0"
+version = "3.1.1"
 description = "Python message queuing with Redis and message deduplication"
 authors = ["Elijas <4084885+Elijas@users.noreply.github.com>"]
 readme = "README.md"
+license = "MIT"
+keywords = ["redis", "message-queue", "deduplication", "task-queue"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: System :: Distributed Computing",
+]
+
+[tool.poetry.urls]
+Homepage = "https://github.com/Elijas/redis-message-queue"
+Repository = "https://github.com/Elijas/redis-message-queue"
+Issues = "https://github.com/Elijas/redis-message-queue/issues"
 
 [tool.poetry.dependencies]
 python = "^3.12"

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/redis_message_queue/_abstract_redis_gateway.py

@@ -19,6 +19,10 @@ class AbstractRedisGateway(ABC):
     silently disables heartbeat validation and lease-token safety checks,
     causing the queue to treat the gateway as a non-lease implementation.
 
+    The queue also reads ``max_delivery_count`` and ``dead_letter_queue``
+    from the gateway via ``getattr``. Avoid using these attribute names for
+    unrelated purposes on custom gateway implementations.
+
     Gateways that wrap a Redis Cluster client should expose an
     ``is_redis_cluster`` property returning ``True`` so the queue can apply
     hash-tag validation at construction time.

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/redis_message_queue/_config.py

@@ -179,6 +179,8 @@ def validate_dead_letter_parameters(
             raise ValueError("'max_delivery_count' requires 'message_visibility_timeout_seconds' to be set.")
     if dead_letter_queue is not None and not isinstance(dead_letter_queue, str):
         raise TypeError(f"'dead_letter_queue' must be a str or None, got {type(dead_letter_queue).__name__}")
+    if isinstance(dead_letter_queue, str) and dead_letter_queue and not dead_letter_queue.strip():
+        raise ValueError("'dead_letter_queue' must be a non-empty string")
     if max_delivery_count is not None and not dead_letter_queue:
         raise ValueError("'dead_letter_queue' is required when 'max_delivery_count' is set.")
     if dead_letter_queue and max_delivery_count is None:

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/redis_message_queue/_redis_gateway.py

@@ -382,7 +382,7 @@ class RedisGateway(AbstractRedisGateway):
                     if not is_redis_retryable_exception(exc):
                         raise
                     claim_may_need_recovery = True
-                    logger.warning(non_blocking_retry_log, exc)
+                    logger.warning(non_blocking_retry_log, type(exc).__name__)
                     if self._is_interrupted():
                         pending_claim_id_to_share = claim_id
                         return None
@@ -418,7 +418,7 @@ class RedisGateway(AbstractRedisGateway):
                             pending_claim_id_to_share = claim_id
                         raise
                     claim_may_need_recovery = True
-                    logger.warning(polling_retry_log, exc)
+                    logger.warning(polling_retry_log, type(exc).__name__)
                     last_retryable_exception = exc
                 except BaseException:
                     pending_claim_id_to_share = claim_id

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/redis_message_queue/asyncio/_abstract_redis_gateway.py

@@ -20,6 +20,10 @@ class AbstractRedisGateway(ABC):
     silently disables heartbeat validation and lease-token safety checks,
     causing the queue to treat the gateway as a non-lease implementation.
 
+    The queue also reads ``max_delivery_count`` and ``dead_letter_queue``
+    from the gateway via ``getattr``. Avoid using these attribute names for
+    unrelated purposes on custom gateway implementations.
+
     Gateways that wrap a Redis Cluster client should expose an
     ``is_redis_cluster`` property returning ``True`` so the queue can apply
     hash-tag validation at construction time.

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/redis_message_queue/asyncio/_redis_gateway.py

@@ -382,7 +382,7 @@ class RedisGateway(AbstractRedisGateway):
                     if not is_redis_retryable_exception(exc):
                         raise
                     claim_may_need_recovery = True
-                    logger.warning(non_blocking_retry_log, exc)
+                    logger.warning(non_blocking_retry_log, type(exc).__name__)
                     if self._is_interrupted():
                         pending_claim_id_to_share = claim_id
                         return None
@@ -419,7 +419,7 @@ class RedisGateway(AbstractRedisGateway):
                             pending_claim_id_to_share = claim_id
                         raise
                     claim_may_need_recovery = True
-                    logger.warning(polling_retry_log, exc)
+                    logger.warning(polling_retry_log, type(exc).__name__)
                     last_retryable_exception = exc
                 except BaseException:
                     pending_claim_id_to_share = claim_id

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/redis_message_queue/asyncio/redis_message_queue.py

@@ -460,7 +460,7 @@ class RedisMessageQueue:
                     "'message' dict keys must all be strings; "
                     f"got non-string keys: {non_str_keys[:3]}" + (" (and more)" if len(non_str_keys) > 3 else "")
                 )
-            message_str = json.dumps(message, sort_keys=True)
+            message_str = json.dumps(message, sort_keys=True, allow_nan=False)
         else:
             message_str = message
 

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/redis_message_queue/interrupt_handler/_implementation.py

@@ -61,7 +61,10 @@ class GracefulInterruptHandler(BaseGracefulInterruptHandler):
                     f"'signals' must contain signal.Signals members, got {type(sig).__name__} at position {i}"
                 )
         for sig in signals:
-            current = signal.getsignal(sig)
+            try:
+                current = signal.getsignal(sig)
+            except OSError:
+                raise ValueError(f"Signal {sig.name} cannot be caught or handled by user code.")
             if _is_graceful_interrupt_handler(current):
                 raise ValueError(
                     f"Signal {sig.name} is already owned by another GracefulInterruptHandler."
@@ -78,7 +81,12 @@ class GracefulInterruptHandler(BaseGracefulInterruptHandler):
         self._signals = signals
         self._previous_handlers = {sig: signal.getsignal(sig) for sig in self._signals}
         for sig in self._signals:
-            signal.signal(sig, self._signal_handler)
+            try:
+                signal.signal(sig, self._signal_handler)
+            except ValueError as e:
+                if "main thread" in str(e):
+                    raise ValueError("GracefulInterruptHandler must be created on the main thread.") from e
+                raise
 
     def is_interrupted(self) -> bool:
         return self._interrupted

{redis_message_queue-3.1.0 → redis_message_queue-3.1.1}/redis_message_queue/redis_message_queue.py

@@ -414,7 +414,7 @@ class RedisMessageQueue:
                     "'message' dict keys must all be strings; "
                     f"got non-string keys: {non_str_keys[:3]}" + (" (and more)" if len(non_str_keys) > 3 else "")
                 )
-            message_str = json.dumps(message, sort_keys=True)
+            message_str = json.dumps(message, sort_keys=True, allow_nan=False)
         else:
             message_str = message