Coverage for faststream/nats/subscriber/usecases/stream_basic.py: 96%

42 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1from collections.abc import AsyncIterator 

2from typing import TYPE_CHECKING, Any, Optional 

3 

4from nats.errors import ConnectionClosedError, TimeoutError 

5from typing_extensions import override 

6 

7from faststream._internal.endpoint.utils import process_msg 

8from faststream.nats.parser import JsParser 

9 

10from .basic import DefaultSubscriber 

11 

12if TYPE_CHECKING: 

13 from nats.aio.msg import Msg 

14 from nats.js import JetStreamContext 

15 

16 from faststream._internal.endpoint.subscriber import SubscriberSpecification 

17 from faststream._internal.endpoint.subscriber.call_item import CallsCollection 

18 from faststream.message import StreamMessage 

19 from faststream.nats.message import NatsMessage 

20 from faststream.nats.schemas import JStream 

21 from faststream.nats.subscriber.config import NatsSubscriberConfig 

22 

23 

24class StreamSubscriber(DefaultSubscriber["Msg"]): 

25 __slots__ = () 

26 

27 _fetch_sub: Optional["JetStreamContext.PullSubscription"] 

28 

29 def __init__( 

30 self, 

31 config: "NatsSubscriberConfig", 

32 specification: "SubscriberSpecification[Any, Any]", 

33 calls: "CallsCollection[Msg]", 

34 *, 

35 stream: "JStream", 

36 queue: str, 

37 ) -> None: 

38 parser = JsParser(pattern=config.subject) 

39 config.decoder = parser.decode_message 

40 config.parser = parser.parse_message 

41 super().__init__(config, specification, calls) 

42 

43 self.queue = queue 

44 self.stream = stream 

45 

46 def get_log_context( 

47 self, 

48 message: Optional["StreamMessage[Msg]"], 

49 ) -> dict[str, str]: 

50 """Log context factory using in `self.consume` scope. 

51 

52 Args: 

53 message: Message which we are building context for 

54 """ 

55 return self.build_log_context( 

56 message=message, 

57 subject=self._resolved_subject_string, 

58 queue=self.queue, 

59 stream=self.stream.name, 

60 ) 

61 

62 @override 

63 async def get_one(self, *, timeout: float = 5) -> Optional["NatsMessage"]: 

64 assert not self.calls, ( 

65 "You can't use `get_one` method if subscriber has registered handlers." 

66 ) 

67 

68 if not self._fetch_sub: 68 ↛ 84line 68 didn't jump to line 84 because the condition on line 68 was always true

69 extra_options = { 

70 "pending_bytes_limit": self.extra_options["pending_bytes_limit"], 

71 "pending_msgs_limit": self.extra_options["pending_msgs_limit"], 

72 "durable": self.extra_options["durable"], 

73 "stream": self.extra_options["stream"], 

74 } 

75 if inbox_prefix := self.extra_options.get("inbox_prefix"): 

76 extra_options["inbox_prefix"] = inbox_prefix 

77 

78 self._fetch_sub = await self.jetstream.pull_subscribe( 

79 subject=self.subject.broker_address, 

80 config=self.config, 

81 **extra_options, 

82 ) 

83 

84 try: 

85 raw_message = ( 

86 await self._fetch_sub.fetch( 

87 batch=1, 

88 timeout=timeout, 

89 ) 

90 )[0] 

91 except (TimeoutError, ConnectionClosedError): 

92 return None 

93 

94 context = self._outer_config.context 

95 async_parser, async_decoder = self._get_parser_and_decoder() 

96 

97 msg: NatsMessage = await process_msg( # type: ignore[assignment] 

98 msg=raw_message, 

99 middlewares=( 

100 m(raw_message, context=context) for m in self._broker_middlewares 

101 ), 

102 parser=async_parser, 

103 decoder=async_decoder, 

104 ) 

105 return msg 

106 

107 @override 

108 async def __aiter__(self) -> AsyncIterator["NatsMessage"]: 

109 assert not self.calls, ( 

110 "You can't use iterator if subscriber has registered handlers." 

111 ) 

112 

113 if not self._fetch_sub: 113 ↛ 129line 113 didn't jump to line 129 because the condition on line 113 was always true

114 extra_options = { 

115 "pending_bytes_limit": self.extra_options["pending_bytes_limit"], 

116 "pending_msgs_limit": self.extra_options["pending_msgs_limit"], 

117 "durable": self.extra_options["durable"], 

118 "stream": self.extra_options["stream"], 

119 } 

120 if inbox_prefix := self.extra_options.get("inbox_prefix"): 

121 extra_options["inbox_prefix"] = inbox_prefix 

122 

123 self._fetch_sub = await self.jetstream.pull_subscribe( 

124 subject=self.subject.broker_address, 

125 config=self.config, 

126 **extra_options, 

127 ) 

128 

129 context = self._outer_config.context 

130 async_parser, async_decoder = self._get_parser_and_decoder() 

131 

132 while True: 

133 raw_message = ( 

134 await self._fetch_sub.fetch( 

135 batch=1, 

136 timeout=None, 

137 ) 

138 )[0] 

139 

140 msg: NatsMessage = await process_msg( # type: ignore[assignment] 

141 msg=raw_message, 

142 middlewares=( 

143 m(raw_message, context=context) for m in self._broker_middlewares 

144 ), 

145 parser=async_parser, 

146 decoder=async_decoder, 

147 ) 

148 yield msg