Coverage for fastblocks/applications.py: 40%

1import typing as t 

2from platform import system 

3 

4from acb.config import AdapterBase 

5from acb.depends import depends 

6from starception import add_link_template, set_editor 

7from starlette.applications import Starlette 

8from starlette.middleware import Middleware 

9from starlette.middleware.errors import ServerErrorMiddleware 

10from starlette.middleware.exceptions import ExceptionMiddleware 

11from starlette.types import ASGIApp, ExceptionHandler, Lifespan 

12 

13from .initializers import ApplicationInitializer 

14from .middleware import MiddlewarePosition 

15 

16 

17class FastBlocksSettings: 

18 def __init_subclass__(cls, **kwargs: t.Any) -> None: 

19 if AdapterBase not in cls.__bases__: 

20 cls.__bases__ = (AdapterBase, *cls.__bases__) 

21 super().__init_subclass__(**kwargs) 

22 

23 

24AppType = t.TypeVar("AppType", bound="FastBlocks") 

25 

26match system(): 

27 case "Windows": 

28 add_link_template("pycharm", "pycharm64.exe --line {lineno} {path}") 

29 case "Darwin": 

30 add_link_template("pycharm", "pycharm --line {lineno} {path}") 

31 case "Linux": 

32 add_link_template("pycharm", "pycharm.sh --line {lineno} {path}") 

33 case _: 

34 ... 

35 

36 

37class MiddlewareManager: 

38 def __init__(self) -> None: 

39 self._system_middleware: dict[MiddlewarePosition, t.Any] = {} 

40 self._middleware_stack_cache: list[Middleware] | None = None 

41 self.user_middleware: list[Middleware] = [] 

42 

43 def add_user_middleware( 

44 self, 

45 middleware_class: t.Any, 

46 *args: t.Any, 

47 **kwargs: t.Any, 

48 ) -> None: 

49 position = kwargs.pop("position", None) 

50 

51 middleware = Middleware(middleware_class, *args, **kwargs) 

52 

53 if not hasattr(self, "user_middleware"): 

54 self.user_middleware = [] 

55 

56 if position is not None and isinstance(position, int): 

57 self.user_middleware.insert(position, middleware) 

58 else: 

59 self.user_middleware.append(middleware) 

60 

61 self._middleware_stack_cache = None 

62 

63 def add_system_middleware( 

64 self, 

65 middleware_class: t.Any, 

66 position: MiddlewarePosition, 

67 **kwargs: t.Any, 

68 ) -> None: 

69 self._system_middleware[position] = (middleware_class, kwargs) 

70 self._middleware_stack_cache = None 

71 

72 def get_middleware_stack(self) -> dict[str, t.Any]: 

73 return { 

74 "user_middleware": [ 

75 self._extract_middleware_info(middleware) 

76 for middleware in self.user_middleware 

77 ], 

78 "system_middleware": { 

79 pos.name: self._extract_middleware_info(middleware) 

80 for pos, middleware in self._system_middleware.items() 

81 }, 

82 } 

83 

84 def _extract_middleware_info(self, middleware: t.Any) -> dict[str, t.Any]: 

85 if isinstance(middleware, Middleware): 

86 return { 

87 "class": getattr(middleware.cls, "__name__", str(middleware.cls)), 

88 "args": middleware.args, 

89 "kwargs": middleware.kwargs, 

90 } 

91 if isinstance(middleware, tuple) and len(middleware) >= 2: 

92 cls, kwargs = middleware[0], middleware[1] 

93 return { 

94 "class": cls.__name__ if hasattr(cls, "__name__") else str(cls), 

95 "kwargs": kwargs, 

96 } 

97 return { 

98 "class": middleware.__class__.__name__, 

99 "raw": str(middleware), 

100 } 

101 

102 

103class FastBlocks(Starlette): 

104 middleware_manager: MiddlewareManager 

105 templates: t.Any 

106 models: t.Any 

