Coverage for faststream/redis/publisher/usecase.py: 95%

115 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1from abc import abstractmethod 

2from collections.abc import Iterable 

3from typing import TYPE_CHECKING, Any, Optional, Union 

4 

5from typing_extensions import override 

6 

7from faststream._internal.endpoint.publisher import ( 

8 PublisherSpecification, 

9 PublisherUsecase, 

10) 

11from faststream.redis.response import RedisPublishCommand 

12from faststream.response.publish_type import PublishType 

13 

14if TYPE_CHECKING: 

15 from redis.asyncio.client import Pipeline 

16 

17 from faststream._internal.basic_types import SendableMessage 

18 from faststream._internal.types import PublisherMiddleware 

19 from faststream.redis.message import RedisChannelMessage 

20 from faststream.redis.schemas import ListSub, PubSub, StreamSub 

21 from faststream.response import PublishCommand 

22 

23 from .config import RedisPublisherConfig 

24 

25 

26class LogicPublisher(PublisherUsecase): 

27 """A class to represent a Redis publisher.""" 

28 

29 __slots__ = ( 

30 "config", 

31 "headers", 

32 "producer", 

33 "reply_to", 

34 ) 

35 

36 def __init__( 

37 self, 

38 config: "RedisPublisherConfig", 

39 specification: "PublisherSpecification[Any, Any]", 

40 ) -> None: 

41 super().__init__(config, specification) 

42 

43 self.config = config 

44 

45 self.reply_to = config.reply_to 

46 self.headers = config.headers or {} 

47 

48 self.producer = self.config._outer_config.producer 

49 

50 async def start(self) -> None: 

51 await super().start() 

52 

53 broker_producer = self.config._outer_config.producer 

54 self.producer = broker_producer._build_child( 

55 connection=self.config._outer_config.connection, 

56 parser=broker_producer._parser.custom_func, 

57 decoder=broker_producer._decoder.custom_func, 

58 message_format=self.config.message_format, 

59 serializer=self.config._outer_config.fd_config._serializer, 

60 ) 

61 

62 @abstractmethod 

63 def subscriber_property(self, *, name_only: bool) -> dict[str, Any]: 

64 raise NotImplementedError 

65 

66 

67class ChannelPublisher(LogicPublisher): 

68 __slots__ = ("_channel",) 

69 

70 def __init__( 

71 self, 

72 config: "RedisPublisherConfig", 

73 specification: "PublisherSpecification[Any, Any]", 

74 *, 

75 channel: "PubSub", 

76 ) -> None: 

77 super().__init__(config, specification) 

78 

79 self._channel = channel 

80 

81 @property 

82 def channel(self) -> "PubSub": 

83 return self._channel.add_prefix(self._outer_config.prefix) 

84 

85 @override 

86 def subscriber_property(self, *, name_only: bool) -> dict[str, Any]: 

87 return { 

88 "channel": self.channel.name if name_only else self.channel, 

89 "list": None, 

90 "stream": None, 

91 } 

92 

93 @override 

94 async def publish( 

95 self, 

96 message: "SendableMessage" = None, 

97 channel: str | None = None, 

98 reply_to: str = "", 

99 headers: dict[str, Any] | None = None, 

100 correlation_id: str | None = None, 

101 *, 

102 pipeline: Optional["Pipeline[bytes]"] = None, 

103 ) -> int: 

104 cmd = RedisPublishCommand( 

105 message, 

106 channel=channel or self.channel.name, 

107 reply_to=reply_to or self.reply_to, 

108 headers=self.headers | (headers or {}), 

109 correlation_id=correlation_id or self._outer_config.id_generator(), 

110 pipeline=pipeline, 

111 _publish_type=PublishType.PUBLISH, 

112 message_format=self.config.message_format, 

113 ) 

114 result: int = await self._basic_publish( 

115 cmd, 

116 producer=self.producer, 

117 _extra_middlewares=(), 

118 ) 

119 return result 

120 

121 @override 

122 async def _publish( 

123 self, 

124 cmd: Union["PublishCommand", "RedisPublishCommand"], 

125 *, 

126 _extra_middlewares: Iterable["PublisherMiddleware"], 

127 ) -> None: 

128 """This method should be called in subscriber flow only.""" 

129 cmd = RedisPublishCommand.from_cmd(cmd, message_format=self.config.message_format) 

130 

131 cmd.set_destination(channel=self.channel.name) 

132 

133 cmd.add_headers(self.headers, override=False) 

134 cmd.reply_to = cmd.reply_to or self.reply_to 

135 

136 await self._basic_publish( 

137 cmd, 

138 producer=self.producer, 

139 _extra_middlewares=_extra_middlewares, 

140 ) 

141 

142 @override 

143 async def request( 

144 self, 

145 message: "SendableMessage" = None, 

146 channel: str | None = None, 

147 *, 

148 correlation_id: str | None = None, 

149 headers: dict[str, Any] | None = None, 

150 timeout: float | None = 30.0, 

151 ) -> "RedisChannelMessage": 

