taskiq-redis 1.0.8__tar.gz → 1.1.0__tar.gz

{taskiq_redis-1.0.8 → taskiq_redis-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: taskiq-redis
-Version: 1.0.8
+Version: 1.1.0
 Summary: Redis integration for taskiq
 Keywords: taskiq,tasks,distributed,async,redis,result_backend
 Author: taskiq-team
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.8
-Requires-Dist: redis (>=5,<6)
+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

{taskiq_redis-1.0.8 → taskiq_redis-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "taskiq-redis"
-version = "1.0.8"
+version = "1.1.0"
 description = "Redis integration for taskiq"
 authors = ["taskiq-team <taskiq@norely.com>"]
 readme = "README.md"
@@ -27,7 +27,7 @@ keywords = [
 [tool.poetry.dependencies]
 python = "^3.9"
 taskiq = ">=0.11.12,<1"
-redis = "^5"
+redis = "^6"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8"

{taskiq_redis-1.0.8 → taskiq_redis-1.1.0}/taskiq_redis/list_schedule_source.py

@@ -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))  # type: ignore
+                schedules.extend(await redis.lrange(key, 0, -1))
 
         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)  # type: ignore
+                    await redis.lrem(self._get_cron_key(), 0, schedule_id)
                 elif schedule.time is not None:
                     time_key = self._get_time_key(schedule.time)
-                    await redis.lrem(time_key, 0, schedule_id)  # type: ignore
+                    await redis.lrem(time_key, 0, schedule_id)
 
     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)  # type: ignore
+                await redis.rpush(self._get_cron_key(), schedule.schedule_id)
             elif schedule.time is not None:
-                await redis.rpush(  # type: ignore
+                await redis.rpush(
                     self._get_time_key(schedule.time),
                     schedule.schedule_id,
                 )
@@ -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)  # type: ignore
+            crons = await redis.lrange(self._get_cron_key(), 0, -1)
             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))  # type: ignore
+            timed.extend(await redis.lrange(self._get_time_key(current_time), 0, -1))
             logger.debug("Got %d timed schedules", len(timed))
             if timed:
                 buffer.extend(timed)

{taskiq_redis-1.0.8 → taskiq_redis-1.1.0}/taskiq_redis/redis_backend.py

@@ -131,7 +131,7 @@ class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
             redis_set_params["px"] = self.result_px_time
 
         async with Redis(connection_pool=self.redis_pool) as redis:
-            await redis.set(**redis_set_params)  # type: ignore
+            await redis.set(**redis_set_params)
 
     async def is_result_ready(self, task_id: str) -> bool:
         """
@@ -205,7 +205,7 @@ class RedisAsyncResultBackend(AsyncResultBackend[_ReturnType]):
             redis_set_params["px"] = self.result_px_time
 
         async with Redis(connection_pool=self.redis_pool) as redis:
-            await redis.set(**redis_set_params)  # type: ignore
+            await redis.set(**redis_set_params)
 
     async def get_progress(
         self,

{taskiq_redis-1.0.8 → taskiq_redis-1.1.0}/taskiq_redis/redis_broker.py

@@ -122,7 +122,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)  # type: ignore
+            await redis_conn.lpush(queue_name, message.message)
 
     async def listen(self) -> AsyncGenerator[bytes, None]:
         """
@@ -137,7 +137,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))[  # type: ignore
+                    yield (await redis_conn.brpop(self.queue_name))[
                         redis_brpop_data_position
                     ]
             except ConnectionError as exc:
@@ -166,6 +166,7 @@ class RedisStreamBroker(BaseRedisBroker):
         mkstream: bool = True,
         xread_block: int = 2000,
         maxlen: Optional[int] = None,
+        approximate: bool = True,
         idle_timeout: int = 600000,  # 10 minutes
         unacknowledged_batch_size: int = 100,
         xread_count: Optional[int] = 100,
@@ -190,6 +191,8 @@ class RedisStreamBroker(BaseRedisBroker):
             Better to set it to a bigger value, to avoid unnecessary calls.
         :param maxlen: sets the maximum length of the stream
             trims (the old values of) the stream each time a new element is added
+        :param approximate: decides wether to trim the stream immediately (False) or
+            later on (True)
         :param xread_count: number of messages to fetch from the stream at once.
         :param additional_streams: additional streams to read from.
             Each key is a stream name, value is a consumer id.
@@ -210,6 +213,7 @@ class RedisStreamBroker(BaseRedisBroker):
         self.mkstream = mkstream
         self.block = xread_block
         self.maxlen = maxlen
+        self.approximate = approximate
         self.additional_streams = additional_streams or {}
         self.idle_timeout = idle_timeout
         self.unacknowledged_batch_size = unacknowledged_batch_size
@@ -252,6 +256,7 @@ class RedisStreamBroker(BaseRedisBroker):
                 self.queue_name,
                 {b"data": message.message},
                 maxlen=self.maxlen,
+                approximate=self.approximate,
             )
 
     def _ack_generator(self, id: str) -> Callable[[], Awaitable[None]]:
