taskiq-redis 1.1.2__tar.gz → 1.2.1__tar.gz

{taskiq_redis-1.1.2 → taskiq_redis-1.2.1}/PKG-INFO

@@ -1,26 +1,26 @@
 Metadata-Version: 2.4
 Name: taskiq-redis
-Version: 1.1.2
+Version: 1.2.1
 Summary: Redis integration for taskiq
+Keywords: async,distributed,redis,result_backend,taskiq,tasks
+Author: Taskiq team
+Author-email: Taskiq team <taskiq@no-reply.com>
+License-Expression: MIT
 License-File: LICENSE
-Keywords: taskiq,tasks,distributed,async,redis,result_backend
-Author: taskiq-team
-Author-email: taskiq@norely.com
-Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
-Requires-Dist: redis (>=6,<7)
-Requires-Dist: taskiq (>=0.11.12,<1)
-Project-URL: Homepage, https://github.com/taskiq-python/taskiq-redis
-Project-URL: Repository, https://github.com/taskiq-python/taskiq-redis
+Requires-Dist: redis>=7.0.0,<8
+Requires-Dist: taskiq>=0.12.0
+Maintainer: Taskiq team
+Maintainer-email: Taskiq team <taskiq@no-reply.com>
+Requires-Python: >=3.10
+Project-URL: homepage, https://github.com/taskiq-python/taskiq-redis
+Project-URL: repository, https://github.com/taskiq-python/taskiq-redis
 Description-Content-Type: text/markdown
 
 # TaskIQ-Redis
