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
« 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)
13from faststream._internal.types import MsgType
14from faststream.exceptions import IgnoredException, SetupError
15from faststream.specification.asyncapi.utils import to_camelcase
17if TYPE_CHECKING:
18 from fast_depends.dependencies import Dependant
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
32class HandlerItem(Generic[MsgType]):
33 """A class representing handler overloaded item."""
35 __slots__ = (
36 "decoder",
37 "dependant",
38 "dependencies",
39 "filter",
40 "handler",
41 "item_decoder",
42 "item_parser",
43 "parser",
44 )
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"]
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
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}'>"
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
90 self.dependant = self.handler.set_wrapped(
91 dependencies=(*broker_dependencies, *self.dependencies),
92 _call_decorators=_call_decorators,
93 config=config,
94 )
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 ""
102 caller = unwrap(self.handler._composed_call)
103 return getattr(caller, "__name__", str(caller))
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
111 caller = unwrap(self.handler._composed_call)
112 return getattr(caller, "__doc__", None)
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)
124 message = cache[parser] = cast(
125 "StreamMessage[MsgType]",
126 cache.get(parser) or await parser(msg),
127 )
129 # NOTE: final decoder will be set for success filter
130 message.set_decoder(decoder)
132 if await self.filter(message):
133 return message
135 return None
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
146 for middleware in _extra_middlewares:
147 call = partial(middleware, call)
149 try:
150 result = await call(message)
152 except (IgnoredException, SystemExit):
153 self.handler.trigger()
154 raise
156 except Exception as e:
157 self.handler.trigger(error=e)
158 raise
160 else:
161 self.handler.trigger(result=result)
162 return result
165class CallsCollection(UserList[HandlerItem[MsgType]]):
166 def add_call(self, call: "HandlerItem[MsgType]") -> None:
167 self.data.append(call)
169 @property
170 def name(self) -> str | None:
171 """The name of the handler call."""
172 if not self.data:
173 return None
175 if len(self.data) == 1:
176 return to_camelcase(self.data[0].name)
178 return f"[{','.join(to_camelcase(c.name) for c in self.data)}]"
180 @property
181 def description(self) -> str | None:
182 if not self.data:
183 return None
185 if len(self.data) == 1:
186 return self.data[0].description
188 return "\n".join(
189 f"{to_camelcase(h.name)}: {h.description or ''}" for h in self.data
190 )