@@ -275,7 +280,7 @@ class RedisStreamBroker(BaseRedisBroker):
                     self.consumer_name,
                     {
                         self.queue_name: ">",
-                        **self.additional_streams,  # type: ignore
+                        **self.additional_streams,
                     },
                     block=self.block,
                     noack=False,

{taskiq_redis-1.0.8 → taskiq_redis-1.1.0}/taskiq_redis/redis_cluster_broker.py

@@ -92,6 +92,8 @@ class RedisStreamClusterBroker(BaseRedisClusterBroker):
         consumer_id: str = "$",
         mkstream: bool = True,
         xread_block: int = 10000,
+        maxlen: Optional[int] = None,
+        approximate: bool = True,
         additional_streams: Optional[Dict[str, str]] = None,
         **connection_kwargs: Any,
     ) -> None:
@@ -111,6 +113,10 @@ class RedisStreamClusterBroker(BaseRedisClusterBroker):
         :param mkstream: create stream if it does not exist.
         :param xread_block: block time in ms for xreadgroup.
             Better to set it to a bigger value, to avoid unnecessary calls.
+        :param maxlen: sets the maximum length of the stream
+            trims (the old values of) the stream each time a new element is added
+        :param approximate: decides wether to trim the stream immediately (False) or
+            later on (True)
         :param additional_streams: additional streams to read from.
             Each key is a stream name, value is a consumer id.
         """
@@ -125,6 +131,8 @@ class RedisStreamClusterBroker(BaseRedisClusterBroker):
         self.consumer_id = consumer_id
         self.mkstream = mkstream
         self.block = xread_block
+        self.maxlen = maxlen
+        self.approximate = approximate
         self.additional_streams = additional_streams or {}
 
     async def _declare_consumer_group(self) -> None:
@@ -154,7 +162,12 @@ class RedisStreamClusterBroker(BaseRedisClusterBroker):
 
         :param message: message to append.
         """
-        await self.redis.xadd(self.queue_name, {b"data": message.message})
+        await self.redis.xadd(
+            self.queue_name,
+            {b"data": message.message},
+            maxlen=self.maxlen,
+            approximate=self.approximate,
+        )
 
     def _ack_generator(self, id: str) -> Callable[[], Awaitable[None]]:
         async def _ack() -> None:

{taskiq_redis-1.0.8 → taskiq_redis-1.1.0}/taskiq_redis/redis_sentinel_broker.py

@@ -157,6 +157,8 @@ class RedisStreamSentinelBroker(BaseSentinelBroker):
         consumer_id: str = "$",
         mkstream: bool = True,
         xread_block: int = 10000,
+        maxlen: Optional[int] = None,
+        approximate: bool = True,
         additional_streams: Optional[Dict[str, str]] = None,
         **connection_kwargs: Any,
     ) -> None:
@@ -176,6 +178,10 @@ class RedisStreamSentinelBroker(BaseSentinelBroker):
         :param mkstream: create stream if it does not exist.
         :param xread_block: block time in ms for xreadgroup.
             Better to set it to a bigger value, to avoid unnecessary calls.
+        :param maxlen: sets the maximum length of the stream
+            trims (the old values of) the stream each time a new element is added
+        :param approximate: decides wether to trim the stream immediately (False) or
+            later on (True)
         :param additional_streams: additional streams to read from.
             Each key is a stream name, value is a consumer id.
         """
@@ -193,6 +199,8 @@ class RedisStreamSentinelBroker(BaseSentinelBroker):
         self.consumer_id = consumer_id
         self.mkstream = mkstream
         self.block = xread_block
+        self.maxlen = maxlen
+        self.approximate = approximate
         self.additional_streams = additional_streams or {}
 
     async def _declare_consumer_group(self) -> None:
@@ -223,7 +231,12 @@ class RedisStreamSentinelBroker(BaseSentinelBroker):
         :param message: message to append.
         """
         async with self._acquire_master_conn() as redis_conn:
-            await redis_conn.xadd(self.queue_name, {b"data": message.message})
+            await redis_conn.xadd(
+                self.queue_name,
+                {b"data": message.message},
+                maxlen=self.maxlen,
+                approximate=self.approximate,
+            )
 
     def _ack_generator(self, id: str) -> Callable[[], Awaitable[None]]:
         async def _ack() -> None: