Coverage for faststream/_internal/endpoint/subscriber/call_item.py: 91%

61 statements  

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

1from collections import UserList 

2from collections.abc import Iterable, Reversible, Sequence 

3from functools import partial 

4from inspect import unwrap 

5from typing import ( 

6 TYPE_CHECKING, 

7 Any, 

8 Generic, 

9 Optional, 

10 cast, 

11) 

12 

13from faststream._internal.types import MsgType 

14from faststream.exceptions import IgnoredException, SetupError 

15from faststream.specification.asyncapi.utils import to_camelcase 

16 

17if TYPE_CHECKING: 

18 from fast_depends.dependencies import Dependant 

19 

20 from faststream._internal.basic_types import AsyncFuncAny, Decorator 

21 from faststream._internal.di import FastDependsConfig 

22 from faststream._internal.endpoint.call_wrapper import HandlerCallWrapper 

23 from faststream._internal.types import ( 

24 AsyncCallable, 

25 AsyncFilter, 

26 CustomCallable, 

27 SubscriberMiddleware, 

28 ) 

29 from faststream.message import StreamMessage 

30 

31 

32class HandlerItem(Generic[MsgType]): 

33 """A class representing handler overloaded item.""" 

34 

35 __slots__ = ( 

36 "decoder", 

37 "dependant", 

38 "dependencies", 

39 "filter", 

40 "handler", 

41 "item_decoder", 

42 "item_parser", 

43 "parser", 

44 ) 

45 

46 dependant: Any | None 

47 # What the handler declared, kept as declared so that composing them again 

48 # from an unchanged declaration produces an unchanged result. 

49 item_parser: Optional["CustomCallable"] 

50 item_decoder: Optional["CustomCallable"] 

51 # What the last composition made of them. 

52 parser: Optional["AsyncCallable"] 

53 decoder: Optional["AsyncCallable"] 

54 

55 def __init__( 

56 self, 

57 *, 

58 handler: "HandlerCallWrapper[..., Any]", 

59 filter: "AsyncFilter[Any]", 

60 item_parser: Optional["CustomCallable"], 

61 item_decoder: Optional["CustomCallable"], 

62 dependencies: Sequence["Dependant"], 

63 ) -> None: 

64 self.handler = handler 

65 self.filter = filter 

66 self.item_parser = item_parser 

67 self.item_decoder = item_decoder 

68 self.parser = None 

69 self.decoder = None 

70 self.dependencies = dependencies 

71 self.dependant = None 

72 

73 def __repr__(self) -> str: 

74 filter_call = unwrap(self.filter) 

75 filter_name = getattr(filter_call, "__name__", str(filter_call)) 

76 return f"<'{self.name}': filter='{filter_name}'>" 

77 

78 def _setup( 

79 self, 

80 *, 

81 parser: "AsyncCallable", 

82 decoder: "AsyncCallable", 

83 config: "FastDependsConfig", 

84 broker_dependencies: Sequence["Dependant"], 

85 _call_decorators: Reversible["Decorator"], 

86 ) -> None: 

87 self.parser = parser 

88 self.decoder = decoder 

89 

90 self.dependant = self.handler.set_wrapped( 

91 dependencies=(*broker_dependencies, *self.dependencies), 

92 _call_decorators=_call_decorators, 

93 config=config, 

94 ) 

95 

96 @property 

97 def name(self) -> str: 

98 """The name of the original call.""" 

99 if self.handler is None: 99 ↛ 100line 99 didn't jump to line 100 because the condition on line 99 was never true

100 return "" 

101 

102 caller = unwrap(self.handler._composed_call) 

103 return getattr(caller, "__name__", str(caller)) 

104 

105 @property 

106 def description(self) -> str | None: 

107 """The description of original call.""" 

108 if self.handler is None: 108 ↛ 109line 108 didn't jump to line 109 because the condition on line 108 was never true

109 return None 

110 

111 caller = unwrap(self.handler._composed_call) 

112 return getattr(caller, "__doc__", None) 

113 

114 async def is_suitable( 

115 self, 

116 msg: MsgType, 

117 cache: dict[Any, Any], 

118 ) -> Optional["StreamMessage[MsgType]"]: 

119 """Check is message suite for current filter.""" 

120 if not (parser := self.parser) or not (decoder := self.decoder): 120 ↛ 121line 120 didn't jump to line 121 because the condition on line 120 was never true

121 error_msg = "You should setup `HandlerItem` at first." 

122 raise SetupError(error_msg) 

123 

124 message = cache[parser] = cast( 

125 "StreamMessage[MsgType]", 

126 cache.get(parser) or await parser(msg), 

127 ) 

128 

129 # NOTE: final decoder will be set for success filter 

130 message.set_decoder(decoder) 

131 

132 if await self.filter(message): 

133 return message 

134 

135 return None 

136 

137 async def call( 

138 self, 

139 /, 

140 message: "StreamMessage[MsgType]", 

141 _extra_middlewares: Iterable["SubscriberMiddleware[Any]"], 

142 ) -> Any: 

143 """Execute wrapped handler with consume middlewares.""" 

144 call: AsyncFuncAny = self.handler.call_wrapped 

145 

146 for middleware in _extra_middlewares: 

147 call = partial(middleware, call) 

148 

149 try: 

150 result = await call(message) 

151 

152 except (IgnoredException, SystemExit): 

153 self.handler.trigger() 

154 raise 

155 

156 except Exception as e: 

157 self.handler.trigger(error=e) 

158 raise 

159 

160 else: 

161 self.handler.trigger(result=result) 

162 return result 

163 

164 

165class CallsCollection(UserList[HandlerItem[MsgType]]): 

166 def add_call(self, call: "HandlerItem[MsgType]") -> None: 

167 self.data.append(call) 

168 

169 @property 

170 def name(self) -> str | None: 

171 """The name of the handler call.""" 

172 if not self.data: 

173 return None 

174 

175 if len(self.data) == 1: 

176 return to_camelcase(self.data[0].name) 

177 

178 return f"[{','.join(to_camelcase(c.name) for c in self.data)}]" 

179 

180 @property 

181 def description(self) -> str | None: 

182 if not self.data: 

183 return None 

184 

185 if len(self.data) == 1: 

186 return self.data[0].description 

187 

188 return "\n".join( 

189 f"{to_camelcase(h.name)}: {h.description or ''}" for h in self.data 

190 )