Coverage for faststream/_internal/endpoint/publisher/specification.py: 91%

27 statements  

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

1from inspect import Parameter, unwrap 

2from typing import TYPE_CHECKING, Any 

3 

4from fast_depends.core import build_call_model 

5from fast_depends.pydantic._compat import create_model, get_config_base # ruff: ignore[import-private-name] 

6from typing_extensions import TypeVar as TypeVar313 

7 

8from faststream._internal.configs import BrokerConfig, PublisherSpecificationConfig 

9from faststream._internal.endpoint.specification import EndpointSpecification 

10from faststream.specification.asyncapi.message import get_model_schema 

11from faststream.specification.asyncapi.utils import to_camelcase 

12 

13if TYPE_CHECKING: 

14 from faststream._internal.basic_types import AnyCallable 

15 from faststream.specification.schema import PublisherSpec 

16 

17 

18T_SpecificationConfig = TypeVar313( 

19 "T_SpecificationConfig", 

20 bound=PublisherSpecificationConfig, 

21 default=PublisherSpecificationConfig, 

22) 

23T_BrokerConfig = TypeVar313("T_BrokerConfig", bound=BrokerConfig, default=BrokerConfig) 

24 

25 

26class PublisherSpecification( 

27 EndpointSpecification[T_BrokerConfig, T_SpecificationConfig], 

28): 

29 __slots__ = ("calls",) 

30 

31 def __init__( 

32 self, 

33 _outer_config: "T_BrokerConfig", 

34 specification_config: "T_SpecificationConfig", 

35 ) -> None: 

36 super().__init__(_outer_config, specification_config) 

37 

38 self.calls: list[AnyCallable] = [] 

39 

40 def add_call(self, call: "AnyCallable") -> None: 

41 self.calls.append(call) 

42 

43 def get_payloads(self) -> list[tuple[dict[str, Any], str]]: 

44 payloads: list[tuple[dict[str, Any], str]] = [] 

45 

46 if self.config.schema_: 

47 body = get_model_schema( 

48 call=create_model( 

49 "", 

50 __config__=get_config_base(), 

51 response__=(self.config.schema_, ...), 

52 ), 

53 prefix=f"{self.name}:Message", 

54 ) 

55 

56 if body: # pragma: no branch 

57 payloads.append((body, "")) 

58 

59 else: 

60 di_state = self._outer_config.fd_config 

61 

62 for call in self.calls: 

63 call_model = build_call_model( 

64 call, 

65 dependency_provider=di_state.provider, 

66 serializer_cls=di_state._serializer, 

67 ) 

68 

69 if call_model.serializer: 69 ↛ 74line 69 didn't jump to line 74 because the condition on line 69 was always true

70 response_type = next( 

71 iter(call_model.serializer.response_option.values()), 

72 ).field_type 

73 else: 

74 response_type = None 

75 

76 if response_type is not None and response_type is not Parameter.empty: 

77 body = get_model_schema( 

78 create_model( 

79 "", 

80 __config__=get_config_base(), 

81 response__=(response_type, ...), 

82 ), 

83 prefix=f"{self.name}:Message", 

84 ) 

85 

86 if body: 86 ↛ 62line 86 didn't jump to line 62 because the condition on line 86 was always true

87 payloads.append((body, to_camelcase(unwrap(call).__name__))) 

88 

89 return payloads 

90 

91 @property 

92 def name(self) -> str: 

93 raise NotImplementedError 

94 

95 def get_schema(self) -> dict[str, "PublisherSpec"]: 

96 raise NotImplementedError