152 cmd = RedisPublishCommand( 

153 message, 

154 channel=channel or self.channel.name, 

155 headers=self.headers | (headers or {}), 

156 correlation_id=correlation_id or self._outer_config.id_generator(), 

157 timeout=timeout, 

158 _publish_type=PublishType.REQUEST, 

159 message_format=self.config.message_format, 

160 ) 

161 

162 msg: RedisChannelMessage = await self._basic_request( 

163 cmd, 

164 producer=self.producer, 

165 ) 

166 return msg 

167 

168 

169class _ListPublisherMixin(LogicPublisher): 

170 __slots__ = ("_list",) 

171 

172 def __init__( 

173 self, 

174 config: "RedisPublisherConfig", 

175 specification: "PublisherSpecification[Any, Any]", 

176 *, 

177 list: "ListSub", 

178 ) -> None: 

179 super().__init__(config, specification) 

180 

181 self._list = list 

182 

183 @property 

184 def list(self) -> "ListSub": 

185 return self._list.add_prefix(self._outer_config.prefix) 

186 

187 @override 

188 def subscriber_property(self, *, name_only: bool) -> dict[str, Any]: 

189 return { 

190 "channel": None, 

191 "list": self.list.name if name_only else self.list, 

192 "stream": None, 

193 } 

194 

195 @override 

196 async def request( 

197 self, 

198 message: "SendableMessage" = None, 

199 list: str | None = None, 

200 *, 

201 correlation_id: str | None = None, 

202 headers: dict[str, Any] | None = None, 

203 timeout: float | None = 30.0, 

204 ) -> "RedisChannelMessage": 

205 cmd = RedisPublishCommand( 

206 message, 

207 list=list or self.list.name, 

208 headers=self.headers | (headers or {}), 

209 correlation_id=correlation_id or self._outer_config.id_generator(), 

210 timeout=timeout, 

211 _publish_type=PublishType.REQUEST, 

212 message_format=self.config.message_format, 

213 ) 

214 

215 msg: RedisChannelMessage = await self._basic_request( 

216 cmd, 

217 producer=self.producer, 

218 ) 

219 return msg 

220 

221 

222class ListPublisher(_ListPublisherMixin): 

223 __slots__ = () 

224 

225 @override 

226 async def publish( 

227 self, 

228 message: "SendableMessage" = None, 

229 list: str | None = None, 

230 reply_to: str = "", 

231 headers: dict[str, Any] | None = None, 

232 correlation_id: str | None = None, 

233 *, 

234 pipeline: Optional["Pipeline[bytes]"] = None, 

235 ) -> int: 

236 cmd = RedisPublishCommand( 

237 message, 

238 list=list or self.list.name, 

239 reply_to=reply_to or self.reply_to, 

240 headers=self.headers | (headers or {}), 

241 correlation_id=correlation_id or self._outer_config.id_generator(), 

242 pipeline=pipeline, 

243 _publish_type=PublishType.PUBLISH, 

244 message_format=self.config.message_format, 

245 ) 

246 

247 result: int = await self._basic_publish( 

248 cmd, 

249 producer=self.producer, 

250 _extra_middlewares=(), 

251 ) 

252 return result 

253 

254 @override 

255 async def _publish( 

256 self, 

257 cmd: Union["PublishCommand", "RedisPublishCommand"], 

258 *, 

259 _extra_middlewares: Iterable["PublisherMiddleware"], 

260 ) -> None: 

261 """This method should be called in subscriber flow only.""" 

262 cmd = RedisPublishCommand.from_cmd(cmd, message_format=self.config.message_format) 

263 

264 cmd.set_destination(list=self.list.name) 

265 

266 cmd.add_headers(self.headers, override=False) 

267 cmd.reply_to = cmd.reply_to or self.reply_to 

268 

269 await self._basic_publish( 

270 cmd, 

271 producer=self.producer, 

272 _extra_middlewares=_extra_middlewares, 

273 ) 

274 

275 

276# Not a `ListPublisher`: its `publish(*messages)` would take the `list` that 

277# `ListPublisher.publish(message, list)` accepts positionally as a second message. 

278class ListBatchPublisher(_ListPublisherMixin): 

279 __slots__ = () 

280 

281 @override 

282 async def publish( 

283 self, 

284 *messages: "SendableMessage", 

285 list: str | None = None, 

286 correlation_id: str | None = None, 

287 reply_to: str = "", 

288 headers: dict[str, Any] | None = None, 

289 pipeline: Optional["Pipeline[bytes]"] = None, 

290 ) -> int: 

291 cmd = RedisPublishCommand( 

292 *messages, 

293 list=list or self.list.name, 

294 reply_to=reply_to or self.reply_to, 

295 headers=self.headers | (headers or {}), 

296 correlation_id=correlation_id or self._outer_config.id_generator(), 

297 pipeline=pipeline, 

298 _publish_type=PublishType.PUBLISH, 

299 message_format=self.config.message_format, 

300 ) 

