taskiq-redis 0.2.0__tar.gz → 0.2.1__tar.gz

{taskiq_redis-0.2.0 → taskiq_redis-0.2.1}/PKG-INFO

@@ -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.0 → taskiq_redis-0.2.1}/README.md

@@ -71,3 +71,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.0 → taskiq_redis-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "taskiq-redis"
-version = "0.2.0"
+version = "0.2.1"
 description = "Redis integration for taskiq"
 authors = ["taskiq-team <taskiq@norely.com>"]
 readme = "README.md"

taskiq_redis-0.2.1/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-0.2.1/taskiq_redis/redis_backend.py

@@ -0,0 +1,126 @@
+import pickle
+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,
+        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,
+        task_id: str,
+        result: TaskiqResult[_ReturnType],
+    ) -> None:
+        """
+        Sets task result in redis.
+
+        Dumps TaskiqResult instance into the bytes and writes
+        it to redis.
+
+        :param task_id: ID of the task.
+        :param result: TaskiqResult instance.
+        """
+        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.set(**redis_set_params)
+
+    async def is_result_ready(self, task_id: str) -> bool:
+        """
+        Returns whether the result is ready.
+
+        :param task_id: ID of the task.
+
+        :returns: True if the result is ready else False.
+        """
+        async with Redis(connection_pool=self.redis_pool) as redis:
+            return bool(await redis.exists(task_id))
+
+    async def get_result(  # noqa: WPS210
+        self,
+        task_id: str,
+        with_logs: bool = False,
+    ) -> TaskiqResult[_ReturnType]:
+        """
+        Gets result from the task.
+
+        :param task_id: task's id.
+        :param with_logs: if True it will download task's logs.
+        :return: task's return value.
+        """
+        async with Redis(connection_pool=self.redis_pool) as redis:
+            if self.keep_results:
+                result_value = await redis.get(
+                    name=task_id,
+                )
+            else:
+                result_value = await redis.getdel(
+                    name=task_id,
+                )
+
+        taskiq_result: TaskiqResult[_ReturnType] = pickle.loads(result_value)
+
+        if not with_logs:
+            taskiq_result.log = None
+
+        return taskiq_result

taskiq_redis-0.2.0/taskiq_redis/redis_backend.py

@@ -1,98 +0,0 @@
-import pickle
-from typing import TypeVar
-
-from redis.asyncio import ConnectionPool, Redis
-from taskiq import AsyncResultBackend
-from taskiq.abc.result_backend import TaskiqResult
-
-_ReturnType = TypeVar("_ReturnType")
-
-
-class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
-    """Async result based on redis."""
-
-    def __init__(self, redis_url: str, keep_results: bool = True):
-        """
-        Constructs a new result backend.
-
-        :param redis_url: url to redis.
-        :param keep_results: flag to not remove results from Redis after reading.
-        """
-        self.redis_pool = ConnectionPool.from_url(redis_url)
-        self.keep_results = keep_results
-
-    async def shutdown(self) -> None:
-        """Closes redis connection."""
-        await self.redis_pool.disconnect()
-
-    async def set_result(
-        self,
-        task_id: str,
-        result: TaskiqResult[_ReturnType],
-    ) -> None:
-        """
-        Sets task result in redis.
-
-        Dumps TaskiqResult instance into the bytes and writes
-        it to redis.
-
-        :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)
-
-        async with Redis(connection_pool=self.redis_pool) as redis:
-            await redis.hset(
-                task_id,
-                mapping=result_dict,
-            )
-
-    async def is_result_ready(self, task_id: str) -> bool:
-        """
-        Returns whether the result is ready.
-
-        :param task_id: ID of the task.
-
-        :returns: True if the result is ready else False.
-        """
-        async with Redis(connection_pool=self.redis_pool) as redis:
-            return bool(await redis.exists(task_id))
-
-    async def get_result(  # noqa: WPS210
-        self,
-        task_id: str,
-        with_logs: bool = False,
-    ) -> TaskiqResult[_ReturnType]:
-        """
-        Gets result from the task.
-
-        :param task_id: task's id.
-        :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 not self.keep_results:
-                await redis.delete(task_id)
-
-        result = {
-            result_key: pickle.loads(result_value)
-            for result_value, result_key in zip(result_values, fields)
-        }
-
-        return TaskiqResult(**result)