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
« 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
5from typing_extensions import override
7from faststream._internal.endpoint.publisher import (
8 PublisherSpecification,
9 PublisherUsecase,
10)
11from faststream.redis.response import RedisPublishCommand
12from faststream.response.publish_type import PublishType
14if TYPE_CHECKING:
15 from redis.asyncio.client import Pipeline
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
23 from .config import RedisPublisherConfig
26class LogicPublisher(PublisherUsecase):
27 """A class to represent a Redis publisher."""
29 __slots__ = (
30 "config",
31 "headers",
32 "producer",
33 "reply_to",
34 )
36 def __init__(
37 self,
38 config: "RedisPublisherConfig",
39 specification: "PublisherSpecification[Any, Any]",
40 ) -> None:
41 super().__init__(config, specification)
43 self.config = config
45 self.reply_to = config.reply_to
46 self.headers = config.headers or {}
48 self.producer = self.config._outer_config.producer
50 async def start(self) -> None:
51 await super().start()
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 )
62 @abstractmethod
63 def subscriber_property(self, *, name_only: bool) -> dict[str, Any]:
64 raise NotImplementedError
67class ChannelPublisher(LogicPublisher):
68 __slots__ = ("_channel",)
70 def __init__(
71 self,
72 config: "RedisPublisherConfig",
73 specification: "PublisherSpecification[Any, Any]",
74 *,
75 channel: "PubSub",
76 ) -> None:
77 super().__init__(config, specification)
79 self._channel = channel
81 @property
82 def channel(self) -> "PubSub":
83 return self._channel.add_prefix(self._outer_config.prefix)
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 }
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
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)
131 cmd.set_destination(channel=self.channel.name)
133 cmd.add_headers(self.headers, override=False)
134 cmd.reply_to = cmd.reply_to or self.reply_to
136 await self._basic_publish(
137 cmd,
138 producer=self.producer,
139 _extra_middlewares=_extra_middlewares,
140 )
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 )
162 msg: RedisChannelMessage = await self._basic_request(
163 cmd,
164 producer=self.producer,
165 )
166 return msg
169class _ListPublisherMixin(LogicPublisher):
170 __slots__ = ("_list",)
172 def __init__(
173 self,
174 config: "RedisPublisherConfig",
175 specification: "PublisherSpecification[Any, Any]",
176 *,
177 list: "ListSub",
178 ) -> None:
179 super().__init__(config, specification)
181 self._list = list
183 @property
184 def list(self) -> "ListSub":
185 return self._list.add_prefix(self._outer_config.prefix)
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 }
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 )
215 msg: RedisChannelMessage = await self._basic_request(
216 cmd,
217 producer=self.producer,
218 )
219 return msg
222class ListPublisher(_ListPublisherMixin):
223 __slots__ = ()
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 )
247 result: int = await self._basic_publish(
248 cmd,
249 producer=self.producer,
250 _extra_middlewares=(),
251 )
252 return result
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)
264 cmd.set_destination(list=self.list.name)
266 cmd.add_headers(self.headers, override=False)
267 cmd.reply_to = cmd.reply_to or self.reply_to
269 await self._basic_publish(
270 cmd,
271 producer=self.producer,
272 _extra_middlewares=_extra_middlewares,
273 )
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__ = ()
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 )
302 result: int = await self._basic_publish_batch(
303 cmd,
304 producer=self.producer,
305 _extra_middlewares=(),
306 )
307 return result
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 )
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"",)
326 cmd.set_destination(list=self.list.name)
328 cmd.add_headers(self.headers, override=False)
329 cmd.reply_to = cmd.reply_to or self.reply_to
331 await self._basic_publish_batch(
332 cmd,
333 producer=self.producer,
334 _extra_middlewares=_extra_middlewares,
335 )
338class StreamPublisher(LogicPublisher):
339 __slots__ = ("_stream",)
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
351 @property
352 def stream(self) -> "StreamSub":
353 return self._stream.add_prefix(self._outer_config.prefix)
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 }
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 )
387 result: bytes = await self._basic_publish(
388 cmd,
389 producer=self.producer,
390 _extra_middlewares=(),
391 )
392 return result
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)
404 cmd.set_destination(stream=self.stream.name)
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
410 await self._basic_publish(
411 cmd,
412 producer=self.producer,
413 _extra_middlewares=_extra_middlewares,
414 )
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 )
438 msg: RedisChannelMessage = await self._basic_request(
439 cmd,
440 producer=self.producer,
441 )
442 return msg