Coverage for /home/runner/work/bijux-cli/bijux-cli/src/bijux_cli/services/__init__.py: 100%

1# SPDX-License-Identifier: MIT 

2# Copyright © 2025 Bijan Mousavi 

3 

4"""Registers the default services for the Bijux CLI application. 

5 

6This module serves as the primary composition root for the application's 

7service layer. It provides a single function, `register_default_services`, 

8which is responsible for binding all core service protocols to their 

9concrete implementations within the Dependency Injection (DI) container. 

10 

11This centralized registration is a key part of the application's Inversion of 

12Control (IoC) architecture, allowing components to be easily swapped or mocked 

13for testing. 

14""" 

15 

16from __future__ import annotations 

17 

18from typing import TYPE_CHECKING 

19 

20from bijux_cli.contracts import ( 

21 AuditProtocol, 

22 ConfigProtocol, 

23 ContextProtocol, 

24 DocsProtocol, 

25 DoctorProtocol, 

26 EmitterProtocol, 

27 HistoryProtocol, 

28 MemoryProtocol, 

29 ObservabilityProtocol, 

30 ProcessPoolProtocol, 

31 RegistryProtocol, 

32 RetryPolicyProtocol, 

33 SerializerProtocol, 

34 TelemetryProtocol, 

35) 

36from bijux_cli.core.enums import OutputFormat 

37 

38if TYPE_CHECKING: 

39 from bijux_cli.core.di import DIContainer 

40 from bijux_cli.core.enums import OutputFormat 

41 

42 

43def register_default_services( 

44 di: DIContainer, debug: bool, output_format: OutputFormat, quiet: bool 

45) -> None: 

46 """Registers all default service implementations with the DI container. 

47 

48 This function populates the container with lazy-loading factories for each 

49 core service the application requires, from configuration and logging to 

50 plugin management and command history. 

51 

52 Args: 

53 di (DIContainer): The dependency injection container instance. 

54 debug (bool): If True, services will be configured for debug mode. 

55 output_format (OutputFormat): The default output format for services 

56 like the emitter and serializer. 

57 quiet (bool): If True, services will be configured to suppress output. 

58 

59 Returns: 

60 None: 

61 """ 

62 import bijux_cli.core.context 

63 import bijux_cli.infra.emitter 

64 import bijux_cli.infra.observability 

65 import bijux_cli.infra.process 

66 import bijux_cli.infra.retry 

67 import bijux_cli.infra.serializer 

68 import bijux_cli.infra.telemetry 

69 import bijux_cli.services.audit 

70 import bijux_cli.services.config 

71 import bijux_cli.services.docs 

72 import bijux_cli.services.doctor 

73 import bijux_cli.services.history 

74 import bijux_cli.services.memory 

75 import bijux_cli.services.plugins.registry 

76 

77 obs_service = bijux_cli.infra.observability.Observability(debug=debug) 

78 

79 di.register(bijux_cli.infra.observability.Observability, lambda: obs_service) 

80 di.register( 

81 ObservabilityProtocol, 

82 lambda: di.resolve(bijux_cli.infra.observability.Observability), 

83 ) 

84 

85 di.register( 

86 bijux_cli.infra.telemetry.LoggingTelemetry, 

87 lambda: bijux_cli.infra.telemetry.LoggingTelemetry( 

88 observability=di.resolve(bijux_cli.infra.observability.Observability) 

89 ), 

90 ) 

91 di.register( 

92 TelemetryProtocol, 

93 lambda: di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry), 

94 ) 

95 

96 di.register( 

97 bijux_cli.infra.emitter.Emitter, 

98 lambda: bijux_cli.infra.emitter.Emitter( 

99 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry), 

100 format=output_format, 

101 debug=debug, 

102 quiet=quiet, 

103 ), 

104 ) 

105 di.register(EmitterProtocol, lambda: di.resolve(bijux_cli.infra.emitter.Emitter)) 

106 

107 di.register( 

108 bijux_cli.infra.serializer.OrjsonSerializer, 

109 lambda: bijux_cli.infra.serializer.OrjsonSerializer( 

110 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry) 

111 ), 

112 ) 

113 di.register( 

114 bijux_cli.infra.serializer.PyYAMLSerializer, 

115 lambda: bijux_cli.infra.serializer.PyYAMLSerializer( 

116 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry) 

117 ), 

118 ) 

