taskiq-redis 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

taskiq_redis/exceptions.py

@@ -0,0 +1,10 @@
+class TaskIQRedisError(Exception):
+    """Base error for all taskiq-redis exceptions."""
+
+
+class DuplicateExpireTimeSelectedError(TaskIQRedisError):
+    """Error if two lifetimes are selected."""
+
+
+class ExpireTimeMustBeMoreThanZeroError(TaskIQRedisError):
+    """Error if two lifetimes are less or equal zero."""

taskiq_redis/redis_backend.py

@@ -1,29 +1,63 @@
 import pickle
-from typing import TypeVar
+from typing import Dict, Optional, TypeVar, Union
 
 from redis.asyncio import ConnectionPool, Redis
 from taskiq import AsyncResultBackend
 from taskiq.abc.result_backend import TaskiqResult
 
+from taskiq_redis.exceptions import (
+    DuplicateExpireTimeSelectedError,
+    ExpireTimeMustBeMoreThanZeroError,
+)
+
 _ReturnType = TypeVar("_ReturnType")
 
 
 class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
     """Async result based on redis."""
 
-    def __init__(self, redis_url: str, keep_results: bool = True):
+    def __init__(
+        self,
+        redis_url: str,
+        keep_results: bool = True,
+        result_ex_time: Optional[int] = None,
+        result_px_time: Optional[int] = None,
+    ):
         """
         Constructs a new result backend.
 
         :param redis_url: url to redis.
         :param keep_results: flag to not remove results from Redis after reading.
+        :param result_ex_time: expire time in seconds for result.
+        :param result_px_time: expire time in milliseconds for result.
+
+        :raises DuplicateExpireTimeSelectedError: if result_ex_time
+            and result_px_time are selected.
+        :raises ExpireTimeMustBeMoreThanZeroError: if result_ex_time
+            and result_px_time are equal zero.
         """
         self.redis_pool = ConnectionPool.from_url(redis_url)
         self.keep_results = keep_results
+        self.result_ex_time = result_ex_time
+        self.result_px_time = result_px_time
+
+        if self.result_ex_time == 0 or self.result_px_time == 0:
+            raise ExpireTimeMustBeMoreThanZeroError(
+                "You must select one expire time param and it must be more than zero.",
+            )
+
+        if self.result_ex_time and self.result_px_time:
+            raise DuplicateExpireTimeSelectedError(
+                "Choose either result_ex_time or result_px_time.",
+            )
+
+        if not self.result_ex_time and not self.result_px_time:
+            self.result_ex_time = 60
 
     async def shutdown(self) -> None:
         """Closes redis connection."""
         await self.redis_pool.disconnect()