107 _middleware_position_map: dict[MiddlewarePosition, int] 

108 

109 def __init__( 

110 self, 

111 middleware: t.Sequence[Middleware] | None = None, 

112 exception_handlers: t.Mapping[t.Any, ExceptionHandler] | None = None, 

113 lifespan: Lifespan["t.Self"] | None = None, 

114 config: t.Any | None = None, 

115 logger: t.Any | None = None, 

116 ) -> None: 

117 initializer = ApplicationInitializer( 

118 self, 

119 middleware=middleware, 

120 exception_handlers=exception_handlers, 

121 lifespan=lifespan, 

122 config=config, 

123 logger=logger, 

124 ) 

125 

126 object.__setattr__(self, "middleware_manager", MiddlewareManager()) 

127 

128 self._middleware_position_map = {pos: pos.value for pos in MiddlewarePosition} 

129 self.templates = None 

130 self.models = None 

131 

132 initializer.initialize() 

133 

134 set_editor("pycharm") 

135 

136 def add_middleware( 

137 self, 

138 middleware_class: t.Any, 

139 *args: t.Any, 

140 **kwargs: t.Any, 

141 ) -> None: 

142 self.middleware_manager.add_user_middleware(middleware_class, *args, **kwargs) 

143 

144 @property 

145 def user_middleware(self) -> list[Middleware]: 

146 return self.middleware_manager.user_middleware 

147 

148 @user_middleware.setter 

149 def user_middleware(self, value: list[Middleware]) -> None: 

150 self.middleware_manager.user_middleware = value 

151 

152 @property 

153 def _system_middleware(self) -> dict[MiddlewarePosition, t.Any]: 

154 return self.middleware_manager._system_middleware 

155 

156 @_system_middleware.setter 

157 def _system_middleware(self, value: dict[MiddlewarePosition, t.Any]) -> None: 

158 self.middleware_manager._system_middleware = value 

159 

160 @property 

161 def _middleware_stack_cache(self) -> list[Middleware] | None: 

162 return self.middleware_manager._middleware_stack_cache 

163 

164 @_middleware_stack_cache.setter 

165 def _middleware_stack_cache(self, value: list[Middleware] | None) -> None: 

166 self.middleware_manager._middleware_stack_cache = value 

167 

168 def add_system_middleware( 

169 self, 

170 middleware_class: type, 

171 *, 

172 position: MiddlewarePosition, 

173 **options: t.Any, 

174 ) -> None: 

175 self.middleware_manager.add_system_middleware( 

176 middleware_class, 

177 position, 

178 **options, 

179 ) 

180 

181 def _extract_middleware_info(self, middleware: t.Any) -> tuple[str, type] | None: 

182 try: 

183 if hasattr(middleware, "cls"): 

184 cls = middleware.cls 

185 elif isinstance(middleware, tuple) and len(middleware) > 0: 

186 cls = middleware[0] 

187 else: 

188 return None 

189 cls_name = str(getattr(cls, "__name__", cls)) 

190 return cls_name, cls 

191 except (AttributeError, IndexError, TypeError): 

192 return None 

193 

194 def _get_system_middleware_with_overrides(self) -> list[t.Any]: 

195 from .middleware import middlewares 

196 

197 modified_system_middleware = middlewares().copy() 

198 for position, middleware in self._system_middleware.items(): 

199 position_index = position.value 

200 if 0 <= position_index < len(modified_system_middleware): 

201 modified_system_middleware[position_index] = middleware 

202 else: 

203 modified_system_middleware.append(middleware) 

204 

205 return modified_system_middleware 

206 

207 def get_middleware_stack(self) -> list[tuple[str, type]]: 

208 middleware_list = [("ExceptionMiddleware", ExceptionMiddleware)] 

209 system_middleware = self._get_system_middleware_with_overrides() 

210 for middleware in system_middleware: 

211 info = self._extract_middleware_info(middleware) 

212 if info: 

213 middleware_list.append(info) 

