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
« 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
4from typing_extensions import override
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
16from .state import EmptyProducerState, ProducerState, RealProducer
18if TYPE_CHECKING:
19 import asyncio
21 from aiokafka import AIOKafkaProducer
22 from aiokafka.structs import RecordMetadata
23 from fast_depends.library.serializer import SerializerProto
25 from faststream._internal.parser import CodecProto
26 from faststream._internal.types import CustomCallable
29class AioKafkaFastProducer(ProducerProto[KafkaPublishCommand]):
30 __slots__ = ()
32 async def connect(
33 self,
34 producer: "AIOKafkaProducer",
35 serializer: Optional["SerializerProto"],
36 codec: Optional["CodecProto"] = None,
37 ) -> None: ...
39 async def disconnect(self) -> None: ...
41 def __bool__(self) -> bool:
42 return False
44 @property
45 def closed(self) -> bool:
46 return True
48 async def flush(self) -> None: # ruff: ignore[no-self-use]
49 return None
51 @abstractmethod
52 async def publish(
53 self,
54 cmd: "KafkaPublishCommand",
55 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]: ...
57 @abstractmethod
58 async def publish_batch(
59 self,
60 cmd: "KafkaPublishCommand",
61 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]: ...
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)
69class AioKafkaFastProducerImpl(AioKafkaFastProducer):
70 """A class to represent Kafka producer."""
72 __slots__ = (
73 "_decoder",
74 "_parser",
75 "_producer",
76 "codec",
77 "serializer",
78 )
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()
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)
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)
105 async def disconnect(self) -> None:
106 await self._producer.stop()
107 self._producer = EmptyProducerState()
109 def __bool__(self) -> bool:
110 return bool(self._producer)
112 @property
113 def closed(self) -> bool:
114 return self._producer.closed
116 async def flush(self) -> None:
117 await self._producer.flush()
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)
132 headers_to_send = {
133 "content-type": content_type or "",
134 **cmd.headers_to_publish(),
135 }
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 )
146 if not cmd.no_confirm:
147 return await send_future
148 return send_future
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()
158 headers_to_send = cmd.headers_to_publish()
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 ]
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()
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)
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
198class FakeAioKafkaFastProducer(AioKafkaFastProducer):
199 __slots__ = ()
201 async def connect(
202 self,
203 producer: "AIOKafkaProducer",
204 serializer: Optional["SerializerProto"],
205 codec: Optional["CodecProto"] = None,
206 ) -> None:
207 raise NotImplementedError
209 async def disconnect(self) -> None:
210 raise NotImplementedError
212 def __bool__(self) -> bool:
213 return False
215 @property
216 def closed(self) -> bool:
217 raise NotImplementedError
219 async def flush(self) -> None:
220 raise NotImplementedError
222 async def publish(
223 self,
224 cmd: "KafkaPublishCommand",
225 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]:
226 raise NotImplementedError
228 async def publish_batch(
229 self,
230 cmd: "KafkaPublishCommand",
231 ) -> Union["asyncio.Future[RecordMetadata]", "RecordMetadata"]:
232 raise NotImplementedError