Coverage for faststream/nats/parser.py: 95%
50 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 typing import TYPE_CHECKING, Any
3from faststream._internal.utils.path import match_path
4from faststream.message import (
5 StreamMessage,
6 decode_message,
7)
8from faststream.nats.message import (
9 NatsBatchMessage,
10 NatsKvMessage,
11 NatsMessage,
12 NatsObjMessage,
13)
14from faststream.nats.schemas.js_stream import compile_nats_wildcard
16if TYPE_CHECKING:
17 from nats.aio.msg import Msg
18 from nats.js.api import ObjectInfo
19 from nats.js.kv import KeyValue
21 from faststream._internal.basic_types import DecodedMessage
24class NatsBaseParser:
25 """A class to parse NATS messages."""
27 __slots__ = ("_path_re",)
29 def __init__(
30 self,
31 *,
32 pattern: str,
33 ) -> None:
34 path_re, _ = compile_nats_wildcard(pattern)
35 self._path_re = path_re
37 async def decode_message( # ruff: ignore[no-self-use]
38 self,
39 msg: "StreamMessage[Any]",
40 ) -> "DecodedMessage":
41 return decode_message(msg)
44class NatsParser(NatsBaseParser):
45 """A class to parse NATS core messages."""
47 __slots__ = ("is_ack_disabled",)
49 def __init__(self, *, pattern: str, is_ack_disabled: bool) -> None:
50 super().__init__(pattern=pattern)
52 self.is_ack_disabled = is_ack_disabled
54 async def parse_message(
55 self,
56 message: "Msg",
57 ) -> "StreamMessage[Msg]":
58 path = match_path(self._path_re, message.subject)
60 headers = message.header or {}
62 if self.is_ack_disabled: 62 ↛ 65line 62 didn't jump to line 65 because the condition on line 62 was always true
63 message._ackd = True
65 return NatsMessage(
66 raw_message=message,
67 body=message.data,
68 path=path,
69 reply_to=message.reply,
70 headers=headers,
71 content_type=headers.get("content-type", ""),
72 message_id=headers.get("message_id"),
73 correlation_id=headers.get("correlation_id"),
74 )
77class JsParser(NatsBaseParser):
78 """A class to parse NATS JS messages."""
80 __slots__ = ()
82 async def parse_message(
83 self,
84 message: "Msg",
85 ) -> "StreamMessage[Msg]":
86 path = match_path(self._path_re, message.subject)
88 headers = message.header or {}
90 return NatsMessage(
91 raw_message=message,
92 body=message.data,
93 path=path,
94 reply_to=headers.get("reply_to", ""), # differ from core
95 headers=headers,
96 content_type=headers.get("content-type"),
97 message_id=headers.get("message_id"),
98 correlation_id=headers.get("correlation_id"),
99 )
102class BatchParser(JsParser):
103 """A class to parse NATS batch messages."""
105 __slots__ = ()
107 async def parse_batch(
108 self,
109 message: list["Msg"],
110 ) -> "StreamMessage[list[Msg]]":
111 body: list[bytes] = []
112 batch_headers: list[dict[str, str]] = []
114 if message: 114 ↛ 122line 114 didn't jump to line 122 because the condition on line 114 was always true
115 path = match_path(self._path_re, message[0].subject)
117 for m in message:
118 batch_headers.append(m.headers or {})
119 body.append(m.data)
121 else:
122 path = {}
124 headers = next(iter(batch_headers), {})
126 return NatsBatchMessage(
127 raw_message=message,
128 body=body,
129 path=path,
130 headers=headers,
131 batch_headers=batch_headers,
132 )
134 async def decode_batch(
135 self,
136 msg: "StreamMessage[list[Msg]]",
137 ) -> list["DecodedMessage"]:
138 data: list[DecodedMessage] = []
140 for m in msg.raw_message:
141 one_msg = await self.parse_message(m)
142 data.append(decode_message(one_msg))
144 return data
147class KvParser(NatsBaseParser):
148 __slots__ = ()
150 async def parse_message(
151 self,
152 msg: "KeyValue.Entry",
153 ) -> StreamMessage["KeyValue.Entry"]:
154 return NatsKvMessage(
155 raw_message=msg,
156 body=msg.value,
157 path=match_path(self._path_re, msg.key),
158 )
161class ObjParser(NatsBaseParser):
162 __slots__ = ()
164 async def parse_message(self, msg: "ObjectInfo") -> StreamMessage["ObjectInfo"]: # ruff: ignore[no-self-use]
165 return NatsObjMessage(
166 raw_message=msg,
167 body=msg.name,
168 )