Coverage for faststream/kafka/publisher/producer.py: 88%

76 statements  

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

1from abc import abstractmethod 

2from typing import TYPE_CHECKING, Any, Optional, Union 

3 

4from typing_extensions import override 

5 

6from faststream._internal.endpoint.utils import ParserComposition 

7from faststream._internal.kafka import encode_headers 

8from faststream._internal.parser import BatchCodecProto, DefaultCodec 

9from faststream._internal.producer import ProducerProto 

10from faststream.exceptions import FeatureNotSupportedException 

11from faststream.kafka.exceptions import BatchBufferOverflowException 

12from faststream.kafka.message import KafkaMessage 

13from faststream.kafka.parser import AioKafkaParser 

14from faststream.kafka.response import KafkaPublishCommand 

15 

16from .state import EmptyProducerState, ProducerState, RealProducer 

17 

18if TYPE_CHECKING: 

19 import asyncio 

20 

21 from aiokafka import AIOKafkaProducer 

22 from aiokafka.structs import RecordMetadata 

23 from fast_depends.library.serializer import SerializerProto 

24 

25 from faststream._internal.parser import CodecProto 

26 from faststream._internal.types import CustomCallable 

27 

28 

29class AioKafkaFastProducer(ProducerProto[KafkaPublishCommand]): 

30 __slots__ = () 

31 

32 async def connect( 

33 self, 

34 producer: "AIOKafkaProducer", 

35 serializer: Optional["SerializerProto"], 

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

37 ) -> None: ... 

38 

39 async def disconnect(self) -> None: ... 

40 

41 def __bool__(self) -> bool: 

42 return False 

43 

44 @property 

45 def closed(self) -> bool: 

46 return True 

47 

48 async def flush(self) -> None: # ruff: ignore[no-self-use] 

49 return None 

50 

51 @abstractmethod 

52 async def publish( 

53 self, 

54 cmd: "KafkaPublishCommand", 

55 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]: ... 

56 

57 @abstractmethod 

58 async def publish_batch( 

59 self, 

60 cmd: "KafkaPublishCommand", 

61 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]: ... 

62 

63 @override 

64 async def request(self, cmd: "KafkaPublishCommand") -> Any: 

65 msg = "Kafka doesn't support `request` method without test client." 

66 raise FeatureNotSupportedException(msg) 

67 

68 

69class AioKafkaFastProducerImpl(AioKafkaFastProducer): 

70 """A class to represent Kafka producer.""" 

71 

72 __slots__ = ( 

73 "_decoder", 

74 "_parser", 

75 "_producer", 

76 "codec", 

77 "serializer", 

78 ) 

79 

80 def __init__( 

81 self, 

82 parser: Optional["CustomCallable"], 

83 decoder: Optional["CustomCallable"], 

84 ) -> None: 

85 self._producer: ProducerState = EmptyProducerState() 

86 self.serializer: SerializerProto | None = None 

87 self.codec: CodecProto = DefaultCodec() 

88 

89 # NOTE: register default parser to be compatible with request 

90 default = AioKafkaParser(msg_class=KafkaMessage, regex=None) 

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

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

93 

94 async def connect( 

95 self, 

96 producer: "AIOKafkaProducer", 

97 serializer: Optional["SerializerProto"], 

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

99 ) -> None: 

100 self.serializer = serializer 

101 self.codec = codec or DefaultCodec() 

102 await producer.start() 

103 self._producer = RealProducer(producer) 

104 

105 async def disconnect(self) -> None: 

106 await self._producer.stop() 

107 self._producer = EmptyProducerState() 

108 

109 def __bool__(self) -> bool: 

110 return bool(self._producer) 

111 

112 @property 

113 def closed(self) -> bool: 

114 return self._producer.closed 

115 

116 async def flush(self) -> None: 

117 await self._producer.flush() 

118 

119 @override 

120 async def publish( 

121 self, 

122 cmd: "KafkaPublishCommand", 

123 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]: 

124 """Publish a message to a topic.""" 

125 if cmd.body is None and cmd.key is not None: 

126 # keyed None is a tombstone: aiokafka requires at least key or value, 

127 # so a keyless None still goes through the codec as b"" 

128 message, content_type = None, None 

129 else: 

130 message, content_type = await self.codec.encode(cmd.body, self.serializer) 

131 

132 headers_to_send = { 

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

134 **cmd.headers_to_publish(), 

135 } 

136 

137 send_future = await self._producer.producer.send( 

138 topic=cmd.destination, 

139 value=message, 

140 key=cmd.key, 

141 partition=cmd.partition, 

142 timestamp_ms=cmd.timestamp_ms, 

143 headers=encode_headers(headers_to_send), 

144 ) 

145 

146 if not cmd.no_confirm: 

147 return await send_future 

148 return send_future 

149 

150 @override 

151 async def publish_batch( 

152 self, 

153 cmd: "KafkaPublishCommand", 

154 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]: 

155 """Publish a batch of messages to a topic.""" 

156 batch = self._producer.producer.create_batch() 

157 

158 headers_to_send = cmd.headers_to_publish() 

159 

160 if isinstance(self.codec, BatchCodecProto): 160 ↛ 161line 160 didn't jump to line 161 because the condition on line 160 was never true

161 encoded_batch = await self.codec.encode_batch( 

162 cmd.batch_bodies, self.serializer 

163 ) 

164 else: 

165 encoded_batch = [ 

166 await self.codec.encode(body, self.serializer) 

167 for body in cmd.batch_bodies 

168 ] 

169 

170 for message_position, (message, content_type) in enumerate(encoded_batch): 

171 if content_type: 

172 final_headers = { 

173 "content-type": content_type, 

174 **headers_to_send, 

175 } 

176 else: 

177 final_headers = headers_to_send.copy() 

178 

179 metadata = batch.append( 

180 key=cmd.key_for(message_position), 

181 value=message, 

182 timestamp=cmd.timestamp_ms, 

183 headers=encode_headers(final_headers), 

184 ) 

185 if metadata is None: 

186 raise BatchBufferOverflowException(message_position=message_position) 

187 

188 send_future = await self._producer.producer.send_batch( 

189 batch, 

190 cmd.destination, 

191 partition=cmd.partition, 

192 ) 

193 if not cmd.no_confirm: 

194 return await send_future 

195 return send_future 

196 

197 

198class FakeAioKafkaFastProducer(AioKafkaFastProducer): 

199 __slots__ = () 

200 

201 async def connect( 

202 self, 

203 producer: "AIOKafkaProducer", 

204 serializer: Optional["SerializerProto"], 

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

206 ) -> None: 

207 raise NotImplementedError 

208 

209 async def disconnect(self) -> None: 

210 raise NotImplementedError 

211 

212 def __bool__(self) -> bool: 

213 return False 

214 

215 @property 

216 def closed(self) -> bool: 

217 raise NotImplementedError 

218 

219 async def flush(self) -> None: 

220 raise NotImplementedError 

221 

222 async def publish( 

223 self, 

224 cmd: "KafkaPublishCommand", 

225 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]: 

226 raise NotImplementedError 

227 

228 async def publish_batch( 

229 self, 

230 cmd: "KafkaPublishCommand", 

231 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]: 

232 raise NotImplementedError