taskiq-redis 1.1.1__tar.gz → 1.2.0__tar.gz

{taskiq_redis-1.1.1 → taskiq_redis-1.2.0}/PKG-INFO

@@ -1,26 +1,26 @@
 Metadata-Version: 2.4
 Name: taskiq-redis
-Version: 1.1.1
+Version: 1.2.0
 Summary: Redis integration for taskiq
-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
+Author: Taskiq team
+Author-email: Taskiq team <taskiq@no-reply.com>
+License-Expression: MIT
+License-File: LICENSE
 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,<7.1.0
+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.1.1 → taskiq_redis-1.2.0}/pyproject.toml

@@ -1,20 +1,26 @@
-[tool.poetry]
+[project]
 name = "taskiq-redis"
-version = "1.1.1"
+version = "1.2.0"
 description = "Redis integration for taskiq"
-authors = ["taskiq-team <taskiq@norely.com>"]
+authors = [
+    { name = "Taskiq team", email = "taskiq@no-reply.com" }
+]
+maintainers = [
+    { name = "Taskiq team", email = "taskiq@no-reply.com" }
+]
+license = "MIT"
+license-files = ["LICENSE"]
 readme = "README.md"
+requires-python = ">=3.10"
 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",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
-homepage = "https://github.com/taskiq-python/taskiq-redis"
-repository = "https://github.com/taskiq-python/taskiq-redis"
 keywords = [
     "taskiq",
     "tasks",
@@ -23,24 +29,34 @@ keywords = [
     "redis",
     "result_backend",
 ]
+dependencies = [
+    "redis>=7.0.0,<7.1.0",  # TODO: fix issues in tests with 7.1.0
+    "taskiq>=0.12.0",
+]
 
-[tool.poetry.dependencies]
-python = "^3.9"
-taskiq = ">=0.11.12,<1"
-redis = "^6"
+[dependency-groups]
+dev = [
+    {include-group = "lint"},
+    {include-group = "test"},
+    "pre-commit>=4.5.0",
+]
+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",
+]
+lint = [
+    "black>=25.11.0",
+    "mypy>=1.19.0",
+    "ruff>=0.14.7",
+]
 
