Coverage for faststream/_internal/broker/registrator.py: 98%

42 statements  

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

1from abc import abstractmethod 

2from collections.abc import Iterable, Sequence 

3from typing import TYPE_CHECKING, Any, Generic 

4from weakref import WeakSet 

5 

6from faststream._internal.configs import ( 

7 BrokerConfig, 

8 BrokerConfigType_co, 

9 ConfigComposition, 

10) 

11from faststream._internal.types import BrokerMiddleware, MsgType 

12 

13if TYPE_CHECKING: 

14 from fast_depends.dependencies import Dependant 

15 

16 from faststream._internal.endpoint.publisher import PublisherUsecase 

17 from faststream._internal.endpoint.subscriber import SubscriberUsecase 

18 

19 

20class Registrator(Generic[MsgType, BrokerConfigType_co]): 

21 """Basic class for brokers and routers. 

22 

23 Contains subscribers & publishers registration logic only. 

24 """ 

25 

26 def __init__( 

27 self, 

28 *, 

29 config: BrokerConfigType_co, 

30 routers: Iterable["Registrator[MsgType]"], 

31 ) -> None: 

32 self._parser = config.broker_parser 

33 self._decoder = config.broker_decoder 

34 

35 self.config: ConfigComposition[BrokerConfigType_co] = ConfigComposition(config) 

36 

37 self._subscribers: WeakSet[SubscriberUsecase[MsgType]] = WeakSet() 

38 self._publishers: WeakSet[PublisherUsecase] = WeakSet() 

39 self.routers: list[Registrator[MsgType, Any]] = [] 

40 

41 self.__persistent_subscribers: list[SubscriberUsecase[MsgType]] = [] 

42 self.__persistent_publishers: list[PublisherUsecase] = [] 

43 

44 self.__parent: Registrator[MsgType, Any] | None = None 

45 

46 self.include_routers(*routers) 

47 

48 @property 

49 def subscribers(self) -> list["SubscriberUsecase[MsgType]"]: 

50 return [*self._subscribers, *(sub for r in self.routers for sub in r.subscribers)] 

51 

52 @property 

53 def publishers(self) -> list["PublisherUsecase"]: 

54 return [*self._publishers, *(pub for r in self.routers for pub in r.publishers)] 

55 

56 def add_middleware(self, middleware: "BrokerMiddleware[Any, Any]") -> None: 

57 """Append BrokerMiddleware to the end of middlewares list. 

58 

59 Current middleware will be used as a most inner of the stack. 

60 """ 

61 self.config.add_middleware(middleware) 

62 

63 def insert_middleware(self, middleware: "BrokerMiddleware[Any, Any]") -> None: 

64 """Insert BrokerMiddleware to the start of middlewares list. 

65 

66 Current middleware will be used as a most outer of the stack. 

67 """ 

68 self.config.insert_middleware(middleware) 

69 

70 @abstractmethod 

71 def subscriber( 

72 self, 

73 subscriber: "SubscriberUsecase[MsgType]", 

74 persistent: bool = True, 

75 ) -> "SubscriberUsecase[MsgType]": 

76 self._subscribers.add(subscriber) 

77 if persistent: 

78 self.__persistent_subscribers.append(subscriber) 

79 return subscriber 

80 

81 @abstractmethod 

82 def publisher( 

83 self, 

84 publisher: "PublisherUsecase", 

85 persistent: bool = True, 

86 ) -> "PublisherUsecase": 

87 self._publishers.add(publisher) 

88 if persistent: 

89 self.__persistent_publishers.append(publisher) 

90 return publisher 

91 

92 def include_router( 

93 self, 

94 router: "Registrator[MsgType, Any]", 

95 *, 

96 prefix: str = "", 

97 dependencies: Sequence["Dependant"] = (), 

98 middlewares: Sequence["BrokerMiddleware[MsgType]"] = (), 

99 include_in_schema: bool | None = None, 

100 ) -> None: 

101 """Includes a router in the current object.""" 

102 if router.parent is self: 

103 return 

104 router.parent = self 

105 

106 if options_config := BrokerConfig( 

107 prefix=prefix, 

108 include_in_schema=include_in_schema, 

109 broker_middlewares=middlewares, 

110 broker_dependencies=dependencies, 

111 ): 

112 router.config.add_config(options_config) 

113 

114 router.config.add_config(self.config) 

115 self.routers.append(router) 

116 

117 @property 

118 def parent(self) -> "Registrator[MsgType, Any] | None": 

119 return self.__parent 

120 

121 @parent.setter 

122 def parent(self, parent: "Registrator[MsgType, Any]") -> None: 

123 if self.__parent is not None and parent is not self.__parent: 

124 self.__parent.routers.remove(self) 

125 self.config.reset() 

126 self.__parent = parent 

127 

128 def include_routers( 

129 self, 

130 *routers: "Registrator[MsgType, Any]", 

131 ) -> None: 

132 """Includes routers in the object.""" 

133 for r in routers: 

134 self.include_router(r)