Coverage for faststream/redis/message.py: 94%
92 statements
« prev ^ index » next coverage.py v7.17.4, created at 2026-11-21 11:35 +0000
« prev ^ index » next coverage.py v7.17.4, created at 2026-11-21 11:35 +0000
1import warnings
2from typing import (
3 TYPE_CHECKING,
4 Annotated,
5 Any,
6 Literal,
7 Optional,
8 Protocol,
9 TypeAlias,
10 TypeVar,
11 Union,
12)
14from typing_extensions import NotRequired, TypedDict, deprecated, override
16from faststream._internal.constants import EMPTY
17from faststream.message import StreamMessage as BrokerStreamMessage
19if TYPE_CHECKING:
20 from redis.asyncio import Redis
22 from faststream._internal.basic_types import DecodedMessage
25BaseMessage: TypeAlias = Union[
26 "PubSubMessage",
27 "DefaultListMessage",
28 "BatchListMessage",
29 "DefaultStreamMessage",
30 "BatchStreamMessage",
31]
34class UnifyRedisDict(TypedDict):
35 type: Literal[
36 "pmessage",
37 "message",
38 "list",
39 "blist",
40 "stream",
41 "bstream",
42 ]
43 channel: str
44 data: bytes | list[bytes] | dict[bytes, bytes] | list[dict[bytes, bytes]]
45 pattern: NotRequired[bytes | None]
48class RedisMessage(BrokerStreamMessage[UnifyRedisDict]):
49 pass
52class PubSubMessage(TypedDict):
53 """A class to represent a PubSub message."""
55 type: Literal["pmessage", "message"]
56 channel: str
57 data: bytes
58 pattern: bytes | None
61class RedisChannelMessage(BrokerStreamMessage[PubSubMessage]):
62 pass
65class _ListMessage(TypedDict):
66 """A class to represent an Abstract List message."""
68 channel: str
71class DefaultListMessage(_ListMessage):
72 """A class to represent a single List message."""
74 type: Literal["list"]
75 data: bytes
78class BatchListMessage(_ListMessage):
79 """A class to represent a List messages batch."""
81 type: Literal["blist"]
82 data: list[bytes]
85class RedisListMessage(BrokerStreamMessage[DefaultListMessage]):
86 """StreamMessage for single List message."""
89class RedisBatchListMessage(BrokerStreamMessage[BatchListMessage]):
90 """StreamMessage for single List message."""
92 decoded_body: list["DecodedMessage"]
95DATA_KEY = "__data__"
96bDATA_KEY = DATA_KEY.encode() # ruff: ignore[mixed-case-variable-in-global-scope]
99class _StreamMessage(TypedDict):
100 channel: str
101 message_ids: list[bytes]
102 # Only with `StreamSub.claim_min_idle_time`, aligned with `message_ids`;
103 # `delivery_counts` is XPENDING's `times_delivered` - 1 (0 = new message).
104 idle_times: NotRequired[list[int]]
105 delivery_counts: NotRequired[list[int]]
108class DefaultStreamMessage(_StreamMessage):
109 type: Literal["stream"]
110 data: dict[bytes, bytes]
113class BatchStreamMessage(_StreamMessage):
114 type: Literal["bstream"]
115 data: list[dict[bytes, bytes]]
118_StreamMsgType = TypeVar("_StreamMsgType", bound=_StreamMessage)
121class ConsumerProtocol(Protocol):
122 """A protocol for Redis consumers."""
124 __slots__ = ()
126 async def xack(self, name: str, groupname: str, *ids: bytes) -> None:
127 pass
129 async def xdel(self, name: str, *ids: bytes) -> None:
130 pass
132 async def xpending_range(
133 self, name: str, groupname: str, min: bytes, max: bytes, count: int
134 ) -> list[dict[str, Any]]:
135 pass
138class FakeConsumer(ConsumerProtocol):
139 """A fake Redis consumer."""
141 __slots__ = ()
143 async def xack(self, name: str, groupname: str, *ids: bytes) -> None:
144 pass
146 async def xdel(self, name: str, *ids: bytes) -> None:
147 pass
149 async def xpending_range( # ruff: ignore[no-self-use]
150 self, name: str, groupname: str, min: bytes, max: bytes, count: int
151 ) -> list[dict[str, Any]]:
152 return []
155FAKE_CONSUMER = FakeConsumer()
158_DEPRECATION_MESSAGE = (
159 "The client and group are bound to the message now."
160 " `redis` and `group` arguments will be removed in 1.0.0."
161)
162T = TypeVar("T")
163_DeprecatedType = Annotated[T, deprecated(_DEPRECATION_MESSAGE)]
166class _RedisStreamMessageMixin(BrokerStreamMessage[_StreamMsgType]):
167 def __init__(
168 self,
169 *args: Any,
170 consumer: ConsumerProtocol = FAKE_CONSUMER,
171 group: str | None = None,
172 **kwargs: Any,
173 ) -> None:
174 super().__init__(*args, **kwargs)
175 self.stream = self.raw_message["channel"]
176 self.message_ids = self.raw_message["message_ids"]
177 self.consumer = consumer
178 self.group = group
180 def _resolve_consumer_context(
181 self, redis: Optional["Redis[bytes]"], group: str | None
182 ) -> tuple[ConsumerProtocol | None, str | None]:
183 if redis is not EMPTY or group is not EMPTY:
184 warnings.warn(
185 _DEPRECATION_MESSAGE,
186 DeprecationWarning,
187 stacklevel=3,
188 )
189 return (
190 redis if redis is not EMPTY else self.consumer,
191 group if group is not EMPTY else self.group,
192 )
194 @override
195 async def ack(
196 self,
197 redis: _DeprecatedType[Optional["Redis[bytes]"]] = EMPTY,
198 group: _DeprecatedType[str | None] = EMPTY,
199 ) -> None:
200 redis_resolved, group_resolved = self._resolve_consumer_context(redis, group)
201 if (
202 not self.committed
203 and group_resolved is not None
204 and redis_resolved is not None
205 ):
206 await redis_resolved.xack(self.stream, group_resolved, *self.message_ids)
207 await super().ack()
209 @override
210 async def nack(
211 self,
212 redis: _DeprecatedType[Optional["Redis[bytes]"]] = EMPTY,
213 group: _DeprecatedType[str | None] = EMPTY,
214 ) -> None:
215 self._resolve_consumer_context(redis, group)
216 await super().nack()
218 @override
219 async def reject(
220 self,
221 redis: _DeprecatedType[Optional["Redis[bytes]"]] = EMPTY,
222 group: _DeprecatedType[str | None] = EMPTY,
223 ) -> None:
224 self._resolve_consumer_context(redis, group)
225 await super().reject()
227 async def delete(
228 self, redis: _DeprecatedType[Optional["Redis[bytes]"]] = EMPTY
229 ) -> None:
230 redis_resolved, _ = self._resolve_consumer_context(redis, EMPTY)
231 if redis_resolved is not None: 231 ↛ exitline 231 didn't return from function 'delete' because the condition on line 231 was always true
232 await redis_resolved.xdel(self.stream, *self.message_ids)
235class RedisStreamMessage(_RedisStreamMessageMixin[DefaultStreamMessage]):
236 async def get_delivery_count(
237 self,
238 redis: _DeprecatedType["Redis[bytes]"] = EMPTY,
239 group: _DeprecatedType[str] = EMPTY,
240 ) -> int:
241 """Return this message's current delivery count from the Redis PEL.
243 The count is queried on every call. Messages without an ID or a pending
244 entry, including acknowledged messages, return ``1``.
245 """
246 redis_resolved, group_resolved = self._resolve_consumer_context(redis, group)
247 if not self.message_ids or redis_resolved is None or group_resolved is None: 247 ↛ 248line 247 didn't jump to line 248 because the condition on line 247 was never true
248 return 1
250 message_id = self.message_ids[0]
251 entries = await redis_resolved.xpending_range(
252 name=self.stream,
253 groupname=group_resolved,
254 min=message_id,
255 max=message_id,
256 count=1,
257 )
258 return int(entries[0]["times_delivered"]) if entries else 1
261class RedisBatchStreamMessage(_RedisStreamMessageMixin[BatchStreamMessage]):
262 decoded_body: list["DecodedMessage"]