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

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) 

13 

14from typing_extensions import NotRequired, TypedDict, deprecated, override 

15 

16from faststream._internal.constants import EMPTY 

17from faststream.message import StreamMessage as BrokerStreamMessage 

18 

19if TYPE_CHECKING: 

20 from redis.asyncio import Redis 

21 

22 from faststream._internal.basic_types import DecodedMessage 

23 

24 

25BaseMessage: TypeAlias = Union[ 

26 "PubSubMessage", 

27 "DefaultListMessage", 

28 "BatchListMessage", 

29 "DefaultStreamMessage", 

30 "BatchStreamMessage", 

31] 

32 

33 

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] 

46 

47 

48class RedisMessage(BrokerStreamMessage[UnifyRedisDict]): 

49 pass 

50 

51 

52class PubSubMessage(TypedDict): 

53 """A class to represent a PubSub message.""" 

54 

55 type: Literal["pmessage", "message"] 

56 channel: str 

57 data: bytes 

58 pattern: bytes | None 

59 

60 

61class RedisChannelMessage(BrokerStreamMessage[PubSubMessage]): 

62 pass 

63 

64 

65class _ListMessage(TypedDict): 

66 """A class to represent an Abstract List message.""" 

67 

68 channel: str 

69 

70 

71class DefaultListMessage(_ListMessage): 

72 """A class to represent a single List message.""" 

73 

74 type: Literal["list"] 

75 data: bytes 

76 

77 

78class BatchListMessage(_ListMessage): 

79 """A class to represent a List messages batch.""" 

80 

81 type: Literal["blist"] 

82 data: list[bytes] 

83 

84 

85class RedisListMessage(BrokerStreamMessage[DefaultListMessage]): 

86 """StreamMessage for single List message.""" 

87 

88 

89class RedisBatchListMessage(BrokerStreamMessage[BatchListMessage]): 

90 """StreamMessage for single List message.""" 

91 

92 decoded_body: list["DecodedMessage"] 

93 

94 

95DATA_KEY = "__data__" 

96bDATA_KEY = DATA_KEY.encode() # ruff: ignore[mixed-case-variable-in-global-scope] 

97 

98 

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]] 

106 

107 

108class DefaultStreamMessage(_StreamMessage): 

109 type: Literal["stream"] 

110 data: dict[bytes, bytes] 

111 

112 

113class BatchStreamMessage(_StreamMessage): 

114 type: Literal["bstream"] 

115 data: list[dict[bytes, bytes]] 

116 

117 

118_StreamMsgType = TypeVar("_StreamMsgType", bound=_StreamMessage) 

119 

120 

121class ConsumerProtocol(Protocol): 

122 """A protocol for Redis consumers.""" 

123 

124 __slots__ = () 

125 

126 async def xack(self, name: str, groupname: str, *ids: bytes) -> None: 

127 pass 

128 

129 async def xdel(self, name: str, *ids: bytes) -> None: 

130 pass 

131 

132 async def xpending_range( 

133 self, name: str, groupname: str, min: bytes, max: bytes, count: int 

134 ) -> list[dict[str, Any]]: 

135 pass 

136 

137 

138class FakeConsumer(ConsumerProtocol): 

139 """A fake Redis consumer.""" 

140 

141 __slots__ = () 

142 

143 async def xack(self, name: str, groupname: str, *ids: bytes) -> None: 

144 pass 

145 

146 async def xdel(self, name: str, *ids: bytes) -> None: 

147 pass 

148 

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 [] 

153 

154 

155FAKE_CONSUMER = FakeConsumer() 

156 

157 

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)] 

164 

165 

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 

179 

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 ) 

193 

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() 

208 

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() 

217 

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() 

226 

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) 

233 

234 

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. 

242 

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 

249 

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 

259 

260 

261class RedisBatchStreamMessage(_RedisStreamMessageMixin[BatchStreamMessage]): 

262 decoded_body: list["DecodedMessage"]