redis-message-queue 0.8.0__tar.gz → 0.9.0__tar.gz

{redis_message_queue-0.8.0 → redis_message_queue-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-message-queue
-Version: 0.8.0
+Version: 0.9.0
 Summary: Python message queuing with Redis and message deduplication
 Author: Elijas
 Author-email: 4084885+Elijas@users.noreply.github.com
@@ -10,8 +10,8 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: redis (>=5.0.1,<6.0.0)
-Requires-Dist: tenacity (>=8.2.3,<9.0.0)
+Requires-Dist: redis
+Requires-Dist: tenacity
 Description-Content-Type: text/markdown
 
 # redis-message-queue

{redis_message_queue-0.8.0 → redis_message_queue-0.9.0}/pyproject.toml

@@ -1,18 +1,18 @@
 [tool.poetry]
 name = "redis-message-queue"
-version = "0.8.0"
+version = "0.9.0"
 description = "Python message queuing with Redis and message deduplication"
 authors = ["Elijas <4084885+Elijas@users.noreply.github.com>"]
 readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.8"
-redis = "^5.0.1"
-tenacity = "^8.2.3"
+redis = "*"
+tenacity = "*"
 
 [tool.poetry.group.test.dependencies]
-pytest = "^7.4.4"
-fakeredis = "^2.20.1"
+pytest = "*"
+fakeredis = "*"
 
 [build-system]
 requires = ["poetry-core"]

redis_message_queue-0.9.0/redis_message_queue/__init__.py

@@ -0,0 +1,13 @@
+from redis_message_queue._abstract_redis_gateway import AbstractRedisGateway
+from redis_message_queue.interrupt_handler import (
+    BaseGracefulInterruptHandler,
+    GracefulInterruptHandler,
+)
+from redis_message_queue.redis_message_queue import RedisMessageQueue
+
+__all__ = [
+    "RedisMessageQueue",
+    "AbstractRedisGateway",
+    "GracefulInterruptHandler",
+    "BaseGracefulInterruptHandler",
+]

redis_message_queue-0.9.0/redis_message_queue/_config.py

@@ -0,0 +1,66 @@
+import logging
+import typing
+
+import redis
+import redis.exceptions
+from tenacity import (
+    RetryCallState,
+    after_log,
+    retry,
+    retry_base,
+    retry_if_exception,
+    stop_after_delay,
+    wait_exponential_jitter,
+)
+
+from redis_message_queue.interrupt_handler._interface import (
+    BaseGracefulInterruptHandler,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def is_redis_retryable_exception(exception):
+    return isinstance(
+        exception,
+        (
+            redis.exceptions.ConnectionError,
+            redis.exceptions.TimeoutError,
+            redis.exceptions.BusyLoadingError,
+            redis.exceptions.ClusterDownError,
+            redis.exceptions.TryAgainError,
+        ),
+    )
+
+
+class interruptable_retry(retry_base):
+    def __init__(
+        self,
+        interrupt: BaseGracefulInterruptHandler | None,
+        get_parent_retry: typing.Callable[[], retry_base],
+    ) -> None:
+        self._parent_instance = get_parent_retry()
+        self.interrupt = interrupt
+
+    def __call__(self, retry_state: RetryCallState) -> bool:
+        if self.interrupt and self.interrupt.is_interrupted():
+            return False
+        return self._parent_instance.__call__(retry_state)
+
+
+def get_default_redis_connection_retry_strategy(
+    *, interrupt: BaseGracefulInterruptHandler | None = None
+):
+    return retry(
+        stop=stop_after_delay(120),
+        wait=wait_exponential_jitter(initial=0.01, exp_base=2, max=5, jitter=0.1),
+        retry=interruptable_retry(
+            interrupt=interrupt,
+            get_parent_retry=lambda: retry_if_exception(is_redis_retryable_exception),
+        ),
+        after=after_log(logger, logging.ERROR),
+    )
+
+
+DEFAULT_MESSAGE_WAIT_INTERVAL_SECONDS = 5
+DEFAULT_MESSAGE_DEDUPLICATION_LOG_TTL = 60 * 60  # 1 hour = 60 seconds * 60 minutes

{redis_message_queue-0.8.0 → redis_message_queue-0.9.0}/redis_message_queue/_redis_gateway.py

@@ -8,7 +8,10 @@ from redis_message_queue._abstract_redis_gateway import AbstractRedisGateway
 from redis_message_queue._config import (
     DEFAULT_MESSAGE_DEDUPLICATION_LOG_TTL,
     DEFAULT_MESSAGE_WAIT_INTERVAL_SECONDS,
-    DEFAULT_REDIS_CONNECTION_RETRY_STRATEGY,
+    get_default_redis_connection_retry_strategy,
+)
+from redis_message_queue.interrupt_handler._interface import (
+    BaseGracefulInterruptHandler,
 )
 
 
@@ -20,9 +23,13 @@ class RedisGateway(AbstractRedisGateway):
         retry_strategy: Optional[Callable] = None,
         message_deduplication_log_ttl_seconds: Optional[int] = None,
         message_wait_interval_seconds: Optional[int] = None,
+        interrupt: BaseGracefulInterruptHandler | None = None,
     ):
         self._redis_client = redis_client
-        self._retry_strategy = retry_strategy or DEFAULT_REDIS_CONNECTION_RETRY_STRATEGY
+        self._retry_strategy = (
+            retry_strategy
+            or get_default_redis_connection_retry_strategy(interrupt=interrupt)
+        )
         self._message_deduplication_log_ttl_seconds = (
             message_deduplication_log_ttl_seconds
             or DEFAULT_MESSAGE_DEDUPLICATION_LOG_TTL

{redis_message_queue-0.8.0 → redis_message_queue-0.9.0}/redis_message_queue/asyncio/_redis_gateway.py

@@ -7,7 +7,10 @@ from redis_message_queue._abstract_redis_gateway import AbstractRedisGateway
 from redis_message_queue._config import (
     DEFAULT_MESSAGE_DEDUPLICATION_LOG_TTL,
     DEFAULT_MESSAGE_WAIT_INTERVAL_SECONDS,
-    DEFAULT_REDIS_CONNECTION_RETRY_STRATEGY,
+    get_default_redis_connection_retry_strategy,
+)
+from redis_message_queue.interrupt_handler._interface import (
+    BaseGracefulInterruptHandler,
 )
 
 
@@ -19,9 +22,13 @@ class RedisGateway(AbstractRedisGateway):
         retry_strategy: Optional[Callable] = None,
         message_deduplication_log_ttl_seconds: Optional[int] = None,
         message_wait_interval_seconds: Optional[int] = None,
+        interrupt: BaseGracefulInterruptHandler | None = None,
     ):
         self._redis_client = redis_client
-        self._retry_strategy = retry_strategy or DEFAULT_REDIS_CONNECTION_RETRY_STRATEGY
+        self._retry_strategy = (
+            retry_strategy
+            or get_default_redis_connection_retry_strategy(interrupt=interrupt)
+        )
         self._message_deduplication_log_ttl_seconds = (
             message_deduplication_log_ttl_seconds
             or DEFAULT_MESSAGE_DEDUPLICATION_LOG_TTL

{redis_message_queue-0.8.0 → redis_message_queue-0.9.0}/redis_message_queue/asyncio/redis_message_queue.py

@@ -8,6 +8,7 @@ import redis.exceptions
 from redis_message_queue._queue_key_manager import QueueKeyManager
 from redis_message_queue.asyncio._abstract_redis_gateway import AbstractRedisGateway
 from redis_message_queue.asyncio._redis_gateway import RedisGateway
+from redis_message_queue.interrupt_handler import BaseGracefulInterruptHandler
 
 
 class RedisMessageQueue:
@@ -22,6 +23,7 @@ class RedisMessageQueue:
         enable_failed_queue: bool = False,
         key_separator: str = "::",
         get_deduplication_key: Optional[Callable] = None,
+        interrupt: BaseGracefulInterruptHandler | None = None,
     ):
         self._redis_client = client
         self.key = QueueKeyManager(name, key_separator=key_separator)
@@ -35,7 +37,7 @@ class RedisMessageQueue:
         elif not client:
             raise ValueError("Either 'client' or 'gateway' must be provided.")
         else:
-            self._redis = RedisGateway(redis_client=client)
+            self._redis = RedisGateway(redis_client=client, interrupt=interrupt)
 
     async def publish(self, message: str | dict) -> bool:
         if isinstance(message, dict):

redis_message_queue-0.9.0/redis_message_queue/interrupt_handler/__init__.py

@@ -0,0 +1,4 @@
+from ._implementation import GracefulInterruptHandler
+from ._interface import BaseGracefulInterruptHandler
+
+__all__ = ["GracefulInterruptHandler", "BaseGracefulInterruptHandler"]

redis_message_queue-0.9.0/redis_message_queue/interrupt_handler/_implementation.py

@@ -0,0 +1,29 @@
+import signal
+from typing import Iterable
+
+from redis_message_queue.interrupt_handler._interface import (
+    BaseGracefulInterruptHandler,
+)
+
+
+class GracefulInterruptHandler(BaseGracefulInterruptHandler):
+    _DEFAULT_SIGNALS = (signal.SIGINT, signal.SIGTERM, signal.SIGHUP)
+
+    def __init__(
+        self,
+        verbose: bool = True,
+        signals: Iterable[signal.Signals] = _DEFAULT_SIGNALS,
+    ):
+        self._interrupted = False
+        self._verbose = verbose
+        self._signals = signals
+        for sig in self._signals:
+            signal.signal(sig, self._signal_handler)
+
+    def is_interrupted(self) -> bool:
+        return self._interrupted
+
+    def _signal_handler(self, signum, frame):
+        if self._verbose:
+            print(f"Received signal: {signal.strsignal(signum)}")
+        self._interrupted = True

redis_message_queue-0.9.0/redis_message_queue/interrupt_handler/_interface.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class BaseGracefulInterruptHandler(ABC):
+    @abstractmethod
+    def is_interrupted(self) -> bool:
+        pass

{redis_message_queue-0.8.0 → redis_message_queue-0.9.0}/redis_message_queue/redis_message_queue.py

@@ -8,6 +8,7 @@ import redis.exceptions
 from redis_message_queue._abstract_redis_gateway import AbstractRedisGateway
 from redis_message_queue._queue_key_manager import QueueKeyManager
 from redis_message_queue._redis_gateway import RedisGateway
+from redis_message_queue.interrupt_handler import BaseGracefulInterruptHandler
 
 
 class RedisMessageQueue:
@@ -22,6 +23,7 @@ class RedisMessageQueue:
         enable_failed_queue: bool = False,
         key_separator: str = "::",
         get_deduplication_key: Optional[Callable] = None,
+        interrupt: BaseGracefulInterruptHandler | None = None,
     ):
         self._redis_client = client
         self.key = QueueKeyManager(name, key_separator=key_separator)
