Coverage for faststream/confluent/publisher/producer.py: 89%

64 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 

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.confluent.parser import AsyncConfluentParser 

11from faststream.confluent.response import KafkaPublishCommand 

12from faststream.exceptions import FeatureNotSupportedException 

13 

14from .state import EmptyProducerState, ProducerState, RealProducer 

15 

16if TYPE_CHECKING: 

17 import asyncio 

18 

19 from confluent_kafka import Message 

20 from fast_depends.library.serializer import SerializerProto 

21 

22 from faststream._internal.parser import CodecProto 

23 from faststream._internal.types import CustomCallable 

24 from faststream.confluent.helpers.client import AsyncConfluentProducer 

25 

26 

27class AsyncConfluentFastProducer(ProducerProto[KafkaPublishCommand]): 

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

29 

30 __slots__ = () 

31 

32 def connect( 

33 self, 

34 producer: "AsyncConfluentProducer", 

35 serializer: Optional["SerializerProto"], 

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

37 ) -> None: ... 

38 

39 def __bool__(self) -> bool: 

40 return False 

41 

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

43 return None 

44 

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

46 return None 

47 

48 @abstractmethod 

49 async def ping(self, timeout: float) -> bool: 

50 return False 

51 

52 @override 

53 @abstractmethod 

54 async def publish( 

55 self, 

56 cmd: "KafkaPublishCommand", 

57 ) -> "asyncio.Future[Message | None] | Message | None": ... 

58 

59 @override 

60 @abstractmethod 

61 async def publish_batch(self, cmd: "KafkaPublishCommand") -> None: ... 

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 FakeConfluentFastProducer(AsyncConfluentFastProducer): 

70 __slots__ = () 

71 

72 def connect( 

73 self, 

74 producer: "AsyncConfluentProducer", 

75 serializer: Optional["SerializerProto"], 

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

77 ) -> None: 

78 raise NotImplementedError 

79 

80 async def disconnect(self) -> None: 

81 raise NotImplementedError 

82 

83 async def flush(self) -> None: 

84 raise NotImplementedError 

85 

86 async def ping(self, timeout: float) -> bool: 

87 raise NotImplementedError 

88 

89 @override 

90 async def publish( 

91 self, 

92 cmd: "KafkaPublishCommand", 

93 ) -> "asyncio.Future[Message | None] | Message | None": 

94 raise NotImplementedError 

95 

96 @override 

97 async def publish_batch(self, cmd: "KafkaPublishCommand") -> None: 

98 raise NotImplementedError 

99 

100 

101class AsyncConfluentFastProducerImpl(AsyncConfluentFastProducer): 

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

103 

104 __slots__ = ( 

105 "_decoder", 

106 "_parser", 

107 "_producer", 

108 "codec", 

109 "serializer", 

110 ) 

111 

112 def __init__( 

113 self, 

114 parser: Optional["CustomCallable"], 

115 decoder: Optional["CustomCallable"], 

116 ) -> None: 

117 self._producer: ProducerState = EmptyProducerState() 

118 self.serializer: SerializerProto | None = None 

119 self.codec: CodecProto = DefaultCodec() 

120 

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

122 default = AsyncConfluentParser() 

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

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

125 

126 def connect( 

127 self, 

128 producer: "AsyncConfluentProducer", 

129 serializer: Optional["SerializerProto"], 

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

131 ) -> None: 

132 self._producer = RealProducer(producer) 

133 self.serializer = serializer 

134 self.codec = codec or DefaultCodec() 

135 

136 async def disconnect(self) -> None: 

137 await self._producer.stop() 

138 self._producer = EmptyProducerState() 

139 

140 def __bool__(self) -> bool: 

141 return bool(self._producer) 

142 

143 async def ping(self, timeout: float) -> bool: 

144 return await self._producer.ping(timeout=timeout) 

145 

146 async def flush(self) -> None: 

147 await self._producer.flush() 

148 

149 @override 

150 async def publish( 

151 self, 

152 cmd: "KafkaPublishCommand", 

153 ) -> "asyncio.Future[Message | None] | Message | None": 

154 """Publish a message to a topic.""" 

155 if cmd.body is None: 

156 message, content_type = None, None 

157 else: 

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

159 

160 headers_to_send = { 

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

162 **cmd.headers_to_publish(), 

163 } 

164 

165 return await self._producer.producer.send( 

166 topic=cmd.destination, 

167 value=message, 

168 key=cmd.key, 

169 partition=cmd.partition, 

170 timestamp_ms=cmd.timestamp_ms, 

171 headers=encode_headers(headers_to_send), 

172 no_confirm=cmd.no_confirm, 

173 ) 

174 

175 @override 

176 async def publish_batch(self, cmd: "KafkaPublishCommand") -> None: 

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

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

179 

180 headers_to_send = cmd.headers_to_publish() 

181 

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

183 encoded_batch = await self.codec.encode_batch( 

184 cmd.batch_bodies, self.serializer 

185 ) 

186 else: 

187 encoded_batch = [ 

188 await self.codec.encode(msg, self.serializer) for msg in cmd.batch_bodies 

189 ] 

190 

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

192 if content_type: 

193 final_headers = { 

194 "content-type": content_type, 

195 **headers_to_send, 

196 } 

197 else: 

198 final_headers = headers_to_send.copy() 

199 

200 batch.append( 

201 key=cmd.key_for(message_position), 

202 value=message, 

203 timestamp=cmd.timestamp_ms, 

204 headers=encode_headers(final_headers), 

205 ) 

206 

207 await self._producer.producer.send_batch( 

208 batch, 

209 cmd.destination, 

210 partition=cmd.partition, 

211 no_confirm=cmd.no_confirm, 

212 )