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

1from typing import TYPE_CHECKING, Any 

2 

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 

15 

16if TYPE_CHECKING: 

17 from nats.aio.msg import Msg 

18 from nats.js.api import ObjectInfo 

19 from nats.js.kv import KeyValue 

20 

21 from faststream._internal.basic_types import DecodedMessage 

22 

23 

24class NatsBaseParser: 

25 """A class to parse NATS messages.""" 

26 

27 __slots__ = ("_path_re",) 

28 

29 def __init__( 

30 self, 

31 *, 

32 pattern: str, 

33 ) -> None: 

34 path_re, _ = compile_nats_wildcard(pattern) 

35 self._path_re = path_re 

36 

37 async def decode_message( # ruff: ignore[no-self-use] 

38 self, 

39 msg: "StreamMessage[Any]", 

40 ) -> "DecodedMessage": 

41 return decode_message(msg) 

42 

43 

44class NatsParser(NatsBaseParser): 

45 """A class to parse NATS core messages.""" 

46 

47 __slots__ = ("is_ack_disabled",) 

48 

49 def __init__(self, *, pattern: str, is_ack_disabled: bool) -> None: 

50 super().__init__(pattern=pattern) 

51 

52 self.is_ack_disabled = is_ack_disabled 

53 

54 async def parse_message( 

55 self, 

56 message: "Msg", 

57 ) -> "StreamMessage[Msg]": 

58 path = match_path(self._path_re, message.subject) 

59 

60 headers = message.header or {} 

61 

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 

64 

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 ) 

75 

76 

77class JsParser(NatsBaseParser): 

78 """A class to parse NATS JS messages.""" 

79 

80 __slots__ = () 

81 

82 async def parse_message( 

83 self, 

84 message: "Msg", 

85 ) -> "StreamMessage[Msg]": 

86 path = match_path(self._path_re, message.subject) 

87 

88 headers = message.header or {} 

89 

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 ) 

100 

101 

102class BatchParser(JsParser): 

103 """A class to parse NATS batch messages.""" 

104 

105 __slots__ = () 

106 

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]] = [] 

113 

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) 

116 

117 for m in message: 

118 batch_headers.append(m.headers or {}) 

119 body.append(m.data) 

120 

121 else: 

122 path = {} 

123 

124 headers = next(iter(batch_headers), {}) 

125 

126 return NatsBatchMessage( 

127 raw_message=message, 

128 body=body, 

129 path=path, 

130 headers=headers, 

131 batch_headers=batch_headers, 

132 ) 

133 

134 async def decode_batch( 

135 self, 

136 msg: "StreamMessage[list[Msg]]", 

137 ) -> list["DecodedMessage"]: 

138 data: list[DecodedMessage] = [] 

139 

140 for m in msg.raw_message: 

141 one_msg = await self.parse_message(m) 

142 data.append(decode_message(one_msg)) 

143 

144 return data 

145 

146 

147class KvParser(NatsBaseParser): 

148 __slots__ = () 

149 

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 ) 

159 

160 

161class ObjParser(NatsBaseParser): 

162 __slots__ = () 

163 

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 )