119 di.register( 

120 SerializerProtocol, 

121 lambda: ( 

122 di.resolve(bijux_cli.infra.serializer.OrjsonSerializer) 

123 if output_format is OutputFormat.JSON 

124 else di.resolve(bijux_cli.infra.serializer.PyYAMLSerializer) 

125 ), 

126 ) 

127 

128 di.register( 

129 bijux_cli.infra.process.ProcessPool, 

130 lambda: bijux_cli.infra.process.ProcessPool( 

131 observability=di.resolve(bijux_cli.infra.observability.Observability), 

132 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry), 

133 ), 

134 ) 

135 di.register( 

136 ProcessPoolProtocol, lambda: di.resolve(bijux_cli.infra.process.ProcessPool) 

137 ) 

138 

139 di.register( 

140 bijux_cli.infra.retry.TimeoutRetryPolicy, 

141 lambda: bijux_cli.infra.retry.TimeoutRetryPolicy( 

142 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry) 

143 ), 

144 ) 

145 di.register( 

146 bijux_cli.infra.retry.ExponentialBackoffRetryPolicy, 

147 lambda: bijux_cli.infra.retry.ExponentialBackoffRetryPolicy( 

148 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry) 

149 ), 

150 ) 

151 di.register( 

152 RetryPolicyProtocol, 

153 lambda: di.resolve(bijux_cli.infra.retry.TimeoutRetryPolicy), 

154 ) 

155 

156 di.register( 

157 bijux_cli.core.context.Context, 

158 lambda: bijux_cli.core.context.Context(di), 

159 ) 

160 di.register(ContextProtocol, lambda: di.resolve(bijux_cli.core.context.Context)) 

161 

162 di.register( 

163 bijux_cli.services.config.Config, 

164 lambda: bijux_cli.services.config.Config(di), 

165 ) 

166 di.register(ConfigProtocol, lambda: di.resolve(bijux_cli.services.config.Config)) 

167 

168 di.register( 

169 bijux_cli.services.plugins.registry.Registry, 

170 lambda: bijux_cli.services.plugins.registry.Registry( 

171 di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry) 

172 ), 

173 ) 

174 di.register( 

175 RegistryProtocol, 

176 lambda: di.resolve(bijux_cli.services.plugins.registry.Registry), 

177 ) 

178 

179 di.register( 

180 bijux_cli.services.audit.DryRunAudit, 

181 lambda: bijux_cli.services.audit.DryRunAudit( 

182 di.resolve(bijux_cli.infra.observability.Observability), 

183 di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry), 

184 ), 

185 ) 

186 di.register( 

187 bijux_cli.services.audit.RealAudit, 

188 lambda: bijux_cli.services.audit.RealAudit( 

189 di.resolve(bijux_cli.infra.observability.Observability), 

190 di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry), 

191 ), 

192 ) 

193 di.register( 

194 AuditProtocol, 

195 lambda: bijux_cli.services.audit.get_audit_service( 

196 observability=di.resolve(bijux_cli.infra.observability.Observability), 

197 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry), 

198 dry_run=False, 

199 ), 

200 ) 

201 

202 di.register( 

203 bijux_cli.services.docs.Docs, 

204 lambda: bijux_cli.services.docs.Docs( 

205 observability=di.resolve(bijux_cli.infra.observability.Observability), 

206 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry), 

207 ), 

208 ) 

209 di.register(DocsProtocol, lambda: di.resolve(bijux_cli.services.docs.Docs)) 

210 

211 di.register( 

212 bijux_cli.services.doctor.Doctor, 

213 lambda: bijux_cli.services.doctor.Doctor(), 

214 ) 

215 di.register(DoctorProtocol, lambda: di.resolve(bijux_cli.services.doctor.Doctor)) 

216 

217 di.register( 

218 bijux_cli.services.history.History, 

219 lambda: bijux_cli.services.history.History( 

220 telemetry=di.resolve(bijux_cli.infra.telemetry.LoggingTelemetry), 

221 observability=di.resolve(bijux_cli.infra.observability.Observability), 

222 ), 

223 ) 

224 di.register(HistoryProtocol, lambda: di.resolve(bijux_cli.services.history.History)) 

225 

226 di.register( 

227 bijux_cli.services.memory.Memory, 

228 lambda: bijux_cli.services.memory.Memory(), 

229 ) 

230 di.register(MemoryProtocol, lambda: di.resolve(bijux_cli.services.memory.Memory)) 

231 

232 

233__all__ = ["register_default_services"]