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
« 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
5from faststream._internal.middlewares import BaseMiddleware
6from faststream.exceptions import (
7 AckMessage,
8 HandlerException,
9 NackMessage,
10 RejectMessage,
11)
13from .config import AckPolicy
15if TYPE_CHECKING:
16 from types import TracebackType
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
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
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 )
50class _AcknowledgementMiddleware(BaseMiddleware):
51 __slots__ = ("ack_policy", "fallback_parser", "logger", "message")
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)
66 self.ack_policy = ack_policy
67 self.logger = logger
68 self.fallback_parser = fallback_parser
70 self.message: StreamMessage[Any] | None = None
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()
81 return await call_next(msg)
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
94 if not exc_type:
95 await self.__ack()
97 elif isinstance(exc_val, HandlerException):
98 if isinstance(exc_val, AckMessage):
99 await self.__ack(**exc_val.extra_options)
101 elif isinstance(exc_val, NackMessage):
102 await self.__nack(**exc_val.extra_options)
104 elif isinstance(exc_val, RejectMessage): # pragma: no branch
105 await self.__reject(**exc_val.extra_options)
107 # Exception was processed and suppressed
108 return True
110 elif isinstance(exc_val, asyncio.CancelledError):
111 return False
113 elif self.ack_policy is AckPolicy.REJECT_ON_ERROR:
114 await self.__reject()
116 elif self.ack_policy is AckPolicy.NACK_ON_ERROR:
117 await self.__nack()
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()
122 # Exception was not processed
123 return False
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
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 )
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)
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)
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)