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

1import asyncio 

2from abc import abstractmethod 

3from contextlib import suppress 

4from typing import TYPE_CHECKING, Any, Optional 

5 

6import anyio 

7import nats 

8from nats.aio.client import NO_RESPONDERS_STATUS 

9from nats.js.api import Header 

10from typing_extensions import override 

11 

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 

23 

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 

29 

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 

36 

37 

38class NatsFastProducer(ProducerProto[NatsPublishCommand]): 

39 __slots__ = () 

40 

41 def connect( 

42 self, 

43 connection: Any, 

44 serializer: Optional["SerializerProto"], 

45 codec: Optional["CodecProto"] = None, 

46 ) -> None: ... 

47 

48 def disconnect(self) -> None: ... 

49 

50 @abstractmethod 

51 async def publish(self, cmd: "NatsPublishCommand") -> Optional["PubAck"]: ... 

52 

53 @abstractmethod 

54 async def request(self, cmd: "NatsPublishCommand") -> "Msg": ... 

55 

56 @override 

57 async def publish_batch(self, cmd: "NatsPublishCommand") -> None: 

58 msg = "NATS doesn't support publishing in batches." 

59 raise FeatureNotSupportedException(msg) 

60 

61 

62class NatsFastProducerImpl(NatsFastProducer): 

63 """A class to represent a NATS producer.""" 

64 

65 __slots__ = ( 

66 "__state", 

67 "_decoder", 

68 "_parser", 

69 "codec", 

70 "serializer", 

71 ) 

72 

73 _decoder: "AsyncCallable" 

74 _parser: "AsyncCallable" 

75 

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

83 

84 default = NatsParser(pattern="", is_ack_disabled=True) 

85 self._parser = ParserComposition(parser, default.parse_message) 

86 self._decoder = ParserComposition(decoder, default.decode_message) 

87 

88 self.__state: ConnectionState[Client] = EmptyConnectionState() 

89 

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) 

99 

100 def disconnect(self) -> None: 

101 self.__state = EmptyConnectionState() 

102 

103 @override 

104 async def publish(self, cmd: "NatsPublishCommand") -> None: 

105 payload, content_type = await self.codec.encode(cmd.body, self.serializer) 

106 

107 headers_to_send = { 

108 "content-type": content_type or "", 

109 **cmd.headers_to_publish(), 

110 } 

111 

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 ) 

118 

119 @override 

120 async def request(self, cmd: "NatsPublishCommand") -> "Msg": 

121 payload, content_type = await self.codec.encode(cmd.body, self.serializer) 

122 

123 headers_to_send = { 

124 "content-type": content_type or "", 

125 **cmd.headers_to_publish(), 

126 } 

127 

128 return await self.__state.connection.request( 

129 subject=cmd.destination, 

130 payload=payload, 

131 headers=headers_to_send, 

132 timeout=cmd.timeout, 

133 ) 

134 

135 

136class NatsJSFastProducer(NatsFastProducer): 

137 """A class to represent a NATS JetStream producer.""" 

138 

139 __slots__ = ( 

140 "__state", 

141 "_decoder", 

142 "_parser", 

143 "codec", 

144 "serializer", 

145 ) 

146 

147 _decoder: "AsyncCallable" 

148 _parser: "AsyncCallable" 

149 

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

158 

159 default = NatsParser(pattern="", is_ack_disabled=True) 

160 self._parser = ParserComposition(parser, default.parse_message) 

161 self._decoder = ParserComposition(decoder, default.decode_message) 

162 

163 self.__state: ConnectionState[JetStreamContext] = EmptyConnectionState() 

164 

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) 

174 

175 def disconnect(self) -> None: 

176 self.__state = EmptyConnectionState() 

177 

178 @override 

179 async def publish(self, cmd: "NatsPublishCommand") -> "PubAck": 

180 payload, content_type = await self.codec.encode(cmd.body, self.serializer) 

181 

182 headers_to_send = { 

183 "content-type": content_type or "", 

184 **cmd.headers_to_publish(js=True), 

185 } 

186 

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 ) 

194 

195 @override 

196 async def request(self, cmd: "NatsPublishCommand") -> "Msg": 

197 payload, content_type = await self.codec.encode(cmd.body, self.serializer) 

198 

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) 

208 

209 headers_to_send = { 

210 "content-type": content_type or "", 

211 "reply_to": reply_to, 

212 **cmd.headers_to_publish(js=False), 

213 } 

214 

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 ) 

223 

224 msg = await future 

225 

226 if ( # pragma: no cover 

227 msg.headers 

228 and (msg.headers.get(Header.STATUS) == NO_RESPONDERS_STATUS) 

229 ): 

230 raise nats.errors.NoRespondersError 

231 

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

244 

245 

246class FakeNatsFastProducer(NatsFastProducer): 

247 __slots__ = () 

248 

249 def connect( 

250 self, 

251 connection: Any, 

252 serializer: Optional["SerializerProto"], 

253 codec: Optional["CodecProto"] = None, 

254 ) -> None: 

255 raise NotImplementedError 

256 

257 def disconnect(self) -> None: 

258 raise NotImplementedError 

259 

260 @override 

261 async def publish(self, cmd: "NatsPublishCommand") -> None: 

262 raise NotImplementedError 

263 

264 @override 

265 async def request(self, cmd: "NatsPublishCommand") -> "Msg": 

266 raise NotImplementedError 

267 

268 @override 

269 async def publish_batch(self, cmd: "NatsPublishCommand") -> None: 

270 msg = "NATS doesn't support publishing in batches." 

271 raise FeatureNotSupportedException(msg)