Coverage for faststream/mqtt/publisher/producer.py: 83%
78 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
1import asyncio
2from typing import TYPE_CHECKING, Any, Optional
4import zmqtt
5from typing_extensions import override
6from zmqtt import PublishProperties
8from faststream._internal.endpoint.utils import ParserComposition
9from faststream._internal.parser import DefaultCodec
10from faststream._internal.producer import ProducerProto
11from faststream._internal.types import IdGenerator
12from faststream.exceptions import FeatureNotSupportedException, IncorrectState
13from faststream.message import gen_cor_id
14from faststream.mqtt.parser import MQTTParserV5, MQTTParserV311
15from faststream.mqtt.response import MQTTPublishCommand
17if TYPE_CHECKING:
18 from fast_depends.library.serializer import SerializerProto
20 from faststream._internal.parser import CodecProto
21 from faststream._internal.types import AsyncCallable, CustomCallable
24class ZmqttBaseProducer(ProducerProto[MQTTPublishCommand]):
25 __slots__ = (
26 "_client",
27 "_decoder",
28 "_parser",
29 "codec",
30 "id_generator",
31 "serializer",
32 )
34 _parser: "AsyncCallable"
35 _decoder: "AsyncCallable"
37 def __init__(
38 self,
39 default_parser: Any,
40 parser: Optional["CustomCallable"],
41 decoder: Optional["CustomCallable"],
42 id_generator: IdGenerator = gen_cor_id,
43 ) -> None:
44 self.serializer: SerializerProto | None = None
45 self._client: zmqtt.MQTTClient | None = None
46 self.codec: CodecProto = DefaultCodec()
47 self.id_generator = id_generator
49 self._parser = ParserComposition(parser, default_parser.parse_message)
50 self._decoder = ParserComposition(decoder, default_parser.decode_message)
52 def connect(
53 self,
54 client: "zmqtt.MQTTClient",
55 serializer: Optional["SerializerProto"],
56 codec: Optional["CodecProto"] = None,
57 ) -> None:
58 self._client = client
59 self.serializer = serializer
60 self.codec = codec or DefaultCodec()
62 def disconnect(self) -> None:
63 self._client = None
64 self.serializer = None
66 @property
67 def _connected_client(self) -> "zmqtt.MQTTClient":
68 if self._client is None: 68 ↛ 69line 68 didn't jump to line 69 because the condition on line 68 was never true
69 msg = "Producer is not connected. Call connect() first."
70 raise IncorrectState(msg)
71 return self._client
73 @override
74 async def publish(self, cmd: "MQTTPublishCommand") -> None:
75 raise NotImplementedError
77 @override
78 async def request(self, cmd: "MQTTPublishCommand") -> Any:
79 raise NotImplementedError
81 @override
82 async def publish_batch(self, cmd: "MQTTPublishCommand") -> None:
83 msg = "MQTT does not support batch publishing."
84 raise FeatureNotSupportedException(msg)
87class ZmqttProducerV311(ZmqttBaseProducer):
88 """Producer for MQTT 3.1.1 — publishes raw bytes only.
90 Headers, correlation_id, and other metadata are not supported.
91 Use MQTT 5.0 for those features. Request/reply is supported via
92 an explicit reply_to topic provided by the caller.
93 """
95 __slots__ = ()
97 def __init__(
98 self,
99 parser: Optional["CustomCallable"],
100 decoder: Optional["CustomCallable"],
101 id_generator: IdGenerator = gen_cor_id,
102 ) -> None:
103 super().__init__(MQTTParserV311(), parser, decoder, id_generator)
105 @override
106 async def publish(self, cmd: "MQTTPublishCommand") -> None:
107 if cmd.headers:
108 msg = "MQTT 3.1.1 does not support message headers. Use MQTT 5.0."
109 raise FeatureNotSupportedException(msg)
110 payload, _ = await self.codec.encode(cmd.body, self.serializer)
111 await self._connected_client.publish(
112 cmd.destination,
113 payload,
114 qos=zmqtt.QoS(cmd.qos),
115 retain=cmd.retain,
116 )
118 @override
119 async def request(self, cmd: "MQTTPublishCommand") -> "zmqtt.Message":
120 """Request/reply for MQTT 3.1.1 via explicit reply topic.
122 The caller must supply ``cmd.reply_to``. FastStream subscribes to
123 that topic, publishes the raw request payload, then waits for the
124 first message on the reply topic. The handler side must publish
125 its response to the same topic (e.g. via ``@broker.publisher``).
126 """
127 if not cmd.reply_to: 127 ↛ 131line 127 didn't jump to line 131 because the condition on line 127 was always true
128 msg = "MQTT 3.1.1 request() requires an explicit reply_to topic."
129 raise FeatureNotSupportedException(msg)
131 sub = self._connected_client.subscribe(cmd.reply_to)
132 await sub.start()
134 try:
135 payload, _ = await self.codec.encode(cmd.body, self.serializer)
136 await self._connected_client.publish(
137 cmd.destination,
138 payload,
139 qos=cmd.qos,
140 retain=cmd.retain,
141 )
142 return await asyncio.wait_for(
143 sub.get_message(),
144 timeout=cmd.timeout or 30.0,
145 )
146 finally:
147 await sub.stop()
150class ZmqttProducerV5(ZmqttBaseProducer):
151 """Producer for MQTT 5.0 — publishes with PublishProperties."""
153 __slots__ = ()
155 def __init__(
156 self,
157 parser: Optional["CustomCallable"],
158 decoder: Optional["CustomCallable"],
159 id_generator: IdGenerator = gen_cor_id,
160 ) -> None:
161 super().__init__(MQTTParserV5(), parser, decoder, id_generator)
163 @override
164 async def publish(self, cmd: "MQTTPublishCommand") -> None:
165 payload, content_type = await self.codec.encode(cmd.body, self.serializer)
167 user_props: list[tuple[str, str]] = [
168 (k, str(v)) for k, v in (cmd.headers or {}).items()
169 ]
171 properties = PublishProperties(
172 content_type=content_type or None,
173 response_topic=cmd.reply_to or None,
174 correlation_data=cmd.correlation_id.encode() if cmd.correlation_id else None,
175 user_properties=tuple(user_props),
176 message_expiry_interval=cmd.message_expiry_interval,
177 )
179 await self._connected_client.publish(
180 cmd.destination,
181 payload,
182 qos=cmd.qos,
183 retain=cmd.retain,
184 properties=properties,
185 )
187 @override
188 async def request(self, cmd: "MQTTPublishCommand") -> "zmqtt.Message":
189 """Request/reply for MQTT 5.0 via zmqtt's native client.request().
191 zmqtt auto-generates a unique reply topic. We pass our correlation
192 ID explicitly so the responder echoes it back and the caller can
193 verify it on the response StreamMessage.
194 """
195 payload, content_type = await self.codec.encode(cmd.body, self.serializer)
196 correlation_id = cmd.correlation_id or self.id_generator()
198 user_props: list[tuple[str, str]] = [
199 (k, str(v)) for k, v in (cmd.headers or {}).items()
200 ]
202 # Pass correlation_data explicitly so the responder echoes it back.
203 # Do NOT set response_topic — let zmqtt generate it.
204 properties = PublishProperties(
205 content_type=content_type or None,
206 correlation_data=correlation_id.encode(),
207 user_properties=tuple(user_props),
208 message_expiry_interval=cmd.message_expiry_interval,
209 )
211 return await self._connected_client.request(
212 cmd.destination,
213 payload,
214 qos=cmd.qos,
215 timeout=cmd.timeout or 30.0,
216 properties=properties,
217 )
220class ZmqttFakeProducer(ZmqttBaseProducer):
221 __slots__ = ()
223 def __init__(self) -> None: ...
224 def __bool__(self) -> bool:
225 return False
227 def connect(
228 self,
229 client: "zmqtt.MQTTClient",
230 serializer: Optional["SerializerProto"],
231 codec: Optional["CodecProto"] = None,
232 ) -> None:
233 raise NotImplementedError
235 def disconnect(self) -> None:
236 raise NotImplementedError