Coverage for faststream/middlewares/acknowledgement/middleware.py: 92%

57 statements  

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

1import asyncio 

2import logging 

3from typing import TYPE_CHECKING, Any, Optional 

4 

5from faststream._internal.middlewares import BaseMiddleware 

6from faststream.exceptions import ( 

7 AckMessage, 

8 HandlerException, 

9 NackMessage, 

10 RejectMessage, 

11) 

12 

13from .config import AckPolicy 

14 

15if TYPE_CHECKING: 

16 from types import TracebackType 

17 

18 from faststream._internal.basic_types import AsyncFunc, AsyncFuncAny 

19 from faststream._internal.context.repository import ContextRepo 

20 from faststream._internal.logger import LoggerState 

21 from faststream._internal.types import AsyncCallable 

22 from faststream.message import StreamMessage 

23 

24 

25class AcknowledgementMiddleware: 

26 def __init__( 

27 self, 

28 logger: "LoggerState", 

29 ack_policy: "AckPolicy", 

30 fallback_parser: "AsyncCallable", 

31 ) -> None: 

32 self.ack_policy = ack_policy 

33 self.logger = logger 

34 self.fallback_parser = fallback_parser 

35 

36 def __call__( 

37 self, 

38 msg: Any | None, 

39 context: "ContextRepo", 

40 ) -> "_AcknowledgementMiddleware": 

41 return _AcknowledgementMiddleware( 

42 msg, 

43 logger=self.logger, 

44 ack_policy=self.ack_policy, 

45 context=context, 

46 fallback_parser=self.fallback_parser, 

47 ) 

48 

49 

50class _AcknowledgementMiddleware(BaseMiddleware): 

51 __slots__ = ("ack_policy", "fallback_parser", "logger", "message") 

52 

53 def __init__( 

54 self, 

55 msg: Any | None, 

56 /, 

57 *, 

58 logger: "LoggerState", 

59 context: "ContextRepo", 

60 # can't be created with AckPolicy.MANUAL 

61 ack_policy: AckPolicy, 

62 fallback_parser: "AsyncCallable", 

63 ) -> None: 

64 super().__init__(msg, context=context) 

65 

66 self.ack_policy = ack_policy 

67 self.logger = logger 

68 self.fallback_parser = fallback_parser 

69 

70 self.message: StreamMessage[Any] | None = None 

71 

72 async def consume_scope( 

73 self, 

74 call_next: "AsyncFuncAny", 

75 msg: "StreamMessage[Any]", 

76 ) -> Any: 

77 self.message = msg 

78 if self.ack_policy is AckPolicy.ACK_FIRST: 78 ↛ 79line 78 didn't jump to line 79 because the condition on line 78 was never true

79 await self.__ack() 

80 

81 return await call_next(msg) 

82 

83 async def __aexit__( 

84 self, 

85 exc_type: type[BaseException] | None = None, 

86 exc_val: BaseException | None = None, 

87 exc_tb: Optional["TracebackType"] = None, 

88 ) -> bool | None: 

89 if self.ack_policy is AckPolicy.ACK_FIRST: 

90 if self.message is None: 90 ↛ 92line 90 didn't jump to line 92 because the condition on line 90 was always true

91 await self.__ack() 

92 return False 

93 

94 if not exc_type: 

95 await self.__ack() 

96 

97 elif isinstance(exc_val, HandlerException): 

98 if isinstance(exc_val, AckMessage): 

99 await self.__ack(**exc_val.extra_options) 

100 

101 elif isinstance(exc_val, NackMessage): 

102 await self.__nack(**exc_val.extra_options) 

103 

104 elif isinstance(exc_val, RejectMessage): # pragma: no branch 

105 await self.__reject(**exc_val.extra_options) 

106 

107 # Exception was processed and suppressed 

108 return True 

109 

110 elif isinstance(exc_val, asyncio.CancelledError): 

111 return False 

112 

113 elif self.ack_policy is AckPolicy.REJECT_ON_ERROR: 

114 await self.__reject() 

115 

116 elif self.ack_policy is AckPolicy.NACK_ON_ERROR: 

117 await self.__nack() 

118 

119 elif self.ack_policy is AckPolicy.ACK: 119 ↛ 123line 119 didn't jump to line 123 because the condition on line 119 was always true

120 await self.__ack() 

121 

122 # Exception was not processed 

123 return False 

124 

125 async def __do_with_logging( 

126 self, func: "AsyncFunc", /, *args: Any, **kwargs: Any 

127 ) -> Any: 

128 try: 

129 return await func(*args, **kwargs) 

130 except Exception as er: 

131 if self.logger is not None: 

132 self.logger.log(repr(er), logging.CRITICAL, exc_info=er) 

133 return None 

134 

135 async def __resolve_message(self) -> "StreamMessage[Any] | None": 

136 return self.message or await self.__do_with_logging( 

137 self.fallback_parser, self.msg 

138 ) 

139 

140 async def __ack(self, **exc_extra_options: Any) -> None: 

141 if message := await self.__resolve_message(): 141 ↛ exitline 141 didn't return from function '__ack' because the condition on line 141 was always true

142 await self.__do_with_logging(message.ack, **exc_extra_options) 

143 

144 async def __nack(self, **exc_extra_options: Any) -> None: 

145 if message := await self.__resolve_message(): 145 ↛ exitline 145 didn't return from function '__nack' because the condition on line 145 was always true

146 await self.__do_with_logging(message.nack, **exc_extra_options) 

147 

148 async def __reject(self, **exc_extra_options: Any) -> None: 

149 if message := await self.__resolve_message(): 149 ↛ exitline 149 didn't return from function '__reject' because the condition on line 149 was always true

150 await self.__do_with_logging(message.reject, **exc_extra_options)