214 for middleware in self.user_middleware: 

215 info = self._extract_middleware_info(middleware) 

216 if info: 

217 middleware_list.append(info) 

218 middleware_list.append( 

219 ("ServerErrorMiddleware", t.cast("type", ServerErrorMiddleware)), 

220 ) 

221 return middleware_list 

222 

223 def _get_dependencies(self, config: t.Any, logger: t.Any) -> tuple[t.Any, t.Any]: 

224 if config is None: 

225 config = depends.get("config") 

226 if logger is None: 

227 try: 

228 logger = depends.get("logger") 

229 except Exception: 

230 logger = None 

231 return config, logger 

232 

233 def _separate_exception_handlers( 

234 self, 

235 ) -> tuple[t.Any, dict[t.Any, ExceptionHandler]]: 

236 error_handler = None 

237 exception_handlers: dict[t.Any, ExceptionHandler] = {} 

238 for key, value in self.exception_handlers.items(): 

239 if key in (500, Exception): 

240 error_handler = value 

241 else: 

242 exception_handlers[key] = value 

243 return error_handler, exception_handlers 

244 

245 def _build_base_middleware_list(self, error_handler: t.Any) -> list[Middleware]: 

246 middleware_list = [ 

247 Middleware( 

248 ServerErrorMiddleware, 

249 handler=error_handler, 

250 debug=self.debug, 

251 ), 

252 ] 

253 middleware_list.extend(self.user_middleware) 

254 return middleware_list 

255 

256 def _apply_system_middleware_overrides( 

257 self, 

258 system_middleware: list[t.Any], 

259 logger: t.Any, 

260 ) -> list[t.Any]: 

261 if not (hasattr(self, "_system_middleware") and self._system_middleware): 

262 return system_middleware 

263 

264 modified_system_middleware = system_middleware.copy() 

265 

266 for position, middleware in self._system_middleware.items(): 

267 position_index = self._middleware_position_map[position] 

268 

269 if 0 <= position_index < len(modified_system_middleware): 

270 if logger: 

271 logger.debug(f"Replacing middleware at position {position.name}") 

272 modified_system_middleware[position_index] = middleware 

273 else: 

274 if logger: 

275 logger.debug(f"Adding middleware at position {position.name}") 

276 modified_system_middleware.append(middleware) 

277 

278 return modified_system_middleware 

279 

280 def _apply_middleware_to_app( 

281 self, 

282 middleware_list: list[t.Any], 

283 logger: t.Any, 

284 ) -> ASGIApp: 

285 app = self.router 

286 for cls, args, kwargs in reversed(middleware_list): 

287 if logger: 

288 logger.debug(f"Adding middleware: {cls.__name__}") 

289 app = cls(*args, app=app, **kwargs) 

290 return app 

291 

292 def build_middleware_stack( 

293 self, 

294 config: t.Any | None = None, 

295 logger: t.Any | None = None, 

296 ) -> ASGIApp: 

297 if self._middleware_stack_cache is not None: 

298 return t.cast(t.Any, self._middleware_stack_cache) 

299 

300 config, logger = self._get_dependencies(config, logger) 

301 error_handler, exception_handlers = self._separate_exception_handlers() 

302 

303 from .middleware import middlewares 

304 

305 middleware_list = self._build_base_middleware_list(error_handler) 

306 system_middleware = middlewares() 

307 system_middleware = self._apply_system_middleware_overrides( 

308 system_middleware, 

309 logger, 

310 ) 

311 

312 middleware_list.extend(system_middleware) 

313 middleware_list.append( 

314 Middleware( 

315 ExceptionMiddleware, 

316 handlers=exception_handlers, 

317 debug=self.debug, 

318 ), 

319 ) 

320 

321 app = self._apply_middleware_to_app(middleware_list, logger) 

322 

323 if logger: 

324 logger.info("Middleware stack built") 

325 

326 object.__setattr__(self, "_middleware_stack_cache", app) 

327 return app