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
« 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
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.confluent.parser import AsyncConfluentParser
11from faststream.confluent.response import KafkaPublishCommand
12from faststream.exceptions import FeatureNotSupportedException
14from .state import EmptyProducerState, ProducerState, RealProducer
16if TYPE_CHECKING:
17 import asyncio
19 from confluent_kafka import Message
20 from fast_depends.library.serializer import SerializerProto
22 from faststream._internal.parser import CodecProto
23 from faststream._internal.types import CustomCallable
24 from faststream.confluent.helpers.client import AsyncConfluentProducer
27class AsyncConfluentFastProducer(ProducerProto[KafkaPublishCommand]):
28 """A class to represent Kafka producer."""
30 __slots__ = ()
32 def connect(
33 self,
34 producer: "AsyncConfluentProducer",
35 serializer: Optional["SerializerProto"],
36 codec: Optional["CodecProto"] = None,
37 ) -> None: ...
39 def __bool__(self) -> bool:
40 return False
42 async def disconnect(self) -> None: # ruff: ignore[no-self-use]
43 return None
45 async def flush(self) -> None: # ruff: ignore[no-self-use]
46 return None
48 @abstractmethod
49 async def ping(self, timeout: float) -> bool:
50 return False
52 @override
53 @abstractmethod
54 async def publish(
55 self,
56 cmd: "KafkaPublishCommand",
57 ) -> "asyncio.Future[Message | None] | Message | None": ...
59 @override
60 @abstractmethod
61 async def publish_batch(self, cmd: "KafkaPublishCommand") -> None: ...
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 FakeConfluentFastProducer(AsyncConfluentFastProducer):
70 __slots__ = ()
72 def connect(
73 self,
74 producer: "AsyncConfluentProducer",
75 serializer: Optional["SerializerProto"],
76 codec: Optional["CodecProto"] = None,
77 ) -> None:
78 raise NotImplementedError
80 async def disconnect(self) -> None:
81 raise NotImplementedError
83 async def flush(self) -> None:
84 raise NotImplementedError
86 async def ping(self, timeout: float) -> bool:
87 raise NotImplementedError
89 @override
90 async def publish(
91 self,
92 cmd: "KafkaPublishCommand",
93 ) -> "asyncio.Future[Message | None] | Message | None":
94 raise NotImplementedError
96 @override
97 async def publish_batch(self, cmd: "KafkaPublishCommand") -> None:
98 raise NotImplementedError
101class AsyncConfluentFastProducerImpl(AsyncConfluentFastProducer):
102 """A class to represent Kafka producer."""
104 __slots__ = (
105 "_decoder",
106 "_parser",
107 "_producer",
108 "codec",
109 "serializer",
110 )
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()
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)
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()
136 async def disconnect(self) -> None:
137 await self._producer.stop()
138 self._producer = EmptyProducerState()
140 def __bool__(self) -> bool:
141 return bool(self._producer)
143 async def ping(self, timeout: float) -> bool:
144 return await self._producer.ping(timeout=timeout)
146 async def flush(self) -> None:
147 await self._producer.flush()
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)
160 headers_to_send = {
161 "content-type": content_type or "",
162 **cmd.headers_to_publish(),
163 }
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 )
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()
180 headers_to_send = cmd.headers_to_publish()
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 ]
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()
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 )
207 await self._producer.producer.send_batch(
208 batch,
209 cmd.destination,
210 partition=cmd.partition,
211 no_confirm=cmd.no_confirm,
212 )