@@ -35,7 +37,7 @@ class RedisMessageQueue:
         elif not client:
             raise ValueError("Either 'client' or 'gateway' must be provided.")
         else:
-            self._redis = RedisGateway(redis_client=client)
+            self._redis = RedisGateway(redis_client=client, interrupt=interrupt)
 
     def publish(self, message: str | dict) -> bool:
         if isinstance(message, dict):

redis_message_queue-0.8.0/redis_message_queue/__init__.py

@@ -1,4 +0,0 @@
-from redis_message_queue._abstract_redis_gateway import AbstractRedisGateway
-from redis_message_queue.redis_message_queue import RedisMessageQueue
-
-__all__ = ["RedisMessageQueue", "AbstractRedisGateway"]

redis_message_queue-0.8.0/redis_message_queue/_config.py

@@ -1,36 +0,0 @@
-import logging
-
-import redis
-import redis.exceptions
-from tenacity import (
-    after_log,
-    retry,
-    retry_if_exception,
-    stop_after_delay,
-    wait_exponential_jitter,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def is_redis_retryable_exception(exception):
-    return isinstance(
-        exception,
-        (
-            redis.exceptions.ConnectionError,
-            redis.exceptions.TimeoutError,
-            redis.exceptions.BusyLoadingError,
-            redis.exceptions.ClusterDownError,
-            redis.exceptions.TryAgainError,
-        ),
-    )
-
-
-DEFAULT_REDIS_CONNECTION_RETRY_STRATEGY = retry(
-    stop=stop_after_delay(120),
-    wait=wait_exponential_jitter(initial=0.01, exp_base=2, max=5, jitter=0.1),
-    retry=retry_if_exception(is_redis_retryable_exception),
-    after=after_log(logger, logging.ERROR),
-)
-DEFAULT_MESSAGE_WAIT_INTERVAL_SECONDS = 5
-DEFAULT_MESSAGE_DEDUPLICATION_LOG_TTL = 60 * 60  # 1 hour = 60 seconds * 60 minutes