@@ -228,4 +228,3 @@ Simply pass the desired queue name as message's label when kicking a task to ove
 async def low_priority_task() -> None:
     print("I don't mind waiting a little longer")
 ```
-

taskiq_redis-1.2.1/pyproject.toml

@@ -0,0 +1,155 @@
+[project]
+name = "taskiq-redis"
+version = "1.2.1"
+description = "Redis integration for taskiq"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Taskiq team", email = "taskiq@no-reply.com" }]
+maintainers = [{ name = "Taskiq team", email = "taskiq@no-reply.com" }]
+keywords = [
+  "async",
+  "distributed",
+  "redis",
+  "result_backend",
+  "taskiq",
+  "tasks",
+]
+classifiers = [
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+  "redis>=7.0.0,<8",  # TODO: fix issues in tests with 7.1.0
+  "taskiq>=0.12.0",
+]
+
+[project.urls]
+homepage = "https://github.com/taskiq-python/taskiq-redis"
+repository = "https://github.com/taskiq-python/taskiq-redis"
+
+[dependency-groups]
+dev = [
+  "pre-commit>=4.5.0",
+  { include-group = "lint" },
+  { include-group = "test" },
+]
+lint = [
+  "black>=25.11.0",
+  "mypy>=1.19.0",
+  "ruff>=0.14.7",
+]
+test = [
+  "fakeredis>=2.32.1",
+  "freezegun>=1.5.5",
+  "pytest>=9.0.1",
+  "pytest-cov>=7.0.0",
+  "pytest-env>=1.2.0",
+  "pytest-xdist>=3.8.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.13,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.mypy]
+strict = true
+ignore_missing_imports = true
+allow_subclassing_any = true
+allow_untyped_calls = true
+pretty = true
+show_error_codes = true
+implicit_reexport = true
+allow_untyped_decorators = true
+warn_return_any = false
+
+[[tool.mypy.overrides]]
+module = ["redis"]
+ignore_missing_imports = true
+ignore_errors = true
+strict = false
+
+[tool.pytest.ini_options]
+filterwarnings = [
+  # about deprecated RedisScheduleSource usage - delete after removing RedisScheduleSource
+  "ignore:RedisScheduleSource is deprecated:DeprecationWarning",
+]
+
+[tool.ruff]
+# List of enabled rulsets.
+# See https://docs.astral.sh/ruff/rules/ for more information.
+lint.select = [
+  "E",  # Error
+  "F",  # Pyflakes
+  "W",  # Pycodestyle
+  "C90",  # McCabe complexity
+  "I",  # Isort
+  "N",  # pep8-naming
+  "D",  # Pydocstyle
+  "ANN",  # Pytype annotations
+  "S",  # Bandit
+  "B",  # Bugbear
+  "COM",  # Commas
+  "C4",  # Comprehensions
+  "ISC",  # Implicit string concat
+  "PIE",  # Unnecessary code
+  "T20",  # Catch prints
+  "PYI",  # validate pyi files
+  "Q",  # Checks for quotes
+  "RSE",  # Checks raise statements
+  "RET",  # Checks return statements
+  "SLF",  # Self checks
+  "SIM",  # Simplificator
+  "PTH",  # Pathlib checks
+  "ERA",  # Checks for commented out code
+  "PL",  # PyLint checks
+  "RUF",  # Specific to Ruff checks
+  "FA102",  # Future annotations
+  "UP",  # Pyupgrade
+]
+lint.ignore = [
+  "D105",  # Missing docstring in magic method
+  "D107",  # Missing docstring in __init__
+  "D212",  # Multi-line docstring summary should start at the first line
+  "D401",  # First line should be in imperative mood
+  "D104",  # Missing docstring in public package
+  "D100",  # Missing docstring in public module
+  "ANN401",  # typing.Any are disallowed in `**kwargs
+  "PLR0913",  # Too many arguments for function call
+  "D106",  # Missing docstring in public nested class
+]
+exclude = [".venv/"]
+line-length = 88
+
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = [
+  "S101",  # Use of assert detected
+  "S301",  # Use of pickle detected
+  "D103",  # Missing docstring in public function
+  "SLF001",  # Private member accessed
+  "S311",  # Standard pseudo-random generators are not suitable for security/cryptographic purposes
+  "D101",  # Missing docstring in public class
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "pep257"
+ignore-decorators = ["typing.overload"]
+
+[tool.ruff.lint.pylint]
+allow-magic-value-types = ["int", "str", "float"]
+
+[tool.ruff.lint.flake8-bugbear]
+extend-immutable-calls = ["taskiq_dependencies.Depends", "taskiq.TaskiqDepends"]
+
+[tool.uv.build-backend]
+module-root = ""
+module-name = "taskiq_redis"

{taskiq_redis-1.1.2 → taskiq_redis-1.2.1}/taskiq_redis/list_schedule_source.py

@@ -1,6 +1,6 @@
 import datetime
 from logging import getLogger
-from typing import Any, List, Optional
+from typing import Any
 
 from redis.asyncio import BlockingConnectionPool, Redis
 from taskiq import ScheduledTask, ScheduleSource
@@ -19,8 +19,8 @@ class ListRedisScheduleSource(ScheduleSource):
         self,
         url: str,
         prefix: str = "schedule",
-        max_connection_pool_size: Optional[int] = None,
-        serializer: Optional[TaskiqSerializer] = None,
+        max_connection_pool_size: int | None = None,
+        serializer: TaskiqSerializer | None = None,
         buffer_size: int = 50,
         skip_past_schedules: bool = False,
         **connection_kwargs: Any,
@@ -48,7 +48,7 @@ class ListRedisScheduleSource(ScheduleSource):
             serializer = PickleSerializer()
         self._serializer = serializer
         self._is_first_run = True
-        self._previous_schedule_source: Optional[ScheduleSource] = None
+        self._previous_schedule_source: ScheduleSource | None = None
         self._delete_schedules_after_migration: bool = True
         self._skip_past_schedules = skip_past_schedules
 
@@ -85,11 +85,14 @@ class ListRedisScheduleSource(ScheduleSource):
         """Get the key for a cron-based schedule."""
         return f"{self._prefix}:cron"
 
+    def _get_interval_key(self) -> str:
+        return f"{self._prefix}:interval"
+
     def _get_data_key(self, schedule_id: str) -> str:
         """Get the key for a schedule data."""
         return f"{self._prefix}:data:{schedule_id}"
 
-    def _parse_time_key(self, key: str) -> Optional[datetime.datetime]:
+    def _parse_time_key(self, key: str) -> datetime.datetime | None:
         """Get time value from the timed-key."""
         try:
             dt_str = key.split(":", 2)[2]
@@ -130,7 +133,7 @@ class ListRedisScheduleSource(ScheduleSource):
                 if key_time and key_time <= minute_before:
                     time_keys.append(key.decode())
             for key in time_keys:
-                schedules.extend(await redis.lrange(key, 0, -1))
+                schedules.extend(await redis.lrange(key, 0, -1))  # type: ignore[misc]
 
         return schedules
 
@@ -146,10 +149,12 @@ class ListRedisScheduleSource(ScheduleSource):
                 )
                 # We need to remove the schedule from the cron or time list.
                 if schedule.cron is not None:
-                    await redis.lrem(self._get_cron_key(), 0, schedule_id)
+                    await redis.lrem(self._get_cron_key(), 0, schedule_id)  # type: ignore[misc]
                 elif schedule.time is not None:
                     time_key = self._get_time_key(schedule.time)
