Coverage for faststream/redis/message.py: 94%
95 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +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, *args: Any, consumer: ConsumerProtocol, group: str | None, **kwargs: Any
169 ) -> None:
170 super().__init__(*args, **kwargs)
171 self.consumer = consumer
172 self.group = group
174 def _resolve_consumer_context(
175 self, redis: Optional["Redis[bytes]"], group: str | None
176 ) -> tuple[ConsumerProtocol | None, str | None]:
177 if redis is not EMPTY or group is not EMPTY:
178 warnings.warn(
179 _DEPRECATION_MESSAGE,
180 DeprecationWarning,
181 stacklevel=3,
182 )
183 return (
184 redis if redis is not EMPTY else self.consumer,
185 group if group is not EMPTY else self.group,
186 )
188 @override
189 async def ack(
190 self,
191 redis: _DeprecatedType[Optional["Redis[bytes]"]] = EMPTY,
192 group: _DeprecatedType[str | None] = EMPTY,
193 ) -> None:
194 redis_resolved, group_resolved = self._resolve_consumer_context(redis, group)
195 if (
196 not self.committed
197 and group_resolved is not None
198 and redis_resolved is not None
199 ):
200 ids = self.raw_message["message_ids"]
201 channel = self.raw_message["channel"]
202 await redis_resolved.xack(channel, group_resolved, *ids)
203 await super().ack()
205 @override
206 async def nack(
207 self,
208 redis: _DeprecatedType[Optional["Redis[bytes]"]] = EMPTY,
209 group: _DeprecatedType[str | None] = EMPTY,
210 ) -> None:
211 self._resolve_consumer_context(redis, group)
212 await super().nack()
214 @override
215 async def reject(
216 self,
217 redis: _DeprecatedType[Optional["Redis[bytes]"]] = EMPTY,
218 group: _DeprecatedType[str | None] = EMPTY,
219 ) -> None:
220 self._resolve_consumer_context(redis, group)
221 await super().reject()
223 async def delete(
224 self, redis: _DeprecatedType[Optional["Redis[bytes]"]] = EMPTY
225 ) -> None:
226 redis_resolved, _ = self._resolve_consumer_context(redis, EMPTY)
227 if redis_resolved is not None: 227 ↛ exitline 227 didn't return from function 'delete' because the condition on line 227 was always true
228 ids = self.raw_message["message_ids"]
229 channel = self.raw_message["channel"]
230 await redis_resolved.xdel(channel, *ids)
233class RedisStreamMessage(_RedisStreamMessageMixin[DefaultStreamMessage]):
234 async def get_delivery_count(
235 self,
236 redis: _DeprecatedType["Redis[bytes]"] = EMPTY,
237 group: _DeprecatedType[str] = EMPTY,
238 ) -> int:
239 """Return this message's current delivery count from the Redis PEL.
241 The count is queried on every call. Messages without an ID or a pending
242 entry, including acknowledged messages, return ``1``.
243 """
244 redis_resolved, group_resolved = self._resolve_consumer_context(redis, group)
245 message_ids = self.raw_message["message_ids"]
246 if not message_ids or redis_resolved is None or group_resolved is None: 246 ↛ 247line 246 didn't jump to line 247 because the condition on line 246 was never true
247 return 1
249 message_id = message_ids[0]
250 entries = await redis_resolved.xpending_range(
251 name=self.raw_message["channel"],
252 groupname=group_resolved,
253 min=message_id,
254 max=message_id,
255 count=1,
256 )
257 return int(entries[0]["times_delivered"]) if entries else 1
260class RedisBatchStreamMessage(_RedisStreamMessageMixin[BatchStreamMessage]):
261 decoded_body: list["DecodedMessage"]