301 

302 result: int = await self._basic_publish_batch( 

303 cmd, 

304 producer=self.producer, 

305 _extra_middlewares=(), 

306 ) 

307 return result 

308 

309 @override 

310 async def _publish( 

311 self, 

312 cmd: Union["PublishCommand", "RedisPublishCommand"], 

313 *, 

314 _extra_middlewares: Iterable["PublisherMiddleware"], 

315 ) -> None: 

316 """This method should be called in subscriber flow only.""" 

317 cmd = RedisPublishCommand.from_cmd( 

318 cmd, batch=True, message_format=self.config.message_format 

319 ) 

320 

321 if not cmd.batch_bodies: 

322 # Match the non-batch publisher: an empty result is one empty message, 

323 # not a batch of zero, which no broker can express (see issue #3056). 

324 cmd.batch_bodies = (b"",) 

325 

326 cmd.set_destination(list=self.list.name) 

327 

328 cmd.add_headers(self.headers, override=False) 

329 cmd.reply_to = cmd.reply_to or self.reply_to 

330 

331 await self._basic_publish_batch( 

332 cmd, 

333 producer=self.producer, 

334 _extra_middlewares=_extra_middlewares, 

335 ) 

336 

337 

338class StreamPublisher(LogicPublisher): 

339 __slots__ = ("_stream",) 

340 

341 def __init__( 

342 self, 

343 config: "RedisPublisherConfig", 

344 specification: "PublisherSpecification[Any, Any]", 

345 *, 

346 stream: "StreamSub", 

347 ) -> None: 

348 super().__init__(config, specification) 

349 self._stream = stream 

350 

351 @property 

352 def stream(self) -> "StreamSub": 

353 return self._stream.add_prefix(self._outer_config.prefix) 

354 

355 @override 

356 def subscriber_property(self, *, name_only: bool) -> dict[str, Any]: 

357 return { 

358 "channel": None, 

359 "list": None, 

360 "stream": self.stream.name if name_only else self.stream, 

361 } 

362 

363 @override 

364 async def publish( 

365 self, 

366 message: "SendableMessage" = None, 

367 stream: str | None = None, 

368 reply_to: str = "", 

369 headers: dict[str, Any] | None = None, 

370 correlation_id: str | None = None, 

371 *, 

372 maxlen: int | None = None, 

373 pipeline: Optional["Pipeline[bytes]"] = None, 

374 ) -> bytes: 

375 cmd = RedisPublishCommand( 

376 message, 

377 stream=stream or self.stream.name, 

378 reply_to=reply_to or self.reply_to, 

379 headers=self.headers | (headers or {}), 

380 correlation_id=correlation_id or self._outer_config.id_generator(), 

381 maxlen=maxlen or self.stream.maxlen, 

382 pipeline=pipeline, 

383 _publish_type=PublishType.PUBLISH, 

384 message_format=self.config.message_format, 

385 ) 

386 

387 result: bytes = await self._basic_publish( 

388 cmd, 

389 producer=self.producer, 

390 _extra_middlewares=(), 

391 ) 

392 return result 

393 

394 @override 

395 async def _publish( 

396 self, 

397 cmd: Union["PublishCommand", "RedisPublishCommand"], 

398 *, 

399 _extra_middlewares: Iterable["PublisherMiddleware"], 

400 ) -> None: 

401 """This method should be called in subscriber flow only.""" 

402 cmd = RedisPublishCommand.from_cmd(cmd, message_format=self.config.message_format) 

403 

404 cmd.set_destination(stream=self.stream.name) 

405 

406 cmd.add_headers(self.headers, override=False) 

407 cmd.reply_to = cmd.reply_to or self.reply_to 

408 cmd.maxlen = self.stream.maxlen 

409 

410 await self._basic_publish( 

411 cmd, 

412 producer=self.producer, 

413 _extra_middlewares=_extra_middlewares, 

414 ) 

415 

416 @override 

417 async def request( 

418 self, 

419 message: "SendableMessage" = None, 

420 stream: str | None = None, 

421 *, 

422 maxlen: int | None = None, 

423 correlation_id: str | None = None, 

424 headers: dict[str, Any] | None = None, 

425 timeout: float | None = 30.0, 

426 ) -> "RedisChannelMessage": 

427 cmd = RedisPublishCommand( 

428 message, 

429 stream=stream or self.stream.name, 

430 headers=self.headers | (headers or {}), 

431 correlation_id=correlation_id or self._outer_config.id_generator(), 

432 maxlen=maxlen or self.stream.maxlen, 

433 timeout=timeout, 

434 _publish_type=PublishType.REQUEST, 

435 message_format=self.config.message_format, 

436 ) 

437 

438 msg: RedisChannelMessage = await self._basic_request( 

439 cmd, 

440 producer=self.producer, 

441 ) 

442 return msg