-                    await redis.lrem(time_key, 0, schedule_id)
+                    await redis.lrem(time_key, 0, schedule_id)  # type: ignore[misc]
+                elif schedule.interval:
+                    await redis.lrem(self._get_interval_key(), 0, schedule_id)  # type: ignore[misc]
 
     async def add_schedule(self, schedule: "ScheduledTask") -> None:
         """Add a schedule to the source."""
@@ -163,19 +168,24 @@ class ListRedisScheduleSource(ScheduleSource):
             # This is an optimization, so we can get all the schedules
             # for the current time much faster.
             if schedule.cron is not None:
-                await redis.rpush(self._get_cron_key(), schedule.schedule_id)
+                await redis.rpush(self._get_cron_key(), schedule.schedule_id)  # type: ignore[misc]
             elif schedule.time is not None:
-                await redis.rpush(
+                await redis.rpush(  # type: ignore[misc]
                     self._get_time_key(schedule.time),
                     schedule.schedule_id,
                 )
+            elif schedule.interval:
+                await redis.rpush(  # type: ignore[misc]
+                    self._get_interval_key(),
+                    schedule.schedule_id,
+                )
 
     async def post_send(self, task: ScheduledTask) -> None:
         """Delete a task after it's completed."""
         if task.time is not None:
             await self.delete_schedule(task.schedule_id)
 
-    async def get_schedules(self) -> List["ScheduledTask"]:
+    async def get_schedules(self) -> list["ScheduledTask"]:
         """
         Get all schedules.
 
@@ -195,11 +205,15 @@ class ListRedisScheduleSource(ScheduleSource):
             self._is_first_run = False
         async with Redis(connection_pool=self._connection_pool) as redis:
             buffer = []
-            crons = await redis.lrange(self._get_cron_key(), 0, -1)
+            crons = await redis.lrange(self._get_cron_key(), 0, -1)  # type: ignore[misc]
             logger.debug("Got %d cron schedules", len(crons))
             if crons:
                 buffer.extend(crons)
-            timed.extend(await redis.lrange(self._get_time_key(current_time), 0, -1))
+            intervals = await redis.lrange(self._get_interval_key(), 0, -1)  # type: ignore[misc]
+            logger.debug("Got %d interval schedules", len(intervals))
+            if intervals:
+                buffer.extend(intervals)
+            timed.extend(await redis.lrange(self._get_time_key(current_time), 0, -1))  # type: ignore[misc]
             logger.debug("Got %d timed schedules", len(timed))
             if timed:
                 buffer.extend(timed)

{taskiq_redis-1.1.2 → taskiq_redis-1.2.1}/taskiq_redis/redis_backend.py

@@ -1,16 +1,6 @@
-import sys
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncIterator,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    TypeVar,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, TypeAlias, TypeVar
 
 from redis.asyncio import BlockingConnectionPool, Redis, Sentinel
 from redis.asyncio.cluster import RedisCluster
@@ -28,11 +18,6 @@ from taskiq_redis.exceptions import (
     ResultIsMissingError,
 )
 
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
 if TYPE_CHECKING:
     _Redis: TypeAlias = Redis[bytes]  # type: ignore
     _BlockingConnectionPool: TypeAlias = BlockingConnectionPool[Connection]  # type: ignore
@@ -52,11 +37,11 @@ class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
         self,
         redis_url: str,
         keep_results: bool = True,
-        result_ex_time: Optional[int] = None,
-        result_px_time: Optional[int] = None,
-        max_connection_pool_size: Optional[int] = None,
-        serializer: Optional[TaskiqSerializer] = None,
-        prefix_str: Optional[str] = None,
+        result_ex_time: int | None = None,
+        result_px_time: int | None = None,
+        max_connection_pool_size: int | None = None,
+        serializer: TaskiqSerializer | None = None,
+        prefix_str: str | None = None,
         **connection_kwargs: Any,
     ) -> None:
         """
@@ -121,17 +106,15 @@ class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
         :param task_id: ID of the task.
         :param result: TaskiqResult instance.
         """
-        redis_set_params: Dict[str, Union[str, int, bytes]] = {
-            "name": self._task_name(task_id),
-            "value": self.serializer.dumpb(model_dump(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
-
+        name = self._task_name(task_id)
+        value = self.serializer.dumpb(model_dump(result))
         async with Redis(connection_pool=self.redis_pool) as redis:
-            await redis.set(**redis_set_params)
+            if self.result_ex_time:
+                await redis.set(name=name, value=value, ex=self.result_ex_time)
+            elif self.result_px_time:
+                await redis.set(name=name, value=value, px=self.result_px_time)
+            else:
+                await redis.set(name=name, value=value)
 
     async def is_result_ready(self, task_id: str) -> bool:
         """
@@ -195,22 +178,20 @@ class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
         :param task_id: ID of the task.
         :param result: task's TaskProgress instance.
         """
-        redis_set_params: Dict[str, Union[str, int, bytes]] = {
-            "name": self._task_name(task_id) + PROGRESS_KEY_SUFFIX,
-            "value": self.serializer.dumpb(model_dump(progress)),
-        }
-        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
-
+        name = self._task_name(task_id) + PROGRESS_KEY_SUFFIX
+        value = self.serializer.dumpb(model_dump(progress))
         async with Redis(connection_pool=self.redis_pool) as redis:
-            await redis.set(**redis_set_params)
+            if self.result_ex_time:
+                await redis.set(name=name, value=value, ex=self.result_ex_time)
+            elif self.result_px_time:
+                await redis.set(name=name, value=value, px=self.result_px_time)
+            else:
+                await redis.set(name=name, value=value)
 
     async def get_progress(
         self,
         task_id: str,
-    ) -> Union[TaskProgress[_ReturnType], None]:
+    ) -> TaskProgress[_ReturnType] | None:
         """
         Gets progress results from the task.
 
@@ -238,10 +219,10 @@ class RedisAsyncClusterResultBackend(AsyncResultBackend[_ReturnType]):
         self,
         redis_url: str,
         keep_results: bool = True,
-        result_ex_time: Optional[int] = None,
-        result_px_time: Optional[int] = None,
-        serializer: Optional[TaskiqSerializer] = None,
-        prefix_str: Optional[str] = None,
+        result_ex_time: int | None = None,
+        result_px_time: int | None = None,
+        serializer: TaskiqSerializer | None = None,
+        prefix_str: str | None = None,
         **connection_kwargs: Any,
     ) -> None:
         """
@@ -258,7 +239,7 @@ class RedisAsyncClusterResultBackend(AsyncResultBackend[_ReturnType]):
         :raises ExpireTimeMustBeMoreThanZeroError: if result_ex_time
             and result_px_time are equal zero.
         """
