Coverage for faststream/redis/subscriber/factory.py: 90%

36 statements  

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

1import warnings 

2from typing import TYPE_CHECKING, Any, TypeAlias, Union 

3 

4from faststream._internal.constants import EMPTY 

5from faststream._internal.endpoint.subscriber.call_item import CallsCollection 

6from faststream.exceptions import SetupError 

7from faststream.middlewares import AckPolicy 

8from faststream.redis.schemas import INCORRECT_SETUP_MSG, ListSub, PubSub, StreamSub 

9from faststream.redis.schemas.proto import validate_options 

10 

11from .config import RedisSubscriberConfig, RedisSubscriberSpecificationConfig 

12from .specification import ( 

13 ChannelSubscriberSpecification, 

14 ListSubscriberSpecification, 

15 RedisSubscriberSpecification, 

16 StreamSubscriberSpecification, 

17) 

18from .usecases import ( 

19 ChannelConcurrentSubscriber, 

20 ChannelSubscriber, 

21 ListBatchSubscriber, 

22 ListConcurrentSubscriber, 

23 ListSubscriber, 

24 LogicSubscriber, 

25 StreamBatchSubscriber, 

26 StreamConcurrentSubscriber, 

27 StreamSubscriber, 

28) 

29 

30if TYPE_CHECKING: 

31 from faststream.redis.configs import RedisBrokerConfig 

32 from faststream.redis.parser import MessageFormat 

33 

34SubscriberType: TypeAlias = LogicSubscriber 

35 

36 

37def create_subscriber( 

38 *, 

39 channel: Union["PubSub", str, None], 

40 list: Union["ListSub", str, None], 

41 stream: Union["StreamSub", str, None], 

42 # Subscriber args 

43 ack_policy: "AckPolicy", 

44 config: "RedisBrokerConfig", 

45 no_reply: bool = False, 

46 message_format: type["MessageFormat"] | None, 

47 # AsyncAPI args 

48 title_: str | None = None, 

49 description_: str | None = None, 

50 include_in_schema: bool = True, 

51 max_workers: int = 1, 

52) -> SubscriberType: 

53 _validate_input_for_misconfigure( 

54 channel=channel, 

55 list=list, 

56 stream=stream, 

57 ack_policy=ack_policy, 

58 max_workers=max_workers, 

59 ) 

60 

61 subscriber_config = RedisSubscriberConfig( 

62 channel_sub=PubSub.validate(channel), 

63 list_sub=ListSub.validate(list), 

64 stream_sub=StreamSub.validate(stream), 

65 no_reply=no_reply, 

66 _outer_config=config, 

67 _ack_policy=ack_policy, 

68 _message_format=message_format, 

69 ) 

70 

71 specification_config = RedisSubscriberSpecificationConfig( 

72 title_=title_, 

73 description_=description_, 

74 include_in_schema=include_in_schema, 

75 ) 

76 

77 calls = CallsCollection[Any]() 

78 

79 specification: RedisSubscriberSpecification 

80 if subscriber_config.channel_sub: 

81 specification = ChannelSubscriberSpecification( 

82 config, 

83 specification_config, 

84 calls, 

85 channel=subscriber_config.channel_sub, 

86 ) 

87 

88 subscriber_config._ack_policy = AckPolicy.MANUAL 

89 

90 if max_workers > 1: 

91 return ChannelConcurrentSubscriber( 

92 subscriber_config, 

93 specification, 

94 calls, 

95 max_workers=max_workers, 

96 ) 

97 

98 return ChannelSubscriber(subscriber_config, specification, calls) 

99 

100 if subscriber_config.stream_sub: 

101 specification = StreamSubscriberSpecification( 

102 config, 

103 specification_config, 

104 calls, 

105 stream_sub=subscriber_config.stream_sub, 

106 ) 

107 

108 if subscriber_config.stream_sub.batch: 

109 return StreamBatchSubscriber(subscriber_config, specification, calls) 

110 

111 if max_workers > 1: 

112 return StreamConcurrentSubscriber( 

113 subscriber_config, 

114 specification, 

115 calls, 

116 max_workers=max_workers, 

117 ) 

118 

119 return StreamSubscriber(subscriber_config, specification, calls) 

120 

121 if subscriber_config.list_sub: 121 ↛ 142line 121 didn't jump to line 142 because the condition on line 121 was always true

122 specification = ListSubscriberSpecification( 

123 config, 

124 specification_config, 

125 calls, 

126 list_sub=subscriber_config.list_sub, 

127 ) 

128 

129 if subscriber_config.list_sub.batch: 

130 return ListBatchSubscriber(subscriber_config, specification, calls) 

131 

132 if max_workers > 1: 

133 return ListConcurrentSubscriber( 

134 subscriber_config, 

135 specification, 

136 calls, 

137 max_workers=max_workers, 

138 ) 

139 

140 return ListSubscriber(subscriber_config, specification, calls) 

141 

142 raise SetupError(INCORRECT_SETUP_MSG) 

143 

144 

145def _validate_input_for_misconfigure( 

146 *, 

147 channel: Union["PubSub", str, None], 

148 list: Union["ListSub", str, None], 

149 stream: Union["StreamSub", str, None], 

150 ack_policy: AckPolicy, 

151 max_workers: int, 

152) -> None: 

153 validate_options(channel=channel, list=list, stream=stream) 

154 

155 if max_workers > 1 and ( 

156 (isinstance(list, ListSub) and list.batch) 

157 or (isinstance(stream, StreamSub) and stream.batch) 

158 ): 

159 warnings.warn( 

160 "The `max_workers` option is ignored by a batch subscriber.", 

161 RuntimeWarning, 

162 stacklevel=4, 

163 ) 

164 

165 if ack_policy is not EMPTY: 

166 if channel: 166 ↛ 167line 166 didn't jump to line 167 because the condition on line 166 was never true

167 warnings.warn( 

168 "You can't use acknowledgement policy with PubSub subscriber.", 

169 RuntimeWarning, 

170 stacklevel=4, 

171 ) 

172 

173 if list: 173 ↛ 174line 173 didn't jump to line 174 because the condition on line 173 was never true

174 warnings.warn( 

175 "You can't use acknowledgement policy with List subscriber.", 

176 RuntimeWarning, 

177 stacklevel=4, 

178 )