+        await super().shutdown()
 
     async def set_result(
         self,
@@ -39,19 +73,17 @@ class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
         :param task_id: ID of the task.
         :param result: TaskiqResult instance.
         """
-        result_dict = result.dict(exclude={"return_value"})
-
-        for result_key, result_value in result_dict.items():
-            result_dict[result_key] = pickle.dumps(result_value)
-        # This trick will preserve original returned value.
-        # It helps when you return not serializable classes.
-        result_dict["return_value"] = pickle.dumps(result.return_value)
+        redis_set_params: Dict[str, Union[str, bytes, int]] = {
+            "name": task_id,
+            "value": pickle.dumps(result),
+        }
+        if self.result_ex_time:
+            redis_set_params["ex"] = self.result_ex_time
+        elif self.result_px_time:
+            redis_set_params["px"] = self.result_px_time
 
         async with Redis(connection_pool=self.redis_pool) as redis:
-            await redis.hset(
-                task_id,
-                mapping=result_dict,
-            )
+            await redis.set(**redis_set_params)
 
     async def is_result_ready(self, task_id: str) -> bool:
         """
@@ -76,23 +108,19 @@ class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
         :param with_logs: if True it will download task's logs.
         :return: task's return value.
         """
-        fields = list(TaskiqResult.__fields__.keys())
-
-        if not with_logs:
-            fields.remove("log")
-
         async with Redis(connection_pool=self.redis_pool) as redis:
-            result_values = await redis.hmget(
-                name=task_id,
-                keys=fields,
-            )
+            if self.keep_results:
+                result_value = await redis.get(
+                    name=task_id,
+                )
+            else:
+                result_value = await redis.getdel(
+                    name=task_id,
+                )
 
-            if not self.keep_results:
-                await redis.delete(task_id)
+        taskiq_result: TaskiqResult[_ReturnType] = pickle.loads(result_value)
 
-        result = {
-            result_key: pickle.loads(result_value)
-            for result_value, result_key in zip(result_values, fields)
-        }
+        if not with_logs:
+            taskiq_result.log = None
 
-        return TaskiqResult(**result)
+        return taskiq_result

{taskiq_redis-0.2.0.dist-info → taskiq_redis-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: taskiq-redis
-Version: 0.2.0
+Version: 0.2.1
 Summary: Redis integration for taskiq
 Home-page: https://github.com/taskiq-python/taskiq-redis
 Keywords: taskiq,tasks,distributed,async,redis,result_backend
@@ -98,4 +98,19 @@ Brokers parameters:
 RedisAsyncResultBackend parameters:
 * `redis_url` - url to redis.
 * `keep_results` - flag to not remove results from Redis after reading.
-
+* `result_ex_time` - expire time in seconds (by default - 1 minute)
+* `result_px_time` - expire time in milliseconds (by default - not specified)
+> IMPORTANT: You must specify either `result_ex_time` or `result_px_time`.  
+>```python
+># First variant
+>redis_async_result = RedisAsyncResultBackend(
+>    redis_url="redis://localhost:6379",
+>    result_ex_time=1000,
+>)
+>
+># Second variant
+>redis_async_result = RedisAsyncResultBackend(
+>    redis_url="redis://localhost:6379",
+>    result_px_time=1000000,
+>)
+>```

taskiq_redis-0.2.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+taskiq_redis/__init__.py,sha256=7APdvz7YtRB2VpB0PvCvgIF_f4cPTXG5XyIBvdmfEVE,212
+taskiq_redis/exceptions.py,sha256=lqvMepJWafxn-oJBum4gI6JKSImxxLSf8esFtn5iR98,314
+taskiq_redis/redis_backend.py,sha256=k_ohDG8vW8MWk1vUQUKZKkylYLSYN5GBroAPrPrtmdc,4053
+taskiq_redis/redis_broker.py,sha256=l8bwfh2qKzqukJwAYY7wJ0aReMd7Ihme_1eUsxR4TPU,4279
+taskiq_redis-0.2.1.dist-info/METADATA,sha256=0gxtd5YkrQ5rUtvJm15Lldjz3dtidtMyrAYSJA9oPlI,3642
+taskiq_redis-0.2.1.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+taskiq_redis-0.2.1.dist-info/RECORD,,

{taskiq_redis-0.2.0.dist-info → taskiq_redis-0.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.5.1
+Generator: poetry-core 1.5.2
 Root-Is-Purelib: true
 Tag: py3-none-any

taskiq_redis-0.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-taskiq_redis/__init__.py,sha256=7APdvz7YtRB2VpB0PvCvgIF_f4cPTXG5XyIBvdmfEVE,212
-taskiq_redis/redis_backend.py,sha256=N6XH_XWUQr2VBoNTe1ZbwgxHh8c4yWW5fF0mkBsXQ1c,2979
-taskiq_redis/redis_broker.py,sha256=l8bwfh2qKzqukJwAYY7wJ0aReMd7Ihme_1eUsxR4TPU,4279
-taskiq_redis-0.2.0.dist-info/METADATA,sha256=SvT_vjNmL4trJ7Md84uo75FRcq9bMYDEscXGxha7SSg,3130
-taskiq_redis-0.2.0.dist-info/WHEEL,sha256=kLuE8m1WYU0Ig0_YEGrXyTtiJvKPpLpDEiChiNyei5Y,88
-taskiq_redis-0.2.0.dist-info/RECORD,,