-        self.redis: "RedisCluster" = RedisCluster.from_url(
+        self.redis: RedisCluster = RedisCluster.from_url(
             redis_url,
             **connection_kwargs,
         )
@@ -296,24 +277,23 @@ class RedisAsyncClusterResultBackend(AsyncResultBackend[_ReturnType]):
         result: TaskiqResult[_ReturnType],
     ) -> None:
         """
-        Sets task result in redis.
+        Sets task result in redis cluster.
 
         Dumps TaskiqResult instance into the bytes and writes
-        it to redis.
+        it to redis cluster.
 
         :param task_id: ID of the task.
         :param result: TaskiqResult instance.
         """
-        redis_set_params: Dict[str, Union[str, bytes, int]] = {
-            "name": self._task_name(task_id),
-            "value": self.serializer.dumpb(model_dump(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
-
-        await self.redis.set(**redis_set_params)  # type: ignore
+        name = self._task_name(task_id)
+        value = self.serializer.dumpb(model_dump(result))
+        async with self.redis as redis:
+            if self.result_ex_time:
+                await redis.set(name=name, value=value, ex=self.result_ex_time)
+            elif self.result_px_time:
+                await redis.set(name=name, value=value, px=self.result_px_time)
+            else:
+                await redis.set(name=name, value=value)
 
     async def is_result_ready(self, task_id: str) -> bool:
         """
@@ -367,29 +347,28 @@ class RedisAsyncClusterResultBackend(AsyncResultBackend[_ReturnType]):
         progress: TaskProgress[_ReturnType],
     ) -> None:
         """
-        Sets task progress in redis.
+        Sets task progress in redis cluster.
 
         Dumps TaskProgress instance into the bytes and writes
-        it to redis with a standard suffix on the task_id as the key
+        it to redis cluster with a standard suffix on the task_id as the key
 
         :param task_id: ID of the task.
         :param result: task's TaskProgress instance.
         """
-        redis_set_params: Dict[str, Union[str, int, bytes]] = {
-            "name": self._task_name(task_id) + PROGRESS_KEY_SUFFIX,
-            "value": self.serializer.dumpb(model_dump(progress)),
-        }
-        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
-
-        await self.redis.set(**redis_set_params)  # type: ignore
+        name = self._task_name(task_id) + PROGRESS_KEY_SUFFIX
+        value = self.serializer.dumpb(model_dump(progress))
+        async with self.redis as redis:
+            if self.result_ex_time:
+                await redis.set(name=name, value=value, ex=self.result_ex_time)
+            elif self.result_px_time:
+                await redis.set(name=name, value=value, px=self.result_px_time)
+            else:
+                await redis.set(name=name, value=value)
 
     async def get_progress(
         self,
         task_id: str,
-    ) -> Union[TaskProgress[_ReturnType], None]:
+    ) -> TaskProgress[_ReturnType] | None:
         """
         Gets progress results from the task.
 
@@ -414,15 +393,15 @@ class RedisAsyncSentinelResultBackend(AsyncResultBackend[_ReturnType]):
 
     def __init__(
         self,
-        sentinels: List[Tuple[str, int]],
+        sentinels: list[tuple[str, int]],
         master_name: str,
         keep_results: bool = True,
-        result_ex_time: Optional[int] = None,
-        result_px_time: Optional[int] = None,
+        result_ex_time: int | None = None,
+        result_px_time: int | None = None,
         min_other_sentinels: int = 0,
-        sentinel_kwargs: Optional[Any] = None,
-        serializer: Optional[TaskiqSerializer] = None,
-        prefix_str: Optional[str] = None,
+        sentinel_kwargs: Any | None = None,
+        serializer: TaskiqSerializer | None = None,
+        prefix_str: str | None = None,
         **connection_kwargs: Any,
     ) -> None:
         """
@@ -490,17 +469,15 @@ class RedisAsyncSentinelResultBackend(AsyncResultBackend[_ReturnType]):
         :param task_id: ID of the task.
         :param result: TaskiqResult instance.
         """
-        redis_set_params: Dict[str, Union[str, bytes, int]] = {
-            "name": self._task_name(task_id),
-            "value": self.serializer.dumpb(model_dump(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
-
+        name = self._task_name(task_id)
+        value = self.serializer.dumpb(model_dump(result))
         async with self._acquire_master_conn() as redis:
-            await redis.set(**redis_set_params)  # type: ignore
+            if self.result_ex_time:
+                await redis.set(name=name, value=value, ex=self.result_ex_time)
+            elif self.result_px_time:
+                await redis.set(name=name, value=value, px=self.result_px_time)
+            else:
+                await redis.set(name=name, value=value)
 
     async def is_result_ready(self, task_id: str) -> bool:
         """
@@ -559,27 +536,25 @@ class RedisAsyncSentinelResultBackend(AsyncResultBackend[_ReturnType]):
         Sets task progress in redis.
 
         Dumps TaskProgress instance into the bytes and writes
-        it to redis with a standard suffix on the task_id as the key
+        it to redis via sentinel with a standard suffix on the task_id as the key
 
         :param task_id: ID of the task.
         :param result: task's TaskProgress instance.
         """
-        redis_set_params: Dict[str, Union[str, int, bytes]] = {
-            "name": self._task_name(task_id) + PROGRESS_KEY_SUFFIX,
-            "value": self.serializer.dumpb(model_dump(progress)),
-        }
-        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
-
+        name = self._task_name(task_id) + PROGRESS_KEY_SUFFIX
+        value = self.serializer.dumpb(model_dump(progress))
         async with self._acquire_master_conn() as redis:
-            await redis.set(**redis_set_params)  # type: ignore
+            if self.result_ex_time:
+                await redis.set(name=name, value=value, ex=self.result_ex_time)
+            elif self.result_px_time:
+                await redis.set(name=name, value=value, px=self.result_px_time)
+            else:
+                await redis.set(name=name, value=value)
 
     async def get_progress(
         self,
         task_id: str,
-    ) -> Union[TaskProgress[_ReturnType], None]:
+    ) -> TaskProgress[_ReturnType] | None:
         """
         Gets progress results from the task.
 

{taskiq_redis-1.1.2 → taskiq_redis-1.2.1}/taskiq_redis/redis_broker.py

@@ -1,14 +1,10 @@
-import sys
 import uuid
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from logging import getLogger
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncGenerator,
-    Awaitable,
-    Callable,
-    Dict,
-    Optional,
+    TypeAlias,
     TypeVar,
 )
 
@@ -22,10 +18,6 @@ _T = TypeVar("_T")
 
 logger = getLogger("taskiq.redis_broker")
 
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
 
 if TYPE_CHECKING:
     _BlockingConnectionPool: TypeAlias = BlockingConnectionPool[Connection]  # type: ignore
@@ -39,10 +31,10 @@ class BaseRedisBroker(AsyncBroker):
     def __init__(
         self,
         url: str,
-        task_id_generator: Optional[Callable[[], str]] = None,
-        result_backend: Optional[AsyncResultBackend[_T]] = None,
+        task_id_generator: Callable[[], str] | None = None,
+        result_backend: AsyncResultBackend[_T] | None = None,
         queue_name: str = "taskiq",
-        max_connection_pool_size: Optional[int] = None,
+        max_connection_pool_size: int | None = None,
         **connection_kwargs: Any,
     ) -> None:
         """
@@ -122,7 +114,7 @@ class ListQueueBroker(BaseRedisBroker):
         """
         queue_name = message.labels.get("queue_name") or self.queue_name
         async with Redis(connection_pool=self.connection_pool) as redis_conn:
-            await redis_conn.lpush(queue_name, message.message)
+            await redis_conn.lpush(queue_name, message.message)  # type: ignore
 
     async def listen(self) -> AsyncGenerator[bytes, None]:
         """
@@ -137,7 +129,7 @@ class ListQueueBroker(BaseRedisBroker):
         while True:
             try:
                 async with Redis(connection_pool=self.connection_pool) as redis_conn:
-                    yield (await redis_conn.brpop(self.queue_name))[
+                    yield (await redis_conn.brpop(self.queue_name))[  # type: ignore
                         redis_brpop_data_position
                     ]
             except ConnectionError as exc:
@@ -159,18 +151,18 @@ class RedisStreamBroker(BaseRedisBroker):
         self,
         url: str,
         queue_name: str = "taskiq",
-        max_connection_pool_size: Optional[int] = None,
+        max_connection_pool_size: int | None = None,
         consumer_group_name: str = "taskiq",
-        consumer_name: Optional[str] = None,
+        consumer_name: str | None = None,
         consumer_id: str = "$",
         mkstream: bool = True,
         xread_block: int = 2000,
-        maxlen: Optional[int] = None,
+        maxlen: int | None = None,
         approximate: bool = True,
         idle_timeout: int = 600000,  # 10 minutes
         unacknowledged_batch_size: int = 100,
-        xread_count: Optional[int] = 100,
-        additional_streams: Optional[Dict[str, str]] = None,
+        xread_count: int | None = 100,
+        additional_streams: dict[str, str | int] | None = None,
         **connection_kwargs: Any,
     ) -> None:
         """
@@ -281,7 +273,7 @@ class RedisStreamBroker(BaseRedisBroker):
                     self.consumer_name,
                     {
                         self.queue_name: ">",
-                        **self.additional_streams,
+                        **self.additional_streams,  # type: ignore[dict-item]
                     },
                     block=self.block,
                     noack=False,

{taskiq_redis-1.1.2 → taskiq_redis-1.2.1}/taskiq_redis/redis_cluster_broker.py

@@ -1,6 +1,7 @@
 import uuid
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from logging import getLogger
-from typing import Any, AsyncGenerator, Awaitable, Callable, Dict, Optional
+from typing import Any
 
 from redis.asyncio import RedisCluster, ResponseError
 from taskiq import AckableMessage
@@ -30,7 +31,7 @@ class BaseRedisClusterBroker(AsyncBroker):
         """
         super().__init__()
 
-        self.redis: "RedisCluster[bytes]" = RedisCluster.from_url(  # type: ignore
+        self.redis: RedisCluster[bytes] = RedisCluster.from_url(  # type: ignore
             url=url,
             max_connections=max_connection_pool_size,
             **connection_kwargs,
@@ -89,13 +90,13 @@ class RedisStreamClusterBroker(BaseRedisClusterBroker):
         queue_name: str = "taskiq",
         max_connection_pool_size: int = 2**31,
         consumer_group_name: str = "taskiq",
-        consumer_name: Optional[str] = None,
+        consumer_name: str | None = None,
         consumer_id: str = "$",
         mkstream: bool = True,
         xread_block: int = 10000,
-        maxlen: Optional[int] = None,
+        maxlen: int | None = None,
         approximate: bool = True,
-        additional_streams: Optional[Dict[str, str]] = None,
+        additional_streams: dict[str, str] | None = None,
         **connection_kwargs: Any,
     ) -> None:
         """

{taskiq_redis-1.1.2 → taskiq_redis-1.2.1}/taskiq_redis/redis_sentinel_broker.py

@@ -1,18 +1,11 @@
-import sys
 import uuid
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 from logging import getLogger
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncGenerator,
-    AsyncIterator,
-    Awaitable,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Tuple,
+    TypeAlias,
     TypeVar,
 )
 
@@ -21,11 +14,6 @@ from redis.asyncio import Redis, Sentinel
 from taskiq import AckableMessage, AsyncResultBackend, BrokerMessage
 from taskiq.abc.broker import AsyncBroker
 
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
 if TYPE_CHECKING:
     _Redis: TypeAlias = Redis[bytes]  # type: ignore
 else:
@@ -41,13 +29,13 @@ class BaseSentinelBroker(AsyncBroker):
 
     def __init__(
         self,
-        sentinels: List[Tuple[str, int]],
+        sentinels: list[tuple[str, int]],
         master_name: str,
-        result_backend: Optional[AsyncResultBackend[_T]] = None,
-        task_id_generator: Optional[Callable[[], str]] = None,
+        result_backend: AsyncResultBackend[_T] | None = None,
+        task_id_generator: Callable[[], str] | None = None,
         queue_name: str = "taskiq",
         min_other_sentinels: int = 0,
-        sentinel_kwargs: Optional[Any] = None,
+        sentinel_kwargs: Any | None = None,
         **connection_kwargs: Any,
     ) -> None:
         super().__init__(
@@ -148,18 +136,18 @@ class RedisStreamSentinelBroker(BaseSentinelBroker):
 
     def __init__(
         self,
-        sentinels: List[Tuple[str, int]],
+        sentinels: list[tuple[str, int]],
         master_name: str,
         min_other_sentinels: int = 0,
         queue_name: str = "taskiq",
         consumer_group_name: str = "taskiq",
-        consumer_name: Optional[str] = None,
+        consumer_name: str | None = None,
         consumer_id: str = "$",
         mkstream: bool = True,
         xread_block: int = 10000,
-        maxlen: Optional[int] = None,
+        maxlen: int | None = None,
         approximate: bool = True,
-        additional_streams: Optional[Dict[str, str]] = None,
+        additional_streams: dict[str, str] | None = None,
         **connection_kwargs: Any,
     ) -> None:
         """

{taskiq_redis-1.1.2 → taskiq_redis-1.2.1}/taskiq_redis/schedule_source.py

@@ -1,7 +1,7 @@
-import sys
 import warnings
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, AsyncIterator, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, TypeAlias
 
 from redis.asyncio import (
     BlockingConnectionPool,
@@ -16,11 +16,6 @@ from taskiq.compat import model_dump, model_validate
 from taskiq.scheduler.scheduled_task import ScheduledTask
 from taskiq.serializers import PickleSerializer
 
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
 if TYPE_CHECKING:
     _Redis: TypeAlias = Redis[bytes]  # type: ignore
     _BlockingConnectionPool: TypeAlias = BlockingConnectionPool[Connection]  # type: ignore
@@ -50,8 +45,8 @@ class RedisScheduleSource(ScheduleSource):
         url: str,
         prefix: str = "schedule",
         buffer_size: int = 50,
-        max_connection_pool_size: Optional[int] = None,
-        serializer: Optional[TaskiqSerializer] = None,
+        max_connection_pool_size: int | None = None,
+        serializer: TaskiqSerializer | None = None,
         **connection_kwargs: Any,
     ) -> None:
         warnings.warn(
@@ -89,7 +84,7 @@ class RedisScheduleSource(ScheduleSource):
                 self.serializer.dumpb(model_dump(schedule)),
             )
 
-    async def get_schedules(self) -> List[ScheduledTask]:
+    async def get_schedules(self) -> list[ScheduledTask]:
         """
         Get all schedules from redis.
 
@@ -143,11 +138,11 @@ class RedisClusterScheduleSource(ScheduleSource):
         self,
         url: str,
         prefix: str = "schedule",
-        serializer: Optional[TaskiqSerializer] = None,
+        serializer: TaskiqSerializer | None = None,
         **connection_kwargs: Any,
     ) -> None:
         self.prefix = prefix
-        self.redis: "RedisCluster" = RedisCluster.from_url(
+        self.redis: RedisCluster = RedisCluster.from_url(
             url,
             **connection_kwargs,
         )
@@ -171,7 +166,7 @@ class RedisClusterScheduleSource(ScheduleSource):
             self.serializer.dumpb(model_dump(schedule)),
         )
 
-    async def get_schedules(self) -> List[ScheduledTask]:
+    async def get_schedules(self) -> list[ScheduledTask]:
         """
         Get all schedules from redis.
 
@@ -218,13 +213,13 @@ class RedisSentinelScheduleSource(ScheduleSource):
 
     def __init__(
         self,
-        sentinels: List[Tuple[str, int]],
+        sentinels: list[tuple[str, int]],
         master_name: str,
         prefix: str = "schedule",
         buffer_size: int = 50,
-        serializer: Optional[TaskiqSerializer] = None,
+        serializer: TaskiqSerializer | None = None,
         min_other_sentinels: int = 0,
-        sentinel_kwargs: Optional[Any] = None,
+        sentinel_kwargs: Any | None = None,
         **connection_kwargs: Any,
     ) -> None:
         self.prefix = prefix
@@ -263,7 +258,7 @@ class RedisSentinelScheduleSource(ScheduleSource):
                 self.serializer.dumpb(model_dump(schedule)),
             )
 
-    async def get_schedules(self) -> List[ScheduledTask]:
+    async def get_schedules(self) -> list[ScheduledTask]:
         """
         Get all schedules from redis.
 

taskiq_redis-1.1.2/pyproject.toml

@@ -1,129 +0,0 @@
-[tool.poetry]
-name = "taskiq-redis"
-version = "1.1.2"
-description = "Redis integration for taskiq"
-authors = ["taskiq-team <taskiq@norely.com>"]
-readme = "README.md"
-classifiers = [
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-]
-homepage = "https://github.com/taskiq-python/taskiq-redis"
-repository = "https://github.com/taskiq-python/taskiq-redis"
-keywords = [
-    "taskiq",
-    "tasks",
-    "distributed",
-    "async",
-    "redis",
-    "result_backend",
-]
-
-[tool.poetry.dependencies]
-python = "^3.9"
-taskiq = ">=0.11.12,<1"
-redis = "^6"
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^8"
-mypy = "^1"
-black = "^25"
-pytest-cov = "^6"
-anyio = "^4"
-pytest-env = "^1"
-fakeredis = "^2"
-pre-commit = "^4"
-pytest-xdist = { version = "^3", extras = ["psutil"] }
-ruff = "^0"
-freezegun = "^1.5.1"
-
-[tool.mypy]
-strict = true
-ignore_missing_imports = true
-allow_subclassing_any = true
-allow_untyped_calls = true
-pretty = true
-show_error_codes = true
-implicit_reexport = true
-allow_untyped_decorators = true
-warn_return_any = false
-
-[[tool.mypy.overrides]]
-module = ['redis']
-ignore_missing_imports = true
-ignore_errors = true
-strict = false
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.ruff]
-# List of enabled rulsets.
-# See https://docs.astral.sh/ruff/rules/ for more information.
-lint.select = [
-    "E",   # Error
-    "F",   # Pyflakes
-    "W",   # Pycodestyle
-    "C90", # McCabe complexity
-    "I",   # Isort
-    "N",   # pep8-naming
-    "D",   # Pydocstyle
-    "ANN", # Pytype annotations
-    "S",   # Bandit
-    "B",   # Bugbear
-    "COM", # Commas
-    "C4",  # Comprehensions
-    "ISC", # Implicit string concat
-    "PIE", # Unnecessary code
-    "T20", # Catch prints
-    "PYI", # validate pyi files
-    "Q",   # Checks for quotes
-    "RSE", # Checks raise statements
-    "RET", # Checks return statements
-    "SLF", # Self checks
-    "SIM", # Simplificator
-    "PTH", # Pathlib checks
-    "ERA", # Checks for commented out code
-    "PL",  # PyLint checks
-    "RUF", # Specific to Ruff checks
-]
-lint.ignore = [
-    "D105",    # Missing docstring in magic method
-    "D107",    # Missing docstring in __init__
-    "D212",    # Multi-line docstring summary should start at the first line
-    "D401",    # First line should be in imperative mood
-    "D104",    # Missing docstring in public package
-    "D100",    # Missing docstring in public module
-    "ANN401",  # typing.Any are disallowed in `**kwargs
-    "PLR0913", # Too many arguments for function call
-    "D106",    # Missing docstring in public nested class
-]
-exclude = [".venv/"]
-lint.mccabe = { max-complexity = 10 }
-line-length = 88
-
-[tool.ruff.lint.per-file-ignores]
-"tests/*" = [
-    "S101",   # Use of assert detected
-    "S301",   # Use of pickle detected
-    "D103",   # Missing docstring in public function
-    "SLF001", # Private member accessed
-    "S311",   # Standard pseudo-random generators are not suitable for security/cryptographic purposes
-    "D101",   # Missing docstring in public class
-]
-
-[tool.ruff.lint.pydocstyle]
-convention = "pep257"
-ignore-decorators = ["typing.overload"]
-
-[tool.ruff.lint.pylint]
-allow-magic-value-types = ["int", "str", "float"]
-
-[tool.ruff.lint.flake8-bugbear]
-extend-immutable-calls = ["taskiq_dependencies.Depends", "taskiq.TaskiqDepends"]