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

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, *args: Any, consumer: ConsumerProtocol, group: str | None, **kwargs: Any 

169 ) -> None: 

170 super().__init__(*args, **kwargs) 

171 self.consumer = consumer 

172 self.group = group 

173 

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 ) 

187 

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

204 

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

213 

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

222 

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) 

231 

232 

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. 

240 

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 

248 

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 

258 

259 

260class RedisBatchStreamMessage(_RedisStreamMessageMixin[BatchStreamMessage]): 

261 decoded_body: list["DecodedMessage"]