Coverage for faststream/nats/publisher/producer.py: 95%
83 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 asyncio
2from abc import abstractmethod
3from contextlib import suppress
4from typing import TYPE_CHECKING, Any, Optional
6import anyio
7import nats
8from nats.aio.client import NO_RESPONDERS_STATUS
9from nats.js.api import Header
10from typing_extensions import override
12from faststream._internal.endpoint.utils import ParserComposition
13from faststream._internal.parser import DefaultCodec
14from faststream._internal.producer import ProducerProto
15from faststream.exceptions import FeatureNotSupportedException
16from faststream.nats.helpers.state import (
17 ConnectedState,
18 ConnectionState,
19 EmptyConnectionState,
20)
21from faststream.nats.parser import NatsParser
22from faststream.nats.response import NatsPublishCommand
24if TYPE_CHECKING:
25 from fast_depends.library.serializer import SerializerProto
26 from nats.aio.client import Client
27 from nats.aio.msg import Msg
28 from nats.js import JetStreamContext
30 from faststream._internal.parser import CodecProto
31 from faststream._internal.types import (
32 AsyncCallable,
33 CustomCallable,
34 )
35 from faststream.nats.schemas import PubAck
38class NatsFastProducer(ProducerProto[NatsPublishCommand]):
39 __slots__ = ()
41 def connect(
42 self,
43 connection: Any,
44 serializer: Optional["SerializerProto"],
45 codec: Optional["CodecProto"] = None,
46 ) -> None: ...
48 def disconnect(self) -> None: ...
50 @abstractmethod
51 async def publish(self, cmd: "NatsPublishCommand") -> Optional["PubAck"]: ...
53 @abstractmethod
54 async def request(self, cmd: "NatsPublishCommand") -> "Msg": ...
56 @override
57 async def publish_batch(self, cmd: "NatsPublishCommand") -> None:
58 msg = "NATS doesn't support publishing in batches."
59 raise FeatureNotSupportedException(msg)
62class NatsFastProducerImpl(NatsFastProducer):
63 """A class to represent a NATS producer."""
65 __slots__ = (
66 "__state",
67 "_decoder",
68 "_parser",
69 "codec",
70 "serializer",
71 )
73 _decoder: "AsyncCallable"
74 _parser: "AsyncCallable"
76 def __init__(
77 self,
78 parser: Optional["CustomCallable"],
79 decoder: Optional["CustomCallable"],
80 ) -> None:
81 self.serializer: SerializerProto | None = None
82 self.codec: CodecProto = DefaultCodec()
84 default = NatsParser(pattern="", is_ack_disabled=True)
85 self._parser = ParserComposition(parser, default.parse_message)
86 self._decoder = ParserComposition(decoder, default.decode_message)
88 self.__state: ConnectionState[Client] = EmptyConnectionState()
90 def connect(
91 self,
92 connection: "Client",
93 serializer: Optional["SerializerProto"],
94 codec: Optional["CodecProto"] = None,
95 ) -> None:
96 self.serializer = serializer
97 self.codec = codec or DefaultCodec()
98 self.__state = ConnectedState(connection)
100 def disconnect(self) -> None:
101 self.__state = EmptyConnectionState()
103 @override
104 async def publish(self, cmd: "NatsPublishCommand") -> None:
105 payload, content_type = await self.codec.encode(cmd.body, self.serializer)
107 headers_to_send = {
108 "content-type": content_type or "",
109 **cmd.headers_to_publish(),
110 }
112 return await self.__state.connection.publish(
113 subject=cmd.destination,
114 payload=payload,
115 reply=cmd.reply_to,
116 headers=headers_to_send,
117 )
119 @override
120 async def request(self, cmd: "NatsPublishCommand") -> "Msg":
121 payload, content_type = await self.codec.encode(cmd.body, self.serializer)
123 headers_to_send = {
124 "content-type": content_type or "",
125 **cmd.headers_to_publish(),
126 }
128 return await self.__state.connection.request(
129 subject=cmd.destination,
130 payload=payload,
131 headers=headers_to_send,
132 timeout=cmd.timeout,
133 )
136class NatsJSFastProducer(NatsFastProducer):
137 """A class to represent a NATS JetStream producer."""
139 __slots__ = (
140 "__state",
141 "_decoder",
142 "_parser",
143 "codec",
144 "serializer",
145 )
147 _decoder: "AsyncCallable"
148 _parser: "AsyncCallable"
150 def __init__(
151 self,
152 *,
153 parser: Optional["CustomCallable"],
154 decoder: Optional["CustomCallable"],
155 ) -> None:
156 self.serializer: SerializerProto | None = None
157 self.codec: CodecProto = DefaultCodec()
159 default = NatsParser(pattern="", is_ack_disabled=True)
160 self._parser = ParserComposition(parser, default.parse_message)
161 self._decoder = ParserComposition(decoder, default.decode_message)
163 self.__state: ConnectionState[JetStreamContext] = EmptyConnectionState()
165 def connect(
166 self,
167 connection: "JetStreamContext",
168 serializer: Optional["SerializerProto"],
169 codec: Optional["CodecProto"] = None,
170 ) -> None:
171 self.serializer = serializer
172 self.codec = codec or DefaultCodec()
173 self.__state = ConnectedState(connection)
175 def disconnect(self) -> None:
176 self.__state = EmptyConnectionState()
178 @override
179 async def publish(self, cmd: "NatsPublishCommand") -> "PubAck":
180 payload, content_type = await self.codec.encode(cmd.body, self.serializer)
182 headers_to_send = {
183 "content-type": content_type or "",
184 **cmd.headers_to_publish(js=True),
185 }
187 return await self.__state.connection.publish(
188 subject=cmd.destination,
189 payload=payload,
190 headers=headers_to_send,
191 stream=cmd.stream,
192 timeout=cmd.timeout,
193 )
195 @override
196 async def request(self, cmd: "NatsPublishCommand") -> "Msg":
197 payload, content_type = await self.codec.encode(cmd.body, self.serializer)
199 reply_to = self.__state.connection._nc.new_inbox()
200 future: asyncio.Future[Msg] = asyncio.Future()
201 sub = await self.__state.connection._nc.subscribe(
202 reply_to,
203 future=future,
204 max_msgs=1,
205 )
206 try:
207 await sub.unsubscribe(limit=1)
209 headers_to_send = {
210 "content-type": content_type or "",
211 "reply_to": reply_to,
212 **cmd.headers_to_publish(js=False),
213 }
215 with anyio.fail_after(cmd.timeout):
216 await self.__state.connection.publish(
217 subject=cmd.destination,
218 payload=payload,
219 headers=headers_to_send,
220 stream=cmd.stream,
221 timeout=cmd.timeout,
222 )
224 msg = await future
226 if ( # pragma: no cover
227 msg.headers
228 and (msg.headers.get(Header.STATUS) == NO_RESPONDERS_STATUS)
229 ):
230 raise nats.errors.NoRespondersError
232 return msg
233 finally:
234 future.cancel()
235 # The one-message limit cannot remove an inbox that never receives a reply.
236 with (
237 anyio.CancelScope(shield=True),
238 suppress(
239 nats.errors.ConnectionClosedError,
240 nats.errors.ConnectionDrainingError,
241 ),
242 ):
243 await sub.unsubscribe()
246class FakeNatsFastProducer(NatsFastProducer):
247 __slots__ = ()
249 def connect(
250 self,
251 connection: Any,
252 serializer: Optional["SerializerProto"],
253 codec: Optional["CodecProto"] = None,
254 ) -> None:
255 raise NotImplementedError
257 def disconnect(self) -> None:
258 raise NotImplementedError
260 @override
261 async def publish(self, cmd: "NatsPublishCommand") -> None:
262 raise NotImplementedError
264 @override
265 async def request(self, cmd: "NatsPublishCommand") -> "Msg":
266 raise NotImplementedError
268 @override
269 async def publish_batch(self, cmd: "NatsPublishCommand") -> None:
270 msg = "NATS doesn't support publishing in batches."
271 raise FeatureNotSupportedException(msg)