-[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"
+[project.urls]
+homepage = "https://github.com/taskiq-python/taskiq-redis"
+repository = "https://github.com/taskiq-python/taskiq-redis"
 
 [tool.mypy]
 strict = true
@@ -60,8 +76,12 @@ ignore_errors = true
 strict = false
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
+requires = ["uv_build>=0.9.13,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+module-name = "taskiq_redis"
 
 [tool.ruff]
 # List of enabled rulsets.
@@ -92,6 +112,8 @@ lint.select = [
     "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
@@ -105,9 +127,11 @@ lint.ignore = [
     "D106",    # Missing docstring in public nested class
 ]
 exclude = [".venv/"]
-lint.mccabe = { max-complexity = 10 }
 line-length = 88
 
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = [
     "S101",   # Use of assert detected
@@ -127,3 +151,9 @@ allow-magic-value-types = ["int", "str", "float"]
 
 [tool.ruff.lint.flake8-bugbear]
 extend-immutable-calls = ["taskiq_dependencies.Depends", "taskiq.TaskiqDepends"]
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    # about deprecated RedisScheduleSource usage - delete after removing RedisScheduleSource
+    'ignore:RedisScheduleSource is deprecated:DeprecationWarning',
+]

{taskiq_redis-1.1.1 → taskiq_redis-1.2.0}/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
 
@@ -89,7 +89,7 @@ class ListRedisScheduleSource(ScheduleSource):
         """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 +130,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 +146,10 @@ 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]
 
     async def add_schedule(self, schedule: "ScheduledTask") -> None:
         """Add a schedule to the source."""
@@ -163,9 +163,9 @@ 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,
                 )
@@ -175,7 +175,7 @@ class ListRedisScheduleSource(ScheduleSource):
         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 +195,11 @@ 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))
+            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.1 → taskiq_redis-1.2.0}/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.1 → taskiq_redis-1.2.0}/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:
         """
@@ -260,11 +252,11 @@ class RedisStreamBroker(BaseRedisBroker):
                 approximate=self.approximate,
             )
 
-    def _ack_generator(self, id: str) -> Callable[[], Awaitable[None]]:
+    def _ack_generator(self, id: str, queue_name: str) -> Callable[[], Awaitable[None]]:
         async def _ack() -> None:
             async with Redis(connection_pool=self.connection_pool) as redis_conn:
                 await redis_conn.xack(
-                    self.queue_name,
+                    queue_name,
                     self.consumer_group_name,
                     id,
                 )
@@ -281,18 +273,18 @@ class RedisStreamBroker(BaseRedisBroker):
                     self.consumer_name,
                     {
                         self.queue_name: ">",
-                        **self.additional_streams,
+                        **self.additional_streams,  # type: ignore[dict-item]
                     },
                     block=self.block,
                     noack=False,
                     count=self.count,
                 )
-                for _, msg_list in fetched:
+                for stream, msg_list in fetched:
                     for msg_id, msg in msg_list:
                         logger.debug("Received message: %s", msg)
                         yield AckableMessage(
                             data=msg[b"data"],
-                            ack=self._ack_generator(msg_id),
+                            ack=self._ack_generator(id=msg_id, queue_name=stream),
                         )
                 logger.debug("Starting fetching unacknowledged messages")
                 for stream in [self.queue_name, *self.additional_streams.keys()]:
@@ -318,5 +310,5 @@ class RedisStreamBroker(BaseRedisBroker):
                             logger.debug("Received message: %s", msg)
                             yield AckableMessage(
                                 data=msg[b"data"],
-                                ack=self._ack_generator(msg_id),
+                                ack=self._ack_generator(id=msg_id, queue_name=stream),
                             )

{taskiq_redis-1.1.1 → taskiq_redis-1.2.0}/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:
         """
@@ -171,10 +172,10 @@ class RedisStreamClusterBroker(BaseRedisClusterBroker):
             approximate=self.approximate,
         )
 
-    def _ack_generator(self, id: str) -> Callable[[], Awaitable[None]]:
+    def _ack_generator(self, id: str, queue_name: str) -> Callable[[], Awaitable[None]]:
         async def _ack() -> None:
             await self.redis.xack(
-                self.queue_name,
+                queue_name,
                 self.consumer_group_name,
                 id,
             )
@@ -194,10 +195,10 @@ class RedisStreamClusterBroker(BaseRedisClusterBroker):
                 block=self.block,
                 noack=False,
             )
-            for _, msg_list in fetched:
+            for stream, msg_list in fetched:
                 for msg_id, msg in msg_list:
                     logger.debug("Received message: %s", msg)
                     yield AckableMessage(
                         data=msg[b"data"],
-                        ack=self._ack_generator(msg_id),
+                        ack=self._ack_generator(id=msg_id, queue_name=stream),
                     )

{taskiq_redis-1.1.1 → taskiq_redis-1.2.0}/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:
         """
@@ -239,11 +227,11 @@ class RedisStreamSentinelBroker(BaseSentinelBroker):
                 approximate=self.approximate,
             )
 
-    def _ack_generator(self, id: str) -> Callable[[], Awaitable[None]]:
+    def _ack_generator(self, id: str, queue_name: str) -> Callable[[], Awaitable[None]]:
         async def _ack() -> None:
             async with self._acquire_master_conn() as redis_conn:
                 await redis_conn.xack(
-                    self.queue_name,
+                    queue_name,
                     self.consumer_group_name,
                     id,
                 )
@@ -264,10 +252,10 @@ class RedisStreamSentinelBroker(BaseSentinelBroker):
                     block=self.block,
                     noack=False,
                 )
-                for _, msg_list in fetched:
+                for stream, msg_list in fetched:
                     for msg_id, msg in msg_list:
                         logger.debug("Received message: %s", msg)
                         yield AckableMessage(
                             data=msg[b"data"],
-                            ack=self._ack_generator(msg_id),
+                            ack=self._ack_generator(id=msg_id, queue_name=stream),
                         )

{taskiq_redis-1.1.1 → taskiq_redis-1.2.0}/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.